cirq-core 1.4.0.dev20240529225110__py3-none-any.whl → 1.5.0__py3-none-any.whl

cirq/protocols/json_test_data/sympy.Indexed.repr

@@ -0,0 +1 @@
+sympy.Indexed(sympy.IndexedBase(sympy.Symbol('s')),sympy.Integer(1))

cirq/protocols/json_test_data/sympy.IndexedBase.json

@@ -0,0 +1,9 @@
+{
+  "cirq_type": "sympy.IndexedBase",
+  "args": [
+    {
+      "cirq_type": "sympy.Symbol",
+      "name": "s"
+    }
+  ]
+}

cirq/protocols/json_test_data/sympy.IndexedBase.repr

@@ -0,0 +1 @@
+sympy.IndexedBase(sympy.Symbol('s'))

cirq/protocols/json_test_data/sympy.Not.json

@@ -0,0 +1,9 @@
+{
+  "cirq_type": "sympy.Not",
+  "args": [
+    {
+      "cirq_type": "sympy.Symbol",
+      "name": "s"
+    }
+  ]
+}

cirq/protocols/json_test_data/sympy.Not.repr

@@ -0,0 +1 @@
+sympy.Not(sympy.Symbol('s'))

cirq/protocols/json_test_data/sympy.Or.json

@@ -0,0 +1,13 @@
+{
+  "cirq_type": "sympy.Or",
+  "args": [
+    {
+      "cirq_type": "sympy.Symbol",
+      "name": "s"
+    },
+    {
+      "cirq_type": "sympy.Symbol",
+      "name": "t"
+    }
+  ]
+}

cirq/protocols/json_test_data/sympy.Or.repr

@@ -0,0 +1 @@
+sympy.Or(sympy.Symbol('s'), sympy.Symbol('t'))

cirq/protocols/json_test_data/sympy.Xor.json

@@ -0,0 +1,13 @@
+{
+  "cirq_type": "sympy.Xor",
+  "args": [
+    {
+      "cirq_type": "sympy.Symbol",
+      "name": "s"
+    },
+    {
+      "cirq_type": "sympy.Symbol",
+      "name": "t"
+    }
+  ]
+}

cirq/protocols/json_test_data/sympy.Xor.repr

@@ -0,0 +1 @@
+sympy.Xor(sympy.Symbol('s'), sympy.Symbol('t'))

cirq/protocols/kraus_protocol.py

@@ -14,8 +14,9 @@
 
 """Protocol and methods for obtaining Kraus representation of quantum channels."""
 
-from typing import Any, Sequence, Tuple, TypeVar, Union
 import warnings
+from types import NotImplementedType
+from typing import Any, Sequence, Tuple, TypeVar, Union
 
 import numpy as np
 from typing_extensions import Protocol
@@ -23,10 +24,7 @@ from typing_extensions import Protocol
 from cirq._doc import doc_private
 from cirq.protocols.decompose_protocol import _try_decompose_into_operations_and_qubits
 from cirq.protocols.mixture_protocol import has_mixture
-
-
-from cirq.type_workarounds import NotImplementedType
-
+from cirq.protocols.unitary_protocol import unitary
 
 # This is a special indicator value used by the channel method to determine
 # whether or not the caller provided a 'default' argument. It must be of type
@@ -135,7 +133,7 @@ def kraus(
     """
     channel_getter = getattr(val, '_channel_', None)
     if channel_getter is not None:
-        warnings.warn(
+        warnings.warn(  # pragma: no cover
             '_channel_ is deprecated and will be removed in cirq 0.13, rename to _kraus_',
             DeprecationWarning,
         )
@@ -148,7 +146,9 @@ def kraus(
     mixture_getter = getattr(val, '_mixture_', None)
     mixture_result = NotImplemented if mixture_getter is None else mixture_getter()
     if mixture_result is not NotImplemented and mixture_result is not None:
-        return tuple(np.sqrt(p) * u for p, u in mixture_result)
+        return tuple(
+            np.sqrt(p) * (u if isinstance(u, np.ndarray) else unitary(u)) for p, u in mixture_result
+        )
 
     unitary_getter = getattr(val, '_unitary_', None)
     unitary_result = NotImplemented if unitary_getter is None else unitary_getter()
@@ -157,7 +157,7 @@ def kraus(
 
     channel_result = NotImplemented if channel_getter is None else channel_getter()
     if channel_result is not NotImplemented:
-        return tuple(channel_result)
+        return tuple(channel_result)  # pragma: no cover
 
     if default is not RaiseTypeErrorIfNotProvided:
         return default

cirq/protocols/kraus_protocol_test.py

@@ -21,7 +21,6 @@ import pytest
 
 import cirq
 
-
 LOCAL_DEFAULT: List[np.ndarray] = [np.array([])]
 
 

cirq/protocols/measurement_key_protocol.py

@@ -13,13 +13,13 @@
 # limitations under the License.
 """Protocol for object that have measurement keys."""
 
+from types import NotImplementedType
 from typing import Any, FrozenSet, Mapping, Optional, Tuple, TYPE_CHECKING, Union
 
 from typing_extensions import Protocol
 
 from cirq import value
 from cirq._doc import doc_private
-from cirq.type_workarounds import NotImplementedType
 
 if TYPE_CHECKING:
     import cirq

cirq/protocols/measurement_key_protocol_test.py

@@ -104,7 +104,7 @@ def test_is_measurement():
 
         @property
         def qubits(self):
-            return cirq.LineQubit.range(2)
+            return cirq.LineQubit.range(2)  # pragma: no cover
 
     assert not cirq.is_measurement(NotImplementedOperation())
 
@@ -123,27 +123,27 @@ def test_measurement_without_key():
 def test_non_measurement_with_key():
     class NonMeasurementGate(cirq.Gate):
         def _is_measurement_(self):
-            return False
+            return False  # pragma: no cover
 
         def _decompose_(self, qubits):
             # Decompose should not be called by `is_measurement`
-            assert False
+            assert False  # pragma: no cover
 
         def _measurement_key_name_(self):
             # `measurement_key_name`` should not be called by `is_measurement`
-            assert False
+            assert False  # pragma: no cover
 
         def _measurement_key_names_(self):
             # `measurement_key_names`` should not be called by `is_measurement`
-            assert False
+            assert False  # pragma: no cover
 
         def _measurement_key_obj_(self):
             # `measurement_key_obj`` should not be called by `is_measurement`
-            assert False
+            assert False  # pragma: no cover
 
         def _measurement_key_objs_(self):
             # `measurement_key_objs`` should not be called by `is_measurement`
-            assert False
+            assert False  # pragma: no cover
 
         def num_qubits(self) -> int:
             return 2  # pragma: no cover

cirq/protocols/mixture_protocol.py

@@ -13,6 +13,8 @@
 # limitations under the License.
 
 """Protocol for objects that are mixtures (probabilistic combinations)."""
+
+from types import NotImplementedType
 from typing import Any, Sequence, Tuple, Union
 
 import numpy as np
@@ -21,7 +23,7 @@ from typing_extensions import Protocol
 from cirq._doc import doc_private
 from cirq.protocols.decompose_protocol import _try_decompose_into_operations_and_qubits
 from cirq.protocols.has_unitary_protocol import has_unitary
-from cirq.type_workarounds import NotImplementedType
+from cirq.protocols.unitary_protocol import unitary
 
 # This is a special indicator value used by the inverse method to determine
 # whether or not the caller provided a 'default' argument.
@@ -83,14 +85,14 @@ def mixture(
         with that probability in the mixture. The probabilities will sum to 1.0.
 
     Raises:
-        TypeError: If `val` has no `_mixture_` or `_unitary_` mehod, or if it
+        TypeError: If `val` has no `_mixture_` or `_unitary_` method, or if it
             does and this method returned `NotImplemented`.
     """
 
     mixture_getter = getattr(val, '_mixture_', None)
     result = NotImplemented if mixture_getter is None else mixture_getter()
-    if result is not NotImplemented:
-        return result
+    if result is not NotImplemented and result is not None:
+        return tuple((p, u if isinstance(u, np.ndarray) else unitary(u)) for p, u in result)
 
     unitary_getter = getattr(val, '_unitary_', None)
     result = NotImplemented if unitary_getter is None else unitary_getter()

cirq/protocols/mixture_protocol_test.py

@@ -12,12 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import pytest
-
 import numpy as np
+import pytest
 
 import cirq
 
+a = np.array([1])
+b = np.array([1j])
+
 
 class NoMethod:
     pass
@@ -33,7 +35,7 @@ class ReturnsNotImplemented:
 
 class ReturnsValidTuple(cirq.SupportsMixture):
     def _mixture_(self):
-        return ((0.4, 'a'), (0.6, 'b'))
+        return ((0.4, a), (0.6, b))
 
     def _has_mixture_(self):
         return True
@@ -41,27 +43,27 @@ class ReturnsValidTuple(cirq.SupportsMixture):
 
 class ReturnsNonnormalizedTuple:
     def _mixture_(self):
-        return ((0.4, 'a'), (0.4, 'b'))
+        return ((0.4, a), (0.4, b))
 
 
 class ReturnsNegativeProbability:
     def _mixture_(self):
-        return ((0.4, 'a'), (-0.4, 'b'))
+        return ((0.4, a), (-0.4, b))
 
 
 class ReturnsGreaterThanUnityProbability:
     def _mixture_(self):
-        return ((1.2, 'a'), (0.4, 'b'))
+        return ((1.2, a), (0.4, b))
 
 
 class ReturnsMixtureButNoHasMixture:
     def _mixture_(self):
-        return ((0.4, 'a'), (0.6, 'b'))
+        return ((0.4, a), (0.6, b))
 
 
 class ReturnsUnitary:
     def _unitary_(self):
-        return np.ones((2, 2))
+        return np.eye(2)
 
     def _has_unitary_(self):
         return True
@@ -75,12 +77,18 @@ class ReturnsNotImplementedUnitary:
         return NotImplemented
 
 
+class ReturnsMixtureOfReturnsUnitary:
+    def _mixture_(self):
+        return ((0.4, ReturnsUnitary()), (0.6, ReturnsUnitary()))
+
+
 @pytest.mark.parametrize(
     'val,mixture',
     (
-        (ReturnsValidTuple(), ((0.4, 'a'), (0.6, 'b'))),
-        (ReturnsNonnormalizedTuple(), ((0.4, 'a'), (0.4, 'b'))),
-        (ReturnsUnitary(), ((1.0, np.ones((2, 2))),)),
+        (ReturnsValidTuple(), ((0.4, a), (0.6, b))),
+        (ReturnsNonnormalizedTuple(), ((0.4, a), (0.4, b))),
+        (ReturnsUnitary(), ((1.0, np.eye(2)),)),
+        (ReturnsMixtureOfReturnsUnitary(), ((0.4, np.eye(2)), (0.6, np.eye(2)))),
     ),
 )
 def test_objects_with_mixture(val, mixture):
@@ -89,7 +97,7 @@ def test_objects_with_mixture(val, mixture):
     np.testing.assert_almost_equal(keys, expected_keys)
     np.testing.assert_equal(values, expected_values)
 
-    keys, values = zip(*cirq.mixture(val, ((0.3, 'a'), (0.7, 'b'))))
+    keys, values = zip(*cirq.mixture(val, ((0.3, a), (0.7, b))))
     np.testing.assert_almost_equal(keys, expected_keys)
     np.testing.assert_equal(values, expected_values)
 
@@ -102,7 +110,7 @@ def test_objects_with_no_mixture(val):
         _ = cirq.mixture(val)
     assert cirq.mixture(val, None) is None
     assert cirq.mixture(val, NotImplemented) is NotImplemented
-    default = ((0.4, 'a'), (0.6, 'b'))
+    default = ((0.4, a), (0.6, b))
     assert cirq.mixture(val, default) == default
 
 

cirq/protocols/pauli_expansion_protocol.py

@@ -14,6 +14,7 @@
 """Protocol for obtaining expansion of linear operators in Pauli basis."""
 
 from typing import Any, TypeVar, Union
+
 from typing_extensions import Protocol
 
 from cirq import value

cirq/protocols/pow_protocol.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Callable, Optional, overload, TypeVar, TYPE_CHECKING, Union
+from typing import Any, Callable, Optional, overload, TYPE_CHECKING, TypeVar, Union
 
 if TYPE_CHECKING:
     import cirq

cirq/protocols/qasm.py

@@ -13,13 +13,13 @@
 # limitations under the License.
 
 import string
-from typing import TYPE_CHECKING, Union, Any, Tuple, TypeVar, Optional, Dict, Iterable
+from types import NotImplementedType
+from typing import Any, Dict, Iterable, Optional, Tuple, TYPE_CHECKING, TypeVar, Union
 
 from typing_extensions import Protocol
 
 from cirq import ops
 from cirq._doc import doc_private
-from cirq.type_workarounds import NotImplementedType
 
 if TYPE_CHECKING:
     import cirq
@@ -38,6 +38,7 @@ class QasmArgs(string.Formatter):
         version: str = '2.0',
         qubit_id_map: Optional[Dict['cirq.Qid', str]] = None,
         meas_key_id_map: Optional[Dict[str, str]] = None,
+        meas_key_bitcount: Optional[Dict[str, int]] = None,
     ) -> None:
         """Inits QasmArgs.
 
@@ -49,11 +50,21 @@ class QasmArgs(string.Formatter):
             qubit_id_map: A dictionary mapping qubits to qreg QASM identifiers.
             meas_key_id_map: A dictionary mapping measurement keys to creg QASM
                 identifiers.
+            meas_key_bitcount: A dictionary with of bits for each measurement
+                key.
         """
         self.precision = precision
         self.version = version
         self.qubit_id_map = {} if qubit_id_map is None else qubit_id_map
         self.meas_key_id_map = {} if meas_key_id_map is None else meas_key_id_map
+        self.meas_key_bitcount = {} if meas_key_bitcount is None else meas_key_bitcount
+
+    def _format_number(self, value) -> str:
+        """OpenQASM 2.0 does not support '1e-5' and wants '1.0e-5'"""
+        s = f'{value}'
+        if 'e' in s and not '.' in s:
+            return s.replace('e', '.0e')
+        return s
 
     def format_field(self, value: Any, spec: str) -> str:
         """Method of string.Formatter that specifies the output of format()."""
@@ -61,8 +72,10 @@ class QasmArgs(string.Formatter):
             if isinstance(value, float):
                 value = round(value, self.precision)
             if spec == 'half_turns':
-                value = f'pi*{value}' if value != 0 else '0'
+                value = f'pi*{self._format_number(value)}' if value != 0 else '0'
                 spec = ''
+            else:
+                value = self._format_number(value)
         elif isinstance(value, ops.Qid):
             value = self.qubit_id_map[value]
         elif isinstance(value, str) and spec == 'meas':
@@ -138,7 +151,7 @@ def qasm(
             involving qubits that the operation wouldn't otherwise know about.
         qubits: A list of qubits that the value is being applied to. This is
             needed for `cirq.Gate` values, which otherwise wouldn't know what
-            qubits to talk about.
+            qubits to talk about.  It should generally not be specified otherwise.
         default: A default result to use if the value doesn't have a
             `_qasm_` method or that method returns `NotImplemented` or `None`.
             If not specified, non-decomposable values cause a `TypeError`.
@@ -159,10 +172,16 @@ def qasm(
         kwargs: Dict[str, Any] = {}
         if args is not None:
             kwargs['args'] = args
+        # pylint: disable=not-callable
         if qubits is not None:
             kwargs['qubits'] = tuple(qubits)
-        # pylint: disable=not-callable
-        result = method(**kwargs)
+        try:
+            result = method(**kwargs)
+        except TypeError as error:
+            raise TypeError(
+                "cirq.qasm does not expect qubits or args to be specified"
+                f"for the given value of type {type(val)}."
+            ) from error
         # pylint: enable=not-callable
     if result is not None and result is not NotImplemented:
         return result

cirq/protocols/qasm_test.py

@@ -52,3 +52,20 @@ def test_qasm():
 
     assert cirq.qasm(ExpectsArgs(), args=cirq.QasmArgs()) == 'text'
     assert cirq.qasm(ExpectsArgsQubits(), args=cirq.QasmArgs(), qubits=()) == 'text'
+
+
+def test_qasm_qubits_improperly_supplied():
+    with pytest.raises(TypeError, match="does not expect qubits or args to be specified"):
+        _ = cirq.qasm(cirq.Circuit(), qubits=[cirq.LineQubit(1)])
+
+
+def test_qasm_args_formatting():
+    args = cirq.QasmArgs()
+    assert args.format_field(0.01, '') == '0.01'
+    assert args.format_field(0.01, 'half_turns') == 'pi*0.01'
+    assert args.format_field(0.00001, '') == '1.0e-05'
+    assert args.format_field(0.00001, 'half_turns') == 'pi*1.0e-05'
+    assert args.format_field(1e-10, 'half_turns') == 'pi*1.0e-10'
+    args = cirq.QasmArgs(precision=6)
+    assert args.format_field(0.00001234, '') == '1.2e-05'
+    assert args.format_field(0.00001234, 'half_turns') == 'pi*1.2e-05'

cirq/protocols/qid_shape_protocol.py

@@ -12,13 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from types import NotImplementedType
 from typing import Any, Sequence, Tuple, TypeVar, Union
 
 from typing_extensions import Protocol
 
 from cirq import ops
-from cirq._doc import document, doc_private
-from cirq.type_workarounds import NotImplementedType
+from cirq._doc import doc_private, document
 
 # This is a special indicator value used by the methods to determine whether or
 # not the caller provided a 'default' argument. It must be of type

cirq/protocols/resolve_parameters.py

@@ -14,10 +14,9 @@
 
 import numbers
 from typing import AbstractSet, Any, cast, TYPE_CHECKING, TypeVar
-from typing_extensions import Self
 
 import sympy
-from typing_extensions import Protocol
+from typing_extensions import Protocol, Self
 
 from cirq import study
 from cirq._doc import doc_private
@@ -68,7 +67,7 @@ def is_parameterized(val: Any) -> bool:
 
     A value is parameterized when it has an `_is_parameterized_` method and
     that method returns a truthy value, or if the value is an instance of
-    sympy.Basic.
+    sympy.Basic. Note this covers sympy constants such as `sympy.pi`.
 
     Returns:
         True if the gate has any unresolved Symbols

cirq/protocols/resolve_parameters_test.py

@@ -12,7 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import pytest, sympy
+import pytest
+import sympy
 
 import cirq
 from cirq.study import ParamResolver

cirq/protocols/trace_distance_bound.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, TypeVar, Optional, Sequence, Union
+from typing import Any, Optional, Sequence, TypeVar, Union
 
 import numpy as np
 from typing_extensions import Protocol

cirq/protocols/trace_distance_bound_test.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 import numpy as np
+
 import cirq
 
 

cirq/protocols/unitary_protocol.py

@@ -12,16 +12,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, TypeVar, Union, Optional
+from types import NotImplementedType
+from typing import Any, Optional, TypeVar, Union
 
 import numpy as np
 from typing_extensions import Protocol
 
 from cirq._doc import doc_private
 from cirq.protocols import qid_shape_protocol
-from cirq.protocols.apply_unitary_protocol import ApplyUnitaryArgs, apply_unitaries
+from cirq.protocols.apply_unitary_protocol import apply_unitaries, ApplyUnitaryArgs
 from cirq.protocols.decompose_protocol import _try_decompose_into_operations_and_qubits
-from cirq.type_workarounds import NotImplementedType
 
 # This is a special indicator value used by the unitary method to determine
 # whether or not the caller provided a 'default' argument. It must be of type

cirq/protocols/unitary_protocol_test.py

@@ -286,7 +286,7 @@ def test_unitary_from_apply_unitary():
 
     class UnknownType:
         def _apply_unitary_(self, args):
-            assert False
+            assert False  # pragma: no cover
 
     class ApplyGateNotUnitary(cirq.Gate):
         def num_qubits(self):

cirq/qis/__init__.py

@@ -15,48 +15,61 @@
 """Tools and methods for primitives used in quantum information science."""
 
 from cirq.qis.channels import (
-    choi_to_kraus,
-    choi_to_superoperator,
-    kraus_to_choi,
-    kraus_to_superoperator,
-    operation_to_choi,
-    operation_to_superoperator,
-    superoperator_to_choi,
-    superoperator_to_kraus,
+    choi_to_kraus as choi_to_kraus,
+    choi_to_superoperator as choi_to_superoperator,
+    kraus_to_choi as kraus_to_choi,
+    kraus_to_superoperator as kraus_to_superoperator,
+    operation_to_choi as operation_to_choi,
+    operation_to_superoperator as operation_to_superoperator,
+    superoperator_to_choi as superoperator_to_choi,
+    superoperator_to_kraus as superoperator_to_kraus,
 )
 
-from cirq.qis.clifford_tableau import CliffordTableau, StabilizerState
+from cirq.qis.clifford_tableau import (
+    CliffordTableau as CliffordTableau,
+    StabilizerState as StabilizerState,
+)
 
-from cirq.qis.measures import entanglement_fidelity, fidelity, von_neumann_entropy
+from cirq.qis.measures import (
+    entanglement_fidelity as entanglement_fidelity,
+    fidelity as fidelity,
+    von_neumann_entropy as von_neumann_entropy,
+)
 
-from cirq.qis.quantum_state_representation import QuantumStateRepresentation
+from cirq.qis.quantum_state_representation import (
+    QuantumStateRepresentation as QuantumStateRepresentation,
+)
 
 from cirq.qis.states import (
-    bloch_vector_from_state_vector,
-    density_matrix,
-    density_matrix_from_state_vector,
-    dirac_notation,
-    eye_tensor,
-    infer_qid_shape,
-    one_hot,
-    QUANTUM_STATE_LIKE,
-    QuantumState,
-    quantum_state,
-    STATE_VECTOR_LIKE,
-    to_valid_density_matrix,
-    to_valid_state_vector,
-    validate_density_matrix,
-    validate_indices,
-    validate_qid_shape,
-    validate_normalized_state_vector,
+    bloch_vector_from_state_vector as bloch_vector_from_state_vector,
+    density_matrix as density_matrix,
+    density_matrix_from_state_vector as density_matrix_from_state_vector,
+    dirac_notation as dirac_notation,
+    eye_tensor as eye_tensor,
+    infer_qid_shape as infer_qid_shape,
+    one_hot as one_hot,
+    QUANTUM_STATE_LIKE as QUANTUM_STATE_LIKE,
+    QuantumState as QuantumState,
+    quantum_state as quantum_state,
+    STATE_VECTOR_LIKE as STATE_VECTOR_LIKE,
+    to_valid_density_matrix as to_valid_density_matrix,
+    to_valid_state_vector as to_valid_state_vector,
+    validate_density_matrix as validate_density_matrix,
+    validate_indices as validate_indices,
+    validate_qid_shape as validate_qid_shape,
+    validate_normalized_state_vector as validate_normalized_state_vector,
 )
 
 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,
+    decay_constant_to_xeb_fidelity as decay_constant_to_xeb_fidelity,
+    decay_constant_to_pauli_error as decay_constant_to_pauli_error,
+    pauli_error_to_decay_constant as pauli_error_to_decay_constant,
+    xeb_fidelity_to_decay_constant as xeb_fidelity_to_decay_constant,
+    pauli_error_from_t1 as pauli_error_from_t1,
+    average_error as average_error,
+    decoherence_pauli_error as decoherence_pauli_error,
+)
+
+from cirq.qis.entropy import (
+    process_renyi_entropy_from_bitstrings as process_renyi_entropy_from_bitstrings,
 )

cirq/qis/channels_test.py

@@ -51,15 +51,6 @@ def compute_choi(channel: cirq.SupportsKraus) -> np.ndarray:
     return c
 
 
-def compute_superoperator(channel: cirq.SupportsKraus) -> np.ndarray:
-    ks = cirq.kraus(channel)
-    d_out, d_in = ks[0].shape
-    m = np.zeros((d_out * d_out, d_in * d_in), dtype=np.complex128)
-    for k, e_in in enumerate(generate_standard_operator_basis(d_in, d_in)):
-        m[:, k] = np.reshape(apply_channel(channel, e_in), d_out * d_out)
-    return m
-
-
 @pytest.mark.parametrize(
     'kraus_operators, expected_choi',
     (