Factor out ProjectorSum

Author: tonybruguier

cirq-core/cirq/__init__.py

@@ -251,7 +251,6 @@
     PhasedXZGate,
     PhaseFlipChannel,
     ProjectorString,
-    ProjectorSum,
     RandomGateChannel,
     qft,
     Qid,

cirq-core/cirq/json_resolver_cache.py

@@ -118,7 +118,6 @@ def two_qubit_matrix_gate(matrix):
         'PhasedXPowGate': cirq.PhasedXPowGate,
         'PhasedXZGate': cirq.PhasedXZGate,
         'ProjectorString': cirq.ProjectorString,
-        'ProjectorSum': cirq.ProjectorSum,
         'RandomGateChannel': cirq.RandomGateChannel,
         'QuantumFourierTransformGate': cirq.QuantumFourierTransformGate,
         'RepetitionsStoppingCriteria': cirq.work.RepetitionsStoppingCriteria,

cirq-core/cirq/ops/__init__.py

@@ -133,7 +133,6 @@
 
 from cirq.ops.projector import (
     ProjectorString,
-    ProjectorSum,
 )
 
 from cirq.ops.controlled_operation import (

cirq-core/cirq/ops/projector.py

@@ -1,16 +1,9 @@
-from collections import defaultdict
-import numbers
 from typing import (
     Any,
-    DefaultDict,
     Dict,
-    FrozenSet,
     Iterable,
-    List,
     Mapping,
     Optional,
-    Tuple,
-    Union,
 )
 
 import numpy as np
@@ -136,111 +129,3 @@ def _from_json_dict_(cls, projector_dict, **kwargs):
     def _value_equality_values_(self) -> Any:
         projector_dict = sorted(self._projector_dict.items())
         return tuple(projector_dict)
-
-
-def _projector_string_from_projector_dict(projector_dict):
-    return ProjectorString(dict(projector_dict))
-
-
-@value.value_equality(approximate=True)
-class ProjectorSum:
-    def __init__(self, linear_dict=None):
-        self._linear_dict = linear_dict if linear_dict is not None else {}
-
-    def _value_equality_values_(self):
-        return self._linear_dict
-
-    def _json_dict_(self) -> Dict[str, Any]:
-        linear_dict = []
-        for projector_dict, scalar in dict(self._linear_dict).items():
-            key = [[k, v] for k, v in dict(projector_dict).items()]
-            linear_dict.append([key, scalar])
-        return {
-            'cirq_type': self.__class__.__name__,
-            'linear_dict': linear_dict,
-        }
-
-    @classmethod
-    def _from_json_dict_(cls, linear_dict, **kwargs):
-        converted_dict = {}
-        for projector_string in linear_dict:
-            projector_dict = {x[0]: x[1] for x in projector_string[0]}
-            scalar = projector_string[1]
-            key = frozenset(projector_dict.items())
-            converted_dict[key] = scalar
-        return cls(linear_dict=value.LinearDict(converted_dict))
-
-    @classmethod
-    def from_projector_strings(
-        cls, terms: Union[ProjectorString, List[ProjectorString]]
-    ) -> 'ProjectorSum':
-        if isinstance(terms, ProjectorString):
-            terms = [terms]
-        termdict: DefaultDict[FrozenSet[Tuple[raw_types.Qid, int]], value.Scalar] = defaultdict(
-            lambda: 0.0
-        )
-        for pstring in terms:
-            key = frozenset(pstring._projector_dict.items())
-            termdict[key] += 1.0
-        return cls(linear_dict=value.LinearDict(termdict))
-
-    def copy(self) -> 'ProjectorSum':
-        return ProjectorSum(self._linear_dict.copy())
-
-    def matrix(self, projector_qids: Optional[Iterable[raw_types.Qid]] = None) -> np.ndarray:
-        return sum(
-            coeff * _projector_string_from_projector_dict(vec).matrix(projector_qids)
-            for vec, coeff in self._linear_dict.items()
-        )
-
-    def expectation_from_state_vector(
-        self,
-        state_vector: np.ndarray,
-        qid_map: Mapping[raw_types.Qid, int],
-        *,
-        atol: float = 1e-7,
-        check_preconditions: bool = True,
-    ) -> float:
-        return sum(
-            coeff
-            * _projector_string_from_projector_dict(vec).expectation_from_state_vector(
-                state_vector, qid_map
-            )
-            for vec, coeff in self._linear_dict.items()
-        )
-
-    def expectation_from_density_matrix(
-        self,
-        state: np.ndarray,
-        qid_map: Mapping[raw_types.Qid, int],
-        *,
-        atol: float = 1e-7,
-        check_preconditions: bool = True,
-    ) -> float:
-        return sum(
-            coeff
-            * _projector_string_from_projector_dict(vec).expectation_from_density_matrix(
-                state, qid_map
-            )
-            for vec, coeff in self._linear_dict.items()
-        )
-
-    def __iadd__(self, other: 'ProjectorSum'):
-        result = self.copy()
-        result._linear_dict += other._linear_dict
-        return result
-
-    def __add__(self, other: 'ProjectorSum'):
-        result = self.copy()
-        result += other
-        return result
-
-    def __imul__(self, other: numbers.Complex):
-        result = self.copy()
-        result._linear_dict *= other
-        return result
-
-    def __rmul__(self, other: numbers.Complex):
-        result = self.copy()
-        result *= other
-        return result

cirq-core/cirq/ops/projector_test.py

@@ -175,36 +175,3 @@ def test_expectation_from_density_matrix_basis_states_single_qubits():
     np.testing.assert_allclose(
         d.expectation_from_density_matrix(np.array([[0.0, 0.0], [0.0, 1.0]]), {q0: 0}), 0.0
     )
-
-
-def test_projector_sum_expectations():
-    q0 = cirq.NamedQubit('q0')
-
-    zero_projector = cirq.ProjectorSum.from_projector_strings(cirq.ProjectorString({q0: 0}))
-    one_projector = cirq.ProjectorSum.from_projector_strings(cirq.ProjectorString({q0: 1}))
-
-    proj_sum = 0.6 * zero_projector + 0.4 * one_projector
-    np.testing.assert_allclose(proj_sum.matrix(), [[0.6, 0.0], [0.0, 0.4]])
-    np.testing.assert_allclose(
-        proj_sum.expectation_from_state_vector(np.array([1.0, 0.0]), {q0: 0}), 0.6
-    )
-    np.testing.assert_allclose(
-        proj_sum.expectation_from_density_matrix(np.array([[1.0, 0.0], [0.0, 0.0]]), {q0: 0}), 0.6
-    )
-
-
-def test_projector_sum_operations():
-    q0 = cirq.NamedQubit('q0')
-
-    zero_projector = cirq.ProjectorSum.from_projector_strings(cirq.ProjectorString({q0: 0}))
-    one_projector = cirq.ProjectorSum.from_projector_strings(cirq.ProjectorString({q0: 1}))
-
-    simple_addition = zero_projector + one_projector
-    np.testing.assert_allclose(simple_addition.matrix(), [[1.0, 0.0], [0.0, 1.0]])
-
-    incrementation = zero_projector
-    incrementation += one_projector
-    np.testing.assert_allclose(incrementation.matrix(), [[1.0, 0.0], [0.0, 1.0]])
-
-    weighted_sum = 0.6 * zero_projector + 0.4 * one_projector
-    np.testing.assert_allclose(weighted_sum.matrix(), [[0.6, 0.0], [0.0, 0.4]])