cirq-core 1.4.0.dev20240518010119__py3-none-any.whl → 1.4.0.dev20240521175101__py3-none-any.whl

cirq/__init__.py

@@ -332,6 +332,7 @@ from cirq.ops import (
     ZPowGate,
     ZZ,
     ZZPowGate,
+    UniformSuperpositionGate,
 )
 
 from cirq.transformers import (

cirq/_version.py

@@ -1 +1 @@
-__version__ = "1.4.0.dev20240518010119"
+__version__ = "1.4.0.dev20240521175101"

cirq/json_resolver_cache.py

@@ -247,6 +247,7 @@ def _class_resolver_dictionary() -> Dict[str, ObjectFactory]:
         'ZipLongest': cirq.ZipLongest,
         'ZPowGate': cirq.ZPowGate,
         'ZZPowGate': cirq.ZZPowGate,
+        'UniformSuperpositionGate': cirq.UniformSuperpositionGate,
         # Old types, only supported for backwards-compatibility
         'BooleanHamiltonian': _boolean_hamiltonian_gate_op,  # Removed in v0.15
         'CrossEntropyResult': _cross_entropy_result,  # Removed in v0.16

cirq/ops/__init__.py

@@ -217,3 +217,5 @@ from cirq.ops.wait_gate import wait, WaitGate
 from cirq.ops.state_preparation_channel import StatePreparationChannel
 
 from cirq.ops.control_values import AbstractControlValues, ProductOfSums, SumOfProducts
+
+from cirq.ops.uniform_superposition_gate import UniformSuperpositionGate

cirq/ops/uniform_superposition_gate.py

@@ -0,0 +1,123 @@
+# Copyright 2024 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 Sequence, Any, Dict, TYPE_CHECKING
+
+import numpy as np
+from cirq.ops.common_gates import H, ry
+from cirq.ops.pauli_gates import X
+from cirq.ops import raw_types
+
+
+if TYPE_CHECKING:
+    import cirq
+
+
+class UniformSuperpositionGate(raw_types.Gate):
+    r"""Creates a uniform superposition state on the states $[0, M)$
+    The gate creates the state $\frac{1}{\sqrt{M}}\sum_{j=0}^{M-1}\ket{j}$
+    (where $1\leq M \leq 2^n$), using n qubits, according to the Shukla-Vedula algorithm [SV24].
+    References:
+        [SV24]
+        [An efficient quantum algorithm for preparation of uniform quantum superposition
+        states](https://arxiv.org/abs/2306.11747)
+    """
+
+    def __init__(self, m_value: int, num_qubits: int) -> None:
+        """Initializes UniformSuperpositionGate.
+
+        Args:
+            m_value: The number of computational basis states.
+            num_qubits: The number of qubits used.
+
+        Raises:
+            ValueError: If `m_value` is not a positive integer, or
+                if `num_qubits` is not an integer greater than or equal to log2(m_value).
+        """
+        if not (isinstance(m_value, int) and (m_value > 0)):
+            raise ValueError("m_value must be a positive integer.")
+        log_two_m_value = m_value.bit_length()
+
+        if (m_value & (m_value - 1)) == 0:
+            log_two_m_value = log_two_m_value - 1
+        if not (isinstance(num_qubits, int) and (num_qubits >= log_two_m_value)):
+            raise ValueError(
+                "num_qubits must be an integer greater than or equal to log2(m_value)."
+            )
+        self._m_value = m_value
+        self._num_qubits = num_qubits
+
+    def _decompose_(self, qubits: Sequence["cirq.Qid"]) -> "cirq.OP_TREE":
+        """Decomposes the gate into a sequence of standard gates.
+        Implements the construction from https://arxiv.org/pdf/2306.11747.
+        """
+        qreg = list(qubits)
+        qreg.reverse()
+
+        if self._m_value == 1:  #  if m_value is 1, do nothing
+            return
+        if (self._m_value & (self._m_value - 1)) == 0:  # if m_value is an integer power of 2
+            m = self._m_value.bit_length() - 1
+            yield H.on_each(qreg[:m])
+            return
+        k = self._m_value.bit_length()
+        l_value = []
+        for i in range(self._m_value.bit_length()):
+            if (self._m_value >> i) & 1:
+                l_value.append(i)  # Locations of '1's
+
+        yield X.on_each(qreg[q_bit] for q_bit in l_value[1:k])
+        m_current = 2 ** (l_value[0])
+        theta = -2 * np.arccos(np.sqrt(m_current / self._m_value))
+        if l_value[0] > 0:  # if m_value is even
+            yield H.on_each(qreg[: l_value[0]])
+
+        yield ry(theta).on(qreg[l_value[1]])
+
+        for i in range(l_value[0], l_value[1]):
+            yield H(qreg[i]).controlled_by(qreg[l_value[1]], control_values=[False])
+
+        for m in range(1, len(l_value) - 1):
+            theta = -2 * np.arccos(np.sqrt(2 ** l_value[m] / (self._m_value - m_current)))
+            yield ry(theta).on(qreg[l_value[m + 1]]).controlled_by(
+                qreg[l_value[m]], control_values=[0]
+            )
+            for i in range(l_value[m], l_value[m + 1]):
+                yield H.on(qreg[i]).controlled_by(qreg[l_value[m + 1]], control_values=[0])
+
+            m_current = m_current + 2 ** (l_value[m])
+
+    def num_qubits(self) -> int:
+        return self._num_qubits
+
+    @property
+    def m_value(self) -> int:
+        return self._m_value
+
+    def __eq__(self, other):
+        if isinstance(other, UniformSuperpositionGate):
+            return (self._m_value == other._m_value) and (self._num_qubits == other._num_qubits)
+        return False
+
+    def __repr__(self) -> str:
+        return f'UniformSuperpositionGate(m_value={self._m_value}, num_qubits={self._num_qubits})'
+
+    def _json_dict_(self) -> Dict[str, Any]:
+        d = {}
+        d['m_value'] = self._m_value
+        d['num_qubits'] = self._num_qubits
+        return d
+
+    def __str__(self) -> str:
+        return f'UniformSuperpositionGate(m_value={self._m_value}, num_qubits={self._num_qubits})'

cirq/ops/uniform_superposition_gate_test.py

@@ -0,0 +1,94 @@
+# Copyright 2024 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 numpy as np
+import pytest
+import cirq
+
+
+@pytest.mark.parametrize(
+    ["m", "n"],
+    [[int(m), n] for n in range(3, 7) for m in np.random.randint(1, 1 << n, size=3)]
+    + [(1, 2), (4, 2), (6, 3), (7, 3)],
+)
+def test_generated_unitary_is_uniform(m: int, n: int) -> None:
+    r"""The code checks that the unitary matrix corresponds to the generated uniform superposition
+    states (see uniform_superposition_gate.py). It is enough to check that the
+    first colum of the unitary matrix (which corresponds to the action of the gate on
+    $\ket{0}^n$ is $\frac{1}{\sqrt{M}} [1 1  \cdots 1 0 \cdots 0]^T$, where the first $M$
+    entries are all "1"s (excluding the normalization factor of $\frac{1}{\sqrt{M}}$ and the
+    remaining $2^n-M$ entries are all "0"s.
+    """
+    gate = cirq.UniformSuperpositionGate(m, n)
+    matrix = np.array(cirq.unitary(gate))
+    np.testing.assert_allclose(
+        matrix[:, 0], (1 / np.sqrt(m)) * np.array([1] * m + [0] * (2**n - m)), atol=1e-8
+    )
+
+
+@pytest.mark.parametrize(["m", "n"], [(1, 1), (-2, 1), (-3.1, 2), (6, -4), (5, 6.1)])
+def test_incompatible_m_value_and_qubit_args(m: int, n: int) -> None:
+    r"""The code checks that test errors are raised if the arguments m (number of
+    superposition states and n (number of qubits) are positive integers and are compatible
+     (i.e., n >= log2(m)).
+    """
+
+    if not (isinstance(m, int)):
+        with pytest.raises(ValueError, match="m_value must be a positive integer."):
+            cirq.UniformSuperpositionGate(m, n)
+    elif not (isinstance(n, int)):
+        with pytest.raises(
+            ValueError,
+            match="num_qubits must be an integer greater than or equal to log2\\(m_value\\).",
+        ):
+            cirq.UniformSuperpositionGate(m, n)
+    elif m < 1:
+        with pytest.raises(ValueError, match="m_value must be a positive integer."):
+            cirq.UniformSuperpositionGate(int(m), int(n))
+    elif n < np.log2(m):
+        with pytest.raises(
+            ValueError,
+            match="num_qubits must be an integer greater than or equal to log2\\(m_value\\).",
+        ):
+            cirq.UniformSuperpositionGate(m, n)
+
+
+def test_repr():
+    assert (
+        repr(cirq.UniformSuperpositionGate(7, 3))
+        == 'UniformSuperpositionGate(m_value=7, num_qubits=3)'
+    )
+
+
+def test_uniform_superposition_gate_json_dict():
+    assert cirq.UniformSuperpositionGate(7, 3)._json_dict_() == {'m_value': 7, 'num_qubits': 3}
+
+
+def test_str():
+    assert (
+        str(cirq.UniformSuperpositionGate(7, 3))
+        == 'UniformSuperpositionGate(m_value=7, num_qubits=3)'
+    )
+
+
+@pytest.mark.parametrize(["m", "n"], [(5, 3), (10, 4)])
+def test_eq(m: int, n: int) -> None:
+    a = cirq.UniformSuperpositionGate(m, n)
+    b = cirq.UniformSuperpositionGate(m, n)
+    c = cirq.UniformSuperpositionGate(m + 1, n)
+    d = cirq.X
+    assert a.m_value == b.m_value
+    assert a.__eq__(b)
+    assert not (a.__eq__(c))
+    assert not (a.__eq__(d))

cirq/protocols/json_test_data/UniformSuperpositionGate.json

@@ -0,0 +1,5 @@
+{
+  "cirq_type": "UniformSuperpositionGate",
+  "m_value": 7,
+  "num_qubits": 3
+}

cirq/protocols/json_test_data/UniformSuperpositionGate.repr

@@ -0,0 +1 @@
+  cirq.UniformSuperpositionGate(m_value=7, num_qubits=3)

{cirq_core-1.4.0.dev20240518010119.dist-info → cirq_core-1.4.0.dev20240521175101.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cirq-core
-Version: 1.4.0.dev20240518010119
+Version: 1.4.0.dev20240521175101
 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.4.0.dev20240518010119.dist-info → cirq_core-1.4.0.dev20240521175101.dist-info}/RECORD

@@ -1,13 +1,13 @@
-cirq/__init__.py,sha256=gQkxjgGyat-egE2jZlrLCVMofvpG_VA1021yh8Tv9j8,15766
+cirq/__init__.py,sha256=dEwUzkNCNrL4qNyln6GUUrk7vGxY8OXNG9lk_C2gi6w,15796
 cirq/_compat.py,sha256=2tkJ50ID2PXzmMNuTfQrsZqqRSblTmfu3Y7g742gojs,29342
 cirq/_compat_test.py,sha256=Qq3ZcfgD-Nb81cEppQdJqhAyrVqXKtfXZYGXT0p-Wh0,34718
 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=fvYIncCrY6PRJBq5ZOweGpxrN8hohY9wqDC3_EtTFAI,40
+cirq/_version.py,sha256=gjXL3lv_qbsRaFrke8tn-Un4QjDXXzaoPaCiMqKwWCg,40
 cirq/_version_test.py,sha256=yYS6xm5-nuBRQJa9R3n41WdvFtVyY7Lb5Q8bea3VgBI,133
 cirq/conftest.py,sha256=X7yLFL8GLhg2CjPw0hp5e_dGASfvHx1-QT03aUbhKJw,1168
-cirq/json_resolver_cache.py,sha256=9g_JQMmfBzTuV-3s2flUbXIgcLjs4K7LjAFFgngdG1U,13204
+cirq/json_resolver_cache.py,sha256=ytePZtNZgKjOF2NiVpUTuotB-JKZmQNOFIFdvXqsxHw,13271
 cirq/py.typed,sha256=VFSlmh_lNwnaXzwY-ZuW-C2Ws5PkuDoVgBdNCs0jXJE,63
 cirq/type_workarounds.py,sha256=-qyat6dmVoz8z76I-JLrnK1vAXmY9G1Qa3LYjQ4rJlI,959
 cirq/circuits/__init__.py,sha256=UPBO-WG6VodQWDkYgJdBzKK8k9CsxHFGIENM95vh7ac,1117
@@ -262,7 +262,7 @@ cirq/neutral_atoms/__init__.py,sha256=D0ewdZZvXM_PC7WiyyM8V3WqBAwrpDV_GU_sCIbtw2
 cirq/neutral_atoms/convert_to_neutral_atom_gates.py,sha256=SsXFh1-NoBGqp4yX8-jIbIw-AK40baA-qh-iTL1wS6Q,1070
 cirq/neutral_atoms/convert_to_neutral_atom_gates_test.py,sha256=mIeGevxs9NoYpfTF_znHL67RrJKVQyQP-DPhn7t9SUA,1862
 cirq/neutral_atoms/neutral_atom_devices.py,sha256=s-LInrNp8k_txKbpLWfsaoiZvUScOWNxr-jiB-nFcDA,1358
-cirq/ops/__init__.py,sha256=x-M1ZOcdguA563aWyr65Ll-zuT191ek0BXTd-90u3U4,5381
+cirq/ops/__init__.py,sha256=7xt2bPwndo2OhuLLnI5GwBpG9rZHlt1rv7cp-bOBmxM,5455
 cirq/ops/arithmetic_operation.py,sha256=PBqIwOfADRlsij11Lo1ao_OZM-O8PDlObgZBxGKsYKs,10125
 cirq/ops/arithmetic_operation_test.py,sha256=axy8xy9IvDb-ATUV-LE1HNWRqCEz06VyZWVrLNOtXXI,4942
 cirq/ops/boolean_hamiltonian.py,sha256=hjmzBvWiZnb18JfdhId-dVxt2VmbyAbqMSFAPWV7s7I,14883
@@ -370,6 +370,8 @@ cirq/ops/three_qubit_gates.py,sha256=U6GGi1aNnLbhM40ViSsRqbOIA51i1kjKMEf5ei8TmIg
 cirq/ops/three_qubit_gates_test.py,sha256=iQfQ4p4TwtyHYCqaWOEeZsqszF_Mp49VwlIKRydClMk,11778
 cirq/ops/two_qubit_diagonal_gate.py,sha256=UYz2lUN8YzQjaqBZ_rmg6TvLFSRAvSlQGhnPOL5FmNQ,5376
 cirq/ops/two_qubit_diagonal_gate_test.py,sha256=qiuREluCDKMok3ormBOdDYCFlOS9u1zFLqTsORO5JtM,4000
+cirq/ops/uniform_superposition_gate.py,sha256=DBItkN48YM6GJCBITdvztEnacGB0HcEYo55ODC02WE0,4705
+cirq/ops/uniform_superposition_gate_test.py,sha256=9N8woRmaFWeuaPMy2K1JlXyTG8bICIpsfmOzXc3NysU,3551
 cirq/ops/wait_gate.py,sha256=ZJ9cqRysAyUYgfswVWO5C2OkDZ9MFEQjSemLw0w3drA,5654
 cirq/ops/wait_gate_test.py,sha256=2Uw8ZjFkYGhDosoxbJr_IW2wWdxY8kXR-CLyC69DYRg,3543
 cirq/protocols/__init__.py,sha256=kGCV1tzQ1m8fjrOPhapDpnStu-rFNe4q188OQY1huHg,4006
@@ -766,6 +768,8 @@ cirq/protocols/json_test_data/TwoQubitMatrixGate.json_inward,sha256=2E6o8tzoiTnt
 cirq/protocols/json_test_data/TwoQubitMatrixGate.repr_inward,sha256=G6v-BqECV3dcPiIjNLRUQYrRVtyLt0HqD00fDXwzt8o,151
 cirq/protocols/json_test_data/UNCONSTRAINED_DEVICE.json,sha256=EK2bbhnx9EEnhJx16J7LjamlC6nUwt_DeKaXmcxcTyU,41
 cirq/protocols/json_test_data/UNCONSTRAINED_DEVICE.repr,sha256=qPILaenyLEonsD0rywxnEyICOS7ANVo6X0cb7Sg5sj8,25
+cirq/protocols/json_test_data/UniformSuperpositionGate.json,sha256=iK4MquwPDvWyDaEzkz7cERIc1xcbNZ-MScdttjHb2VU,81
+cirq/protocols/json_test_data/UniformSuperpositionGate.repr,sha256=lft1g9nxkx_63DFHixSQL8e8tIOoz4PXDW7RqEhGw6A,57
 cirq/protocols/json_test_data/VarianceStoppingCriteria.json,sha256=PVdbXD8P9qjLqBI1ULgEVGEHxZhl0ahduLASk2VhrDU,105
 cirq/protocols/json_test_data/VarianceStoppingCriteria.repr,sha256=8J4dzmOZuhZ8jjDISwSLwY3JqIFG8f_8HvLT7az-tqA,84
 cirq/protocols/json_test_data/VirtualTag.json,sha256=yd6Yr22V94ycuO8UoYnWkV5Y8LgX83M-6Us2mUj7wq4,31
@@ -1171,8 +1175,8 @@ cirq/work/sampler.py,sha256=JEAeQQRF3bqlO9AkOf4XbrTATDI5f5JgyM_FAUCNxao,19751
 cirq/work/sampler_test.py,sha256=B2ZsuqGT854gQtBIAh8k0LiG9Vj5wSzcGvkxOUoTcW4,13217
 cirq/work/zeros_sampler.py,sha256=x1C7cup66a43n-3tm8QjhiqJa07qcJW10FxNp9jJ59Q,2356
 cirq/work/zeros_sampler_test.py,sha256=JIkpBBFPJe5Ba4142vzogyWyboG1Q1ZAm0UVGgOoZn8,3279
-cirq_core-1.4.0.dev20240518010119.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-cirq_core-1.4.0.dev20240518010119.dist-info/METADATA,sha256=_B0kSyB6jWVIHsGmfswYX-IFIC_dGpn2itPtIdxb4aE,2000
-cirq_core-1.4.0.dev20240518010119.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-cirq_core-1.4.0.dev20240518010119.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
-cirq_core-1.4.0.dev20240518010119.dist-info/RECORD,,
+cirq_core-1.4.0.dev20240521175101.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+cirq_core-1.4.0.dev20240521175101.dist-info/METADATA,sha256=CwznpFgBHsmlBrBR4YPtL792EIaxWuS3RKxCjCQTgy0,2000
+cirq_core-1.4.0.dev20240521175101.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+cirq_core-1.4.0.dev20240521175101.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
+cirq_core-1.4.0.dev20240521175101.dist-info/RECORD,,