cirq-core 1.4.1__py3-none-any.whl → 1.5.0__py3-none-any.whl

cirq/circuits/optimization_pass_test.py

@@ -11,16 +11,15 @@
 # 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 Optional, TYPE_CHECKING, Set, List
+
+from typing import List, Optional, Set
 
 import pytest
+
 import cirq
-from cirq import PointOptimizer, PointOptimizationSummary, Operation
+from cirq import Operation, PointOptimizationSummary, PointOptimizer
 from cirq.testing import EqualsTester
 
-if TYPE_CHECKING:
-    import cirq
-
 
 def test_equality():
     a = cirq.NamedQubit('a')
@@ -62,8 +61,8 @@ class ReplaceWithXGates(PointOptimizer):
     """
 
     def optimization_at(
-        self, circuit: 'cirq.Circuit', index: int, op: 'cirq.Operation'
-    ) -> Optional['cirq.PointOptimizationSummary']:
+        self, circuit: cirq.Circuit, index: int, op: cirq.Operation
+    ) -> Optional[cirq.PointOptimizationSummary]:
         end = index + 1
         new_ops = [cirq.X(q) for q in op.qubits]
         done = False
@@ -156,8 +155,8 @@ def test_point_optimizer_raises_on_gates_changing_qubits():
         """Changes all single qubit operations to act on LineQubit(42)"""
 
         def optimization_at(
-            self, circuit: 'cirq.Circuit', index: int, op: 'cirq.Operation'
-        ) -> Optional['cirq.PointOptimizationSummary']:
+            self, circuit: cirq.Circuit, index: int, op: cirq.Operation
+        ) -> Optional[cirq.PointOptimizationSummary]:
             new_op = op
             if len(op.qubits) == 1 and isinstance(op, cirq.GateOperation):
                 new_op = op.gate(cirq.LineQubit(42))

cirq/circuits/qasm_output.py

@@ -14,12 +14,14 @@
 
 """Utility classes for representing QASM."""
 
-from typing import Callable, Dict, Optional, Sequence, Set, Tuple, Union, TYPE_CHECKING
+from __future__ import annotations
 
 import re
+from typing import Callable, Dict, Iterator, Optional, Sequence, Tuple, TYPE_CHECKING, Union
+
 import numpy as np
 
-from cirq import ops, linalg, protocols, value
+from cirq import linalg, ops, protocols, value
 
 if TYPE_CHECKING:
     import cirq
@@ -46,15 +48,15 @@ class QasmUGate(ops.Gate):
         return 1
 
     @staticmethod
-    def from_matrix(mat: np.ndarray) -> 'QasmUGate':
+    def from_matrix(mat: np.ndarray) -> QasmUGate:
         pre_phase, rotation, post_phase = linalg.deconstruct_single_qubit_matrix_into_angles(mat)
         return QasmUGate(rotation / np.pi, post_phase / np.pi, pre_phase / np.pi)
 
     def _has_unitary_(self):
         return True
 
-    def _qasm_(self, qubits: Tuple['cirq.Qid', ...], args: 'cirq.QasmArgs') -> str:
-        args.validate_version('2.0')
+    def _qasm_(self, qubits: Tuple[cirq.Qid, ...], args: cirq.QasmArgs) -> str:
+        args.validate_version('2.0', '3.0')
         return args.format(
             'u3({0:half_turns},{1:half_turns},{2:half_turns}) {3};\n',
             self.theta,
@@ -86,13 +88,13 @@ class QasmUGate(ops.Gate):
         return {'theta': self.theta, 'phi': self.phi, 'lmda': self.lmda}
 
     @classmethod
-    def _from_json_dict_(cls, theta: float, phi: float, lmda: float, **kwargs) -> 'QasmUGate':
+    def _from_json_dict_(cls, theta: float, phi: float, lmda: float, **kwargs) -> QasmUGate:
         return cls(theta, phi, lmda)
 
 
 @value.value_equality
 class QasmTwoQubitGate(ops.Gate):
-    def __init__(self, kak: 'cirq.KakDecomposition') -> None:
+    def __init__(self, kak: cirq.KakDecomposition) -> None:
         """A two qubit gate represented in QASM by the KAK decomposition.
 
         All angles are in half turns.  Assumes a canonicalized KAK
@@ -110,7 +112,7 @@ class QasmTwoQubitGate(ops.Gate):
         return self.kak
 
     @staticmethod
-    def from_matrix(mat: np.ndarray, atol=1e-8) -> 'QasmTwoQubitGate':
+    def from_matrix(mat: np.ndarray, atol=1e-8) -> QasmTwoQubitGate:
         """Creates a QasmTwoQubitGate from the given matrix.
 
         Args:
@@ -126,7 +128,7 @@ class QasmTwoQubitGate(ops.Gate):
     def _unitary_(self):
         return protocols.unitary(self.kak)
 
-    def _decompose_(self, qubits: Sequence['cirq.Qid']) -> 'cirq.OP_TREE':
+    def _decompose_(self, qubits: Sequence[cirq.Qid]) -> Iterator[cirq.OP_TREE]:
         q0, q1 = qubits
         x, y, z = self.kak.interaction_coefficients
         a = x * -2 / np.pi + 0.5
@@ -170,8 +172,8 @@ class QasmOutput:
 
     def __init__(
         self,
-        operations: 'cirq.OP_TREE',
-        qubits: Tuple['cirq.Qid', ...],
+        operations: cirq.OP_TREE,
+        qubits: Tuple[cirq.Qid, ...],
         header: str = '',
         precision: int = 10,
         version: str = '2.0',
@@ -197,11 +199,13 @@ class QasmOutput:
         meas_key_id_map, meas_comments = self._generate_measurement_ids()
         self.meas_comments = meas_comments
         qubit_id_map = self._generate_qubit_ids()
+        self.cregs = self._generate_cregs(meas_key_id_map)
         self.args = protocols.QasmArgs(
             precision=precision,
             version=version,
             qubit_id_map=qubit_id_map,
             meas_key_id_map=meas_key_id_map,
+            meas_key_bitcount={k: v[0] for k, v in self.cregs.items()},
         )
 
     def _generate_measurement_ids(self) -> Tuple[Dict[str, str], Dict[str, Optional[str]]]:
@@ -223,9 +227,33 @@ class QasmOutput:
             meas_key_id_map[key] = meas_id
         return meas_key_id_map, meas_comments
 
-    def _generate_qubit_ids(self) -> Dict['cirq.Qid', str]:
+    def _generate_qubit_ids(self) -> Dict[cirq.Qid, str]:
         return {qubit: f'q[{i}]' for i, qubit in enumerate(self.qubits)}
 
+    def _generate_cregs(self, meas_key_id_map: Dict[str, str]) -> Dict[str, tuple[int, str]]:
+        """Pick an id for the creg that will store each measurement
+
+        This function finds the largest measurement using each key.
+        That is, if multiple measurements are made with the same key,
+        it will use the key with the most number of qubits.
+
+        Returns: dictionary with key of measurement id and value of (#qubits, comment).
+        """
+        cregs: Dict[str, tuple[int, str]] = {}
+        for meas in self.measurements:
+            key = protocols.measurement_key_name(meas)
+            meas_id = meas_key_id_map[key]
+
+            if self.meas_comments[key] is not None:
+                comment = f'  // Measurement: {self.meas_comments[key]}'
+            else:
+                comment = ''
+
+            if meas_id not in cregs or cregs[meas_id][0] < len(meas.qubits):
+                cregs[meas_id] = (len(meas.qubits), comment)
+
+        return cregs
+
     def is_valid_qasm_id(self, id_str: str) -> bool:
         """Test if id_str is a valid id in QASM grammar."""
         return self.valid_id_re.match(id_str) is not None
@@ -246,7 +274,7 @@ class QasmOutput:
         return ''.join(output)
 
     def _write_qasm(self, output_func: Callable[[str], None]) -> None:
-        self.args.validate_version('2.0')
+        self.args.validate_version('2.0', '3.0')
 
         # Generate nice line spacing
         line_gap = [0]
@@ -267,8 +295,12 @@ class QasmOutput:
             output('\n')
 
         # Version
-        output('OPENQASM 2.0;\n')
-        output('include "qelib1.inc";\n')
+        output(f'OPENQASM {self.args.version};\n')
+        if self.args.version == '2.0':
+            output('include "qelib1.inc";\n')
+        else:
+            output('include "stdgates.inc";\n')
+
         output_line_gap(2)
 
         # Function definitions
@@ -276,23 +308,22 @@ class QasmOutput:
 
         # Register definitions
         # Qubit registers
+
         output(f"// Qubits: [{', '.join(map(str, self.qubits))}]\n")
         if len(self.qubits) > 0:
-            output(f'qreg q[{len(self.qubits)}];\n')
+            if self.args.version == '2.0':
+                output(f'qreg q[{len(self.qubits)}];\n')
+            else:
+                output(f'qubit[{len(self.qubits)}] q;\n')
+
         # Classical registers
-        # Pick an id for the creg that will store each measurement
-        already_output_keys: Set[str] = set()
-        for meas in self.measurements:
-            key = protocols.measurement_key_name(meas)
-            if key in already_output_keys:
-                continue
-            already_output_keys.add(key)
-            meas_id = self.args.meas_key_id_map[key]
-            comment = self.meas_comments[key]
-            if comment is None:
-                output(f'creg {meas_id}[{len(meas.qubits)}];\n')
+        for meas_id in self.cregs:
+            length, comment = self.cregs[meas_id]
+            if self.args.version == '2.0':
+                output(f'creg {meas_id}[{length}];{comment}\n')
             else:
-                output(f'creg {meas_id}[{len(meas.qubits)}];  // Measurement: {comment}\n')
+                output(f'bit[{length}] {meas_id};{comment}\n')
+
         # In OpenQASM 2.0, the transformation of global phase gates is ignored.
         # Therefore, no newline is created when the operations contained in
         # a circuit consist only of global phase gates.
@@ -304,11 +335,11 @@ class QasmOutput:
 
     def _write_operations(
         self,
-        op_tree: 'cirq.OP_TREE',
+        op_tree: cirq.OP_TREE,
         output: Callable[[str], None],
         output_line_gap: Callable[[int], None],
     ) -> None:
-        def keep(op: 'cirq.Operation') -> bool:
+        def keep(op: cirq.Operation) -> bool:
             return protocols.qasm(op, args=self.args, default=None) is not None
 
         def fallback(op):
@@ -320,7 +351,7 @@ class QasmOutput:
                 return NotImplemented
 
             if len(op.qubits) == 1:
-                return QasmUGate.from_matrix(mat).on(*op.qubits)
+                return QasmUGate.from_matrix(mat).on(*op.qubits)  # pragma: no cover
             return QasmTwoQubitGate.from_matrix(mat).on(*op.qubits)
 
         def on_stuck(bad_op):
@@ -337,10 +368,10 @@ class QasmOutput:
             if should_annotate:
                 output_line_gap(1)
                 if isinstance(main_op, ops.GateOperation):
-                    x = str(main_op.gate).replace('\n', '\n //')
+                    x = str(main_op.gate).replace('\n', '\n//       ')
                     output(f'// Gate: {x!s}\n')
                 else:
-                    x = str(main_op).replace('\n', '\n //')
+                    x = str(main_op).replace('\n', '\n//            ')
                     output(f'// Operation: {x!s}\n')
 
             for qasm in qasms:

cirq/circuits/qasm_output_test.py

@@ -11,8 +11,9 @@
 # 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 re
 import os
+import re
+
 import numpy as np
 import pytest
 
@@ -52,6 +53,11 @@ def test_qasm_u_qubit_gate_unitary():
 
     cirq.testing.assert_implements_consistent_protocols(g)
 
+    u = cirq.unitary(cirq.Y)
+    g = QasmUGate.from_matrix(u)
+    cirq.testing.assert_allclose_up_to_global_phase(cirq.unitary(g), u, atol=1e-7)
+    cirq.testing.assert_implements_consistent_protocols(g)
+
 
 def test_qasm_two_qubit_gate_unitary():
     u = cirq.testing.random_unitary(4)
@@ -225,7 +231,7 @@ rx(pi*0.123) q[0];
 def test_version():
     (q0,) = _make_qubits(1)
     with pytest.raises(ValueError):
-        output = cirq.QasmOutput((), (q0,), version='3.0')
+        output = cirq.QasmOutput((), (q0,), version='4.0')
         _ = str(output)
 
 
@@ -590,3 +596,58 @@ reset q[0];
 reset q[1];
     """.strip()
     )
+
+
+def test_different_sized_registers():
+    qubits = cirq.LineQubit.range(2)
+    c = cirq.Circuit(cirq.measure(qubits[0], key='c'), cirq.measure(qubits, key='c'))
+    output = cirq.QasmOutput(
+        c.all_operations(), tuple(sorted(c.all_qubits())), header='Generated from Cirq!'
+    )
+    assert (
+        str(output)
+        == """// Generated from Cirq!
+
+OPENQASM 2.0;
+include "qelib1.inc";
+
+
+// Qubits: [q(0), q(1)]
+qreg q[2];
+creg m_c[2];
+
+
+measure q[0] -> m_c[0];
+
+// Gate: cirq.MeasurementGate(2, cirq.MeasurementKey(name='c'), ())
+measure q[0] -> m_c[0];
+measure q[1] -> m_c[1];
+"""
+    )
+    # OPENQASM 3.0
+    output3 = cirq.QasmOutput(
+        c.all_operations(),
+        tuple(sorted(c.all_qubits())),
+        header='Generated from Cirq!',
+        version='3.0',
+    )
+    assert (
+        str(output3)
+        == """// Generated from Cirq!
+
+OPENQASM 3.0;
+include "stdgates.inc";
+
+
+// Qubits: [q(0), q(1)]
+qubit[2] q;
+bit[2] m_c;
+
+
+m_c[0] = measure q[0];
+
+// Gate: cirq.MeasurementGate(2, cirq.MeasurementKey(name='c'), ())
+m_c[0] = measure q[0];
+m_c[1] = measure q[1];
+"""
+    )

cirq/circuits/text_diagram_drawer.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from typing import (
     Any,
     Callable,
@@ -25,7 +27,6 @@ from typing import (
     Sequence,
     Tuple,
     TYPE_CHECKING,
-    Union,
 )
 
 import numpy as np
@@ -33,11 +34,11 @@ import numpy as np
 from cirq import value
 from cirq.circuits._block_diagram_drawer import BlockDiagramDrawer
 from cirq.circuits._box_drawing_character_data import (
-    BoxDrawCharacterSet,
-    NORMAL_BOX_CHARS,
-    BOLD_BOX_CHARS,
     ASCII_BOX_CHARS,
+    BOLD_BOX_CHARS,
+    BoxDrawCharacterSet,
     DOUBLED_BOX_CHARS,
+    NORMAL_BOX_CHARS,
 )
 
 if TYPE_CHECKING:
@@ -45,23 +46,11 @@ if TYPE_CHECKING:
 
 _HorizontalLine = NamedTuple(
     '_HorizontalLine',
-    [
-        ('y', Union[int, float]),
-        ('x1', Union[int, float]),
-        ('x2', Union[int, float]),
-        ('emphasize', bool),
-        ('doubled', bool),
-    ],
+    [('y', float), ('x1', float), ('x2', float), ('emphasize', bool), ('doubled', bool)],
 )
 _VerticalLine = NamedTuple(
     '_VerticalLine',
-    [
-        ('x', Union[int, float]),
-        ('y1', Union[int, float]),
-        ('y2', Union[int, float]),
-        ('emphasize', bool),
-        ('doubled', bool),
-    ],
+    [('x', float), ('y1', float), ('y2', float), ('emphasize', bool), ('doubled', bool)],
 )
 _DiagramText = NamedTuple('_DiagramText', [('text', str), ('transposed_text', str)])
 
@@ -99,10 +88,10 @@ class TextDiagramDrawer:
         self.vertical_lines: List[_VerticalLine] = (
             [] if vertical_lines is None else list(vertical_lines)
         )
-        self.horizontal_padding: Dict[int, Union[int, float]] = (
+        self.horizontal_padding: Dict[int, float] = (
             dict() if horizontal_padding is None else dict(horizontal_padding)
         )
-        self.vertical_padding: Dict[int, Union[int, float]] = (
+        self.vertical_padding: Dict[int, float] = (
             dict() if vertical_padding is None else dict(vertical_padding)
         )
 
@@ -148,7 +137,7 @@ class TextDiagramDrawer:
 
         # Horizontal line?
         if any(line_y == y and x1 < x < x2 for line_y, x1, x2, _, _ in self.horizontal_lines):
-            return True
+            return True  # pragma: no cover
 
         return False
 
@@ -171,30 +160,20 @@ class TextDiagramDrawer:
             raise ValueError("Line is neither horizontal nor vertical")
 
     def vertical_line(
-        self,
-        x: Union[int, float],
-        y1: Union[int, float],
-        y2: Union[int, float],
-        emphasize: bool = False,
-        doubled: bool = False,
+        self, x: float, y1: float, y2: float, emphasize: bool = False, doubled: bool = False
     ) -> None:
         """Adds a line from (x, y1) to (x, y2)."""
         y1, y2 = sorted([y1, y2])
         self.vertical_lines.append(_VerticalLine(x, y1, y2, emphasize, doubled))
 
     def horizontal_line(
-        self,
-        y: Union[int, float],
-        x1: Union[int, float],
-        x2: Union[int, float],
-        emphasize: bool = False,
-        doubled: bool = False,
+        self, y: float, x1: float, x2: float, emphasize: bool = False, doubled: bool = False
     ) -> None:
         """Adds a line from (x1, y) to (x2, y)."""
         x1, x2 = sorted([x1, x2])
         self.horizontal_lines.append(_HorizontalLine(y, x1, x2, emphasize, doubled))
 
-    def transpose(self) -> 'cirq.TextDiagramDrawer':
+    def transpose(self) -> cirq.TextDiagramDrawer:
         """Returns the same diagram, but mirrored across its diagonal."""
         out = TextDiagramDrawer()
         out.entries = {
@@ -228,26 +207,21 @@ class TextDiagramDrawer:
             max_y = max(max_y, v.y1, v.y2)
         return 1 + int(max_y)
 
-    def force_horizontal_padding_after(self, index: int, padding: Union[int, float]) -> None:
+    def force_horizontal_padding_after(self, index: int, padding: float) -> None:
         """Change the padding after the given column."""
         self.horizontal_padding[index] = padding
 
-    def force_vertical_padding_after(self, index: int, padding: Union[int, float]) -> None:
+    def force_vertical_padding_after(self, index: int, padding: float) -> None:
         """Change the padding after the given row."""
         self.vertical_padding[index] = padding
 
-    def _transform_coordinates(
-        self,
-        func: Callable[
-            [Union[int, float], Union[int, float]], Tuple[Union[int, float], Union[int, float]]
-        ],
-    ) -> None:
+    def _transform_coordinates(self, func: Callable[[float, float], Tuple[float, float]]) -> None:
         """Helper method to transformer either row or column coordinates."""
 
-        def func_x(x: Union[int, float]) -> Union[int, float]:
+        def func_x(x: float) -> float:
             return func(x, 0)[0]
 
-        def func_y(y: Union[int, float]) -> Union[int, float]:
+        def func_y(y: float) -> float:
             return func(0, y)[1]
 
         self.entries = {
@@ -271,9 +245,7 @@ class TextDiagramDrawer:
     def insert_empty_columns(self, x: int, amount: int = 1) -> None:
         """Insert a number of columns after the given column."""
 
-        def transform_columns(
-            column: Union[int, float], row: Union[int, float]
-        ) -> Tuple[Union[int, float], Union[int, float]]:
+        def transform_columns(column: float, row: float) -> Tuple[float, float]:
             return column + (amount if column >= x else 0), row
 
         self._transform_coordinates(transform_columns)
@@ -281,9 +253,7 @@ class TextDiagramDrawer:
     def insert_empty_rows(self, y: int, amount: int = 1) -> None:
         """Insert a number of rows after the given row."""
 
-        def transform_rows(
-            column: Union[int, float], row: Union[int, float]
-        ) -> Tuple[Union[int, float], Union[int, float]]:
+        def transform_rows(column: float, row: float) -> Tuple[float, float]:
             return column, row + (amount if row >= y else 0)
 
         self._transform_coordinates(transform_rows)
@@ -365,14 +335,14 @@ class TextDiagramDrawer:
             horizontal_padding=self.horizontal_padding,
         )
 
-    def shift(self, dx: int = 0, dy: int = 0) -> 'cirq.TextDiagramDrawer':
+    def shift(self, dx: int = 0, dy: int = 0) -> cirq.TextDiagramDrawer:
         self._transform_coordinates(lambda x, y: (x + dx, y + dy))
         return self
 
-    def shifted(self, dx: int = 0, dy: int = 0) -> 'cirq.TextDiagramDrawer':
+    def shifted(self, dx: int = 0, dy: int = 0) -> cirq.TextDiagramDrawer:
         return self.copy().shift(dx, dy)
 
-    def superimpose(self, other: 'cirq.TextDiagramDrawer') -> 'cirq.TextDiagramDrawer':
+    def superimpose(self, other: cirq.TextDiagramDrawer) -> cirq.TextDiagramDrawer:
         self.entries.update(other.entries)
         self.horizontal_lines += other.horizontal_lines
         self.vertical_lines += other.vertical_lines
@@ -380,13 +350,13 @@ class TextDiagramDrawer:
         self.vertical_padding.update(other.vertical_padding)
         return self
 
-    def superimposed(self, other: 'cirq.TextDiagramDrawer') -> 'cirq.TextDiagramDrawer':
+    def superimposed(self, other: cirq.TextDiagramDrawer) -> cirq.TextDiagramDrawer:
         return self.copy().superimpose(other)
 
     @classmethod
     def vstack(
         cls,
-        diagrams: Sequence['cirq.TextDiagramDrawer'],
+        diagrams: Sequence[cirq.TextDiagramDrawer],
         padding_resolver: Optional[Callable[[Sequence[Optional[int]]], int]] = None,
     ):
         """Vertically stack text diagrams.
@@ -427,7 +397,7 @@ class TextDiagramDrawer:
     @classmethod
     def hstack(
         cls,
-        diagrams: Sequence['cirq.TextDiagramDrawer'],
+        diagrams: Sequence[cirq.TextDiagramDrawer],
         padding_resolver: Optional[Callable[[Sequence[Optional[int]]], int]] = None,
     ):
         """Horizontally stack text diagrams.

cirq/circuits/text_diagram_drawer_test.py

@@ -13,23 +13,24 @@
 # limitations under the License.
 
 from unittest import mock
+
 import pytest
 
+import cirq.testing as ct
 from cirq.circuits import TextDiagramDrawer
 from cirq.circuits._block_diagram_drawer_test import _assert_same_diagram
 from cirq.circuits._box_drawing_character_data import (
     ASCII_BOX_CHARS,
-    NORMAL_BOX_CHARS,
-    DOUBLED_BOX_CHARS,
     BOLD_BOX_CHARS,
+    DOUBLED_BOX_CHARS,
+    NORMAL_BOX_CHARS,
 )
 from cirq.circuits.text_diagram_drawer import (
+    _DiagramText,
     _HorizontalLine,
     _VerticalLine,
-    _DiagramText,
     pick_charset,
 )
-import cirq.testing as ct
 
 
 def assert_has_rendering(actual: TextDiagramDrawer, desired: str, **kwargs) -> None:

cirq/contrib/__init__.py

@@ -21,6 +21,6 @@ this package.
 from cirq.contrib import acquaintance
 from cirq.contrib import graph_device
 from cirq.contrib import quirk
-from cirq.contrib.qcircuit import circuit_to_latex_using_qcircuit
+from cirq.contrib.qcircuit import circuit_to_latex_using_qcircuit as circuit_to_latex_using_qcircuit
 from cirq.contrib import json
-from cirq.contrib.circuitdag import CircuitDag, Unique
+from cirq.contrib.circuitdag import CircuitDag as CircuitDag, Unique as Unique