cirq-core 1.7.0.dev20250825174419__py3-none-any.whl → 1.7.0.dev20251203004401__py3-none-any.whl

cirq/contrib/qasm_import/_parser.py

@@ -17,7 +17,8 @@ from __future__ import annotations
 import dataclasses
 import functools
 import operator
-from typing import Any, Callable, cast, Iterable, TYPE_CHECKING
+from collections.abc import Callable, Iterable
+from typing import Any, cast, TYPE_CHECKING
 
 import numpy as np
 import sympy
@@ -1100,19 +1101,34 @@ class QasmParser:
 
         p[0] = [ops.ResetChannel().on(qreg[i]) for i in range(len(qreg))]
 
+    # condition list
+    # condition_list : carg EQ NATURAL_NUMBER
+    #                | condition_list AND carg EQ NATURAL_NUMBER
+
+    def p_condition_list_single(self, p):
+        """condition_list : carg EQ NATURAL_NUMBER"""
+        p[0] = [(p[1], p[3])]
+
+    def p_condition_list_and(self, p):
+        """condition_list : condition_list AND carg EQ NATURAL_NUMBER"""
+        p[0] = p[1] + [(p[3], p[5])]
+
     # if operations
     # if : IF '(' carg EQ NATURAL_NUMBER ')' ID qargs
 
     def p_if(self, p):
-        """if : IF '(' carg EQ NATURAL_NUMBER ')' gate_op"""
-        # We have to split the register into bits (since that's what measurement does above),
-        # and create one condition per bit, checking against that part of the binary value.
+        """if : IF '(' condition_list ')' gate_op"""
+        # For each condition, we have to split the register into bits (since that's what
+        # measurement does above), and create one condition per bit, checking against that part of
+        # the binary value.
         conditions = []
-        for i, key in enumerate(p[3]):
-            v = (p[5] >> i) & 1
-            conditions.append(sympy.Eq(sympy.Symbol(key), v))
+        for cond in p[3]:
+            carg, val = cond
+            for i, key in enumerate(carg):
+                v = (val >> i) & 1
+                conditions.append(sympy.Eq(sympy.Symbol(key), v))
         p[0] = [
-            ops.ClassicallyControlledOperation(conditions=conditions, sub_operation=tuple(p[7])[0])
+            ops.ClassicallyControlledOperation(conditions=conditions, sub_operation=tuple(p[5])[0])
         ]
 
     def p_gate_params_multiple(self, p):

cirq/contrib/qasm_import/_parser_test.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 import re
 import textwrap
-from typing import Callable
+from collections.abc import Callable
 
 import numpy as np
 import pytest
@@ -294,12 +294,50 @@ def test_classical_control_multi_bit() -> None:
     ct.assert_same_circuits(parsed_qasm.circuit, expected_circuit)
     assert parsed_qasm.qregs == {'q': 2}
 
-    # Note that this will *not* round-trip, but there's no good way around that due to the
-    # difference in how Cirq and QASM do multi-bit measurements.
-    with pytest.raises(ValueError, match='QASM does not support multiple conditions'):
+    # Note that this will *not* round-trip in QASM 2.0, but there's no good way around that due
+    # to the difference in how Cirq and QASM 2.0 do multi-bit measurements.
+    # Exporting multi-controlled operations in QASM 3.0 is supported with explicit '&&' between
+    # conditions.
+    with pytest.raises(
+        ValueError,
+        match='QASM 2.0 does not support multiple conditions. Consider exporting with QASM 3.0.',
+    ):
         _ = cirq.qasm(parsed_qasm.circuit)
 
 
+def test_classical_control_multi_cond_and() -> None:
+    qasm = """OPENQASM 3.0;
+        include "stdgates.inc";
+        qubit[2] q;
+        bit[2] a;
+
+        a[0] = measure q[0];
+        a[1] = measure q[1];
+
+        if (a[0]==1 && a[1]==0) cx q[0],q[1];
+    """
+    parser = QasmParser()
+
+    q_0 = cirq.NamedQubit('q_0')
+    q_1 = cirq.NamedQubit('q_1')
+
+    # Expect two independent conditions: a_0 == 1 and a_1 == 0
+    expected_circuit = cirq.Circuit(
+        cirq.measure(q_0, key='a_0'),
+        cirq.measure(q_1, key='a_1'),
+        cirq.CNOT(q_0, q_1).with_classical_controls(
+            sympy.Eq(sympy.Symbol('a_0'), 1), sympy.Eq(sympy.Symbol('a_1'), 0)
+        ),
+    )
+
+    parsed_qasm = parser.parse(qasm)
+
+    assert parsed_qasm.supportedFormat
+
+    ct.assert_same_circuits(parsed_qasm.circuit, expected_circuit)
+    assert parsed_qasm.qregs == {'q': 2}
+
+
 def test_CX_gate_not_enough_args() -> None:
     qasm = """OPENQASM 2.0;
      qreg q[2];
@@ -1051,8 +1089,8 @@ two_qubit_gates = [
 # Mapping of two-qubit gates and `num_params`
 two_qubit_param_gates = {
     # TODO: fix and enable commented gates below
-    # ('cu1', cirq.ControlledGate(QasmUGate(0, 0, 0.1 / np.pi))): 1,
-    # ('cu3', cirq.ControlledGate(QasmUGate(0.1 / np.pi, 0.2 / np.pi, 0.3 / np.pi))): 3,
+    ('cu1', cirq.ControlledGate(QasmUGate(0, 0, 0.1 / np.pi))): 1,
+    ('cu3', cirq.ControlledGate(QasmUGate(0.1 / np.pi, 0.2 / np.pi, 0.3 / np.pi))): 3,
     # ('cu', cirq.ControlledGate(QasmUGate(0.1 / np.pi, 0.2 / np.pi, 0.3 / np.pi))): 3,
     ('crx', cirq.ControlledGate(cirq.rx(0.1))): 1,
     ('cry', cirq.ControlledGate(cirq.ry(0.1))): 1,

cirq/contrib/qcircuit/qcircuit_pdf_test.py

@@ -14,18 +14,15 @@
 
 from __future__ import annotations
 
-from unittest import mock
-
-import pylatex
+import pathlib
 
 import cirq
 import cirq.contrib.qcircuit.qcircuit_pdf as qcircuit_pdf
 
 
-@mock.patch.object(pylatex.Document, "generate_pdf")
-def test_qcircuit_pdf(mock_generate_pdf) -> None:
+def test_qcircuit_pdf(tmp_path: pathlib.Path) -> None:
     circuit = cirq.Circuit(cirq.X(cirq.q(0)), cirq.CZ(cirq.q(0), cirq.q(1)))
-    qcircuit_pdf.circuit_to_pdf_using_qcircuit_via_tex(circuit, "/tmp/test_file")
-    mock_generate_pdf.assert_called_once_with(
-        "/tmp/test_file", compiler="latexmk", compiler_args=["-pdfps"]
-    )
+    qcircuit_pdf.circuit_to_pdf_using_qcircuit_via_tex(circuit, f"{tmp_path}/test_file")
+    assert (tmp_path / "test_file.pdf").is_file()
+    assert not (tmp_path / "test_file.dvi").exists()
+    assert not (tmp_path / "test_file.ps").exists()

cirq/contrib/quantikz/__init__.py

@@ -0,0 +1,21 @@
+# Copyright 2025 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.
+
+"""Converts Cirq circuits to LaTeX diagrams using the Quantikz package."""
+
+from cirq.contrib.quantikz.circuit_to_latex_quantikz import (
+    CircuitToQuantikz as CircuitToQuantikz,
+    GATE_STYLES_COLORFUL as GATE_STYLES_COLORFUL,
+)
+from cirq.contrib.quantikz.circuit_to_latex_render import render_circuit as render_circuit