cirq-core 1.2.0.dev20230712233101__py3-none-any.whl → 1.2.0.dev20230717131509__py3-none-any.whl

cirq/_version.py

@@ -1 +1 @@
-__version__ = "1.2.0.dev20230712233101"
+__version__ = "1.2.0.dev20230717131509"

cirq/testing/__init__.py

@@ -109,3 +109,5 @@ from cirq.testing.routing_devices import (
 from cirq.testing.sample_circuits import nonoptimal_toffoli_circuit
 
 from cirq.testing.sample_gates import PhaseUsingCleanAncilla, PhaseUsingDirtyAncilla
+
+from cirq.testing.consistent_unitary import assert_unitary_is_consistent

cirq/testing/consistent_decomposition.py

@@ -40,8 +40,17 @@ def assert_decompose_is_consistent_with_unitary(val: Any, ignoring_global_phase:
         # If there's no decomposition, it's vacuously consistent.
         return
 
-    actual = circuits.Circuit(dec).unitary(qubit_order=qubits)
-
+    c = circuits.Circuit(dec)
+    if len(c.all_qubits().difference(qubits)):
+        # The decomposition contains ancilla qubits.
+        ancilla = tuple(c.all_qubits().difference(qubits))
+        qubit_order = ancilla + qubits
+        actual = c.unitary(qubit_order=qubit_order)
+        qid_shape = protocols.qid_shape(qubits)
+        vol = np.prod(qid_shape, dtype=np.int64)
+        actual = actual[:vol, :vol]
+    else:
+        actual = c.unitary(qubit_order=qubits)
     if ignoring_global_phase:
         lin_alg_utils.assert_allclose_up_to_global_phase(actual, expected, atol=1e-8)
     else:

cirq/testing/consistent_decomposition_test.py

@@ -43,6 +43,14 @@ def test_assert_decompose_is_consistent_with_unitary():
         GoodGateDecompose().on(cirq.NamedQubit('q'))
     )
 
+    cirq.testing.assert_decompose_is_consistent_with_unitary(
+        cirq.testing.PhaseUsingCleanAncilla(theta=0.1, ancilla_bitsize=3)
+    )
+
+    cirq.testing.assert_decompose_is_consistent_with_unitary(
+        cirq.testing.PhaseUsingDirtyAncilla(phase_state=1, ancilla_bitsize=4)
+    )
+
     with pytest.raises(AssertionError):
         cirq.testing.assert_decompose_is_consistent_with_unitary(BadGateDecompose())
 
@@ -83,7 +91,6 @@ class ParameterizedGate(cirq.Gate):
 
 
 def test_assert_decompose_ends_at_default_gateset():
-
     cirq.testing.assert_decompose_ends_at_default_gateset(GateDecomposesToDefaultGateset())
     cirq.testing.assert_decompose_ends_at_default_gateset(
         GateDecomposesToDefaultGateset().on(*cirq.LineQubit.range(2))

cirq/testing/consistent_protocols.py

@@ -37,6 +37,7 @@ from cirq.testing.consistent_resolve_parameters import assert_consistent_resolve
 from cirq.testing.consistent_specified_has_unitary import assert_specifies_has_unitary_if_unitary
 from cirq.testing.equivalent_repr_eval import assert_equivalent_repr
 from cirq.testing.consistent_controlled_gate_op import assert_controlled_and_controlled_by_identical
+from cirq.testing.consistent_unitary import assert_unitary_is_consistent
 
 
 def assert_implements_consistent_protocols(
@@ -153,6 +154,7 @@ def _assert_meets_standards_helper(
     assert_qasm_is_consistent_with_unitary(val)
     assert_has_consistent_trace_distance_bound(val)
     assert_decompose_is_consistent_with_unitary(val, ignoring_global_phase=ignoring_global_phase)
+    assert_unitary_is_consistent(val, ignoring_global_phase=ignoring_global_phase)
     if not ignore_decompose_to_default_gateset:
         assert_decompose_ends_at_default_gateset(val)
     assert_phase_by_is_consistent_with_unitary(val)

cirq/testing/consistent_unitary.py

@@ -0,0 +1,85 @@
+# Copyright 2023 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.
+
+
+from typing import Any
+import cirq
+import numpy as np
+
+
+def assert_unitary_is_consistent(val: Any, ignoring_global_phase: bool = False):
+    if not isinstance(val, (cirq.Operation, cirq.Gate)):
+        return
+
+    if not cirq.has_unitary(val):
+        return
+
+    # Ensure that `u` is a unitary.
+    u = cirq.unitary(val)
+    assert not (u is None or u is NotImplemented)
+    assert cirq.is_unitary(u)
+
+    if isinstance(val, cirq.Operation):
+        qubits = val.qubits
+        decomposition = cirq.decompose_once(val, default=None)
+    else:
+        qubits = tuple(cirq.LineQid.for_gate(val))
+        decomposition = cirq.decompose_once_with_qubits(val, qubits, default=None)
+
+    if decomposition is None or decomposition is NotImplemented:
+        return
+
+    c = cirq.Circuit(decomposition)
+    if len(c.all_qubits().difference(qubits)) == 0:
+        return
+
+    clean_qubits = tuple(q for q in c.all_qubits() if isinstance(q, cirq.ops.CleanQubit))
+    borrowable_qubits = tuple(q for q in c.all_qubits() if isinstance(q, cirq.ops.BorrowableQubit))
+    qubit_order = clean_qubits + borrowable_qubits + qubits
+
+    # Check that the decomposition uses all data qubits in addition to
+    # clean and/or borrowable qubits.
+    assert set(qubit_order) == c.all_qubits()
+
+    qid_shape = cirq.qid_shape(qubit_order)
+    full_unitary = cirq.apply_unitaries(
+        decomposition,
+        qubits=qubit_order,
+        args=cirq.ApplyUnitaryArgs.for_unitary(qid_shape=qid_shape),
+        default=None,
+    )
+    if full_unitary is None:
+        raise ValueError(f'apply_unitaries failed on the decomposition of {val}')
+    vol = np.prod(qid_shape, dtype=np.int64)
+    full_unitary = full_unitary.reshape((vol, vol))
+
+    vol = np.prod(cirq.qid_shape(borrowable_qubits + qubits), dtype=np.int64)
+
+    # Extract the submatrix acting on the |0..0> subspace of clean qubits.
+    # This submatirx must be a unitary.
+    clean_qubits_zero_subspace = full_unitary[:vol, :vol]
+
+    # If the borrowable qubits are restored to their initial state, then
+    # the decomposition's effect on it is the identity matrix.
+    # This means that the `clean_qubits_zero_subspace` must be I \otimes u.
+    # So checking that `clean_qubits_zero_subspace` is I \otimes u checks correctness
+    # for both clean and borrowable qubits at the same time.
+    expected = np.kron(np.eye(2 ** len(borrowable_qubits), dtype=np.complex128), u)
+
+    if ignoring_global_phase:
+        cirq.testing.assert_allclose_up_to_global_phase(
+            clean_qubits_zero_subspace, expected, atol=1e-8
+        )
+    else:
+        np.testing.assert_allclose(clean_qubits_zero_subspace, expected, atol=1e-8)

cirq/testing/consistent_unitary_test.py

@@ -0,0 +1,96 @@
+# Copyright 2023 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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 cirq
+
+import pytest
+import numpy as np
+
+
+class InconsistentGate(cirq.Gate):
+    def _num_qubits_(self) -> int:
+        return 1
+
+    def _unitary_(self) -> np.ndarray:
+        return np.eye(2, dtype=np.complex128)
+
+    def _decompose_with_context_(self, qubits, *, context):
+        (q,) = context.qubit_manager.qalloc(1)
+        yield cirq.X(q)
+        yield cirq.CNOT(q, qubits[0])
+
+
+class FailsOnDecompostion(cirq.Gate):
+    def _num_qubits_(self) -> int:
+        return 1
+
+    def _unitary_(self) -> np.ndarray:
+        return np.eye(2, dtype=np.complex128)
+
+    def _has_unitary_(self) -> bool:
+        return True
+
+    def _decompose_with_context_(self, qubits, *, context):
+        (q,) = context.qubit_manager.qalloc(1)
+        yield cirq.X(q)
+        yield cirq.measure(qubits[0])
+
+
+class CleanCorrectButBorrowableIncorrectGate(cirq.Gate):
+    """Ancilla type determines if the decomposition is correct or not."""
+
+    def __init__(self, use_clean_ancilla: bool) -> None:
+        self.ancillas_are_clean = use_clean_ancilla
+
+    def _num_qubits_(self):
+        return 2
+
+    def _decompose_with_context_(self, qubits, *, context):
+        if self.ancillas_are_clean:
+            anc = context.qubit_manager.qalloc(1)
+        else:
+            anc = context.qubit_manager.qborrow(1)
+        yield cirq.CCNOT(*qubits, *anc)
+        yield cirq.Z(*anc)
+        yield cirq.CCNOT(*qubits, *anc)
+        context.qubit_manager.qfree(anc)
+
+
+@pytest.mark.parametrize('ignore_phase', [False, True])
+@pytest.mark.parametrize(
+    'g,is_consistent',
+    [
+        (cirq.testing.PhaseUsingCleanAncilla(theta=0.1, ancilla_bitsize=3), True),
+        (cirq.testing.PhaseUsingDirtyAncilla(phase_state=1, ancilla_bitsize=4), True),
+        (InconsistentGate(), False),
+        (CleanCorrectButBorrowableIncorrectGate(use_clean_ancilla=True), True),
+        (CleanCorrectButBorrowableIncorrectGate(use_clean_ancilla=False), False),
+    ],
+)
+def test_assert_unitary_is_consistent(g, ignore_phase, is_consistent):
+    if is_consistent:
+        cirq.testing.assert_unitary_is_consistent(g, ignore_phase)
+        cirq.testing.assert_unitary_is_consistent(g.on(*cirq.LineQid.for_gate(g)), ignore_phase)
+    else:
+        with pytest.raises(AssertionError):
+            cirq.testing.assert_unitary_is_consistent(g, ignore_phase)
+        with pytest.raises(AssertionError):
+            cirq.testing.assert_unitary_is_consistent(g.on(*cirq.LineQid.for_gate(g)), ignore_phase)
+
+
+def test_failed_decomposition():
+    with pytest.raises(ValueError):
+        cirq.testing.assert_unitary_is_consistent(FailsOnDecompostion())
+
+    _ = cirq.testing.assert_unitary_is_consistent(cirq.Circuit())

cirq/testing/sample_gates.py

@@ -15,7 +15,7 @@ import dataclasses
 
 import cirq
 import numpy as np
-from cirq import ops, qis
+from cirq import ops, qis, protocols
 
 
 def _matrix_for_phasing_state(num_qubits, phase_state, phase):
@@ -39,8 +39,8 @@ class PhaseUsingCleanAncilla(ops.Gate):
     def _num_qubits_(self):
         return self.target_bitsize
 
-    def _decompose_(self, qubits):
-        anc = ops.NamedQubit.range(self.ancilla_bitsize, prefix="anc")
+    def _decompose_with_context_(self, qubits, *, context: protocols.DecompositionContext):
+        anc = context.qubit_manager.qalloc(self.ancilla_bitsize)
         cv = [int(x) for x in f'{self.phase_state:0{self.target_bitsize}b}']
         cnot_ladder = [cirq.CNOT(anc[i - 1], anc[i]) for i in range(1, self.ancilla_bitsize)]
 
@@ -65,8 +65,8 @@ class PhaseUsingDirtyAncilla(ops.Gate):
     def _num_qubits_(self):
         return self.target_bitsize
 
-    def _decompose_(self, qubits):
-        anc = ops.NamedQubit.range(self.ancilla_bitsize, prefix="anc")
+    def _decompose_with_context_(self, qubits, *, context: protocols.DecompositionContext):
+        anc = context.qubit_manager.qalloc(self.ancilla_bitsize)
         cv = [int(x) for x in f'{self.phase_state:0{self.target_bitsize}b}']
         cnot_ladder = [cirq.CNOT(anc[i - 1], anc[i]) for i in range(1, self.ancilla_bitsize)]
         yield ops.X(anc[0]).controlled_by(*qubits, control_values=cv)

{cirq_core-1.2.0.dev20230712233101.dist-info → cirq_core-1.2.0.dev20230717131509.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cirq-core
-Version: 1.2.0.dev20230712233101
+Version: 1.2.0.dev20230717131509
 Summary: A framework for creating, editing, and invoking Noisy Intermediate Scale Quantum (NISQ) circuits.
 Home-page: http://github.com/quantumlib/cirq
 Author: The Cirq Developers

{cirq_core-1.2.0.dev20230712233101.dist-info → cirq_core-1.2.0.dev20230717131509.dist-info}/RECORD

@@ -4,7 +4,7 @@ cirq/_compat_test.py,sha256=tFt1lskrZi_Pmn8ZDeMxxfCNTivqVGzKiIYrskK0dE4,33898
 cirq/_doc.py,sha256=yDyWUD_2JDS0gShfGRb-rdqRt9-WeL7DhkqX7np0Nko,2879
 cirq/_import.py,sha256=p9gMHJscbtDDkfHOaulvd3Aer0pwUF5AXpL89XR8dNw,8402
 cirq/_import_test.py,sha256=6K_v0riZJXOXUphHNkGA8MY-JcmGlezFaGmvrNhm3OQ,1015
-cirq/_version.py,sha256=yzW5fCWOEqzpiO03c0juYR6Sd0YmGNzP04VMceYnCvI,40
+cirq/_version.py,sha256=QQD_zp2Pz0RjGtHznPQGYTcKwoDhcAb9nl0tOqHjiKU,40
 cirq/_version_test.py,sha256=ZM9GLAiU02rzyJQ_HOT2o_tZixJ0lMXs4tCkOareqTA,133
 cirq/conftest.py,sha256=mHCDs5--u17oLFDAfIlkTS4TRGSc35eLnZ2CXuIuB7I,1175
 cirq/json_resolver_cache.py,sha256=JJiO1dhHsEqYClUv68eg-hiOzbb_C1QiQ-BCcvoe4Ck,13067
@@ -924,7 +924,7 @@ cirq/study/sweepable.py,sha256=BMgq8lxVnyJGBeu4gFUt_0P_v4gFwKgazZFftRUEwnA,4185
 cirq/study/sweepable_test.py,sha256=xjUksIurfbh240fEC7Al_TuiHGz7xZGktQUh86XBG9U,4772
 cirq/study/sweeps.py,sha256=IzonyU-LgEcMpvQrKZbl14v-BHi01oncp9CmHtLw0J4,19813
 cirq/study/sweeps_test.py,sha256=IqZp0ywYA430nNE_slBfc4vdKjULttzPl8ytxHLlgWo,11966
-cirq/testing/__init__.py,sha256=j0fTBwpqzz_CW9dnkkSQMnaUkPRQAhikpXJxZwhbaQY,3691
+cirq/testing/__init__.py,sha256=fYJsFpYtz_4JY3ClCh647oZY7ev27lebzwJ4hXDevXQ,3765
 cirq/testing/circuit_compare.py,sha256=Daor8s6gVQKRO9JX0vOi3rU4hWu7_a0sWKc1E7sypOk,19350
 cirq/testing/circuit_compare_test.py,sha256=6Xw1hrBUDavhji_ygpCKLBHUt_0melvy2VTjH2VcJwk,19743
 cirq/testing/consistent_act_on.py,sha256=bgV2LzqTG8rcxMephuWqoAhd_Q2rPWNGHOnbLRg6KT4,7854
@@ -933,19 +933,21 @@ cirq/testing/consistent_channels.py,sha256=hrPRjaabPko2l0xqqkJ8F3OM7pornkDNCP-St
 cirq/testing/consistent_channels_test.py,sha256=Xpm0KA5ArxGKh3h1GJ9sdDrLuyDCrnkVZgzPZOQYsTY,3485
 cirq/testing/consistent_controlled_gate_op.py,sha256=mU3h3OtpPzqntRcKn8SqaaYU_evw2MpoB_jQywECsnI,2206
 cirq/testing/consistent_controlled_gate_op_test.py,sha256=K2oqmMQvMepQ_SM1sre-E7wNeQlCATKvuGG7rwJUhGQ,2941
-cirq/testing/consistent_decomposition.py,sha256=srPFMIHTXv-sxdQQC99b8kX4wLn4E7zYAA2gopv-SIg,3325
-cirq/testing/consistent_decomposition_test.py,sha256=-GpUKAjMdKUKso_5xNbgqg8d0YVuI-r0_PWGEkwqoq0,3531
+cirq/testing/consistent_decomposition.py,sha256=UxXW0Mn6XyDcVtL5-JcPC2f7BAkndyU1HNokQj8PB_Y,3731
+cirq/testing/consistent_decomposition_test.py,sha256=6GUPhZQI4FVHM9fYZbHr62-TrwiK0jOPMTOznDellFw,3820
 cirq/testing/consistent_pauli_expansion.py,sha256=NVloOg1I8LGGIEoZxvtUQIUHRvMgo9CNgw5-atuXGsE,1580
 cirq/testing/consistent_pauli_expansion_test.py,sha256=Gy95osE-L4uQs1E1oxAKHCgVguXl-hjI5UNQJW5cEdI,2402
 cirq/testing/consistent_phase_by.py,sha256=oSZcZnKMOIJnBS0HgYi-8aRaVJmHGgI--WAUGC5JxQ8,2085
 cirq/testing/consistent_phase_by_test.py,sha256=YbI0n0FpWpBkbgYp0-yGZSeesDZEst0cmYtXgJE2LQY,3273
-cirq/testing/consistent_protocols.py,sha256=9apl2Ed1j2FeWDh-tPNOdnGQhOLbwmSojINPD3YL1OA,7473
+cirq/testing/consistent_protocols.py,sha256=dFixwCjCeXmu9EXv4QjIUBXnl1K1UYeMjBUQcZgBD_o,7629
 cirq/testing/consistent_protocols_test.py,sha256=vRRWpp2nqtbIJEvAvRLpKbrfZgTsl1fOm8hv4zlJBiE,10126
 cirq/testing/consistent_qasm.py,sha256=QjawKbxbKhcnbybLqls2OoQ7AusU14H1afv1qj-uxzM,5191
 cirq/testing/consistent_qasm_test.py,sha256=PGXPXexT6sjbbgKdouWWZ9pyXvwRA0HaMrtUzE-yyiQ,2890
 cirq/testing/consistent_resolve_parameters.py,sha256=hYbp6kbXrOLCc1DMDRC2zTAx1qlvCCJMuzZ7a5cGhmA,1973
 cirq/testing/consistent_specified_has_unitary.py,sha256=WY2YPFvRTGoj5gxtbs4jtB18S-yj5MIJkdz2gVda9Gw,1237
 cirq/testing/consistent_specified_has_unitary_test.py,sha256=qMar7K1CoubcX_rl9i3iQdI-LpF-OxvY8V4h7k_f26A,2571
+cirq/testing/consistent_unitary.py,sha256=JWUNy4HeWbs4JjPm6kLTKfqNq1wP2e3WYQxpDabkfZU,3247
+cirq/testing/consistent_unitary_test.py,sha256=MS0cHzR7gwy4zM_AHiYqNErj7bhqmQX78eIuaYORO6Q,3260
 cirq/testing/deprecation.py,sha256=neyww8gBZZmgwPX8xPw8Mg4HgG0OXwSixhOAHnIU2ks,2152
 cirq/testing/deprecation_test.py,sha256=bWq_VY-rGnfvdeJVqdkMIDzMtxQRj9rdR6gu0kCHtzo,2166
 cirq/testing/devices.py,sha256=fA0rcpZxMU0fVObtLcsDJa4XS_QBzi6uH58W0PAYOoA,3259
@@ -978,7 +980,7 @@ cirq/testing/routing_devices.py,sha256=uIm0j7GcChiHog9-c7kyIw9qdfBEmLLETRF37UwLv
 cirq/testing/routing_devices_test.py,sha256=iyNZp3J8fUt8bOktXZNhDgxR6L8UBRphgzYmDsmHvTw,5598
 cirq/testing/sample_circuits.py,sha256=8HTrY_RWoPHV18q7aLz6e5Fjd2Twkt9Wkc_IDBzTE1o,1585
 cirq/testing/sample_circuits_test.py,sha256=IMz72CMXJeRt7Eg1rRB68hFV1v3k7OQpYUyhqmfjNpo,876
-cirq/testing/sample_gates.py,sha256=xhFeAMWt-VZWjYW4UEnmlXuZYZIlvLx7idbalT1gor4,3164
+cirq/testing/sample_gates.py,sha256=qSCZhb-A-Mwm_J81Su2sUFyEUdvqfq7Je66dsk8cFy0,3277
 cirq/testing/sample_gates_test.py,sha256=mkfYPNo4WFH6y33Vr_f9zy2Ry1oq5yYLpB__sqSCkjQ,2377
 cirq/testing/_compat_test_data/__init__.py,sha256=yIe0dUE7-FT1bxYjc0hcoOZQkecBdYN5onC6KOpsx8U,3040
 cirq/testing/_compat_test_data/module_a/__init__.py,sha256=klpfbI8BVz2BA5TwhUDGqMSM0Sjw6ABIA_4hpyADHaE,386
@@ -1138,8 +1140,8 @@ cirq/work/sampler.py,sha256=JVv1vvfa6EgFiR3UeDk44U186dCrioH2NZXueCgsb9w,19828
 cirq/work/sampler_test.py,sha256=zo1Hj6sn6fLs_WZMxYRApBqgBsldmptn74NL0jhNukc,12325
 cirq/work/zeros_sampler.py,sha256=D3hbNZC-jXKuNAWg2OUiUuT8pmDV_WFnEfMank6In4o,2357
 cirq/work/zeros_sampler_test.py,sha256=JIkpBBFPJe5Ba4142vzogyWyboG1Q1ZAm0UVGgOoZn8,3279
-cirq_core-1.2.0.dev20230712233101.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-cirq_core-1.2.0.dev20230712233101.dist-info/METADATA,sha256=-qt8i5CFsCs6yaRtIQ8KttPxzi2MxEetd0HFSTzD0BU,2095
-cirq_core-1.2.0.dev20230712233101.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-cirq_core-1.2.0.dev20230712233101.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
-cirq_core-1.2.0.dev20230712233101.dist-info/RECORD,,
+cirq_core-1.2.0.dev20230717131509.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+cirq_core-1.2.0.dev20230717131509.dist-info/METADATA,sha256=bSlKWub-9LcGFV10b2VqNPinYWWU8WLsBNXvVIILi64,2095
+cirq_core-1.2.0.dev20230717131509.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+cirq_core-1.2.0.dev20230717131509.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
+cirq_core-1.2.0.dev20230717131509.dist-info/RECORD,,