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)
