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

cirq/devices/grid_qubit.py

@@ -14,6 +14,7 @@
 
 import abc
 import functools
+import weakref
 from typing import Any, Dict, Iterable, List, Optional, Tuple, Set, TYPE_CHECKING, Union
 from typing_extensions import Self
 
@@ -32,43 +33,66 @@ class _BaseGridQid(ops.Qid):
     _row: int
     _col: int
     _dimension: int
+    _comp_key: Optional[Tuple[int, int]] = None
     _hash: Optional[int] = None
 
-    def __getstate__(self):
-        # Don't save hash when pickling; see #3777.
-        state = self.__dict__
-        if "_hash" in state:
-            state = state.copy()
-            del state["_hash"]
-        return state
-
     def __hash__(self) -> int:
         if self._hash is None:
             self._hash = hash((self._row, self._col, self._dimension))
         return self._hash
 
-    def __eq__(self, other):
+    def __eq__(self, other) -> bool:
         # Explicitly implemented for performance (vs delegating to Qid).
         if isinstance(other, _BaseGridQid):
-            return (
+            return self is other or (
                 self._row == other._row
                 and self._col == other._col
                 and self._dimension == other._dimension
             )
         return NotImplemented
 
-    def __ne__(self, other):
+    def __ne__(self, other) -> bool:
         # Explicitly implemented for performance (vs delegating to Qid).
         if isinstance(other, _BaseGridQid):
-            return (
+            return self is not other and (
                 self._row != other._row
                 or self._col != other._col
                 or self._dimension != other._dimension
             )
         return NotImplemented
 
+    def __lt__(self, other) -> bool:
+        # Explicitly implemented for performance (vs delegating to Qid).
+        if isinstance(other, _BaseGridQid):
+            k0, k1 = self._comparison_key(), other._comparison_key()
+            return k0 < k1 or (k0 == k1 and self._dimension < other._dimension)
+        return super().__lt__(other)
+
+    def __le__(self, other) -> bool:
+        # Explicitly implemented for performance (vs delegating to Qid).
+        if isinstance(other, _BaseGridQid):
+            k0, k1 = self._comparison_key(), other._comparison_key()
+            return k0 < k1 or (k0 == k1 and self._dimension <= other._dimension)
+        return super().__le__(other)
+
+    def __ge__(self, other) -> bool:
+        # Explicitly implemented for performance (vs delegating to Qid).
+        if isinstance(other, _BaseGridQid):
+            k0, k1 = self._comparison_key(), other._comparison_key()
+            return k0 > k1 or (k0 == k1 and self._dimension >= other._dimension)
+        return super().__ge__(other)
+
+    def __gt__(self, other) -> bool:
+        # Explicitly implemented for performance (vs delegating to Qid).
+        if isinstance(other, _BaseGridQid):
+            k0, k1 = self._comparison_key(), other._comparison_key()
+            return k0 > k1 or (k0 == k1 and self._dimension > other._dimension)
+        return super().__gt__(other)
+
     def _comparison_key(self):
-        return self._row, self._col
+        if self._comp_key is None:
+            self._comp_key = self._row, self._col
+        return self._comp_key
 
     @property
     def row(self) -> int:
@@ -178,8 +202,12 @@ class GridQid(_BaseGridQid):
     cirq.GridQid(5, 4, dimension=2)
     """
 
-    def __init__(self, row: int, col: int, *, dimension: int) -> None:
-        """Initializes a grid qid at the given row, col coordinate
+    # Cache of existing GridQid instances, returned by __new__ if available.
+    # Holds weak references so instances can still be garbage collected.
+    _cache = weakref.WeakValueDictionary[Tuple[int, int, int], 'cirq.GridQid']()
+
+    def __new__(cls, row: int, col: int, *, dimension: int) -> 'cirq.GridQid':
+        """Creates a grid qid at the given row, col coordinate
 
         Args:
             row: the row coordinate
@@ -187,13 +215,23 @@ class GridQid(_BaseGridQid):
             dimension: The dimension of the qid's Hilbert space, i.e.
                 the number of quantum levels.
         """
-        self.validate_dimension(dimension)
-        self._row = row
-        self._col = col
-        self._dimension = dimension
+        key = (row, col, dimension)
+        inst = cls._cache.get(key)
+        if inst is None:
+            cls.validate_dimension(dimension)
+            inst = super().__new__(cls)
+            inst._row = row
+            inst._col = col
+            inst._dimension = dimension
+            cls._cache[key] = inst
+        return inst
+
+    def __getnewargs_ex__(self):
+        """Returns a tuple of (args, kwargs) to pass to __new__ when unpickling."""
+        return (self._row, self._col), {"dimension": self._dimension}
 
     def _with_row_col(self, row: int, col: int) -> 'GridQid':
-        return GridQid(row, col, dimension=self.dimension)
+        return GridQid(row, col, dimension=self._dimension)
 
     @staticmethod
     def square(diameter: int, top: int = 0, left: int = 0, *, dimension: int) -> List['GridQid']:
@@ -290,16 +328,16 @@ class GridQid(_BaseGridQid):
         return [GridQid(*c, dimension=dimension) for c in coords]
 
     def __repr__(self) -> str:
-        return f"cirq.GridQid({self._row}, {self._col}, dimension={self.dimension})"
+        return f"cirq.GridQid({self._row}, {self._col}, dimension={self._dimension})"
 
     def __str__(self) -> str:
-        return f"q({self._row}, {self._col}) (d={self.dimension})"
+        return f"q({self._row}, {self._col}) (d={self._dimension})"
 
     def _circuit_diagram_info_(
         self, args: 'cirq.CircuitDiagramInfoArgs'
     ) -> 'cirq.CircuitDiagramInfo':
         return protocols.CircuitDiagramInfo(
-            wire_symbols=(f"({self._row}, {self._col}) (d={self.dimension})",)
+            wire_symbols=(f"({self._row}, {self._col}) (d={self._dimension})",)
         )
 
     def _json_dict_(self) -> Dict[str, Any]:
@@ -325,17 +363,32 @@ class GridQubit(_BaseGridQid):
 
     _dimension = 2
 
-    def __init__(self, row: int, col: int) -> None:
-        self._row = row
-        self._col = col
+    # Cache of existing GridQubit instances, returned by __new__ if available.
+    # Holds weak references so instances can still be garbage collected.
+    _cache = weakref.WeakValueDictionary[Tuple[int, int], 'cirq.GridQubit']()
 
-    def _with_row_col(self, row: int, col: int):
-        return GridQubit(row, col)
+    def __new__(cls, row: int, col: int) -> 'cirq.GridQubit':
+        """Creates a grid qubit at the given row, col coordinate
 
-    def _cmp_tuple(self):
-        cls = GridQid if type(self) is GridQubit else type(self)
-        # Must be same as Qid._cmp_tuple but with cls in place of type(self).
-        return (cls.__name__, repr(cls), self._comparison_key(), self.dimension)
+        Args:
+            row: the row coordinate
+            col: the column coordinate
+        """
+        key = (row, col)
+        inst = cls._cache.get(key)
+        if inst is None:
+            inst = super().__new__(cls)
+            inst._row = row
+            inst._col = col
+            cls._cache[key] = inst
+        return inst
+
+    def __getnewargs__(self):
+        """Returns a tuple of args to pass to __new__ when unpickling."""
+        return (self._row, self._col)
+
+    def _with_row_col(self, row: int, col: int) -> 'GridQubit':
+        return GridQubit(row, col)
 
     @staticmethod
     def square(diameter: int, top: int = 0, left: int = 0) -> List['GridQubit']:

cirq/devices/grid_qubit_test.py

@@ -40,11 +40,29 @@ def test_eq():
     eq.make_equality_group(lambda: cirq.GridQid(0, 0, dimension=3))
 
 
-def test_pickled_hash():
-    q = cirq.GridQubit(3, 4)
-    q_bad = cirq.GridQubit(3, 4)
+def test_grid_qubit_pickled_hash():
+    # Use a large number that is unlikely to be used by any other tests.
+    row, col = 123456789, 2345678910
+    q_bad = cirq.GridQubit(row, col)
+    cirq.GridQubit._cache.pop((row, col))
+    q = cirq.GridQubit(row, col)
+    _test_qid_pickled_hash(q, q_bad)
+
+
+def test_grid_qid_pickled_hash():
+    # Use a large number that is unlikely to be used by any other tests.
+    row, col = 123456789, 2345678910
+    q_bad = cirq.GridQid(row, col, dimension=3)
+    cirq.GridQid._cache.pop((row, col, 3))
+    q = cirq.GridQid(row, col, dimension=3)
+    _test_qid_pickled_hash(q, q_bad)
+
+
+def _test_qid_pickled_hash(q: 'cirq.Qid', q_bad: 'cirq.Qid') -> None:
+    """Test that hashes are not pickled with Qid instances."""
+    assert q_bad is not q
     _ = hash(q_bad)  # compute hash to ensure it is cached.
-    q_bad._hash = q_bad._hash + 1
+    q_bad._hash = q_bad._hash + 1  # type: ignore[attr-defined]
     assert q_bad == q
     assert hash(q_bad) != hash(q)
     data = pickle.dumps(q_bad)

cirq/devices/line_qubit.py

@@ -14,7 +14,8 @@
 
 import abc
 import functools
-from typing import Any, Dict, Iterable, List, Optional, Sequence, Set, TYPE_CHECKING, Union
+import weakref
+from typing import Any, Dict, Iterable, List, Optional, Sequence, Set, Tuple, TYPE_CHECKING, Union
 from typing_extensions import Self
 
 from cirq import ops, protocols
@@ -31,31 +32,57 @@ class _BaseLineQid(ops.Qid):
     _dimension: int
     _hash: Optional[int] = None
 
-    def __getstate__(self):
-        # Don't save hash when pickling; see #3777.
-        state = self.__dict__
-        if "_hash" in state:
-            state = state.copy()
-            del state["_hash"]
-        return state
-
     def __hash__(self) -> int:
         if self._hash is None:
             self._hash = hash((self._x, self._dimension))
         return self._hash
 
-    def __eq__(self, other):
+    def __eq__(self, other) -> bool:
         # Explicitly implemented for performance (vs delegating to Qid).
         if isinstance(other, _BaseLineQid):
-            return self._x == other._x and self._dimension == other._dimension
+            return self is other or (self._x == other._x and self._dimension == other._dimension)
         return NotImplemented
 
-    def __ne__(self, other):
+    def __ne__(self, other) -> bool:
         # Explicitly implemented for performance (vs delegating to Qid).
         if isinstance(other, _BaseLineQid):
-            return self._x != other._x or self._dimension != other._dimension
+            return self is not other and (
+                self._x != other._x or self._dimension != other._dimension
+            )
         return NotImplemented
 
+    def __lt__(self, other) -> bool:
+        # Explicitly implemented for performance (vs delegating to Qid).
+        if isinstance(other, _BaseLineQid):
+            return self._x < other._x or (
+                self._x == other._x and self._dimension < other._dimension
+            )
+        return super().__lt__(other)
+
+    def __le__(self, other) -> bool:
+        # Explicitly implemented for performance (vs delegating to Qid).
+        if isinstance(other, _BaseLineQid):
+            return self._x < other._x or (
+                self._x == other._x and self._dimension <= other._dimension
+            )
+        return super().__le__(other)
+
+    def __ge__(self, other) -> bool:
+        # Explicitly implemented for performance (vs delegating to Qid).
+        if isinstance(other, _BaseLineQid):
+            return self._x > other._x or (
+                self._x == other._x and self._dimension >= other._dimension
+            )
+        return super().__ge__(other)
+
+    def __gt__(self, other) -> bool:
+        # Explicitly implemented for performance (vs delegating to Qid).
+        if isinstance(other, _BaseLineQid):
+            return self._x > other._x or (
+                self._x == other._x and self._dimension > other._dimension
+            )
+        return super().__gt__(other)
+
     def _comparison_key(self):
         return self._x
 
@@ -154,7 +181,11 @@ class LineQid(_BaseLineQid):
 
     """
 
-    def __init__(self, x: int, dimension: int) -> None:
+    # Cache of existing LineQid instances, returned by __new__ if available.
+    # Holds weak references so instances can still be garbage collected.
+    _cache = weakref.WeakValueDictionary[Tuple[int, int], 'cirq.LineQid']()
+
+    def __new__(cls, x: int, dimension: int) -> 'cirq.LineQid':
         """Initializes a line qid at the given x coordinate.
 
         Args:
@@ -162,9 +193,19 @@ class LineQid(_BaseLineQid):
             dimension: The dimension of the qid's Hilbert space, i.e.
                 the number of quantum levels.
         """
-        self.validate_dimension(dimension)
-        self._x = x
-        self._dimension = dimension
+        key = (x, dimension)
+        inst = cls._cache.get(key)
+        if inst is None:
+            cls.validate_dimension(dimension)
+            inst = super().__new__(cls)
+            inst._x = x
+            inst._dimension = dimension
+            cls._cache[key] = inst
+        return inst
+
+    def __getnewargs__(self):
+        """Returns a tuple of args to pass to __new__ when unpickling."""
+        return (self._x, self._dimension)
 
     def _with_x(self, x: int) -> 'LineQid':
         return LineQid(x, dimension=self._dimension)
@@ -246,23 +287,30 @@ class LineQubit(_BaseLineQid):
 
     _dimension = 2
 
-    def __init__(self, x: int) -> None:
-        """Initializes a line qubit at the given x coordinate.
+    # Cache of existing LineQubit instances, returned by __new__ if available.
+    # Holds weak references so instances can still be garbage collected.
+    _cache = weakref.WeakValueDictionary[int, 'cirq.LineQubit']()
+
+    def __new__(cls, x: int) -> 'cirq.LineQubit':
+        """Initializes a line qid at the given x coordinate.
 
         Args:
             x: The x coordinate.
         """
-        self._x = x
+        inst = cls._cache.get(x)
+        if inst is None:
+            inst = super().__new__(cls)
+            inst._x = x
+            cls._cache[x] = inst
+        return inst
+
+    def __getnewargs__(self):
+        """Returns a tuple of args to pass to __new__ when unpickling."""
+        return (self._x,)
 
     def _with_x(self, x: int) -> 'LineQubit':
         return LineQubit(x)
 
-    def _cmp_tuple(self):
-        cls = LineQid if type(self) is LineQubit else type(self)
-        # Must be the same as Qid._cmp_tuple but with cls in place of
-        # type(self).
-        return (cls.__name__, repr(cls), self._comparison_key(), self._dimension)
-
     @staticmethod
     def range(*range_args) -> List['LineQubit']:
         """Returns a range of line qubits.

cirq/devices/line_qubit_test.py

@@ -15,6 +15,7 @@
 import pytest
 
 import cirq
+from cirq.devices.grid_qubit_test import _test_qid_pickled_hash
 
 
 def test_init():
@@ -67,6 +68,24 @@ def test_cmp_failure():
         _ = cirq.LineQid(1, 3) < 0
 
 
+def test_line_qubit_pickled_hash():
+    # Use a large number that is unlikely to be used by any other tests.
+    x = 1234567891011
+    q_bad = cirq.LineQubit(x)
+    cirq.LineQubit._cache.pop(x)
+    q = cirq.LineQubit(x)
+    _test_qid_pickled_hash(q, q_bad)
+
+
+def test_line_qid_pickled_hash():
+    # Use a large number that is unlikely to be used by any other tests.
+    x = 1234567891011
+    q_bad = cirq.LineQid(x, dimension=3)
+    cirq.LineQid._cache.pop((x, 3))
+    q = cirq.LineQid(x, dimension=3)
+    _test_qid_pickled_hash(q, q_bad)
+
+
 def test_is_adjacent():
     assert cirq.LineQubit(1).is_adjacent(cirq.LineQubit(2))
     assert cirq.LineQubit(1).is_adjacent(cirq.LineQubit(0))

cirq/devices/noise_utils.py

@@ -13,10 +13,9 @@
 # limitations under the License.
 
 from typing import TYPE_CHECKING, Any, Dict, Tuple, Type, Union
-import numpy as np
 
-from cirq import ops, protocols, value
-from cirq._compat import proper_repr
+from cirq import ops, protocols, value, qis
+from cirq._compat import proper_repr, deprecated
 
 if TYPE_CHECKING:
     import cirq
@@ -97,8 +96,10 @@ class OpIdentifier:
         return cls(gate_type, *qubits)
 
 
-# TODO: expose all from top-level cirq?
-def decay_constant_to_xeb_fidelity(decay_constant: float, num_qubits: int = 2) -> float:
+@deprecated(deadline='v2.0', fix='use cirq.qis.decay_constant_to_xeb_fidelity')
+def decay_constant_to_xeb_fidelity(
+    decay_constant: float, num_qubits: int = 2
+) -> float:  # pragma: no cover
     """Calculates the XEB fidelity from the depolarization decay constant.
 
     Args:
@@ -108,11 +109,13 @@ def decay_constant_to_xeb_fidelity(decay_constant: float, num_qubits: int = 2) -
     Returns:
         Calculated XEB fidelity.
     """
-    N = 2**num_qubits
-    return 1 - ((1 - decay_constant) * (1 - 1 / N))
+    return qis.decay_constant_to_xeb_fidelity(decay_constant, num_qubits)
 
 
-def decay_constant_to_pauli_error(decay_constant: float, num_qubits: int = 1) -> float:
+@deprecated(deadline='v2.0', fix='use cirq.qis.decay_constant_to_pauli_error')
+def decay_constant_to_pauli_error(
+    decay_constant: float, num_qubits: int = 1
+) -> float:  # pragma: no cover
     """Calculates pauli error from the depolarization decay constant.
 
     Args:
@@ -122,11 +125,13 @@ def decay_constant_to_pauli_error(decay_constant: float, num_qubits: int = 1) ->
     Returns:
         Calculated Pauli error.
     """
-    N = 2**num_qubits
-    return (1 - decay_constant) * (1 - 1 / N / N)
+    return qis.decay_constant_to_pauli_error(decay_constant, num_qubits)
 
 
-def pauli_error_to_decay_constant(pauli_error: float, num_qubits: int = 1) -> float:
+@deprecated(deadline='v2.0', fix='use cirq.qis.pauli_error_to_decay_constant')
+def pauli_error_to_decay_constant(
+    pauli_error: float, num_qubits: int = 1
+) -> float:  # pragma: no cover
     """Calculates depolarization decay constant from pauli error.
 
     Args:
@@ -136,11 +141,13 @@ def pauli_error_to_decay_constant(pauli_error: float, num_qubits: int = 1) -> fl
     Returns:
         Calculated depolarization decay constant.
     """
-    N = 2**num_qubits
-    return 1 - (pauli_error / (1 - 1 / N / N))
+    return qis.pauli_error_to_decay_constant(pauli_error, num_qubits)
 
 
-def xeb_fidelity_to_decay_constant(xeb_fidelity: float, num_qubits: int = 2) -> float:
+@deprecated(deadline='v2.0', fix='use cirq.qis.xeb_fidelity_to_decay_constant')
+def xeb_fidelity_to_decay_constant(
+    xeb_fidelity: float, num_qubits: int = 2
+) -> float:  # pragma: no cover
     """Calculates the depolarization decay constant from XEB fidelity.
 
     Args:
@@ -150,11 +157,11 @@ def xeb_fidelity_to_decay_constant(xeb_fidelity: float, num_qubits: int = 2) ->
     Returns:
         Calculated depolarization decay constant.
     """
-    N = 2**num_qubits
-    return 1 - (1 - xeb_fidelity) / (1 - 1 / N)
+    return qis.xeb_fidelity_to_decay_constant(xeb_fidelity, num_qubits)
 
 
-def pauli_error_from_t1(t_ns: float, t1_ns: float) -> float:
+@deprecated(deadline='v2.0', fix='use cirq.qis.pauli_error_from_t1')
+def pauli_error_from_t1(t_ns: float, t1_ns: float) -> float:  # pragma: no cover
     """Calculates the pauli error from T1 decay constant.
 
     This computes error for a specific duration, `t`.
@@ -166,11 +173,11 @@ def pauli_error_from_t1(t_ns: float, t1_ns: float) -> float:
     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
+    return qis.pauli_error_from_t1(t_ns, t1_ns)
 
 
-def average_error(decay_constant: float, num_qubits: int = 1) -> float:
+@deprecated(deadline='v2.0', fix='use cirq.qis.average_error')
+def average_error(decay_constant: float, num_qubits: int = 1) -> float:  # pragma: no cover
     """Calculates the average error from the depolarization decay constant.
 
     Args:
@@ -180,11 +187,13 @@ def average_error(decay_constant: float, num_qubits: int = 1) -> float:
     Returns:
         Calculated average error.
     """
-    N = 2**num_qubits
-    return (1 - decay_constant) * (1 - 1 / N)
+    return qis.average_error(decay_constant, num_qubits)
 
 
-def decoherence_pauli_error(t1_ns: float, tphi_ns: float, gate_time_ns: float) -> float:
+@deprecated(deadline='v2.0', fix='use cirq.qis.decoherence_pauli_error')
+def decoherence_pauli_error(
+    t1_ns: float, tphi_ns: float, gate_time_ns: float
+) -> float:  # pragma: no cover
     """The component of Pauli error caused by decoherence on a single qubit.
 
     Args:
@@ -195,11 +204,4 @@ def decoherence_pauli_error(t1_ns: float, tphi_ns: float, gate_time_ns: float) -
     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
+    return qis.decoherence_pauli_error(t1_ns, tphi_ns, gate_time_ns)

cirq/devices/noise_utils_test.py

@@ -12,20 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import numpy as np
-import pytest
-
 import cirq
-from cirq.devices.noise_utils import (
-    OpIdentifier,
-    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,
-)
+from cirq.devices.noise_utils import OpIdentifier
 
 
 def test_op_identifier():
@@ -67,74 +55,3 @@ def test_op_id_instance():
     gate = cirq.SingleQubitCliffordGate.from_xz_map((cirq.X, False), (cirq.Z, False))
     op_id = OpIdentifier(gate, q0)
     cirq.testing.assert_equivalent_repr(op_id)
-
-
-@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