Merge branch 'master' into cg-device-refactor/measure-two-qubits

Author: verult

cirq-core/cirq/contrib/quantum_volume/quantum_volume.py

@@ -197,24 +197,6 @@ def process_results(
     return data
 
 
-class SwapPermutationReplacer(cirq.PointOptimizer):
-    """Replaces SwapPermutationGates with their underlying implementation
-    gate."""
-
-    def __init__(self):
-        super().__init__()
-
-    def optimization_at(
-        self, circuit: cirq.Circuit, index: int, op: cirq.Operation
-    ) -> Optional[cirq.PointOptimizationSummary]:
-        if isinstance(op.gate, cirq.contrib.acquaintance.SwapPermutationGate):
-            new_ops = op.gate.swap_gate.on(*op.qubits)
-            return cirq.PointOptimizationSummary(
-                clear_span=1, clear_qubits=op.qubits, new_operations=new_ops
-            )
-        return None  # Don't make changes to other gates.
-
-
 def compile_circuit(
     circuit: cirq.Circuit,
     *,
@@ -296,7 +278,15 @@ def compile_circuit(
     mapping = swap_networks[0].final_mapping()
     # Replace the PermutationGates with regular gates, so we don't proliferate
     # the routing implementation details to the compiler and the device itself.
-    SwapPermutationReplacer().optimize_circuit(routed_circuit)
+
+    def replace_swap_permutation_gate(op: 'cirq.Operation', _):
+        if isinstance(op.gate, cirq.contrib.acquaintance.SwapPermutationGate):
+            return [op.gate.swap_gate.on(*op.qubits)]
+        return op
+
+    routed_circuit = cirq.map_operations_and_unroll(
+        routed_circuit, map_func=replace_swap_permutation_gate
+    )
 
     if not compiler:
         return CompilationResult(circuit=routed_circuit, mapping=mapping, parity_map=parity_map)
@@ -307,7 +297,7 @@ def compile_circuit(
     # as well, we allow this to be passed in. This compiler is not allowed to
     # change the order of the qubits.
     return CompilationResult(
-        circuit=compiler(swap_networks[0].circuit), mapping=mapping, parity_map=parity_map
+        circuit=compiler(routed_circuit), mapping=mapping, parity_map=parity_map
     )
 
 

cirq-core/cirq/ops/global_phase_op.py

@@ -12,18 +12,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """A no-qubit global phase operation."""
-from typing import AbstractSet, Any, Dict, Sequence, Tuple, TYPE_CHECKING, Union
+
+from typing import AbstractSet, Any, cast, Dict, Sequence, Tuple, Union
 
 import numpy as np
 import sympy
 
+import cirq
 from cirq import value, protocols
 from cirq.ops import raw_types
 from cirq.type_workarounds import NotImplementedType
 
-if TYPE_CHECKING:
-    import cirq
-
 
 @value.value_equality(approximate=True)
 class GlobalPhaseGate(raw_types.Gate):
@@ -57,7 +56,8 @@ def _apply_unitary_(
     ) -> Union[np.ndarray, NotImplementedType]:
         if not self._has_unitary_():
             return NotImplemented
-        args.target_tensor *= self.coefficient
+        assert not cirq.is_parameterized(self)
+        args.target_tensor *= cast(np.generic, self.coefficient)
         return args.target_tensor
 
     def _has_stabilizer_effect_(self) -> bool:

cirq-core/cirq/ops/pauli_string.py

@@ -41,6 +41,7 @@
 import numpy as np
 import sympy
 
+import cirq
 from cirq import value, protocols, linalg, qis
 from cirq._doc import document
 from cirq._import import LazyLoader
@@ -498,9 +499,15 @@ def matrix(self, qubits: Optional[Iterable[TKey]] = None) -> np.ndarray:
                 in which the matrix representation of the Pauli string is to
                 be computed. Qubits absent from `self.qubits` are acted on by
                 the identity. Defaults to `self.qubits`.
+
+        Raises:
+            NotImplementedError: If this PauliString is parameterized.
         """
         qubits = self.qubits if qubits is None else qubits
         factors = [self.get(q, default=identity.I) for q in qubits]
+        if cirq.is_parameterized(self):
+            raise NotImplementedError('Cannot express as matrix when parameterized')
+        assert isinstance(self.coefficient, complex)
         return linalg.kron(self.coefficient, *[protocols.unitary(f) for f in factors])
 
     def _has_unitary_(self) -> bool:
@@ -516,6 +523,7 @@ def _unitary_(self) -> Optional[np.ndarray]:
     def _apply_unitary_(self, args: 'protocols.ApplyUnitaryArgs'):
         if not self._has_unitary_():
             return None
+        assert isinstance(self.coefficient, complex)
         if self.coefficient != 1:
             args.target_tensor *= self.coefficient
         return protocols.apply_unitaries([self[q].on(q) for q in self.qubits], self.qubits, args)

cirq-core/cirq/ops/pauli_string_test.py

@@ -1985,6 +1985,8 @@ def test_parameterization():
         pst.expectation_from_state_vector(np.array([]), {})
     with pytest.raises(NotImplementedError, match='parameterized'):
         pst.expectation_from_density_matrix(np.array([]), {})
+    with pytest.raises(NotImplementedError, match='as matrix when parameterized'):
+        pst.matrix()
     assert pst**1 == pst
     assert pst**-1 == pst.with_coefficient(1.0 / t)
     assert (-pst) ** 1 == -pst

cirq-core/cirq/ops/phased_iswap_gate.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 """ISWAPPowGate conjugated by tensor product Rz(phi) and Rz(-phi)."""
 
-from typing import AbstractSet, Any, Dict, List, Optional, Sequence, Tuple, Union
+from typing import AbstractSet, Any, cast, Dict, List, Optional, Sequence, Tuple, Union
 
 import numpy as np
 import sympy
@@ -173,7 +173,7 @@ def _pauli_expansion_(self) -> value.LinearDict[str]:
             return NotImplemented
         expansion = protocols.pauli_expansion(self._iswap)
         assert set(expansion.keys()).issubset({'II', 'XX', 'YY', 'ZZ'})
-        assert np.isclose(expansion['XX'], expansion['YY'])
+        assert np.isclose(cast(np.generic, expansion['XX']), cast(np.generic, expansion['YY']))
 
         v = (expansion['XX'] + expansion['YY']) / 2
         phase_angle = np.pi * self.phase_exponent

cirq-google/cirq_google/engine/__init__.py

@@ -72,6 +72,7 @@
 from cirq_google.engine.validating_sampler import ValidatingSampler
 
 from cirq_google.engine.virtual_engine_factory import (
+    create_default_noisy_quantum_virtual_machine,
     create_device_from_processor_id,
     create_noiseless_virtual_engine_from_device,
     create_noiseless_virtual_engine_from_proto,

cirq-google/cirq_google/engine/virtual_engine_factory.py

@@ -14,16 +14,19 @@
 
 """Functions to instantiate SimulatedLocalEngines to simulate various Google Devices."""
 import json
-from typing import cast, Iterable, List, Optional, Union
+from typing import cast, Iterable, List, Optional, Union, Type
 import pathlib
 import time
 
 import google.protobuf.text_format as text_format
 import cirq
+from cirq.sim.simulator import SimulatesSamples
 from cirq_google.api import v2
 from cirq_google.engine import calibration, engine_validator, simulated_local_processor, util
 from cirq_google.devices import grid_device
+from cirq_google.devices.google_noise_properties import NoiseModelFromGoogleNoiseProperties
 from cirq_google.serialization import serializable_gate_set
+from cirq_google.engine.calibration_to_noise_properties import noise_properties_from_calibration
 from cirq_google.engine.simulated_local_engine import SimulatedLocalEngine
 from cirq_google.engine.simulated_local_processor import SimulatedLocalProcessor
 
@@ -367,3 +370,44 @@ def create_noiseless_virtual_engine_from_latest_templates() -> SimulatedLocalEng
     processor_ids = list(MOST_RECENT_TEMPLATES.keys())
     template_names = [MOST_RECENT_TEMPLATES[k] for k in processor_ids]
     return create_noiseless_virtual_engine_from_templates(processor_ids, template_names)
+
+
+def create_default_noisy_quantum_virtual_machine(
+    processor_id: str, simulator_class: Type[SimulatesSamples] = None, **kwargs
+) -> SimulatedLocalEngine:
+    """Creates a virtual engine with a noisy simulator based on a processor id.
+
+    Args:
+        processor_id: The string name of a processor that has available noise data.
+        simulator_class: The class of the type of simulator to be initialized. The
+            simulator class initializer needs to support the `noise` parameter.
+        kwargs: Other arguments which are passed through to the simulator initializer.
+            The 'noise' argument will be overwritten with a new noise model.
+
+    Returns:
+        A SimulatedLocalEngine that uses a simulator of type simulator_class with a
+            noise model based on available noise data for the processor processor_id.
+    """
+
+    if simulator_class is None:
+        try:  # coverage: ignore
+            import qsimcirq  # type: ignore
+
+            simulator_class = qsimcirq.Simulator  # coverage: ignore
+        except ImportError:
+            simulator_class = cirq.Simulator  # coverage: ignore
+
+    calibration = load_median_device_calibration(processor_id)
+    noise_properties = noise_properties_from_calibration(calibration)
+    noise_model = NoiseModelFromGoogleNoiseProperties(noise_properties)
+    simulator = simulator_class(noise=noise_model, **kwargs)  # type: ignore
+
+    device = create_device_from_processor_id(processor_id)
+    simulated_processor = SimulatedLocalProcessor(
+        processor_id=processor_id,
+        sampler=simulator,
+        device=device,
+        calibrations={calibration.timestamp // 1000: calibration},
+    )
+
+    return SimulatedLocalEngine([simulated_processor])

cirq-google/cirq_google/engine/virtual_engine_factory_test.py

@@ -175,3 +175,19 @@ def test_create_from_proto_no_qubits():
         _ = factory.create_noiseless_virtual_engine_from_device(
             'sycamore', cirq.UNCONSTRAINED_DEVICE
         )
+
+
+def test_create_default_noisy_quantum_virtual_machine():
+    for processor_id in ["rainbow", "weber"]:
+        engine = factory.create_default_noisy_quantum_virtual_machine(
+            processor_id=processor_id, simulator_class=cirq.Simulator
+        )
+        processor = engine.get_processor(processor_id)
+        bad_qubit = cirq.GridQubit(10, 10)
+        circuit = cirq.Circuit(cirq.X(bad_qubit), cirq.measure(bad_qubit))
+        with pytest.raises(ValueError, match='Qubit not on device'):
+            _ = processor.run(circuit, repetitions=100)
+        good_qubit = cirq.GridQubit(5, 4)
+        circuit = cirq.Circuit(cirq.H(good_qubit), cirq.measure(good_qubit))
+        with pytest.raises(ValueError, match='.* contains a gate which is not supported.'):
+            _ = processor.run(circuit, repetitions=100)

cirq-rigetti/requirements.txt

@@ -9,6 +9,8 @@ pydantic~=1.8.2
 pyjwt~=1.7.1
 pyquil~=2.28.2; python_version < "3.7"
 pyquil~=3.0.0; python_version >= "3.7"
+# Remove once https://github.com/python-rapidjson/python-rapidjson/issues/166 is resolved.
+python-rapidjson<=1.6
 python-dateutil~=2.8.1
 qcs-api-client~=0.8.0
 retrying~=1.3.3

docs/dev/development.md

@@ -28,12 +28,12 @@ Note that if you are using PyCharm, you might have to Restart & Invalidate Cache
 
 ```bash
     docker build -t cirq --target cirq_stable .
-    docker run -it cirq python -c "import cirq_google; print(cirq_google.Foxtail)"
+    docker run -it cirq python -c "import cirq_google; print(cirq_google.Sycamore23)"
 ```
 
 ```bash
     docker build -t cirq_pre --target cirq_pre_release .
-    docker run -it cirq_pre python -c "import cirq_google; print(cirq_google.Foxtail)"
+    docker run -it cirq_pre python -c "import cirq_google; print(cirq_google.Sycamore23)"
 ```
 
 If you want to contribute changes to Cirq, you will instead want to fork the repository and submit pull requests from your fork.
@@ -85,6 +85,9 @@ At this point your local git master should be synced with the master from the ma
 
 ## Setting up an environment
 
+These instructions are primarily for linux-based environments that use the apt
+package manager. 
+
 0. First clone the repository, if you have not already done so.
 See the previous section for instructions.