cirq-core 1.5.0.dev20250409225226__py3-none-any.whl → 1.6.0__py3-none-any.whl

cirq/transformers/analytical_decompositions/two_qubit_to_sqrt_iswap.py

@@ -20,7 +20,9 @@ References:
     https://arxiv.org/abs/2105.06074
 """
 
-from typing import Optional, Sequence, Tuple, TYPE_CHECKING
+from __future__ import annotations
+
+from typing import Sequence, TYPE_CHECKING
 
 import numpy as np
 import sympy
@@ -34,7 +36,7 @@ if TYPE_CHECKING:
 
 
 def parameterized_2q_op_to_sqrt_iswap_operations(
-    op: 'cirq.Operation', *, use_sqrt_iswap_inv: bool = False
+    op: cirq.Operation, *, use_sqrt_iswap_inv: bool = False
 ) -> protocols.decompose_protocol.DecomposeResult:
     """Tries to decompose a parameterized 2q operation into √iSWAP's + parameterized 1q rotations.
 
@@ -68,9 +70,7 @@ def parameterized_2q_op_to_sqrt_iswap_operations(
     return NotImplemented
 
 
-def _sqrt_iswap_inv(
-    a: 'cirq.Qid', b: 'cirq.Qid', use_sqrt_iswap_inv: bool = True
-) -> 'cirq.OP_TREE':
+def _sqrt_iswap_inv(a: cirq.Qid, b: cirq.Qid, use_sqrt_iswap_inv: bool = True) -> cirq.OP_TREE:
     """Optree implementing `cirq.SQRT_ISWAP_INV(a, b)` using √iSWAPs.
 
     Args:
@@ -89,7 +89,7 @@ def _sqrt_iswap_inv(
 
 
 def _cphase_symbols_to_sqrt_iswap(
-    a: 'cirq.Qid', b: 'cirq.Qid', turns: 'cirq.TParamVal', use_sqrt_iswap_inv: bool = True
+    a: cirq.Qid, b: cirq.Qid, turns: cirq.TParamVal, use_sqrt_iswap_inv: bool = True
 ):
     """Implements `cirq.CZ(a, b) ** turns` using two √iSWAPs and single qubit rotations.
 
@@ -136,7 +136,7 @@ def _cphase_symbols_to_sqrt_iswap(
 
 
 def _swap_symbols_to_sqrt_iswap(
-    a: 'cirq.Qid', b: 'cirq.Qid', turns: 'cirq.TParamVal', use_sqrt_iswap_inv: bool = True
+    a: cirq.Qid, b: cirq.Qid, turns: cirq.TParamVal, use_sqrt_iswap_inv: bool = True
 ):
     """Implements `cirq.SWAP(a, b) ** turns` using two √iSWAPs and single qubit rotations.
 
@@ -170,7 +170,7 @@ def _swap_symbols_to_sqrt_iswap(
 
 
 def _iswap_symbols_to_sqrt_iswap(
-    a: 'cirq.Qid', b: 'cirq.Qid', turns: 'cirq.TParamVal', use_sqrt_iswap_inv: bool = True
+    a: cirq.Qid, b: cirq.Qid, turns: cirq.TParamVal, use_sqrt_iswap_inv: bool = True
 ):
     """Implements `cirq.ISWAP(a, b) ** turns` using two √iSWAPs and single qubit rotations.
 
@@ -202,10 +202,10 @@ def _iswap_symbols_to_sqrt_iswap(
 
 
 def _fsim_symbols_to_sqrt_iswap(
-    a: 'cirq.Qid',
-    b: 'cirq.Qid',
-    theta: 'cirq.TParamVal',
-    phi: 'cirq.TParamVal',
+    a: cirq.Qid,
+    b: cirq.Qid,
+    theta: cirq.TParamVal,
+    phi: cirq.TParamVal,
     use_sqrt_iswap_inv: bool = True,
 ):
     """Implements `cirq.FSimGate(theta, phi)(a, b)` using two √iSWAPs and single qubit rotations.
@@ -229,16 +229,16 @@ def _fsim_symbols_to_sqrt_iswap(
 
 
 def two_qubit_matrix_to_sqrt_iswap_operations(
-    q0: 'cirq.Qid',
-    q1: 'cirq.Qid',
+    q0: cirq.Qid,
+    q1: cirq.Qid,
     mat: np.ndarray,
     *,
-    required_sqrt_iswap_count: Optional[int] = None,
+    required_sqrt_iswap_count: int | None = None,
     use_sqrt_iswap_inv: bool = False,
     atol: float = 1e-8,
     check_preconditions: bool = True,
     clean_operations: bool = False,
-) -> Sequence['cirq.Operation']:
+) -> Sequence[cirq.Operation]:
     """Decomposes a two-qubit operation into ZPow/XPow/YPow/sqrt-iSWAP gates.
 
     This method uses the KAK decomposition of the matrix to determine how many
@@ -300,13 +300,13 @@ def two_qubit_matrix_to_sqrt_iswap_operations(
 
 
 def _kak_decomposition_to_sqrt_iswap_operations(
-    q0: 'cirq.Qid',
-    q1: 'cirq.Qid',
+    q0: cirq.Qid,
+    q1: cirq.Qid,
     kak: linalg.KakDecomposition,
-    required_sqrt_iswap_count: Optional[int] = None,
+    required_sqrt_iswap_count: int | None = None,
     use_sqrt_iswap_inv: bool = False,
     atol: float = 1e-8,
-) -> Sequence['cirq.Operation']:
+) -> Sequence[cirq.Operation]:
     single_qubit_operations, _ = _single_qubit_matrices_with_sqrt_iswap(
         kak, required_sqrt_iswap_count, atol=atol
     )
@@ -325,14 +325,14 @@ def _kak_decomposition_to_sqrt_iswap_operations(
 
 
 def _decomp_to_operations(
-    q0: 'cirq.Qid',
-    q1: 'cirq.Qid',
-    two_qubit_gate: 'cirq.Gate',
-    single_qubit_operations: Sequence[Tuple[np.ndarray, np.ndarray]],
+    q0: cirq.Qid,
+    q1: cirq.Qid,
+    two_qubit_gate: cirq.Gate,
+    single_qubit_operations: Sequence[tuple[np.ndarray, np.ndarray]],
     u0_before: np.ndarray = np.eye(2),
     u0_after: np.ndarray = np.eye(2),
     atol: float = 1e-8,
-) -> Sequence['cirq.Operation']:
+) -> Sequence[cirq.Operation]:
     """Converts a sequence of single-qubit unitary matrices on two qubits into a
     list of operations with interleaved two-qubit gates."""
     two_qubit_op = two_qubit_gate(q0, q1)
@@ -401,10 +401,8 @@ def _decomp_to_operations(
 
 
 def _single_qubit_matrices_with_sqrt_iswap(
-    kak: 'cirq.KakDecomposition',
-    required_sqrt_iswap_count: Optional[int] = None,
-    atol: float = 1e-8,
-) -> Tuple[Sequence[Tuple[np.ndarray, np.ndarray]], complex]:
+    kak: cirq.KakDecomposition, required_sqrt_iswap_count: int | None = None, atol: float = 1e-8
+) -> tuple[Sequence[tuple[np.ndarray, np.ndarray]], complex]:
     """Computes the sequence of interleaved single-qubit unitary matrices in the
     sqrt-iSWAP decomposition."""
     decomposers = [
@@ -430,7 +428,7 @@ def _single_qubit_matrices_with_sqrt_iswap(
 
 
 def _in_0_region(
-    interaction_coefficients: Tuple[float, float, float], weyl_tol: float = 1e-8
+    interaction_coefficients: tuple[float, float, float], weyl_tol: float = 1e-8
 ) -> bool:
     """Tests if (x, y, z) ~= (0, 0, 0) assuming x, y, z are canonical."""
     x, y, z = interaction_coefficients
@@ -438,7 +436,7 @@ def _in_0_region(
 
 
 def _in_1sqrt_iswap_region(
-    interaction_coefficients: Tuple[float, float, float], weyl_tol: float = 1e-8
+    interaction_coefficients: tuple[float, float, float], weyl_tol: float = 1e-8
 ) -> bool:
     """Tests if (x, y, z) ~= (π/8, π/8, 0), assuming x, y, z are canonical."""
     x, y, z = interaction_coefficients
@@ -446,7 +444,7 @@ def _in_1sqrt_iswap_region(
 
 
 def _in_2sqrt_iswap_region(
-    interaction_coefficients: Tuple[float, float, float], weyl_tol: float = 1e-8
+    interaction_coefficients: tuple[float, float, float], weyl_tol: float = 1e-8
 ) -> bool:
     """Tests if (x, y, z) is inside or within weyl_tol of the volume
     x >= y + |z| assuming x, y, z are canonical.
@@ -463,7 +461,7 @@ def _in_2sqrt_iswap_region(
 
 
 def _in_3sqrt_iswap_region(
-    interaction_coefficients: Tuple[float, float, float], weyl_tol: float = 1e-8
+    interaction_coefficients: tuple[float, float, float], weyl_tol: float = 1e-8
 ) -> bool:
     """Any two-qubit operation is decomposable into three SQRT_ISWAP gates.
 
@@ -476,8 +474,8 @@ def _in_3sqrt_iswap_region(
 
 
 def _decomp_0_matrices(
-    kak: 'cirq.KakDecomposition', atol: float = 1e-8
-) -> Tuple[Sequence[Tuple[np.ndarray, np.ndarray]], complex]:
+    kak: cirq.KakDecomposition, atol: float = 1e-8
+) -> tuple[Sequence[tuple[np.ndarray, np.ndarray]], complex]:
     """Returns the single-qubit matrices for the 0-SQRT_ISWAP decomposition.
 
     Assumes canonical x, y, z and (x, y, z) = (0, 0, 0) within tolerance.
@@ -494,8 +492,8 @@ def _decomp_0_matrices(
 
 
 def _decomp_1sqrt_iswap_matrices(
-    kak: 'cirq.KakDecomposition', atol: float = 1e-8
-) -> Tuple[Sequence[Tuple[np.ndarray, np.ndarray]], complex]:
+    kak: cirq.KakDecomposition, atol: float = 1e-8
+) -> tuple[Sequence[tuple[np.ndarray, np.ndarray]], complex]:
     """Returns the single-qubit matrices for the 1-SQRT_ISWAP decomposition.
 
     Assumes canonical x, y, z and (x, y, z) = (π/8, π/8, 0) within tolerance.
@@ -507,8 +505,8 @@ def _decomp_1sqrt_iswap_matrices(
 
 
 def _decomp_2sqrt_iswap_matrices(
-    kak: 'cirq.KakDecomposition', atol: float = 1e-8
-) -> Tuple[Sequence[Tuple[np.ndarray, np.ndarray]], complex]:
+    kak: cirq.KakDecomposition, atol: float = 1e-8
+) -> tuple[Sequence[tuple[np.ndarray, np.ndarray]], complex]:
     """Returns the single-qubit matrices for the 2-SQRT_ISWAP decomposition.
 
     Assumes canonical x, y, z and x >= y + |z| within tolerance.  For x, y, z
@@ -570,8 +568,8 @@ def _decomp_2sqrt_iswap_matrices(
 
 
 def _decomp_3sqrt_iswap_matrices(
-    kak: 'cirq.KakDecomposition', atol: float = 1e-8
-) -> Tuple[Sequence[Tuple[np.ndarray, np.ndarray]], complex]:
+    kak: cirq.KakDecomposition, atol: float = 1e-8
+) -> tuple[Sequence[tuple[np.ndarray, np.ndarray]], complex]:
     """Returns the single-qubit matrices for the 3-SQRT_ISWAP decomposition.
 
     Assumes any canonical x, y, z.  Three sqrt-iSWAP gates are only needed if

cirq/transformers/analytical_decompositions/two_qubit_to_sqrt_iswap_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import itertools
 
 import numpy as np

cirq/transformers/drop_empty_moments.py

@@ -14,7 +14,9 @@
 
 """Transformer pass that removes empty moments from a circuit."""
 
-from typing import Optional, TYPE_CHECKING
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
 
 from cirq.transformers import transformer_api, transformer_primitives
 
@@ -24,8 +26,8 @@ if TYPE_CHECKING:
 
 @transformer_api.transformer
 def drop_empty_moments(
-    circuit: 'cirq.AbstractCircuit', *, context: Optional['cirq.TransformerContext'] = None
-) -> 'cirq.Circuit':
+    circuit: cirq.AbstractCircuit, *, context: cirq.TransformerContext | None = None
+) -> cirq.Circuit:
     """Removes empty moments from a circuit.
 
     Args:

cirq/transformers/drop_empty_moments_test.py

@@ -12,10 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import cirq
 
 
-def test_drop():
+def test_drop() -> None:
     q1 = cirq.NamedQubit('q1')
     q2 = cirq.NamedQubit('q2')
     cirq.testing.assert_same_circuits(
@@ -28,7 +30,7 @@ def test_drop():
     )
 
 
-def test_drop_empty_moments():
+def test_drop_empty_moments() -> None:
     q1, q2 = cirq.LineQubit.range(2)
     c_nested = cirq.FrozenCircuit(
         cirq.Moment(), cirq.Moment(), cirq.Moment([cirq.CNOT(q1, q2)]), cirq.Moment()

cirq/transformers/drop_negligible_operations.py

@@ -14,7 +14,9 @@
 
 """Transformer pass that removes operations with tiny effects."""
 
-from typing import Optional, TYPE_CHECKING
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
 
 from cirq import protocols
 from cirq.transformers import transformer_api, transformer_primitives
@@ -25,11 +27,11 @@ if TYPE_CHECKING:
 
 @transformer_api.transformer
 def drop_negligible_operations(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = None,
+    context: cirq.TransformerContext | None = None,
     atol: float = 1e-8,
-) -> 'cirq.Circuit':
+) -> cirq.Circuit:
     """Removes operations with tiny effects.
 
     An operation `op` is considered to have a tiny effect if
@@ -47,7 +49,7 @@ def drop_negligible_operations(
     if context is None:
         context = transformer_api.TransformerContext()
 
-    def map_func(op: 'cirq.Operation', _: int) -> 'cirq.OP_TREE':
+    def map_func(op: cirq.Operation, _: int) -> cirq.OP_TREE:
         return (
             op
             if protocols.num_qubits(op) > 10

cirq/transformers/drop_negligible_operations_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import cirq
 
 NO_COMPILE_TAG = "no_compile_tag"

cirq/transformers/dynamical_decoupling.py

@@ -14,13 +14,16 @@
 
 """Transformer pass that adds dynamical decoupling operations to a circuit."""
 
+from __future__ import annotations
+
 from functools import reduce
 from itertools import cycle
-from typing import Dict, Optional, Tuple, TYPE_CHECKING, Union
+from typing import TYPE_CHECKING
 
 import numpy as np
 
-from cirq import circuits, ops, protocols
+from cirq import ops, protocols
+from cirq.circuits import Circuit, FrozenCircuit, Moment
 from cirq.protocols import unitary_protocol
 from cirq.protocols.has_stabilizer_effect_protocol import has_stabilizer_effect
 from cirq.protocols.has_unitary_protocol import has_unitary
@@ -31,7 +34,7 @@ if TYPE_CHECKING:
     import cirq
 
 
-def _get_dd_sequence_from_schema_name(schema: str) -> Tuple[ops.Gate, ...]:
+def _get_dd_sequence_from_schema_name(schema: str) -> tuple[ops.Gate, ...]:
     """Gets dynamical decoupling sequence from a schema name."""
     match schema:
         case 'DEFAULT':
@@ -48,17 +51,17 @@ def _get_dd_sequence_from_schema_name(schema: str) -> Tuple[ops.Gate, ...]:
             raise ValueError('Invalid schema name.')
 
 
-def _pauli_up_to_global_phase(gate: ops.Gate) -> Union[ops.Pauli, None]:
+def _pauli_up_to_global_phase(gate: ops.Gate) -> ops.Pauli | None:
     for pauli_gate in [ops.X, ops.Y, ops.Z]:
         if protocols.equal_up_to_global_phase(gate, pauli_gate):
             return pauli_gate
     return None
 
 
-def _validate_dd_sequence(dd_sequence: Tuple[ops.Gate, ...]) -> None:
+def _validate_dd_sequence(dd_sequence: tuple[ops.Gate, ...]) -> None:
     """Validates a given dynamical decoupling sequence.
 
-    The sequence should only consists of Pauli gates and is essentially an identity gate.
+    The sequence should only consist of Pauli gates and is essentially an identity gate.
 
     Args:
         dd_sequence: Input dynamical sequence to be validated.
@@ -79,14 +82,14 @@ def _validate_dd_sequence(dd_sequence: Tuple[ops.Gate, ...]) -> None:
 
     if not protocols.equal_up_to_global_phase(product, np.eye(2)):
         raise ValueError(
-            'Invalid dynamical decoupling sequence. Expect sequence production equals'
+            'Invalid dynamical decoupling sequence. Expect sequence product equals'
             f' identity up to a global phase, got {product}.'.replace('\n', ' ')
         )
 
 
 def _parse_dd_sequence(
-    schema: Union[str, Tuple[ops.Gate, ...]],
-) -> Tuple[Tuple[ops.Gate, ...], Dict[ops.Gate, ops.Pauli]]:
+    schema: str | tuple[ops.Gate, ...],
+) -> tuple[tuple[ops.Gate, ...], dict[ops.Gate, ops.Pauli]]:
     """Parses and returns dynamical decoupling sequence and its associated pauli map from schema."""
     dd_sequence = None
     if isinstance(schema, str):
@@ -96,7 +99,7 @@ def _parse_dd_sequence(
         dd_sequence = schema
 
     # Map gate to Pauli gate. This is necessary as dd sequence might contain gates like X^-1.
-    pauli_map: Dict[ops.Gate, ops.Pauli] = {}
+    pauli_map: dict[ops.Gate, ops.Pauli] = {}
     for gate in dd_sequence:
         pauli_gate = _pauli_up_to_global_phase(gate)
         if pauli_gate is not None:
@@ -111,7 +114,7 @@ def _is_single_qubit_operation(operation: ops.Operation) -> bool:
     return len(operation.qubits) == 1
 
 
-def _is_single_qubit_gate_moment(moment: circuits.Moment) -> bool:
+def _is_single_qubit_gate_moment(moment: Moment) -> bool:
     return all(_is_single_qubit_operation(op) for op in moment)
 
 
@@ -119,10 +122,8 @@ def _is_clifford_op(op: ops.Operation) -> bool:
     return has_unitary(op) and has_stabilizer_effect(op)
 
 
-def _calc_busy_moment_range_of_each_qubit(
-    circuit: circuits.FrozenCircuit,
-) -> Dict[ops.Qid, list[int]]:
-    busy_moment_range_by_qubit: Dict[ops.Qid, list[int]] = {
+def _calc_busy_moment_range_of_each_qubit(circuit: FrozenCircuit) -> dict[ops.Qid, list[int]]:
+    busy_moment_range_by_qubit: dict[ops.Qid, list[int]] = {
         q: [len(circuit), -1] for q in circuit.all_qubits()
     }
     for moment_id, moment in enumerate(circuit):
@@ -132,12 +133,12 @@ def _calc_busy_moment_range_of_each_qubit(
     return busy_moment_range_by_qubit
 
 
-def _is_insertable_moment(moment: circuits.Moment, single_qubit_gate_moments_only: bool) -> bool:
+def _is_insertable_moment(moment: Moment, single_qubit_gate_moments_only: bool) -> bool:
     return not single_qubit_gate_moments_only or _is_single_qubit_gate_moment(moment)
 
 
 def _merge_single_qubit_ops_to_phxz(
-    q: ops.Qid, operations: Tuple[ops.Operation, ...]
+    q: ops.Qid, operations: tuple[ops.Operation, ...]
 ) -> ops.Operation:
     """Merges [op1, op2, ...] and returns an equivalent op"""
     if len(operations) == 1:
@@ -148,9 +149,7 @@ def _merge_single_qubit_ops_to_phxz(
     return gate.on(q)
 
 
-def _try_merge_single_qubit_ops_of_two_moments(
-    m1: circuits.Moment, m2: circuits.Moment
-) -> Tuple[circuits.Moment, ...]:
+def _try_merge_single_qubit_ops_of_two_moments(m1: Moment, m2: Moment) -> tuple[Moment, ...]:
     """Merge single qubit ops of 2 moments if possible, returns 2 moments otherwise."""
     for q in m1.qubits & m2.qubits:
         op1 = m1.operation_at(q)
@@ -167,12 +166,10 @@ def _try_merge_single_qubit_ops_of_two_moments(
         # ops_on_q may contain 1 op or 2 ops.
         ops_on_q = [op for op in [m.operation_at(q) for m in [m1, m2]] if op is not None]
         merged_ops.add(_merge_single_qubit_ops_to_phxz(q, tuple(ops_on_q)))
-    return (circuits.Moment(merged_ops),)
+    return (Moment(merged_ops),)
 
 
-def _calc_pulled_through(
-    moment: circuits.Moment, input_pauli_ops: ops.PauliString
-) -> ops.PauliString:
+def _calc_pulled_through(moment: Moment, input_pauli_ops: ops.PauliString) -> ops.PauliString:
     """Calculates the pulled_through such that circuit(input_pauli_ops, moment.clifford_ops) is
     equivalent to circuit(moment.clifford_ops, pulled_through).
     """
@@ -182,7 +179,7 @@ def _calc_pulled_through(
     return input_pauli_ops.after(clifford_ops_in_moment)
 
 
-def _get_stop_qubits(moment: circuits.Moment) -> set[ops.Qid]:
+def _get_stop_qubits(moment: Moment) -> set[ops.Qid]:
     stop_pulling_through_qubits: set[ops.Qid] = set()
     for op in moment:
         if (not _is_clifford_op(op) and not _is_single_qubit_operation(op)) or not has_unitary(
@@ -204,20 +201,20 @@ def _need_merge_pulled_through(op_at_q: ops.Operation, is_at_last_busy_moment: b
 
 @transformer_api.transformer
 def add_dynamical_decoupling(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = None,
-    schema: Union[str, Tuple[ops.Gate, ...]] = 'DEFAULT',
+    context: cirq.TransformerContext | None = None,
+    schema: str | tuple[ops.Gate, ...] = 'DEFAULT',
     single_qubit_gate_moments_only: bool = True,
-) -> 'cirq.Circuit':
+) -> cirq.Circuit:
     """Adds dynamical decoupling gate operations to a given circuit.
-    This transformer might add new moments thus change structure of the original circuit.
+    This transformer might add new moments and thus change the structure of the original circuit.
 
     Args:
           circuit: Input circuit to transform.
           context: `cirq.TransformerContext` storing common configurable options for transformers.
           schema: Dynamical decoupling schema name or a dynamical decoupling sequence.
-            If a schema is specified, provided dynamical decouping sequence will be used.
+            If a schema is specified, the provided dynamical decoupling sequence will be used.
             Otherwise, customized dynamical decoupling sequence will be applied.
           single_qubit_gate_moments_only: If set True, dynamical decoupling operation will only be
             added in single-qubit gate moments.
@@ -231,7 +228,7 @@ def add_dynamical_decoupling(
     busy_moment_range_by_qubit = _calc_busy_moment_range_of_each_qubit(orig_circuit)
 
     # Stores all the moments of the output circuit chronologically.
-    transformed_moments: list[circuits.Moment] = []
+    transformed_moments: list[Moment] = []
     # A PauliString stores the result of 'pulling' Pauli gates past each operations
     # right before the current moment.
     pulled_through: ops.PauliString = ops.PauliString()
@@ -274,17 +271,27 @@ def add_dynamical_decoupling(
             dd_iter_by_qubits[q] = cycle(base_dd_sequence)
         # Need to insert a new moment before current moment
         if new_moment_ops:
-            # Fill insertable idle moments in the new moment using dd sequence
-            for q in orig_circuit.all_qubits() - stop_pulling_through_qubits:
-                if busy_moment_range_by_qubit[q][0] < moment_id <= busy_moment_range_by_qubit[q][1]:
-                    new_moment_ops.append(_update_pulled_through(q, next(dd_iter_by_qubits[q])))
             moments_to_be_appended = _try_merge_single_qubit_ops_of_two_moments(
-                transformed_moments.pop(), circuits.Moment(new_moment_ops)
+                transformed_moments[-1], Moment(new_moment_ops)
             )
-            transformed_moments.extend(moments_to_be_appended)
+            if len(moments_to_be_appended) == 1:
+                transformed_moments.pop()
+                transformed_moments.append(moments_to_be_appended[0])
+            else:  # Fill insertable idle moments in the new moment using dd sequence
+                for q in orig_circuit.all_qubits() - stop_pulling_through_qubits:
+                    if (
+                        busy_moment_range_by_qubit[q][0]
+                        < moment_id
+                        <= busy_moment_range_by_qubit[q][1]
+                    ):
+                        new_moment_ops.append(_update_pulled_through(q, next(dd_iter_by_qubits[q])))
+                moments_to_be_appended = _try_merge_single_qubit_ops_of_two_moments(
+                    transformed_moments.pop(), Moment(new_moment_ops)
+                )
+                transformed_moments.extend(moments_to_be_appended)
 
         # Step 2, calc updated_moment with insertions / merges.
-        updated_moment_ops: set['cirq.Operation'] = set()
+        updated_moment_ops: set[cirq.Operation] = set()
         for q in orig_circuit.all_qubits():
             op_at_q = moment.operation_at(q)
             remaining_pulled_through_gate = pulled_through.get(q)
@@ -313,7 +320,7 @@ def add_dynamical_decoupling(
                 updated_moment_ops.add(updated_op)
 
         if updated_moment_ops:
-            updated_moment = circuits.Moment(updated_moment_ops)
+            updated_moment = Moment(updated_moment_ops)
             transformed_moments.append(updated_moment)
 
             # Step 3, update pulled through.
@@ -327,8 +334,8 @@ def add_dynamical_decoupling(
     if ending_moment_ops:
         transformed_moments.extend(
             _try_merge_single_qubit_ops_of_two_moments(
-                transformed_moments.pop(), circuits.Moment(ending_moment_ops)
+                transformed_moments.pop(), Moment(ending_moment_ops)
             )
         )
 
-    return circuits.Circuit(transformed_moments)
+    return Circuit.from_moments(*transformed_moments)