cirq-core 1.3.0.dev20231201164435__py3-none-any.whl → 1.4.0__py3-none-any.whl

cirq/qis/noise_utils.py

@@ -0,0 +1,123 @@
+# Copyright 2021 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# 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.
+
+import numpy as np
+
+
+# TODO: expose all from top-level cirq?
+def decay_constant_to_xeb_fidelity(decay_constant: float, num_qubits: int = 2) -> float:
+    """Calculates the XEB fidelity from the depolarization decay constant.
+
+    Args:
+        decay_constant: Depolarization decay constant.
+        num_qubits: Number of qubits.
+
+    Returns:
+        Calculated XEB fidelity.
+    """
+    N = 2**num_qubits
+    return 1 - ((1 - decay_constant) * (1 - 1 / N))
+
+
+def decay_constant_to_pauli_error(decay_constant: float, num_qubits: int = 1) -> float:
+    """Calculates pauli error from the depolarization decay constant.
+
+    Args:
+        decay_constant: Depolarization decay constant.
+        num_qubits: Number of qubits.
+
+    Returns:
+        Calculated Pauli error.
+    """
+    N = 2**num_qubits
+    return (1 - decay_constant) * (1 - 1 / N / N)
+
+
+def pauli_error_to_decay_constant(pauli_error: float, num_qubits: int = 1) -> float:
+    """Calculates depolarization decay constant from pauli error.
+
+    Args:
+        pauli_error: The pauli error.
+        num_qubits: Number of qubits.
+
+    Returns:
+        Calculated depolarization decay constant.
+    """
+    N = 2**num_qubits
+    return 1 - (pauli_error / (1 - 1 / N / N))
+
+
+def xeb_fidelity_to_decay_constant(xeb_fidelity: float, num_qubits: int = 2) -> float:
+    """Calculates the depolarization decay constant from XEB fidelity.
+
+    Args:
+        xeb_fidelity: The XEB fidelity.
+        num_qubits: Number of qubits.
+
+    Returns:
+        Calculated depolarization decay constant.
+    """
+    N = 2**num_qubits
+    return 1 - (1 - xeb_fidelity) / (1 - 1 / N)
+
+
+def pauli_error_from_t1(t_ns: float, t1_ns: float) -> float:
+    """Calculates the pauli error from T1 decay constant.
+
+    This computes error for a specific duration, `t`.
+
+    Args:
+        t_ns: The duration of the gate in ns.
+        t1_ns: The T1 decay constant in ns.
+
+    Returns:
+        Calculated Pauli error resulting from T1 decay.
+    """
+    t2 = 2 * t1_ns
+    return (1 - np.exp(-t_ns / t2)) / 2 + (1 - np.exp(-t_ns / t1_ns)) / 4
+
+
+def average_error(decay_constant: float, num_qubits: int = 1) -> float:
+    """Calculates the average error from the depolarization decay constant.
+
+    Args:
+        decay_constant: Depolarization decay constant.
+        num_qubits: Number of qubits.
+
+    Returns:
+        Calculated average error.
+    """
+    N = 2**num_qubits
+    return (1 - decay_constant) * (1 - 1 / N)
+
+
+def decoherence_pauli_error(t1_ns: float, tphi_ns: float, gate_time_ns: float) -> float:
+    """The component of Pauli error caused by decoherence on a single qubit.
+
+    Args:
+        t1_ns: T1 time in nanoseconds.
+        tphi_ns: Tphi time in nanoseconds.
+        gate_time_ns: Duration in nanoseconds of the gate affected by this error.
+
+    Returns:
+        Calculated Pauli error resulting from decoherence.
+    """
+    gamma_2 = (1 / (2 * t1_ns)) + 1 / tphi_ns
+
+    exp1 = np.exp(-gate_time_ns / t1_ns)
+    exp2 = np.exp(-gate_time_ns * gamma_2)
+    px = 0.25 * (1 - exp1)
+    py = px
+    pz = 0.5 * (1 - exp2) - px
+    return px + py + pz

cirq/qis/noise_utils_test.py

@@ -0,0 +1,97 @@
+# Copyright 2021 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# 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.
+
+import numpy as np
+import pytest
+
+from cirq.qis.noise_utils import (
+    decay_constant_to_xeb_fidelity,
+    decay_constant_to_pauli_error,
+    pauli_error_to_decay_constant,
+    xeb_fidelity_to_decay_constant,
+    pauli_error_from_t1,
+    average_error,
+    decoherence_pauli_error,
+)
+
+
+@pytest.mark.parametrize(
+    'decay_constant,num_qubits,expected_output',
+    [(0.01, 1, 1 - (0.99 * 1 / 2)), (0.05, 2, 1 - (0.95 * 3 / 4))],
+)
+def test_decay_constant_to_xeb_fidelity(decay_constant, num_qubits, expected_output):
+    val = decay_constant_to_xeb_fidelity(decay_constant, num_qubits)
+    assert val == expected_output
+
+
+@pytest.mark.parametrize(
+    'decay_constant,num_qubits,expected_output',
+    [(0.01, 1, 0.99 * 3 / 4), (0.05, 2, 0.95 * 15 / 16)],
+)
+def test_decay_constant_to_pauli_error(decay_constant, num_qubits, expected_output):
+    val = decay_constant_to_pauli_error(decay_constant, num_qubits)
+    assert val == expected_output
+
+
+@pytest.mark.parametrize(
+    'pauli_error,num_qubits,expected_output',
+    [(0.01, 1, 1 - (0.01 / (3 / 4))), (0.05, 2, 1 - (0.05 / (15 / 16)))],
+)
+def test_pauli_error_to_decay_constant(pauli_error, num_qubits, expected_output):
+    val = pauli_error_to_decay_constant(pauli_error, num_qubits)
+    assert val == expected_output
+
+
+@pytest.mark.parametrize(
+    'xeb_fidelity,num_qubits,expected_output',
+    [(0.01, 1, 1 - 0.99 / (1 / 2)), (0.05, 2, 1 - 0.95 / (3 / 4))],
+)
+def test_xeb_fidelity_to_decay_constant(xeb_fidelity, num_qubits, expected_output):
+    val = xeb_fidelity_to_decay_constant(xeb_fidelity, num_qubits)
+    assert val == expected_output
+
+
+@pytest.mark.parametrize(
+    't,t1_ns,expected_output',
+    [
+        (20, 1e5, (1 - np.exp(-20 / 2e5)) / 2 + (1 - np.exp(-20 / 1e5)) / 4),
+        (4000, 1e4, (1 - np.exp(-4000 / 2e4)) / 2 + (1 - np.exp(-4000 / 1e4)) / 4),
+    ],
+)
+def test_pauli_error_from_t1(t, t1_ns, expected_output):
+    val = pauli_error_from_t1(t, t1_ns)
+    assert val == expected_output
+
+
+@pytest.mark.parametrize(
+    'decay_constant,num_qubits,expected_output', [(0.01, 1, 0.99 * 1 / 2), (0.05, 2, 0.95 * 3 / 4)]
+)
+def test_average_error(decay_constant, num_qubits, expected_output):
+    val = average_error(decay_constant, num_qubits)
+    assert val == expected_output
+
+
+@pytest.mark.parametrize(
+    'T1_ns,Tphi_ns,gate_time_ns', [(1e4, 2e4, 25), (1e5, 2e3, 25), (1e4, 2e4, 4000)]
+)
+def test_decoherence_pauli_error(T1_ns, Tphi_ns, gate_time_ns):
+    val = decoherence_pauli_error(T1_ns, Tphi_ns, gate_time_ns)
+    # Expected value is of the form:
+    #
+    #   (1/4) * [1 - e^(-t/T1)] + (1/2) * [1 - e^(-t/(2*T1) - t/Tphi]
+    #
+    expected_output = 0.25 * (1 - np.exp(-gate_time_ns / T1_ns)) + 0.5 * (
+        1 - np.exp(-gate_time_ns * ((1 / (2 * T1_ns)) + 1 / Tphi_ns))
+    )
+    assert val == expected_output

cirq/sim/classical_simulator.py

@@ -12,96 +12,236 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Dict
-from collections import defaultdict
-from cirq.sim.simulator import SimulatesSamples
-from cirq import ops, protocols
-from cirq.study.resolver import ParamResolver
-from cirq.circuits.circuit import AbstractCircuit
-from cirq.ops.raw_types import Qid
+
+from typing import Dict, Generic, Any, Sequence, List, Optional, Union, TYPE_CHECKING
+from copy import deepcopy, copy
+from cirq import ops, qis
+from cirq.value import big_endian_int_to_bits
+from cirq import sim
+from cirq.sim.simulation_state import TSimulationState, SimulationState
 import numpy as np
 
+if TYPE_CHECKING:
+    import cirq
+
 
-def _is_identity(op: ops.Operation) -> bool:
-    if isinstance(op.gate, (ops.XPowGate, ops.CXPowGate, ops.CCXPowGate, ops.SwapPowGate)):
-        return op.gate.exponent % 2 == 0
+def _is_identity(action) -> bool:
+    """Check if the given action is equivalent to an identity."""
+    gate = action.gate if isinstance(action, ops.Operation) else action
+    if isinstance(gate, (ops.XPowGate, ops.CXPowGate, ops.CCXPowGate, ops.SwapPowGate)):
+        return gate.exponent % 2 == 0
     return False
 
 
-class ClassicalStateSimulator(SimulatesSamples):
-    """A simulator that accepts only gates with classical counterparts.
-
-    This simulator evolves a single state, using only gates that output a single state for each
-    input state. The simulator runs in linear time, at the cost of not supporting superposition.
-    It can be used to estimate costs and simulate circuits for simple non-quantum algorithms using
-    many more qubits than fully capable quantum simulators.
-
-    The supported gates are:
-        - cirq.X
-        - cirq.CNOT
-        - cirq.SWAP
-        - cirq.TOFFOLI
-        - cirq.measure
-
-    Args:
-        circuit: The circuit to simulate.
-        param_resolver: Parameters to run with the program.
-        repetitions: Number of times to repeat the run. It is expected that
-            this is validated greater than zero before calling this method.
-
-    Returns:
-        A dictionary mapping measurement keys to measurement results.
-
-    Raises:
-        ValueError: If
-            - one of the gates is not an X, CNOT, SWAP, TOFFOLI or a measurement.
-            - A measurement key is used for measurements on different numbers of qubits.
-    """
-
-    def _run(
-        self, circuit: AbstractCircuit, param_resolver: ParamResolver, repetitions: int
-    ) -> Dict[str, np.ndarray]:
-        results_dict: Dict[str, np.ndarray] = {}
-        values_dict: Dict[Qid, int] = defaultdict(int)
-        param_resolver = param_resolver or ParamResolver({})
-        resolved_circuit = protocols.resolve_parameters(circuit, param_resolver)
-
-        for moment in resolved_circuit:
-            for op in moment:
-                if _is_identity(op):
-                    continue
-                if op.gate == ops.X:
-                    (q,) = op.qubits
-                    values_dict[q] ^= 1
-                elif op.gate == ops.CNOT:
-                    c, q = op.qubits
-                    values_dict[q] ^= values_dict[c]
-                elif op.gate == ops.SWAP:
-                    a, b = op.qubits
-                    values_dict[a], values_dict[b] = values_dict[b], values_dict[a]
-                elif op.gate == ops.TOFFOLI:
-                    c1, c2, q = op.qubits
-                    values_dict[q] ^= values_dict[c1] & values_dict[c2]
-                elif protocols.is_measurement(op):
-                    measurement_values = np.array(
-                        [[[values_dict[q] for q in op.qubits]]] * repetitions, dtype=np.uint8
-                    )
-                    key = op.gate.key  # type: ignore
-                    if key in results_dict:
-                        if op._num_qubits_() != results_dict[key].shape[-1]:
-                            raise ValueError(
-                                f'Measurement shape {len(measurement_values)} does not match '
-                                f'{results_dict[key].shape[-1]} in {key}.'
-                            )
-                        results_dict[key] = np.concatenate(
-                            (results_dict[key], measurement_values), axis=1
-                        )
-                    else:
-                        results_dict[key] = measurement_values
-                else:
-                    raise ValueError(
-                        f'{op} is not one of cirq.X, cirq.CNOT, cirq.SWAP, '
-                        'cirq.CCNOT, or a measurement'
-                    )
-
-        return results_dict
+class ClassicalBasisState(qis.QuantumStateRepresentation):
+    """Represents a classical basis state for efficient state evolution."""
+
+    def __init__(self, initial_state: Union[List[int], np.ndarray]):
+        """Initializes the ClassicalBasisState object.
+
+        Args:
+            initial_state: The initial state in the computational basis.
+        """
+        self.basis = initial_state
+
+    def copy(self, deep_copy_buffers: bool = True) -> 'ClassicalBasisState':
+        """Creates a copy of the ClassicalBasisState object.
+
+        Args:
+            deep_copy_buffers: Whether to deep copy the internal buffers.
+        Returns:
+            A copy of the ClassicalBasisState object.
+        """
+        return ClassicalBasisState(
+            initial_state=deepcopy(self.basis) if deep_copy_buffers else copy(self.basis)
+        )
+
+    def measure(
+        self, axes: Sequence[int], seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None
+    ) -> List[int]:
+        """Measures the density matrix.
+
+        Args:
+            axes: The axes to measure.
+            seed: The random number seed to use.
+        Returns:
+            The measurements in order.
+        """
+        return [self.basis[i] for i in axes]
+
+
+class ClassicalBasisSimState(SimulationState[ClassicalBasisState]):
+    """Represents the state of a quantum simulation using classical basis states."""
+
+    def __init__(
+        self,
+        initial_state: Union[int, List[int]] = 0,
+        qubits: Optional[Sequence['cirq.Qid']] = None,
+        classical_data: Optional['cirq.ClassicalDataStore'] = None,
+    ):
+        """Initializes the ClassicalBasisSimState object.
+
+        Args:
+            qubits: The qubits to simulate.
+            initial_state: The initial state for the simulation.
+            classical_data: The classical data container for the simulation.
+
+        Raises:
+            ValueError: If qubits not provided and initial_state is int.
+                        If initial_state is not an int, List[int], or np.ndarray.
+
+        An initial_state value of type integer is parsed in big endian order.
+        """
+        if isinstance(initial_state, int):
+            if qubits is None:
+                raise ValueError('qubits must be provided if initial_state is not List[int]')
+            state = ClassicalBasisState(
+                big_endian_int_to_bits(initial_state, bit_count=len(qubits))
+            )
+        elif isinstance(initial_state, (list, np.ndarray)):
+            state = ClassicalBasisState(initial_state)
+        else:
+            raise ValueError('initial_state must be an int or List[int] or np.ndarray')
+        super().__init__(state=state, qubits=qubits, classical_data=classical_data)
+
+    def _act_on_fallback_(self, action, qubits: Sequence['cirq.Qid'], allow_decompose: bool = True):
+        """Acts on the state with a given operation.
+
+        Args:
+            action: The operation to apply.
+            qubits: The qubits to apply the operation to.
+            allow_decompose: Whether to allow decomposition of the operation.
+
+        Returns:
+            True if the operation was applied successfully.
+
+        Raises:
+            ValueError: If initial_state shape for type np.ndarray is not equal to 1.
+                        If gate is not one of X, SWAP, a controlled version of X or SWAP,
+                            or a measurement.
+        """
+        if isinstance(self._state.basis, np.ndarray) and len(self._state.basis.shape) != 1:
+            raise ValueError('initial_state shape for type np.ndarray is not equal to 1')
+        gate = action.gate if isinstance(action, ops.Operation) else action
+        mapped_qubits = [self.qubit_map[i] for i in qubits]
+
+        if isinstance(gate, ops.ControlledGate):
+            control_qubits = mapped_qubits[: gate.num_controls()]
+            mapped_qubits = mapped_qubits[gate.num_controls() :]
+
+            controls_state = tuple(self._state.basis[c] for c in control_qubits)
+            if controls_state not in gate.control_values.expand():
+                # gate has no effect; controls were off
+                return True
+
+            gate = gate.sub_gate
+
+        if _is_identity(gate):
+            pass
+        elif gate == ops.X:
+            (q,) = mapped_qubits
+            self._state.basis[q] ^= 1
+        elif gate == ops.CNOT:
+            c, q = mapped_qubits
+            self._state.basis[q] ^= self._state.basis[c]
+        elif gate == ops.SWAP:
+            a, b = mapped_qubits
+            self._state.basis[a], self._state.basis[b] = self._state.basis[b], self._state.basis[a]
+        elif gate == ops.TOFFOLI:
+            c1, c2, q = mapped_qubits
+            self._state.basis[q] ^= self._state.basis[c1] & self._state.basis[c2]
+        else:
+            raise ValueError(
+                f'{gate} is not one of X, SWAP; a controlled version '
+                'of X or SWAP; or a measurement'
+            )
+        return True
+
+
+class ClassicalStateStepResult(
+    sim.StepResultBase['ClassicalBasisSimState'], Generic[TSimulationState]
+):
+    """The step result provided by `ClassicalStateSimulator.simulate_moment_steps`."""
+
+
+class ClassicalStateTrialResult(
+    sim.SimulationTrialResultBase['ClassicalBasisSimState'], Generic[TSimulationState]
+):
+    """The trial result provided by `ClassicalStateSimulator.simulate`."""
+
+
+class ClassicalStateSimulator(
+    sim.SimulatorBase[
+        ClassicalStateStepResult['ClassicalBasisSimState'],
+        ClassicalStateTrialResult['ClassicalBasisSimState'],
+        'ClassicalBasisSimState',
+    ],
+    Generic[TSimulationState],
+):
+    """A simulator that accepts only gates with classical counterparts."""
+
+    def __init__(
+        self, *, noise: 'cirq.NOISE_MODEL_LIKE' = None, split_untangled_states: bool = False
+    ):
+        """Initializes a ClassicalStateSimulator.
+
+        Args:
+            noise: The noise model used by the simulator.
+            split_untangled_states: Whether to run the simulation as a product state.
+
+        Raises:
+            ValueError: If noise_model is not None.
+        """
+        if noise is not None:
+            raise ValueError(f'{noise=} is not supported')
+        super().__init__(noise=noise, split_untangled_states=split_untangled_states)
+
+    def _create_simulator_trial_result(
+        self,
+        params: 'cirq.ParamResolver',
+        measurements: Dict[str, np.ndarray],
+        final_simulator_state: 'cirq.SimulationStateBase[ClassicalBasisSimState]',
+    ) -> 'ClassicalStateTrialResult[ClassicalBasisSimState]':
+        """Creates a trial result for the simulator.
+
+        Args:
+            params: The parameter resolver for the simulation.
+            measurements: The measurement results.
+            final_simulator_state: The final state of the simulator.
+        Returns:
+            A trial result for the simulator.
+        """
+        return ClassicalStateTrialResult(
+            params, measurements, final_simulator_state=final_simulator_state
+        )
+
+    def _create_step_result(
+        self, sim_state: 'cirq.SimulationStateBase[ClassicalBasisSimState]'
+    ) -> 'ClassicalStateStepResult[ClassicalBasisSimState]':
+        """Creates a step result for the simulator.
+
+        Args:
+            sim_state: The current state of the simulator.
+        Returns:
+            A step result for the simulator.
+        """
+        return ClassicalStateStepResult(sim_state)
+
+    def _create_partial_simulation_state(
+        self,
+        initial_state: Any,
+        qubits: Sequence['cirq.Qid'],
+        classical_data: 'cirq.ClassicalDataStore',
+    ) -> 'ClassicalBasisSimState':
+        """Creates a partial simulation state for the simulator.
+
+        Args:
+            initial_state: The initial state for the simulation.
+            qubits: The qubits associated with the state.
+            classical_data: The shared classical data container for this simulation.
+        Returns:
+            A partial simulation state.
+        """
+        return ClassicalBasisSimState(
+            initial_state=initial_state, qubits=qubits, classical_data=classical_data
+        )