Merge branch 'main' into update_serialization

Author: NoureldinYosri

Diff for: cirq-core/cirq/circuits/qasm_output.py

@@ -293,7 +293,11 @@ def output(text):
                 output(f'creg {meas_id}[{len(meas.qubits)}];\n')
             else:
                 output(f'creg {meas_id}[{len(meas.qubits)}];  // Measurement: {comment}\n')
-        output_line_gap(2)
+        # In OpenQASM 2.0, the transformation of global phase gates is ignored.
+        # Therefore, no newline is created when the operations contained in
+        # a circuit consist only of global phase gates.
+        if any(not isinstance(op.gate, ops.GlobalPhaseGate) for op in self.operations):
+            output_line_gap(2)
 
         # Operations
         self._write_operations(self.operations, output, output_line_gap)

Diff for: cirq-core/cirq/circuits/qasm_output_test.py

@@ -191,6 +191,19 @@ def test_h_gate_with_parameter():
     )
 
 
+def test_qasm_global_pahse():
+    output = cirq.QasmOutput((cirq.global_phase_operation(np.exp(1j * 5))), ())
+    assert (
+        str(output)
+        == """OPENQASM 2.0;
+include "qelib1.inc";
+
+
+// Qubits: []
+"""
+    )
+
+
 def test_precision():
     (q0,) = _make_qubits(1)
     output = cirq.QasmOutput((cirq.X(q0) ** 0.1234567,), (q0,), precision=3)

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

@@ -15,6 +15,7 @@
 """Basic types defining qubits, gates, and operations."""
 
 import re
+import warnings
 from typing import (
     AbstractSet,
     Any,
@@ -35,7 +36,7 @@
 
 import numpy as np
 
-from cirq import protocols, value
+from cirq import ops, protocols, value
 from cirq.ops import raw_types, gate_features, control_values as cv
 from cirq.type_workarounds import NotImplementedType
 
@@ -348,6 +349,14 @@ def __rmul__(self, other: Any) -> Any:
         return self.gate._rmul_with_qubits(self._qubits, other)
 
     def _qasm_(self, args: 'protocols.QasmArgs') -> Optional[str]:
+        if isinstance(self.gate, ops.GlobalPhaseGate):
+            warnings.warn(
+                "OpenQASM 2.0 does not support global phase."
+                "Since the global phase does not affect the measurement results, "
+                "the conversion to QASM is disregarded."
+            )
+            return ""
+
         return protocols.qasm(self.gate, args=args, qubits=self.qubits, default=None)
 
     def _equal_up_to_global_phase_(

Diff for: cirq-core/cirq/testing/consistent_qasm.py

@@ -42,6 +42,7 @@ def assert_qasm_is_consistent_with_unitary(val: Any):
     if isinstance(val, ops.Operation):
         qubits: Sequence[ops.Qid] = val.qubits
         op = val
+        gate = val.gate
     elif isinstance(val, ops.Gate):
         qid_shape = protocols.qid_shape(val)
         remaining_shape = list(qid_shape)
@@ -52,9 +53,14 @@ def assert_qasm_is_consistent_with_unitary(val: Any):
                     remaining_shape.pop(i)
         qubits = devices.LineQid.for_qid_shape(remaining_shape)
         op = val.on(*qubits)
+        gate = val
     else:
         raise NotImplementedError(f"Don't know how to test {val!r}")
 
+    if isinstance(gate, ops.GlobalPhaseGate):
+        # OpenQASM 2.0 does not support global phase gates.
+        return
+
     args = protocols.QasmArgs(qubit_id_map={q: f'q[{i}]' for i, q in enumerate(qubits)})
     qasm = protocols.qasm(op, args=args, default=None)
     if qasm is None:

Diff for: cirq-core/requirements.txt

@@ -2,6 +2,9 @@
 
 duet>=0.2.8
 matplotlib~=3.0
+# Temporary fix for https://github.com/sympy/sympy/issues/26273
+# TODO: remove once `pip install --pre sympy` works in a fresh environment
+mpmath<1.4
 networkx>=2.4
 numpy~=1.16
 pandas

Diff for: cirq-google/cirq_google/engine/qcs_notebook.py

@@ -82,32 +82,14 @@ def get_qcs_objects_for_notebook(
         ValueError: if processor_id is not specified and no processors are available.
     """
 
-    # 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
-    # Attempt to connect to the Quantum Engine API, and use a simulator if unable to connect.
     if not virtual:
         # Set up auth
         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:
-                a = auth.authenticate_user(clear_output=False)
-                print(a)
-                print("Authentication complete.")
-            except Exception as exc:
-                print(f"Authentication failed: {exc}")
-                print("Using virtual engine instead.")
-                virtual = True
+            authenticate_user()
+        except Exception as exc:
+            print(f"Authentication failed: {exc}")
+            print("Using virtual engine instead.")
+            virtual = True
 
     if not virtual:
         # Set up production engine
@@ -152,3 +134,46 @@ def get_qcs_objects_for_notebook(
         processor_id=processor_id,
         is_simulator=is_simulator,
     )
+
+
+def authenticate_user(clear_output: bool = False) -> None:
+    """Authenticates on Google Cloud.
+
+    Args:
+        clear_output: Optional bool for whether to clear output before
+            authenticating. Defaults to false.
+
+    Returns:
+        None.
+
+    Raises:
+        Exception: if authentication fails.
+    """
+
+    # 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
+    # Attempt to connect to the Quantum Engine API, and use a simulator if unable to connect.
+    try:
+        from google.colab import auth
+    except ImportError:
+        print("Not running in a colab kernel. Will use Application Default Credentials.")
+        return
+
+    try:
+        print("Getting OAuth2 credentials.")
+        print("Press enter after entering the verification code.")
+        a = auth.authenticate_user(clear_output=clear_output)
+        print(a)
+        print("Authentication complete.")
+    except Exception as exc:
+        print(
+            "Authentication failed, you may not have permission to access a"
+            + " hardware Engine. Use a virtual Engine instead."
+        )
+        raise exc

Diff for: cirq-google/cirq_google/engine/qcs_notebook_test.py

@@ -17,7 +17,11 @@
 import pytest
 
 import cirq_google as cg
-from cirq_google.engine.qcs_notebook import get_qcs_objects_for_notebook, QCSObjectsForNotebook
+from cirq_google.engine.qcs_notebook import (
+    get_qcs_objects_for_notebook,
+    QCSObjectsForNotebook,
+    authenticate_user,
+)
 
 
 def _assert_correct_types(result: QCSObjectsForNotebook):
@@ -132,3 +136,39 @@ def test_get_qcs_objects_for_notebook_auth_fails(engine_mock):
     assert not result.signed_in
     assert result.is_simulator
     assert result.project_id == 'fake_project'
+
+
+class TestAuthenticateUser:
+    """Tests for the public API `get_hardware_engine_and_authenticate_user` which
+    authenticates the user and returns a production engine instance ."""
+
+    @mock.patch.dict('sys.modules', {'google.colab': mock.Mock()})
+    def test_authentication_succeeds_no_exceptions_thrown(self):
+        auth_mock = sys.modules['google.colab']
+
+        authenticate_user()
+
+        assert auth_mock.auth.authenticate_user.called
+
+    @mock.patch.dict('sys.modules', {'google.colab': mock.Mock()})
+    def test_authentication_failure(self):
+        project_id = "invalid-project"
+        # Mock authentication failure
+        auth_mock = sys.modules['google.colab']
+
+        auth_mock.auth.authenticate_user = mock.Mock(side_effect=Exception('mock auth failure'))
+
+        with pytest.raises(Exception, match="mock auth failure"):
+            authenticate_user(project_id)
+
+    @mock.patch.dict('sys.modules', {'google.colab': mock.Mock()})
+    @pytest.mark.parametrize('clear_output', ([True, False]))
+    def test_clear_output_is_passed(self, clear_output):
+        auth_mock = sys.modules['google.colab']
+
+        with mock.patch.object(
+            auth_mock.auth, 'authenticate_user', return_value=None
+        ) as mock_authenticate_user:
+            authenticate_user(clear_output)
+
+        mock_authenticate_user.assert_called_with(clear_output=clear_output)

Diff for: dev_tools/docker_test.py

@@ -22,7 +22,6 @@ def test_docker_stable():
     assert result.returncode == 0
 
 
-@pytest.mark.skip(reason="fails due to boken dependendencies #6475")
 def test_docker_pre():
     if platform.system() != 'Linux':
         pytest.skip("Unsupported os")

Diff for: docs/tutorials/google/start.ipynb

@@ -132,22 +132,24 @@
       "cell_type": "code",
       "execution_count": null,
       "metadata": {
-        "id": "YoqI9GrOPExP",
-        "cellView": "form"
+        "id": "YoqI9GrOPExP"
       },
       "outputs": [],
       "source": [
         "# The Google Cloud Project id to use.\n",
         "project_id = \"\" #@param {type:\"string\"}\n",
         "\n",
-        "from cirq_google.engine.qcs_notebook import get_qcs_objects_for_notebook\n",
-        "# For virtual engine instances, set 'virtual=True' below.\n",
-        "qcs_objects = get_qcs_objects_for_notebook(project_id)\n",
+        "from cirq_google.engine import get_engine\n",
+        "from cirq_google.engine.qcs_notebook import authenticate_user\n",
         "\n",
-        "engine = qcs_objects.engine\n",
-        "if not qcs_objects.signed_in:\n",
-        "    print(\"ERROR: Please setup project_id in this cell or set the `GOOGLE_CLOUD_PROJECT` env var to your project id.\")\n",
-        "    print(\"Using noisy simulator instead.\")\n"
+        "authenticate_user()\n",
+        "try:\n",
+        "  engine = get_engine(project_id)\n",
+        "except Exception:\n",
+        "  from cirq_google.engine.qcs_notebook import get_qcs_objects_for_notebook\n",
+        "  print(\"Unable to connect to a hardware engine. Using a virtual instance instead.\")\n",
+        "  qcs_objects = get_qcs_objects_for_notebook(project_id, virtual=True)\n",
+        "  engine = qcs_objects.engine"
       ]
     },
     {
@@ -175,11 +177,11 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 9,
+      "execution_count": 24,
       "metadata": {
         "cellView": "both",
         "id": "EQoTYZIEPa9S",
-        "outputId": "43c72568-3bc8-4b44-871b-b9db19c9e672",
+        "outputId": "beb04676-8404-4831-8d40-3291ee2d6127",
         "colab": {
           "base_uri": "https://localhost:8080/"
         }
@@ -275,7 +277,8 @@
     {
       "cell_type": "code",
       "source": [
-        "processors = [p.processor_id for p in engine.list_processors() if p.health() == 'OK']"
+        "processors = [p.processor_id for p in engine.list_processors() if p.health() == 'OK']\n",
+        "print(f\"Available processors: {processors}\")"
       ],
       "metadata": {
         "id": "rvMeXrC1wnQi"