Merge remote-tracking branch 'upstream/master' into v13_flush

Author: MichaelBroughton

cirq-aqt/cirq_aqt/__init__.py

@@ -12,7 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+"""Types and methods related to the AQT ion trap device"""
+
+from cirq_aqt._version import (
+    __version__,
+)
+
 from cirq_aqt.aqt_sampler import AQTSampler, AQTSamplerLocalSimulator
 from cirq_aqt.aqt_device import AQTSimulator
-
-"""Types and methods related to the AQT ion trap device"""

cirq-aqt/cirq_aqt/_version.py

@@ -14,4 +14,4 @@
 
 """Define version number here, read it from setup.py automatically"""
 
-__version__ = "0.13.0.dev"
+__version__ = "0.14.0.dev"

cirq-aqt/cirq_aqt/_version_test.py

@@ -0,0 +1,5 @@
+import cirq_aqt
+
+
+def test_version():
+    assert cirq_aqt.__version__ == "0.14.0.dev"

cirq-core/cirq/_version.py

@@ -29,4 +29,4 @@
         'of cirq (e.g. "python -m pip install cirq==0.5.*")'
     )
 
-__version__ = "0.13.0.dev"
+__version__ = "0.14.0.dev"

cirq-core/cirq/_version_test.py

@@ -0,0 +1,5 @@
+import cirq
+
+
+def test_version():
+    assert cirq.__version__ == "0.14.0.dev"

cirq-core/cirq/contrib/qcircuit/qcircuit_diagram_info.py

@@ -98,9 +98,8 @@ def multigate_qcircuit_diagram_info(
     assert args.qubit_map is not None
     assert args.known_qubits is not None
     symbols = tuple(box if (args.qubit_map[q] == min_index) else ghost for q in args.known_qubits)
-    return protocols.CircuitDiagramInfo(
-        symbols, exponent=1 if info is None else info.exponent, connected=False
-    )
+    # Force exponent=1 to defer to exponent formatting given above.
+    return protocols.CircuitDiagramInfo(symbols, connected=False)
 
 
 def fallback_qcircuit_diagram_info(

cirq-core/cirq/contrib/qcircuit/qcircuit_diagram_info_test.py

@@ -32,7 +32,7 @@ def test_get_qcircuit_diagram_info():
     actual_info = ccq.get_qcircuit_diagram_info(op, args)
     name = r'{\text{SWAP}^{0.5}}'
     expected_info = cirq.CircuitDiagramInfo(
-        (r'\multigate{1}' + name, r'\ghost' + name), exponent=0.5, connected=False
+        (r'\multigate{1}' + name, r'\ghost' + name), exponent=1, connected=False
     )
     assert actual_info == expected_info
 

cirq-core/cirq/contrib/qcircuit/qcircuit_test.py

@@ -155,3 +155,17 @@ def test_two_cx_diagram():
  \\
 }""".strip()
     assert_has_qcircuit_diagram(circuit, expected_diagram)
+
+
+def test_sqrt_iswap_diagram():
+    # test for proper rendering of ISWAP^{0.5}
+    q0, q1 = cirq.LineQubit.range(2)
+    circuit = cirq.Circuit(cirq.ISWAP(q0, q1) ** 0.5)
+    expected_diagram = r"""
+\Qcircuit @R=1em @C=0.75em {
+ \\
+ &\lstick{\text{0}}& \qw&\multigate{1}{\text{ISWAP}^{0.5}} \qw&\qw\\
+ &\lstick{\text{1}}& \qw&\ghost{\text{ISWAP}^{0.5}}        \qw&\qw\\
+ \\
+}""".strip()
+    assert_has_qcircuit_diagram(circuit, expected_diagram)

cirq-core/cirq/qis/channels.py

@@ -153,7 +153,7 @@ def kraus_to_superoperator(kraus_operators: Sequence[np.ndarray]) -> np.ndarray:
     return m
 
 
-def superoperator_to_kraus(superoperator: np.ndarray) -> Sequence[np.ndarray]:
+def superoperator_to_kraus(superoperator: np.ndarray, atol: float = 1e-10) -> Sequence[np.ndarray]:
     r"""Returns a Kraus representation of a channel specified via the superoperator matrix.
 
     Quantum channel E: L(H1) -> L(H2) may be described by a collection of operators A_i, called
@@ -180,14 +180,16 @@ def superoperator_to_kraus(superoperator: np.ndarray) -> Sequence[np.ndarray]:
 
     Args:
         superoperator: Superoperator matrix specifying a quantum channel.
+        atol: Tolerance used to check which Kraus operators to omit.
 
     Returns:
         Sequence of Kraus operators of the channel specified by superoperator.
+        Kraus operators with Frobenius norm smaller than atol are omitted.
 
     Raises:
         ValueError: If superoperator is not a valid superoperator matrix.
     """
-    return choi_to_kraus(superoperator_to_choi(superoperator))
+    return choi_to_kraus(superoperator_to_choi(superoperator), atol=atol)
 
 
 def choi_to_superoperator(choi: np.ndarray) -> np.ndarray:

cirq-core/cirq/qis/channels_test.py

@@ -229,6 +229,13 @@ def test_choi_to_kraus_inverse_of_kraus_to_choi(choi):
     assert np.allclose(recovered_choi, choi)
 
 
+def test_choi_to_kraus_atol():
+    """Verifies that insignificant Kraus operators are omitted."""
+    choi = cirq.kraus_to_choi(cirq.kraus(cirq.phase_damp(1e-6)))
+    assert len(cirq.choi_to_kraus(choi, atol=1e-2)) == 1
+    assert len(cirq.choi_to_kraus(choi, atol=1e-4)) == 2
+
+
 @pytest.mark.parametrize(
     'channel',
     (
@@ -340,6 +347,13 @@ def test_superoperator_to_kraus_inverse_of_kraus_to_superoperator(superoperator)
     assert np.allclose(recovered_superoperator, superoperator)
 
 
+def test_superoperator_to_kraus_atol():
+    """Verifies that insignificant Kraus operators are omitted."""
+    superop = cirq.kraus_to_superoperator(cirq.kraus(cirq.phase_damp(1e-6)))
+    assert len(cirq.superoperator_to_kraus(superop, atol=1e-2)) == 1
+    assert len(cirq.superoperator_to_kraus(superop, atol=1e-4)) == 2
+
+
 @pytest.mark.parametrize(
     'choi, error',
     (

cirq-google/cirq_google/__init__.py

@@ -16,6 +16,10 @@
 
 from cirq_google import api
 
+from cirq_google._version import (
+    __version__,
+)
+
 from cirq_google.calibration import (
     ALL_ANGLES_FLOQUET_PHASED_FSIM_CHARACTERIZATION,
     CircuitWithCalibration,
@@ -129,6 +133,7 @@
     ExecutableResult,
     ExecutableGroupResult,
     QuantumRuntimeConfiguration,
+    execute,
 )
 
 from cirq_google import experimental

cirq-google/cirq_google/_version.py

@@ -29,4 +29,4 @@
         'of cirq (e.g. "python -m pip install cirq==0.5.*")'
     )
 
-__version__ = "0.13.0.dev"
+__version__ = "0.14.0.dev"

cirq-google/cirq_google/_version_test.py

@@ -0,0 +1,5 @@
+import cirq_google
+
+
+def test_version():
+    assert cirq_google.__version__ == "0.14.0.dev"

cirq-google/cirq_google/workflow/__init__.py

@@ -12,4 +12,5 @@
     ExecutableResult,
     ExecutableGroupResult,
     QuantumRuntimeConfiguration,
+    execute,
 )

cirq-google/cirq_google/workflow/quantum_executable.py

@@ -17,10 +17,10 @@
 import abc
 import dataclasses
 from dataclasses import dataclass
-from typing import Union, Tuple, Optional, Sequence, cast, Iterable, Dict, Any, List
+from typing import Union, Tuple, Optional, Sequence, cast, Dict, Any, List, Iterator
 
-from cirq import _compat, study
 import cirq
+from cirq import _compat, study
 
 
 class ExecutableSpec(metaclass=abc.ABCMeta):
@@ -232,7 +232,7 @@ def __init__(
     def __len__(self) -> int:
         return len(self.executables)
 
-    def __iter__(self) -> Iterable[QuantumExecutable]:
+    def __iter__(self) -> Iterator[QuantumExecutable]:
         yield from self.executables
 
     def __str__(self) -> str:

cirq-google/cirq_google/workflow/quantum_runtime.py

@@ -12,9 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""Runtime information dataclasses that accompany execution of executables."""
+"""Runtime information dataclasses and execution of executables."""
 
 import dataclasses
+import os
+import uuid
 from typing import Any, Dict, Optional, List
 
 import cirq
@@ -23,6 +25,7 @@
 from cirq_google.workflow._abstract_engine_processor_shim import AbstractEngineProcessorShim
 from cirq_google.workflow.quantum_executable import (
     ExecutableSpec,
+    QuantumExecutableGroup,
 )
 
 
@@ -133,3 +136,79 @@ def _json_dict_(self) -> Dict[str, Any]:
 
     def __repr__(self) -> str:
         return _compat.dataclass_repr(self, namespace='cirq_google')
+
+
+def execute(
+    rt_config: QuantumRuntimeConfiguration,
+    executable_group: QuantumExecutableGroup,
+    base_data_dir: str = ".",
+) -> ExecutableGroupResult:
+    """Execute a `cg.QuantumExecutableGroup` according to a `cg.QuantumRuntimeConfiguration`.
+
+    Args:
+        rt_config: The `cg.QuantumRuntimeConfiguration` specifying how to execute
+            `executable_group`.
+        executable_group: The `cg.QuantumExecutableGroup` containing the executables to execute.
+        base_data_dir: A filesystem path to write data. We write
+            "{base_data_dir}/{run_id}/ExecutableGroupResult.json.gz"
+            containing the `cg.ExecutableGroupResult` as well as one file
+            "{base_data_dir}/{run_id}/ExecutableResult.{i}.json.gz" per `cg.ExecutableResult` as
+            each executable result becomes available.
+
+    Returns:
+        The `cg.ExecutableGroupResult` containing all data and metadata for an execution.
+
+    Raises:
+        NotImplementedError: If an executable uses the `params` field or anything other than
+            a BitstringsMeasurement measurement field.
+        ValueError: If `base_data_dir` is not a valid directory.
+    """
+    # run_id defaults logic.
+    if rt_config.run_id is None:
+        run_id = str(uuid.uuid4())
+    else:
+        run_id = rt_config.run_id
+
+    # base_data_dir handling.
+    if not base_data_dir:
+        # coverage: ignore
+        raise ValueError("Please provide a non-empty `base_data_dir`.")
+
+    os.makedirs(f'{base_data_dir}/{run_id}', exist_ok=False)
+
+    # Results object that we will fill in in the main loop.
+    exegroup_result = ExecutableGroupResult(
+        runtime_configuration=rt_config,
+        shared_runtime_info=SharedRuntimeInfo(run_id=run_id),
+        executable_results=list(),
+    )
+    cirq.to_json_gzip(exegroup_result, f'{base_data_dir}/{run_id}/ExecutableGroupResult.json.gz')
+
+    # Loop over executables.
+    sampler = rt_config.processor.get_sampler()
+    n_executables = len(executable_group)
+    print()
+    for i, exe in enumerate(executable_group):
+        runtime_info = RuntimeInfo(execution_index=i)
+
+        if exe.params != tuple():
+            raise NotImplementedError("Circuit params are not yet supported.")
+
+        circuit = exe.circuit
+
+        if not hasattr(exe.measurement, 'n_repetitions'):
+            raise NotImplementedError("Only `BitstringsMeasurement` are supported.")
+
+        sampler_run_result = sampler.run(circuit, repetitions=exe.measurement.n_repetitions)
+
+        exe_result = ExecutableResult(
+            spec=exe.spec,
+            runtime_info=runtime_info,
+            raw_data=sampler_run_result,
+        )
+        cirq.to_json_gzip(exe_result, f'{base_data_dir}/{run_id}/ExecutableResult.{i}.json.gz')
+        exegroup_result.executable_results.append(exe_result)
+        print(f'\r{i+1} / {n_executables}', end='', flush=True)
+    print()
+
+    return exegroup_result

cirq-google/cirq_google/workflow/quantum_runtime_test.py

@@ -11,13 +11,19 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+import glob
+import re
+import uuid
 from dataclasses import dataclass
+from typing import List
+
+import numpy as np
+import pytest
 
 import cirq
 import cirq_google as cg
-import numpy as np
 from cirq_google.workflow._abstract_engine_processor_shim import AbstractEngineProcessorShim
-from cirq_google.workflow.quantum_executable_test import _get_example_spec
+from cirq_google.workflow.quantum_executable_test import _get_quantum_executables, _get_example_spec
 
 
 @dataclass
@@ -120,3 +126,30 @@ def test_executable_group_result(tmpdir):
     cg_assert_equivalent_repr(egr)
     assert len(egr.executable_results) == 3
     _assert_json_roundtrip(egr, tmpdir)
+
+
+@pytest.mark.parametrize('run_id', ['unit_test_runid', None])
+def test_execute(tmpdir, run_id):
+    rt_config = cg.QuantumRuntimeConfiguration(processor=_MockEngineProcessor(), run_id=run_id)
+    executable_group = cg.QuantumExecutableGroup(_get_quantum_executables())
+    returned_exegroup_result = cg.execute(
+        rt_config=rt_config, executable_group=executable_group, base_data_dir=tmpdir
+    )
+    actual_run_id = returned_exegroup_result.shared_runtime_info.run_id
+    if run_id is not None:
+        assert run_id == actual_run_id
+    else:
+        assert isinstance(uuid.UUID(actual_run_id), uuid.UUID)
+    fns = glob.glob(f'{tmpdir}/{actual_run_id}/ExecutableGroupResult.json.gz')
+    assert len(fns) == 1
+    exegroup_result: cg.ExecutableGroupResult = _cg_read_json_gzip(fns[0])
+
+    fns = glob.glob(f'{tmpdir}/{actual_run_id}/ExecutableResult.*.json.gz')
+    fns = sorted(
+        fns, key=lambda s: int(re.search(r'ExecutableResult\.(\d+)\.json\.gz$', s).group(1))
+    )
+    assert len(fns) == 3
+    exe_results: List[cg.ExecutableResult] = [_cg_read_json_gzip(fn) for fn in fns]
+
+    exegroup_result.executable_results = exe_results
+    assert returned_exegroup_result == exegroup_result

cirq-ionq/cirq_ionq/__init__.py

@@ -12,6 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from cirq_ionq._version import (
+    __version__,
+)
+
 from cirq_ionq.calibration import (
     Calibration,
 )

cirq-ionq/cirq_ionq/_version.py

@@ -14,4 +14,4 @@
 
 """Define version number here, read it from setup.py automatically"""
 
-__version__ = "0.13.0.dev"
+__version__ = "0.14.0.dev"

cirq-ionq/cirq_ionq/_version_test.py

@@ -0,0 +1,5 @@
+import cirq_ionq
+
+
+def test_version():
+    assert cirq_ionq.__version__ == "0.14.0.dev"

cirq-pasqal/cirq_pasqal/__init__.py

@@ -14,6 +14,10 @@
 
 """Devices, qubits, and sampler for Pasqal's neutral atom device."""
 
+from cirq_pasqal._version import (
+    __version__,
+)
+
 from cirq_pasqal.pasqal_qubits import (
     ThreeDQubit,
     TwoDQubit,

cirq-pasqal/cirq_pasqal/_version.py

@@ -14,4 +14,4 @@
 
 """Define version number here, read it from setup.py automatically"""
 
-__version__ = "0.13.0.dev"
+__version__ = "0.14.0.dev"

cirq-pasqal/cirq_pasqal/_version_test.py

@@ -0,0 +1,5 @@
+import cirq_pasqal
+
+
+def test_version():
+    assert cirq_pasqal.__version__ == "0.14.0.dev"