Merge branch 'master' into u/maffoo/gate-sets-dep

Author: maffoo

Diff for: cirq-core/cirq/__init__.py

@@ -196,7 +196,6 @@
     BaseDensePauliString,
     bit_flip,
     BitFlipChannel,
-    BooleanHamiltonian,
     BooleanHamiltonianGate,
     CCX,
     CCXPowGate,

Diff for: cirq-core/cirq/json_resolver_cache.py

@@ -33,6 +33,11 @@ def _class_resolver_dictionary() -> Dict[str, ObjectFactory]:
     from cirq.experiments import CrossEntropyResult, CrossEntropyResultDict, GridInteractionLayer
     from cirq.experiments.grid_parallel_two_qubit_xeb import GridParallelXEBMetadata
 
+    def _boolean_hamiltonian_gate_op(qubit_map, boolean_strs, theta):
+        return cirq.BooleanHamiltonianGate(
+            parameter_names=list(qubit_map.keys()), boolean_strs=boolean_strs, theta=theta
+        ).on(*qubit_map.values())
+
     def _identity_operation_from_dict(qubits, **kwargs):
         return cirq.identity_each(*qubits)
 
@@ -58,7 +63,6 @@ def _parallel_gate_op(gate, qubits):
         'AsymmetricDepolarizingChannel': cirq.AsymmetricDepolarizingChannel,
         'BitFlipChannel': cirq.BitFlipChannel,
         'BitstringAccumulator': cirq.work.BitstringAccumulator,
-        'BooleanHamiltonian': cirq.BooleanHamiltonian,
         'BooleanHamiltonianGate': cirq.BooleanHamiltonianGate,
         'CCNotPowGate': cirq.CCNotPowGate,
         'CCXPowGate': cirq.CCXPowGate,
@@ -186,6 +190,7 @@ def _parallel_gate_op(gate, qubits):
         'ZPowGate': cirq.ZPowGate,
         'ZZPowGate': cirq.ZZPowGate,
         # Old types, only supported for backwards-compatibility
+        'BooleanHamiltonian': _boolean_hamiltonian_gate_op,  # Removed in v0.15
         'IdentityOperation': _identity_operation_from_dict,
         'ParallelGateOperation': _parallel_gate_op,  # Removed in v0.14
         'SingleQubitMatrixGate': single_qubit_matrix_gate,

Diff for: cirq-core/cirq/ops/__init__.py

@@ -31,7 +31,6 @@
 )
 
 from cirq.ops.boolean_hamiltonian import (
-    BooleanHamiltonian,
     BooleanHamiltonianGate,
 )
 

Diff for: cirq-core/cirq/ops/boolean_hamiltonian.py

@@ -30,106 +30,10 @@
 
 import cirq
 from cirq import value
-from cirq._compat import deprecated_class
 from cirq.ops import raw_types
 from cirq.ops.linear_combinations import PauliSum, PauliString
 
 
-@deprecated_class(deadline='v0.15', fix='Use cirq.BooleanHamiltonianGate')
-@value.value_equality
-class BooleanHamiltonian(raw_types.Operation):
-    """An operation that represents a Hamiltonian from a set of Boolean functions."""
-
-    def __init__(
-        self,
-        qubit_map: Dict[str, 'cirq.Qid'],
-        boolean_strs: Sequence[str],
-        theta: float,
-    ):
-        """Builds a BooleanHamiltonian.
-
-        For each element of a sequence of Boolean expressions, the code first transforms it into a
-        polynomial of Pauli Zs that represent that particular expression. Then, we sum all the
-        polynomials, thus making a function that goes from a series to Boolean inputs to an integer
-        that is the number of Boolean expressions that are true.
-
-        For example, if we were using this gate for the unweighted max-cut problem that is typically
-        used to demonstrate the QAOA algorithm, there would be one Boolean expression per edge. Each
-        Boolean expression would be true iff the vertices on that are in different cuts (i.e. it's)
-        an XOR.
-
-        Then, we compute exp(-j * theta * polynomial), which is unitary because the polynomial is
-        Hermitian.
-
-        Args:
-            boolean_strs: The list of Sympy-parsable Boolean expressions.
-            qubit_map: map of string (boolean variable name) to qubit.
-            theta: The evolution time (angle) for the Hamiltonian
-
-        Raises:
-            ValueError: If the any qubits are not 2D.
-        """
-        if any(q.dimension != 2 for q in qubit_map.values()):
-            raise ValueError('All qubits must be 2-dimensional.')
-        self._qubit_map: Dict[str, 'cirq.Qid'] = qubit_map
-        self._boolean_strs: Sequence[str] = boolean_strs
-        self._theta: float = theta
-
-    def with_qubits(self, *new_qubits: 'cirq.Qid') -> 'BooleanHamiltonian':
-        if len(self._qubit_map) != len(new_qubits):
-            raise ValueError('Length of replacement qubits must be the same')
-        new_qubit_map = {
-            variable_name: new_qubit
-            for variable_name, new_qubit in zip(self._qubit_map, new_qubits)
-        }
-        return BooleanHamiltonian(
-            new_qubit_map,
-            self._boolean_strs,
-            self._theta,
-        )
-
-    @property
-    def qubits(self) -> Tuple[raw_types.Qid, ...]:
-        return tuple(self._qubit_map.values())
-
-    def num_qubits(self) -> int:
-        return len(self._qubit_map)
-
-    def _value_equality_values_(self):
-        return self._qubit_map, self._boolean_strs, self._theta
-
-    def _json_dict_(self) -> Dict[str, Any]:
-        return {
-            'qubit_map': self._qubit_map,
-            'boolean_strs': self._boolean_strs,
-            'theta': self._theta,
-        }
-
-    @classmethod
-    def _from_json_dict_(cls, qubit_map, boolean_strs, theta, **kwargs):
-        return cls(qubit_map, boolean_strs, theta)
-
-    def _decompose_(self):
-        boolean_exprs = [sympy_parser.parse_expr(boolean_str) for boolean_str in self._boolean_strs]
-        hamiltonian_polynomial_list = [
-            PauliSum.from_boolean_expression(boolean_expr, self._qubit_map)
-            for boolean_expr in boolean_exprs
-        ]
-
-        return _get_gates_from_hamiltonians(
-            hamiltonian_polynomial_list, self._qubit_map, self._theta
-        )
-
-    def _has_unitary_(self):
-        return True
-
-    @property
-    def gate(self) -> 'cirq.Gate':
-        return BooleanHamiltonianGate(
-            tuple(self._qubit_map.keys()), self._boolean_strs, self._theta
-        )
-
-
 @value.value_equality
 class BooleanHamiltonianGate(raw_types.Gate):
     """A gate that represents a Hamiltonian from a set of Boolean functions."""

Diff for: cirq-core/cirq/ops/boolean_hamiltonian_test.py

@@ -53,8 +53,7 @@
         '(x2 | x1) ^ x0',
     ],
 )
-@pytest.mark.parametrize('transform', [lambda op: op, lambda op: op.gate.on(*op.qubits)])
-def test_circuit(boolean_str, transform):
+def test_circuit(boolean_str):
     boolean_expr = sympy_parser.parse_expr(boolean_str)
     var_names = cirq.parameter_names(boolean_expr)
     qubits = [cirq.NamedQubit(name) for name in var_names]
@@ -73,14 +72,13 @@ def test_circuit(boolean_str, transform):
     circuit = cirq.Circuit()
     circuit.append(cirq.H.on_each(*qubits))
 
-    with cirq.testing.assert_deprecated('Use cirq.BooleanHamiltonianGate', deadline='v0.15'):
-        hamiltonian_gate = cirq.BooleanHamiltonian(
-            {q.name: q for q in qubits}, [boolean_str], 0.1 * math.pi
-        )
+    hamiltonian_gate = cirq.BooleanHamiltonianGate(
+        {q.name: q for q in qubits}, [boolean_str], 0.1 * math.pi
+    )
 
     assert hamiltonian_gate.num_qubits() == n
 
-    circuit.append(transform(hamiltonian_gate))
+    circuit.append(hamiltonian_gate.on(*qubits))
 
     phi = cirq.Simulator().simulate(circuit, qubit_order=qubits, initial_state=0).state_vector()
     actual = np.arctan2(phi.real, phi.imag) - math.pi / 2.0 > 0.0
@@ -89,28 +87,6 @@ def test_circuit(boolean_str, transform):
     np.testing.assert_array_equal(actual, expected)
 
 
-def test_with_custom_names():
-    q0, q1, q2, q3 = cirq.LineQubit.range(4)
-    with cirq.testing.assert_deprecated(
-        'Use cirq.BooleanHamiltonianGate', deadline='v0.15', count=3
-    ):
-        original_op = cirq.BooleanHamiltonian(
-            {'a': q0, 'b': q1},
-            ['a'],
-            0.1,
-        )
-        assert cirq.decompose(original_op) == [cirq.Rz(rads=-0.05).on(q0)]
-
-        renamed_op = original_op.with_qubits(q2, q3)
-        assert cirq.decompose(renamed_op) == [cirq.Rz(rads=-0.05).on(q2)]
-
-        with pytest.raises(ValueError, match='Length of replacement qubits must be the same'):
-            original_op.with_qubits(q2)
-
-        with pytest.raises(ValueError, match='All qubits must be 2-dimensional'):
-            original_op.with_qubits(q0, cirq.LineQid(1, 3))
-
-
 def test_gate_with_custom_names():
     q0, q1, q2, q3 = cirq.LineQubit.range(4)
     gate = cirq.BooleanHamiltonianGate(

Diff for: cirq-core/cirq/protocols/json_test_data/BooleanHamiltonian.json renamed to cirq-core/cirq/protocols/json_test_data/BooleanHamiltonian.json_inward

@@ -0,0 +1 @@
+[cirq.BooleanHamiltonianGate(parameter_names=['q0'], boolean_strs=['q0'], theta=0.20160913).on(cirq.NamedQubit('q0'))]

Diff for: cirq-core/cirq/protocols/json_test_data/BooleanHamiltonian.repr

@@ -190,7 +190,6 @@
     ],
     deprecated={
         'GlobalPhaseOperation': 'v0.16',
-        'BooleanHamiltonian': 'v0.15',
         'SymmetricalQidPair': 'v0.15',
     },
     tested_elsewhere=[

Diff for: cirq-core/cirq/protocols/json_test_data/BooleanHamiltonian.repr_inward

@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os
 import dataclasses
 from typing import Union, Optional
 
@@ -24,8 +23,7 @@
     Sycamore,
     SQRT_ISWAP_INV_PARAMETERS,
     PhasedFSimCharacterization,
-    get_engine_sampler,
-    get_engine_device,
+    get_engine,
 )
 
 
@@ -40,9 +38,12 @@ def is_simulator(self):
         return isinstance(self.sampler, PhasedFSimEngineSimulator)
 
 
+# Disable missing-raises-doc lint check, since pylint gets confused
+# by exceptions that are raised and caught within this function.
+# pylint: disable=missing-raises-doc
 def get_qcs_objects_for_notebook(
     project_id: Optional[str] = None, processor_id: Optional[str] = None
-) -> QCSObjectsForNotebook:
+) -> QCSObjectsForNotebook:  # pragma: nocover
     """Authenticates on Google Cloud, can return a Device and Simulator.
 
     Args:
@@ -57,68 +58,54 @@ def get_qcs_objects_for_notebook(
         An instance of DeviceSamplerInfo.
     """
 
-    # Converting empty strings to None for form field inputs
-    if project_id == "":
-        project_id = None
-    if processor_id == "":
-        processor_id = None
-
-    google_cloud_signin_failed: bool = False
-    if project_id is None:
-        if 'GOOGLE_CLOUD_PROJECT' not in os.environ:
-            print("No project_id provided and environment variable GOOGLE_CLOUD_PROJECT not set.")
-            google_cloud_signin_failed = True
-    else:  # pragma: no cover
-        os.environ['GOOGLE_CLOUD_PROJECT'] = project_id
-
-        # Following code runs the user through the Colab OAuth process.
-
-        # Checks for Google Application Default Credentials and runs
-        # interactive login if the notebook is executed in Colab. In
-        # case the notebook is executed in Jupyter notebook or other
-        # IPython runtimes, no interactive login is provided, it is
-        # assumed that the `GOOGLE_APPLICATION_CREDENTIALS` env var is
-        # set or `gcloud auth application-default login` was executed
-        # already. For more information on using Application Default Credentials
-        # see https://cloud.google.com/docs/authentication/production
-
-        in_colab = False
+    # Check for Google Application Default Credentials and run
+    # interactive login if the notebook is executed in Colab. In
+    # case the notebook is executed in Jupyter notebook or other
+    # IPython runtimes, no interactive login is provided, it is
+    # assumed that the `GOOGLE_APPLICATION_CREDENTIALS` env var is
+    # set or `gcloud auth application-default login` was executed
+    # already. For more information on using Application Default Credentials
+    # see https://cloud.google.com/docs/authentication/production
+    try:
+        from google.colab import auth
+    except ImportError:
+        print("Not running in a colab kernel. Will use Application Default Credentials.")
+    else:
+        print("Getting OAuth2 credentials.")
+        print("Press enter after entering the verification code.")
         try:
-            from IPython import get_ipython
-
-            in_colab = 'google.colab' in str(get_ipython())
-
-            if in_colab:
-                from google.colab import auth
+            auth.authenticate_user(clear_output=False)
+            print("Authentication complete.")
+        except Exception as exc:
+            print(f"Authentication failed: {exc}")
 
-                print("Getting OAuth2 credentials.")
-                print("Press enter after entering the verification code.")
-                auth.authenticate_user(clear_output=False)
-                print("Authentication complete.")
-            else:
-                print(
-                    "Notebook isn't executed with Colab, assuming "
-                    "Application Default Credentials are setup."
-                )
-        except:
-            pass
-
-        # End of Google Colab Authentication segment
-
-    device: cirq.Device
+    # Attempt to connect to the Quantum Engine API, and use a simulator if unable to connect.
     sampler: Union[PhasedFSimEngineSimulator, QuantumEngineSampler]
-    if google_cloud_signin_failed or processor_id is None:
+    try:
+        engine = get_engine(project_id)
+        if processor_id:
+            processor = engine.get_processor(processor_id)
+        else:
+            processors = engine.list_processors()
+            if not processors:
+                raise ValueError("No processors available.")
+            processor = processors[0]
+            print(f"Available processors: {[p.processor_id for p in processors]}")
+            print(f"Using processor: {processor.processor_id}")
+        device = processor.get_device()
+        sampler = processor.get_sampler()
+        signed_in = True
+    except Exception as exc:
+        print(f"Unable to connect to quantum engine: {exc}")
         print("Using a noisy simulator.")
         sampler = PhasedFSimEngineSimulator.create_with_random_gaussian_sqrt_iswap(
             mean=SQRT_ISWAP_INV_PARAMETERS,
             sigma=PhasedFSimCharacterization(theta=0.01, zeta=0.10, chi=0.01, gamma=0.10, phi=0.02),
         )
         device = Sycamore
-    else:  # pragma: no cover
-        device = get_engine_device(processor_id)
-        sampler = get_engine_sampler(processor_id, gate_set_name="sqrt_iswap")
-    return QCSObjectsForNotebook(
-        device=device,
-        sampler=sampler,
-        signed_in=not google_cloud_signin_failed,
-    )
+        signed_in = False
+
+    return QCSObjectsForNotebook(device=device, sampler=sampler, signed_in=signed_in)
+
+
+# pylint: enable=missing-raises-doc

Diff for: cirq-core/cirq/protocols/json_test_data/spec.py

@@ -19,8 +19,8 @@
 def test_get_device_sampler():
     result = get_qcs_objects_for_notebook()
     assert result.device is cg.Sycamore
-    assert result.signed_in is False
-    assert type(result.sampler) is cg.PhasedFSimEngineSimulator
+    assert not result.signed_in
+    assert isinstance(result.sampler, cg.PhasedFSimEngineSimulator)
     assert result.is_simulator
 
     result = get_qcs_objects_for_notebook("", "")