cirq-core 1.1.0.dev20221220224914__py3-none-any.whl → 1.2.0__py3-none-any.whl

cirq/circuits/frozen_circuit.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """An immutable version of the Circuit data structure."""
-from typing import FrozenSet, Iterable, Iterator, Sequence, Tuple, TYPE_CHECKING, Union
+from typing import AbstractSet, FrozenSet, Iterable, Iterator, Sequence, Tuple, TYPE_CHECKING, Union
 
 import numpy as np
 
@@ -83,6 +83,10 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
     def _qid_shape_(self) -> Tuple[int, ...]:
         return super()._qid_shape_()
 
+    @_compat.cached_method
+    def _has_unitary_(self) -> bool:
+        return super()._has_unitary_()
+
     @_compat.cached_method
     def _unitary_(self) -> Union[np.ndarray, NotImplementedType]:
         return super()._unitary_()
@@ -124,6 +128,14 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
     def all_measurement_key_names(self) -> FrozenSet[str]:
         return frozenset(str(key) for key in self.all_measurement_key_objs())
 
+    @_compat.cached_method
+    def _is_parameterized_(self) -> bool:
+        return super()._is_parameterized_()
+
+    @_compat.cached_method
+    def _parameter_names_(self) -> AbstractSet[str]:
+        return super()._parameter_names_()
+
     def _measurement_key_names_(self) -> FrozenSet[str]:
         return self.all_measurement_key_names()
 

cirq/circuits/frozen_circuit_test.py

@@ -68,5 +68,9 @@ def test_immutable():
     q = cirq.LineQubit(0)
     c = cirq.FrozenCircuit(cirq.X(q), cirq.H(q))
 
-    with pytest.raises(AttributeError, match="can't set attribute"):
+    # Match one of two strings. The second one is message returned since python 3.11.
+    with pytest.raises(
+        AttributeError,
+        match="(can't set attribute)|(property 'moments' of 'FrozenCircuit' object has no setter)",
+    ):
         c.moments = (cirq.Moment(cirq.H(q)), cirq.Moment(cirq.X(q)))

cirq/circuits/moment.py

@@ -19,6 +19,7 @@ from typing import (
     AbstractSet,
     Any,
     Callable,
+    cast,
     Dict,
     FrozenSet,
     Iterable,
@@ -30,13 +31,13 @@ from typing import (
     Sequence,
     Tuple,
     TYPE_CHECKING,
-    TypeVar,
     Union,
 )
+from typing_extensions import Self
 
 import numpy as np
 
-from cirq import protocols, ops, qis
+from cirq import protocols, ops, qis, _compat
 from cirq._import import LazyLoader
 from cirq.ops import raw_types, op_tree
 from cirq.protocols import circuit_diagram_info_protocol
@@ -52,8 +53,6 @@ text_diagram_drawer = LazyLoader(
     "text_diagram_drawer", globals(), "cirq.circuits.text_diagram_drawer"
 )
 
-TSelf_Moment = TypeVar('TSelf_Moment', bound='Moment')
-
 
 def _default_breakdown(qid: 'cirq.Qid') -> Tuple[Any, Any]:
     # Attempt to convert into a position on the complex plane.
@@ -82,17 +81,26 @@ class Moment:
             are no such operations, returns an empty Moment.
     """
 
-    def __init__(self, *contents: 'cirq.OP_TREE') -> None:
+    def __init__(self, *contents: 'cirq.OP_TREE', _flatten_contents: bool = True) -> None:
         """Constructs a moment with the given operations.
 
         Args:
             contents: The operations applied within the moment.
                 Will be flattened and frozen into a tuple before storing.
+            _flatten_contents: If True, use flatten_to_ops to convert
+                the OP_TREE of contents into a tuple of Operation. If False,
+                we skip flattening and assume that contents already consists
+                of individual operations. This is used internally by helper
+                methods to avoid unnecessary validation.
 
         Raises:
             ValueError: A qubit appears more than once.
         """
-        self._operations = tuple(op_tree.flatten_to_ops(contents))
+        self._operations = (
+            tuple(op_tree.flatten_to_ops(contents))
+            if _flatten_contents
+            else cast(Tuple['cirq.Operation'], contents)
+        )
         self._sorted_operations: Optional[Tuple['cirq.Operation', ...]] = None
 
         # An internal dictionary to support efficient operation access by qubit.
@@ -108,6 +116,20 @@ class Moment:
         self._measurement_key_objs: Optional[FrozenSet['cirq.MeasurementKey']] = None
         self._control_keys: Optional[FrozenSet['cirq.MeasurementKey']] = None
 
+    @classmethod
+    def from_ops(cls, *ops: 'cirq.Operation') -> 'cirq.Moment':
+        """Construct a Moment from the given operations.
+
+        This avoids calling `flatten_to_ops` in the moment constructor, which
+        results in better performance in cases where the contents of the moment
+        are already in the form of a sequence of operations rather than an
+        arbitrary OP_TREE.
+
+        Args:
+            *ops: Operations to include in the Moment.
+        """
+        return cls(*ops, _flatten_contents=False)
+
     @property
     def operations(self) -> Tuple['cirq.Operation', ...]:
         return self._operations
@@ -148,8 +170,7 @@ class Moment:
         """
         if self.operates_on([qubit]):
             return self.__getitem__(qubit)
-        else:
-            return None
+        return None
 
     def with_operation(self, operation: 'cirq.Operation') -> 'cirq.Moment':
         """Returns an equal moment, but with the given op added.
@@ -167,7 +188,7 @@ class Moment:
             raise ValueError(f'Overlapping operations: {operation}')
 
         # Use private variables to facilitate a quick copy.
-        m = Moment()
+        m = Moment(_flatten_contents=False)
         m._operations = self._operations + (operation,)
         m._sorted_operations = None
         m._qubits = self._qubits.union(operation.qubits)
@@ -197,7 +218,7 @@ class Moment:
         if not flattened_contents:
             return self
 
-        m = Moment()
+        m = Moment(_flatten_contents=False)
         # Use private variables to facilitate a quick copy.
         m._qubit_to_op = self._qubit_to_op.copy()
         qubits = set(self._qubits)
@@ -238,9 +259,11 @@ class Moment:
             if qubits.isdisjoint(frozenset(operation.qubits))
         )
 
+    @_compat.cached_method()
     def _is_parameterized_(self) -> bool:
         return any(protocols.is_parameterized(op) for op in self)
 
+    @_compat.cached_method()
     def _parameter_names_(self) -> AbstractSet[str]:
         return {name for op in self for name in protocols.parameter_names(op)}
 
@@ -266,6 +289,7 @@ class Moment:
             for op in self.operations
         )
 
+    @_compat.cached_method()
     def _measurement_key_names_(self) -> FrozenSet[str]:
         return frozenset(str(key) for key in self._measurement_key_objs_())
 
@@ -333,6 +357,7 @@ class Moment:
     def __ne__(self, other) -> bool:
         return not self == other
 
+    @_compat.cached_method()
     def __hash__(self):
         return hash((Moment, self._sorted_operations_()))
 
@@ -370,9 +395,8 @@ class Moment:
         return self._operations
 
     def transform_qubits(
-        self: TSelf_Moment,
-        qubit_map: Union[Dict['cirq.Qid', 'cirq.Qid'], Callable[['cirq.Qid'], 'cirq.Qid']],
-    ) -> TSelf_Moment:
+        self, qubit_map: Union[Dict['cirq.Qid', 'cirq.Qid'], Callable[['cirq.Qid'], 'cirq.Qid']]
+    ) -> Self:
         """Returns the same moment, but with different qubits.
 
         Args:
@@ -406,6 +430,7 @@ class Moment:
             operations.append(ops.I(q))
         return Moment(*operations)
 
+    @_compat.cached_method()
     def _has_kraus_(self) -> bool:
         """Returns True if self has a Kraus representation and self uses <= 10 qubits."""
         return all(protocols.has_kraus(op) for op in self.operations) and len(self.qubits) <= 10
@@ -482,7 +507,7 @@ class Moment:
 
     @classmethod
     def _from_json_dict_(cls, operations, **kwargs):
-        return Moment(operations)
+        return cls.from_ops(*operations)
 
     def __add__(self, other: 'cirq.OP_TREE') -> 'cirq.Moment':
 

cirq/circuits/moment_test.py

@@ -170,6 +170,13 @@ def test_operation_at():
     assert cirq.Moment([cirq.CZ(a, b), cirq.X(c)]).operation_at(a) == cirq.CZ(a, b)
 
 
+def test_from_ops():
+    a = cirq.NamedQubit('a')
+    b = cirq.NamedQubit('b')
+
+    assert cirq.Moment.from_ops(cirq.X(a), cirq.Y(b)) == cirq.Moment(cirq.X(a), cirq.Y(b))
+
+
 def test_with_operation():
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')

cirq/circuits/text_diagram_drawer.py

@@ -292,7 +292,7 @@ class TextDiagramDrawer:
         self,
         horizontal_spacing: int = 1,
         vertical_spacing: int = 1,
-        crossing_char: str = None,
+        crossing_char: Optional[str] = None,
         use_unicode_characters: bool = True,
     ) -> str:
         """Outputs text containing the diagram."""

cirq/circuits/text_diagram_drawer_test.py

@@ -46,17 +46,13 @@ def assert_has_rendering(actual: TextDiagramDrawer, desired: str, **kwargs) -> N
         "Diagram's rendering differs from the desired rendering.\n"
         '\n'
         'Actual rendering:\n'
-        '{}\n'
+        f'{actual_diagram}\n'
         '\n'
         'Desired rendering:\n'
-        '{}\n'
+        f'{desired_diagram}\n'
         '\n'
         'Highlighted differences:\n'
-        '{}\n'.format(
-            actual_diagram,
-            desired_diagram,
-            ct.highlight_text_differences(actual_diagram, desired_diagram),
-        )
+        f'{ct.highlight_text_differences(actual_diagram, desired_diagram)}\n'
     )
 
 

cirq/contrib/acquaintance/bipartite.py

@@ -133,7 +133,7 @@ class BipartiteSwapNetworkGate(PermutationGate):
         if self.subgraph == BipartiteGraphType.MATCHING:
             name = 'Matching'
         elif self.subgraph == BipartiteGraphType.COMPLETE:
-            name = 'K_{{{0}, {0}}}'.format(self.part_size)
+            name = f'K_{{{self.part_size}, {self.part_size}}}'
         # NB: self.subgraph not in BipartiteGraphType caught by self.permutation
         arrow = '↦' if args.use_unicode_characters else '->'
 

cirq/contrib/acquaintance/devices.py

@@ -36,8 +36,8 @@ class AcquaintanceDevice(devices.Device, metaclass=abc.ABCMeta):
             isinstance(operation, ops.GateOperation) and isinstance(operation.gate, self.gate_types)
         ):
             raise ValueError(
-                'not (isinstance({0!r}, {1!r}) and '
-                'ininstance({0!r}.gate, {2!r})'.format(operation, ops.Operation, self.gate_types)
+                f'not (isinstance({operation!r}, {ops.Operation!r}) and '
+                f'ininstance({operation!r}.gate, {self.gate_types!r})'
             )
 
 

cirq/contrib/acquaintance/executor.py

@@ -34,7 +34,7 @@ if TYPE_CHECKING:
 
 
 class ExecutionStrategy(metaclass=abc.ABCMeta):
-    """Tells `StrategyExecutorTransormer` how to execute an acquaintance strategy.
+    """Tells `StrategyExecutorTransformer` how to execute an acquaintance strategy.
 
     An execution strategy tells `StrategyExecutorTransformer` how to execute
     an acquaintance strategy, i.e. what gates to implement at the available
@@ -174,7 +174,10 @@ class GreedyExecutionStrategy(ExecutionStrategy):
     """
 
     def __init__(
-        self, gates: LogicalGates, initial_mapping: LogicalMapping, device: 'cirq.Device' = None
+        self,
+        gates: LogicalGates,
+        initial_mapping: LogicalMapping,
+        device: Optional['cirq.Device'] = None,
     ) -> None:
         """Inits GreedyExecutionStrategy.
 

cirq/contrib/acquaintance/gates.py

@@ -347,8 +347,9 @@ class SwapNetworkGate(PermutationGate):
         return {i: j for i, j in enumerate(reversed(range(sum(self.part_lens))))}
 
     def __repr__(self) -> str:
-        return 'cirq.contrib.acquaintance.SwapNetworkGate({!r}, {!r})'.format(
-            self.part_lens, self.acquaintance_size
+        return (
+            'cirq.contrib.acquaintance.SwapNetworkGate('
+            f'{self.part_lens!r}, {self.acquaintance_size!r})'
         )
 
     def _value_equality_values_(self):

cirq/contrib/acquaintance/permutation.py

@@ -13,7 +13,18 @@
 # limitations under the License.
 
 import abc
-from typing import Any, cast, Dict, Iterable, Sequence, Tuple, TypeVar, Union, TYPE_CHECKING
+from typing import (
+    Any,
+    cast,
+    Dict,
+    Iterable,
+    Optional,
+    Sequence,
+    Tuple,
+    TypeVar,
+    Union,
+    TYPE_CHECKING,
+)
 
 from cirq import circuits, ops, protocols, transformers, value
 from cirq.type_workarounds import NotImplementedType
@@ -72,7 +83,7 @@ class PermutationGate(ops.Gate, metaclass=abc.ABCMeta):
                 mapping[new_key] = old_element
 
     @staticmethod
-    def validate_permutation(permutation: Dict[int, int], n_elements: int = None) -> None:
+    def validate_permutation(permutation: Dict[int, int], n_elements: Optional[int] = None) -> None:
         if not permutation:
             return
         if set(permutation.values()) != set(permutation):

cirq/contrib/acquaintance/testing.py

@@ -29,13 +29,11 @@ def assert_permutation_decomposition_equivalence(gate: PermutationGate, n_qubits
     update_mapping(mapping, operations)
     expected_mapping = {qubits[j]: i for i, j in gate.permutation().items()}
     assert mapping == expected_mapping, (
-        "{!r}.permutation({}) doesn't match decomposition.\n"
+        f"{gate!r}.permutation({n_qubits}) doesn't match decomposition.\n"
         '\n'
         'Actual mapping:\n'
-        '{}\n'
+        f'{[mapping[q] for q in qubits]}\n'
         '\n'
         'Expected mapping:\n'
-        '{}\n'.format(
-            gate, n_qubits, [mapping[q] for q in qubits], [expected_mapping[q] for q in qubits]
-        )
+        f'{[expected_mapping[q] for q in qubits]}\n'
     )

cirq/contrib/paulistring/recombine.py

@@ -27,7 +27,6 @@ def _sorted_best_string_placements(
     output_ops: Sequence[ops.Operation],
     key: Callable[[Any], ops.PauliStringPhasor] = lambda node: node.val,
 ) -> List[Tuple[ops.PauliStringPhasor, int, circuitdag.Unique[ops.PauliStringPhasor]]]:
-
     sort_key = lambda placement: (-len(placement[0].pauli_string), placement[1])
 
     node_maxes = []
@@ -84,11 +83,9 @@ def move_pauli_strings_into_circuit(
         # Pick the Pauli string that can be moved furthest through
         # the Clifford circuit
         for best_string_op, best_index, best_node in placements:
-
-            assert (
-                best_index <= last_index
-            ), "Unexpected insertion index order, {} >= {}, len: {}".format(
-                best_index, last_index, len(output_ops)
+            assert best_index <= last_index, (
+                "Unexpected insertion index order, "
+                f"{best_index} >= {last_index}, len: {len(output_ops)}"
             )
 
             last_index = best_index

cirq/contrib/qasm_import/_parser.py

@@ -11,6 +11,7 @@
 # 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 functools
 import operator
 from typing import Any, Callable, cast, Dict, Iterable, List, Optional, Union, TYPE_CHECKING
@@ -82,16 +83,15 @@ class QasmGateStatement:
     def _validate_args(self, args: List[List[ops.Qid]], lineno: int):
         if len(args) != self.num_args:
             raise QasmException(
-                "{} only takes {} arg(s) (qubits and/or registers), "
-                "got: {}, at line {}".format(self.qasm_gate, self.num_args, len(args), lineno)
+                f"{self.qasm_gate} only takes {self.num_args} arg(s) (qubits and/or registers), "
+                f"got: {len(args)}, at line {lineno}"
             )
 
     def _validate_params(self, params: List[float], lineno: int):
         if len(params) != self.num_params:
             raise QasmException(
-                "{} takes {} parameter(s), got: {}, at line {}".format(
-                    self.qasm_gate, self.num_params, len(params), lineno
-                )
+                f"{self.qasm_gate} takes {self.num_params} parameter(s), "
+                f"got: {len(params)}, at line {lineno}"
             )
 
     def on(
@@ -141,7 +141,7 @@ class QasmParser:
         parsedQasm = QasmParser().parse(qasm)
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.parser = yacc.yacc(module=self, debug=False, write_tables=False)
         self.circuit = Circuit()
         self.qregs: Dict[str, int] = {}
@@ -287,8 +287,7 @@ class QasmParser:
         """format : FORMAT_SPEC"""
         if p[1] != "2.0":
             raise QasmException(
-                "Unsupported OpenQASM version: {}, "
-                "only 2.0 is supported currently by Cirq".format(p[1])
+                f"Unsupported OpenQASM version: {p[1]}, only 2.0 is supported currently by Cirq"
             )
 
     # circuit : new_reg circuit
@@ -345,11 +344,8 @@ class QasmParser:
     ):
         gate_set = self.basic_gates if not self.qelibinc else self.all_gates
         if gate not in gate_set.keys():
-            msg = 'Unknown gate "{}" at line {}{}'.format(
-                gate,
-                p.lineno(1),
-                ", did you forget to include qelib1.inc?" if not self.qelibinc else "",
-            )
+            tip = ", did you forget to include qelib1.inc?" if not self.qelibinc else ""
+            msg = f'Unknown gate "{gate}" at line {p.lineno(1)}{tip}'
             raise QasmException(msg)
         p[0] = gate_set[gate].on(args=args, params=params, lineno=p.lineno(1))
 
@@ -460,9 +456,9 @@ class QasmParser:
         size = self.qregs[reg]
         if idx >= size:
             raise QasmException(
-                'Out of bounds qubit index {} '
-                'on register {} of size {} '
-                'at line {}'.format(idx, reg, size, p.lineno(1))
+                f'Out of bounds qubit index {idx} '
+                f'on register {reg} of size {size} '
+                f'at line {p.lineno(1)}'
             )
         if arg_name not in self.qubits.keys():
             self.qubits[arg_name] = NamedQubit(arg_name)
@@ -479,9 +475,9 @@ class QasmParser:
         size = self.cregs[reg]
         if idx >= size:
             raise QasmException(
-                'Out of bounds bit index {} '
-                'on classical register {} of size {} '
-                'at line {}'.format(idx, reg, size, p.lineno(1))
+                f'Out of bounds bit index {idx} '
+                f'on classical register {reg} of size {size} '
+                f'at line {p.lineno(1)}'
             )
         p[0] = [arg_name]
 
@@ -495,8 +491,8 @@ class QasmParser:
 
         if len(qreg) != len(creg):
             raise QasmException(
-                'mismatched register sizes {} -> {} for measurement '
-                'at line {}'.format(len(qreg), len(creg), p.lineno(1))
+                f'mismatched register sizes {len(qreg)} -> {len(creg)} for measurement '
+                f'at line {p.lineno(1)}'
             )
 
         p[0] = [

cirq/contrib/qasm_import/_parser_test.py

@@ -11,6 +11,7 @@
 # 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 Callable
 
 import numpy as np
@@ -489,14 +490,12 @@ single_qubit_gates = [
 
 @pytest.mark.parametrize('qasm_gate,cirq_gate', rotation_gates)
 def test_rotation_gates(qasm_gate: str, cirq_gate: Callable[[float], cirq.Gate]):
-    qasm = """OPENQASM 2.0;
+    qasm = f"""OPENQASM 2.0;
      include "qelib1.inc";
      qreg q[2];
-     {0}(pi/2) q[0];
-     {0}(pi) q;
-    """.format(
-        qasm_gate
-    )
+     {qasm_gate}(pi/2) q[0];
+     {qasm_gate}(pi) q;
+    """
 
     parser = QasmParser()
 
@@ -527,7 +526,7 @@ def test_rotation_gates_wrong_number_of_args(qasm_gate: str):
 
     parser = QasmParser()
 
-    with pytest.raises(QasmException, match=r".*{}.* takes 1.*got.*2.*line 5".format(qasm_gate)):
+    with pytest.raises(QasmException, match=f".*{qasm_gate}.* takes 1.*got.*2.*line 5"):
         parser.parse(qasm)
 
 
@@ -541,7 +540,7 @@ def test_rotation_gates_zero_params_error(qasm_gate: str):
 
     parser = QasmParser()
 
-    with pytest.raises(QasmException, match=r".*{}.* takes 1.*got.*0.*line 4".format(qasm_gate)):
+    with pytest.raises(QasmException, match=f".*{qasm_gate}.* takes 1.*got.*0.*line 4"):
         parser.parse(qasm)
 
 
@@ -867,9 +866,7 @@ def test_standard_gates_wrong_params_error(qasm_gate: str, num_params: int):
 
     parser = QasmParser()
 
-    with pytest.raises(
-        QasmException, match=r".*{}.* takes {}.*got.*5.*line 4".format(qasm_gate, num_params)
-    ):
+    with pytest.raises(QasmException, match=f".*{qasm_gate}.* takes {num_params}.*got.*5.*line 4"):
         parser.parse(qasm)
 
     if num_params == 0:
@@ -883,9 +880,7 @@ def test_standard_gates_wrong_params_error(qasm_gate: str, num_params: int):
 
     parser = QasmParser()
 
-    with pytest.raises(
-        QasmException, match=r".*{}.* takes {}.*got.*0.*line 4".format(qasm_gate, num_params)
-    ):
+    with pytest.raises(QasmException, match=f".*{qasm_gate}.* takes {num_params}.*got.*0.*line 4"):
         parser.parse(qasm)
 
 
@@ -901,17 +896,15 @@ two_qubit_gates = [
 
 @pytest.mark.parametrize('qasm_gate,cirq_gate', two_qubit_gates)
 def test_two_qubit_gates(qasm_gate: str, cirq_gate: cirq.testing.TwoQubitGate):
-    qasm = """
-     OPENQASM 2.0;   
-     include "qelib1.inc";       
+    qasm = f"""
+     OPENQASM 2.0;
+     include "qelib1.inc";
      qreg q1[2];
      qreg q2[2];
-     {0} q1[0], q1[1];
-     {0} q1, q2[0];
-     {0} q2, q1;      
-""".format(
-        qasm_gate
-    )
+     {qasm_gate} q1[0], q1[1];
+     {qasm_gate} q1, q2[0];
+     {qasm_gate} q2, q1;
+"""
     parser = QasmParser()
 
     q1_0 = cirq.NamedQubit('q1_0')
@@ -949,9 +942,7 @@ def test_two_qubit_gates_not_enough_args(qasm_gate: str):
 
     parser = QasmParser()
 
-    with pytest.raises(
-        QasmException, match=r".*{}.* takes 2 arg\(s\).*got.*1.*line 5".format(qasm_gate)
-    ):
+    with pytest.raises(QasmException, match=rf".*{qasm_gate}.* takes 2 arg\(s\).*got.*1.*line 5"):
         parser.parse(qasm)
 
 
@@ -967,7 +958,7 @@ def test_two_qubit_gates_with_too_much_parameters(qasm_gate: str):
     parser = QasmParser()
 
     with pytest.raises(
-        QasmException, match=r".*{}.* takes 0 parameter\(s\).*got.*1.*line 5".format(qasm_gate)
+        QasmException, match=rf".*{qasm_gate}.* takes 0 parameter\(s\).*got.*1.*line 5"
     ):
         parser.parse(qasm)
 
@@ -977,18 +968,16 @@ three_qubit_gates = [('ccx', cirq.TOFFOLI), ('cswap', cirq.CSWAP)]
 
 @pytest.mark.parametrize('qasm_gate,cirq_gate', three_qubit_gates)
 def test_three_qubit_gates(qasm_gate: str, cirq_gate: cirq.testing.TwoQubitGate):
-    qasm = """
+    qasm = f"""
      OPENQASM 2.0;
-     include "qelib1.inc";       
+     include "qelib1.inc";
      qreg q1[2];
      qreg q2[2];
      qreg q3[2];
-     {0} q1[0], q1[1], q2[0];
-     {0} q1, q2[0], q3[0];
-     {0} q1, q2, q3;      
-""".format(
-        qasm_gate
-    )
+     {qasm_gate} q1[0], q1[1], q2[0];
+     {qasm_gate} q1, q2[0], q3[0];
+     {qasm_gate} q1, q2, q3;
+"""
     parser = QasmParser()
 
     q1_0 = cirq.NamedQubit('q1_0')
@@ -1027,9 +1016,7 @@ def test_three_qubit_gates_not_enough_args(qasm_gate: str):
 
     parser = QasmParser()
 
-    with pytest.raises(
-        QasmException, match=r""".*{}.* takes 3 arg\(s\).*got.*1.*line 4""".format(qasm_gate)
-    ):
+    with pytest.raises(QasmException, match=rf".*{qasm_gate}.* takes 3 arg\(s\).*got.*1.*line 4"):
         parser.parse(qasm)
 
 
@@ -1043,20 +1030,18 @@ def test_three_qubit_gates_with_too_much_parameters(qasm_gate: str):
 
     parser = QasmParser()
 
-    with pytest.raises(QasmException, match=r""".*{}.*parameter.*line 4.*""".format(qasm_gate)):
+    with pytest.raises(QasmException, match=f".*{qasm_gate}.*parameter.*line 4.*"):
         parser.parse(qasm)
 
 
 @pytest.mark.parametrize('qasm_gate,cirq_gate', single_qubit_gates)
 def test_single_qubit_gates(qasm_gate: str, cirq_gate: cirq.Gate):
-    qasm = """OPENQASM 2.0;
+    qasm = f"""OPENQASM 2.0;
      include "qelib1.inc";
      qreg q[2];
-     {0} q[0];
-     {0} q;
-    """.format(
-        qasm_gate
-    )
+     {qasm_gate} q[0];
+     {qasm_gate} q;
+    """
 
     parser = QasmParser()