def test_lazy_loader(): linalg = _import.LazyLoader("linalg", globals(), "scipy.linalg") linalg.fun = 1 assert linalg._module is None assert "linalg" not in linalg.__dict__ linalg.det([[1]]) assert linalg._module is not None assert globals()["linalg"] == linalg._module assert "fun" in linalg.__dict__ assert "LinAlgError" in dir(linalg) assert linalg.fun == 1
Union, ) import dataclasses import numpy as np from matplotlib import pyplot as plt from cirq import _compat, _import, circuits, devices, ops, protocols, sim, value, work if TYPE_CHECKING: import cirq CrossEntropyPair = NamedTuple('CrossEntropyPair', [('num_cycle', int), ('xeb_fidelity', float)]) SpecklePurityPair = NamedTuple('SpecklePurityPair', [('num_cycle', int), ('purity', float)]) optimize = _import.LazyLoader("optimize", globals(), "scipy.optimize") @dataclasses.dataclass class CrossEntropyDepolarizingModel: """A depolarizing noise model for cross entropy benchmarking. The depolarizing channel maps a density matrix ρ as ρ → p_eff ρ + (1 - p_eff) I / D where I / D is the maximally mixed state and p_eff is between 0 and 1. It is used to model the effect of noise in certain quantum processes. This class models the noise that results from the execution of multiple layers, or cycles, of a random quantum circuit. In this model, p_eff for the whole process is separated into a part that is independent of the number
# limitations under the License. """Quantum gates defined by a matrix.""" from typing import Any, cast, Dict, Iterable, Optional, Tuple, TYPE_CHECKING import numpy as np from cirq import linalg, protocols, _import from cirq._compat import proper_repr from cirq.ops import raw_types if TYPE_CHECKING: import cirq single_qubit_decompositions = _import.LazyLoader( 'single_qubit_decompositions', globals(), 'cirq.transformers.analytical_decompositions') two_qubit_to_cz = _import.LazyLoader( 'two_qubit_to_cz', globals(), 'cirq.transformers.analytical_decompositions') three_qubit_decomposition = _import.LazyLoader( 'three_qubit_decomposition', globals(), 'cirq.transformers.analytical_decompositions') class MatrixGate(raw_types.Gate): r"""A unitary qubit or qudit gate defined entirely by its numpy matrix. For example `cirq.MatrixGate(np.array([[0, 1j], [1, 0]]))` has the unitary matrix: $$
from typing import Optional, TYPE_CHECKING, Tuple import numpy as np from cirq import protocols, value, _import from cirq.qis.states import ( QuantumState, infer_qid_shape, quantum_state, validate_density_matrix, validate_normalized_state_vector, ) # We initialize these lazily, otherwise they slow global import speed. stats = _import.LazyLoader("stats", globals(), "scipy.stats") linalg = _import.LazyLoader("linalg", globals(), "scipy.linalg") if TYPE_CHECKING: import cirq def _sqrt_positive_semidefinite_matrix(mat: np.ndarray) -> np.ndarray: """Square root of a positive semidefinite matrix.""" eigs, vecs = linalg.eigh(mat) return vecs @ (np.sqrt(np.abs(eigs)) * vecs).T.conj() def _validate_int_state(state: int, qid_shape: Optional[Tuple[int, ...]]) -> None: if state < 0:
from abc import abstractmethod, ABC from typing import Dict, Iterable, List, Optional, Sequence, Tuple, TYPE_CHECKING import numpy as np import pandas as pd import sympy from cirq import circuits, ops, protocols, _import from cirq.experiments.xeb_simulation import simulate_2q_xeb_circuits if TYPE_CHECKING: import cirq import multiprocessing import scipy.optimize # We initialize these lazily, otherwise they slow global import speed. optimize = _import.LazyLoader("optimize", globals(), "scipy.optimize") stats = _import.LazyLoader("stats", globals(), "scipy.stats") THETA_SYMBOL, ZETA_SYMBOL, CHI_SYMBOL, GAMMA_SYMBOL, PHI_SYMBOL = sympy.symbols( 'theta zeta chi gamma phi') def benchmark_2q_xeb_fidelities( sampled_df: pd.DataFrame, circuits: Sequence['cirq.Circuit'], cycle_depths: Optional[Sequence[int]] = None, param_resolver: 'cirq.ParamResolverOrSimilarType' = None, pool: Optional['multiprocessing.pool.Pool'] = None, ) -> pd.DataFrame: """Simulate and benchmark two-qubit XEB circuits.
# # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Base class for creating custom target gatesets which can be used for compilation.""" from typing import Optional, List, Hashable, TYPE_CHECKING import abc from cirq import circuits, ops, protocols, _import from cirq.protocols.decompose_protocol import DecomposeResult from cirq.transformers import merge_k_qubit_gates, merge_single_qubit_gates drop_empty_moments = _import.LazyLoader('drop_empty_moments', globals(), 'cirq.transformers') drop_negligible = _import.LazyLoader('drop_negligible_operations', globals(), 'cirq.transformers') expand_composite = _import.LazyLoader('expand_composite', globals(), 'cirq.transformers') if TYPE_CHECKING: import cirq def create_transformer_with_kwargs(transformer: 'cirq.TRANSFORMER', **kwargs) -> 'cirq.TRANSFORMER': """Method to capture additional keyword arguments to transformers while preserving mypy type. Returns a `cirq.TRANSFORMER` which, when called with a circuit and transformer context, is equivalent to calling `transformer(circuit, context=context, **kwargs)`. It is often useful to
# limitations under the License. """Classes for representing device noise. NoiseProperties is an abstract class for capturing metrics of a device that can be translated into noise models. NoiseModelFromNoiseProperties consumes those noise models to produce a single noise model which replicates device noise. """ import abc from typing import Iterable, Sequence, TYPE_CHECKING, List from cirq import _import, ops, protocols, devices from cirq.devices.noise_utils import ( PHYSICAL_GATE_TAG, ) circuits = _import.LazyLoader("circuits", globals(), "cirq.circuits.circuit") if TYPE_CHECKING: import cirq class NoiseProperties(abc.ABC): """Noise-defining properties for a quantum device.""" @abc.abstractmethod def build_noise_models(self) -> List['cirq.NoiseModel']: """Construct all NoiseModels associated with this NoiseProperties.""" class NoiseModelFromNoiseProperties(devices.NoiseModel): def __init__(self, noise_properties: NoiseProperties) -> None: """Creates a Noise Model from a NoiseProperties object that can be used with a Simulator.
Tuple, Union, TYPE_CHECKING, ) import numpy as np from cirq import protocols, value, _import from cirq._compat import deprecated from cirq.ops import raw_types, controlled_operation as cop, matrix_gates from cirq.type_workarounds import NotImplementedType if TYPE_CHECKING: import cirq line_qubit = _import.LazyLoader('line_qubit', globals(), 'cirq.devices') @value.value_equality class ControlledGate(raw_types.Gate): """Augments existing gates to have one or more control qubits. This object is typically created via `gate.controlled()`. """ def __init__( self, sub_gate: 'cirq.Gate', num_controls: int = None, control_values: Optional[Sequence[Union[int, Collection[int]]]] = None, control_qid_shape: Optional[Sequence[int]] = None, ) -> None:
# # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Transformer pass to repack circuits avoiding simultaneous operations with different classes.""" import itertools from typing import TYPE_CHECKING, Type, Callable, Optional, Union, Iterable, Sequence, List, Tuple from cirq import ops, circuits, _import from cirq.transformers import transformer_api, transformer_primitives drop_empty_moments = _import.LazyLoader('drop_empty_moments', globals(), 'cirq.transformers') if TYPE_CHECKING: import cirq # A function that decides based on an operation # whether it belongs to a class or not Classifier = Callable[['cirq.Operation'], bool] # Any of the possible operation categories that we can stratify on. Category = Union[ 'cirq.Gate', 'cirq.Operation', Type['cirq.Gate'], Type['cirq.Operation'], Classifier ] @transformer_api.transformer(add_deep_support=True)