cirq-core 1.2.0.dev20230717232332__py3-none-any.whl → 1.3.0__py3-none-any.whl

cirq/testing/consistent_qasm_test.py

@@ -54,8 +54,7 @@ class QuditGate(cirq.Gate):
 def test_assert_qasm_is_consistent_with_unitary():
     try:
         import qiskit as _
-    except ImportError:
-        # coverage: ignore
+    except ImportError:  # pragma: no cover
         warnings.warn(
             "Skipped test_assert_qasm_is_consistent_with_unitary "
             "because qiskit isn't installed to verify against."
@@ -84,7 +83,7 @@ def test_assert_qasm_is_consistent_with_unitary():
     )
 
     # Checks that code is valid.
-    with pytest.raises(AssertionError, match='Check your OPENQASM'):
+    with pytest.raises(AssertionError, match='QASM not consistent'):
         cirq.testing.assert_qasm_is_consistent_with_unitary(
             Fixed(np.array([[1, 0], [0, -1]]), 'JUNK$&*@($#::=[];')
         )

cirq/testing/consistent_specified_has_unitary_test.py

@@ -32,12 +32,10 @@ def test_assert_specifies_has_unitary_if_unitary_from_apply():
     class Bad(cirq.Operation):
         @property
         def qubits(self):
-            # coverage: ignore
             return ()
 
         def with_qubits(self, *new_qubits):
-            # coverage: ignore
-            return self
+            return self  # pragma: no cover
 
         def _apply_unitary_(self, args):
             return args.target_tensor

cirq/testing/equals_tester.py

@@ -157,7 +157,7 @@ class _TestsForNotImplemented:
 
     def __eq__(self, other: object) -> bool:
         if other is not self.other:
-            return NotImplemented  # coverage: ignore
+            return NotImplemented  # pragma: no cover
         return True
 
 

cirq/testing/equals_tester_test.py

@@ -169,16 +169,16 @@ def test_fails_when_ne_is_inconsistent():
 
         def __eq__(self, other):
             if not isinstance(other, type(self)):
-                return NotImplemented  # coverage: ignore
+                return NotImplemented  # pragma: no cover
             return self.x == other.x
 
         def __ne__(self, other):
             if not isinstance(other, type(self)):
-                return NotImplemented  # coverage: ignore
+                return NotImplemented  # pragma: no cover
             return self.x == other.x
 
         def __hash__(self):
-            return hash(self.x)  # coverage: ignore
+            return hash(self.x)  # pragma: no cover
 
     with pytest.raises(AssertionError, match='inconsistent'):
         eq.make_equality_group(InconsistentNeImplementation)
@@ -278,7 +278,7 @@ def test_returns_not_implemented_for_other_types():
             if isinstance(other, (FirstClass, SecondClass)):
                 return self.val == other.val
             # Ignore coverage, this is just for illustrative purposes.
-            return NotImplemented  # coverage: ignore
+            return NotImplemented  # pragma: no cover
 
     # But we see that this does not work because it fails commutativity of ==
     assert SecondClass("a") == FirstClass("a")
@@ -306,7 +306,7 @@ def test_returns_not_implemented_for_other_types():
             if isinstance(other, (ThirdClass, FourthClass)):
                 return self.val == other.val
             # Ignore coverage, this is just for illustrative purposes.
-            return NotImplemented  # coverage: ignore
+            return NotImplemented  # pragma: no cover
 
     # We see this is fixed:
     assert ThirdClass("a") == FourthClass("a")

cirq/testing/equivalent_repr_eval_test.py

@@ -30,9 +30,7 @@ def test_external():
 
 
 def test_custom_class_repr():
-    class CustomRepr:
-        # coverage: ignore
-
+    class CustomRepr:  # pragma: no cover
         setup_code = """class CustomRepr:
             def __init__(self, eq_val):
                 self.eq_val = eq_val

cirq/testing/gate_features_test.py

@@ -26,11 +26,11 @@ def test_two_qubit_gate_is_abstract_can_implement():
 
 
 def test_two_qubit_gate_validate_pass():
-    class Dummy(cirq.testing.TwoQubitGate):
+    class Example(cirq.testing.TwoQubitGate):
         def matrix(self):
             pass
 
-    g = Dummy()
+    g = Example()
     q1 = cirq.NamedQubit('q1')
     q2 = cirq.NamedQubit('q2')
     q3 = cirq.NamedQubit('q3')
@@ -42,11 +42,11 @@ def test_two_qubit_gate_validate_pass():
 
 
 def test_two_qubit_gate_validate_wrong_number():
-    class Dummy(cirq.testing.TwoQubitGate):
+    class Example(cirq.testing.TwoQubitGate):
         def matrix(self):
             pass
 
-    g = Dummy()
+    g = Example()
     q1 = cirq.NamedQubit('q1')
     q2 = cirq.NamedQubit('q2')
     q3 = cirq.NamedQubit('q3')
@@ -60,11 +60,11 @@ def test_two_qubit_gate_validate_wrong_number():
 
 
 def test_three_qubit_gate_validate():
-    class Dummy(cirq.testing.ThreeQubitGate):
+    class Example(cirq.testing.ThreeQubitGate):
         def matrix(self):
             pass
 
-    g = Dummy()
+    g = Example()
     a, b, c, d = cirq.LineQubit.range(4)
 
     assert g.num_qubits() == 3

cirq/testing/order_tester_test.py

@@ -89,9 +89,7 @@ def test_add_ordering_group_incorrect():
 
 
 def test_propagates_internal_errors():
-    class UnorderableClass:
-        # coverage: ignore
-
+    class UnorderableClass:  # pragma: no cover
         def __eq__(self, other):
             return NotImplemented
 

cirq/testing/random_circuit_test.py

@@ -60,8 +60,7 @@ def _cases_for_random_circuit():
             # number of qubits greater that the number of qubits for the
             # circuit. In this case, try again.
             if all(n > n_qubits for n in gate_domain.values()):
-                # coverage: ignore
-                continue
+                continue  # pragma: no cover
         else:
             gate_domain = None
         pass_qubits = random.choice((True, False))
@@ -107,7 +106,6 @@ def test_random_circuit_reproducible_with_seed(seed):
 
 
 def test_random_circuit_not_expected_number_of_qubits():
-
     circuit = cirq.testing.random_circuit(
         qubits=3, n_moments=1, op_density=1.0, gate_domain={cirq.CNOT: 2}
     )

cirq/transformers/__init__.py

@@ -24,6 +24,7 @@ from cirq.transformers.analytical_decompositions import (
     is_negligible_turn,
     parameterized_2q_op_to_sqrt_iswap_operations,
     prepare_two_qubit_state_using_cz,
+    prepare_two_qubit_state_using_iswap,
     prepare_two_qubit_state_using_sqrt_iswap,
     quantum_shannon_decomposition,
     single_qubit_matrix_to_gates,
@@ -93,6 +94,8 @@ from cirq.transformers.merge_single_qubit_gates import (
     merge_single_qubit_moments_to_phxz,
 )
 
+from cirq.transformers.qubit_management_transformers import map_clean_and_borrowable_qubits
+
 from cirq.transformers.synchronize_terminal_measurements import synchronize_terminal_measurements
 
 from cirq.transformers.transformer_api import (

cirq/transformers/analytical_decompositions/__init__.py

@@ -66,6 +66,7 @@ from cirq.transformers.analytical_decompositions.two_qubit_to_sqrt_iswap import
 from cirq.transformers.analytical_decompositions.two_qubit_state_preparation import (
     prepare_two_qubit_state_using_cz,
     prepare_two_qubit_state_using_sqrt_iswap,
+    prepare_two_qubit_state_using_iswap,
 )
 
 from cirq.transformers.analytical_decompositions.single_to_two_qubit_isometry import (

cirq/transformers/analytical_decompositions/three_qubit_decomposition.py

@@ -56,8 +56,7 @@ def three_qubit_matrix_to_operations(
 
     try:
         from scipy.linalg import cossin
-    except ImportError:  # coverage: ignore
-        # coverage: ignore
+    except ImportError:  # pragma: no cover
         raise ImportError(
             "cirq.three_qubit_unitary_to_operations requires "
             "SciPy 1.5.0+, as it uses the cossin function. Please"

cirq/transformers/analytical_decompositions/three_qubit_decomposition_test.py

@@ -30,15 +30,13 @@ from cirq.transformers.analytical_decompositions.three_qubit_decomposition impor
 
 
 def _skip_if_scipy(*, version_is_greater_than_1_5_0: bool) -> Callable[[Callable], Callable]:
-    def decorator(func):
+    def decorator(func):  # pragma: no cover
         try:
             # pylint: disable=unused-import
             from scipy.linalg import cossin
 
-            # coverage: ignore
             return None if version_is_greater_than_1_5_0 else func
         except ImportError:
-            # coverage: ignore
             return func if version_is_greater_than_1_5_0 else None
 
     return decorator
@@ -84,8 +82,7 @@ def test_three_qubit_matrix_to_operations_errors():
 # environment like that, we'll need to ignore the coverage somehow conditionally on
 # the scipy version.
 @_skip_if_scipy(version_is_greater_than_1_5_0=True)
-# coverage: ignore
-def test_three_qubit_matrix_to_operations_scipy_error():
+def test_three_qubit_matrix_to_operations_scipy_error():  # pragma: no cover
     a, b, c = cirq.LineQubit.range(3)
     with pytest.raises(ImportError, match="three_qubit.*1.5.0+"):
         cirq.three_qubit_matrix_to_operations(a, b, c, np.eye(8))

cirq/transformers/analytical_decompositions/two_qubit_state_preparation.py

@@ -106,3 +106,41 @@ def prepare_two_qubit_state_using_cz(
     return op_list + _1q_matrices_to_ops(
         np.dot(u, np.linalg.inv(u_CZ)), np.dot(vh.T, np.linalg.inv(vh_CZ.T)), q0, q1
     )
+
+
+def prepare_two_qubit_state_using_iswap(
+    q0: 'cirq.Qid', q1: 'cirq.Qid', state: 'cirq.STATE_VECTOR_LIKE', use_iswap_inv: bool = False
+) -> List['cirq.Operation']:
+    """Prepares the given 2q state from |00> using at-most 1 ISWAP gate + single qubit rotations.
+
+    Entangled states are prepared using exactly 1 ISWAP gate while product states are prepared
+    using only single qubit rotations (0 ISWAP gates)
+
+    Args:
+        q0: The first qubit being operated on.
+        q1: The other qubit being operated on.
+        state: 4x1 matrix representing two qubit state vector, ordered as 00, 01, 10, 11.
+        use_iswap_inv: If True, uses `cirq.ISWAP_INV` instead of `cirq.ISWAP`.
+
+    Returns:
+        List of operations (at-most 1 ISWAP + single qubit rotations) preparing state from |00>.
+    """
+    state_vector = qis.to_valid_state_vector(state, num_qubits=2)
+    state_vector = state_vector / np.linalg.norm(state_vector)
+    u, s, vh = np.linalg.svd(state_vector.reshape(2, 2))
+    if np.isclose(s[0], 1):
+        # Product state can be prepare with just single qubit unitaries.
+        return _1q_matrices_to_ops(u, vh.T, q0, q1, True)
+    alpha = np.arccos(np.clip(s[0], 0, 1))
+    op_list = [
+        ops.ry(2 * alpha).on(q0),
+        ops.H.on(q1),
+        ops.ISWAP_INV.on(q0, q1) if use_iswap_inv else ops.ISWAP.on(q0, q1),
+    ]
+    intermediate_state = circuits.Circuit(op_list).final_state_vector(
+        ignore_terminal_measurements=False, dtype=np.complex64
+    )
+    u_CZ, _, vh_CZ = np.linalg.svd(intermediate_state.reshape(2, 2))
+    return op_list + _1q_matrices_to_ops(
+        np.dot(u, np.linalg.inv(u_CZ)), np.dot(vh.T, np.linalg.inv(vh_CZ.T)), q0, q1
+    )

cirq/transformers/analytical_decompositions/two_qubit_state_preparation_test.py

@@ -71,6 +71,24 @@ def test_prepare_two_qubit_state_using_cz(state):
     )
 
 
+@pytest.mark.parametrize("state", STATES_TO_PREPARE)
+@pytest.mark.parametrize("use_iswap_inv", [True, False])
+def test_prepare_two_qubit_state_using_iswap(state, use_iswap_inv):
+    state = cirq.to_valid_state_vector(state, num_qubits=2)
+    q = cirq.LineQubit.range(2)
+    circuit = cirq.Circuit(
+        cirq.prepare_two_qubit_state_using_iswap(*q, state, use_iswap_inv=use_iswap_inv)
+    )
+    iswap_gate = cirq.ISWAP_INV if use_iswap_inv else cirq.ISWAP
+    ops_iswap = [*circuit.findall_operations(lambda op: op.gate == iswap_gate)]
+    ops_2q = [*circuit.findall_operations(lambda op: cirq.num_qubits(op) > 1)]
+    assert ops_iswap == ops_2q
+    assert len(ops_iswap) <= 1
+    assert cirq.allclose_up_to_global_phase(
+        circuit.final_state_vector(ignore_terminal_measurements=False, dtype=np.complex64), state
+    )
+
+
 @pytest.mark.parametrize("state", STATES_TO_PREPARE)
 @pytest.mark.parametrize("use_sqrt_iswap_inv", [True, False])
 def test_prepare_two_qubit_state_using_sqrt_iswap(state, use_sqrt_iswap_inv):

cirq/transformers/expand_composite_test.py

@@ -105,14 +105,14 @@ def test_recursive_composite():
 
 
 def test_decompose_returns_not_flat_op_tree():
-    class DummyGate(cirq.testing.SingleQubitGate):
+    class ExampleGate(cirq.testing.SingleQubitGate):
         def _decompose_(self, qubits):
             (q0,) = qubits
             # Yield a tuple of gates instead of yielding a gate
             yield cirq.X(q0),
 
     q0 = cirq.NamedQubit('q0')
-    circuit = cirq.Circuit(DummyGate()(q0))
+    circuit = cirq.Circuit(ExampleGate()(q0))
 
     circuit = cirq.expand_composite(circuit)
     expected = cirq.Circuit(cirq.X(q0))
@@ -120,7 +120,7 @@ def test_decompose_returns_not_flat_op_tree():
 
 
 def test_decompose_returns_deep_op_tree():
-    class DummyGate(cirq.testing.TwoQubitGate):
+    class ExampleGate(cirq.testing.TwoQubitGate):
         def _decompose_(self, qubits):
             q0, q1 = qubits
             # Yield a tuple
@@ -139,7 +139,7 @@ def test_decompose_returns_deep_op_tree():
             yield generator(2)
 
     q0, q1 = cirq.LineQubit.range(2)
-    circuit = cirq.Circuit(DummyGate()(q0, q1))
+    circuit = cirq.Circuit(ExampleGate()(q0, q1))
 
     circuit = cirq.expand_composite(circuit)
     expected = cirq.Circuit(

cirq/transformers/heuristic_decompositions/gate_tabulation_math_utils.py

@@ -174,7 +174,7 @@ def kak_vector_infidelity(
 
     # Ensure we consider equivalent vectors for only the smallest input.
     if k_vec_a.size < k_vec_b.size:
-        k_vec_a, k_vec_b = k_vec_b, k_vec_a  # coverage: ignore
+        k_vec_a, k_vec_b = k_vec_b, k_vec_a  # pragma: no cover
 
     k_vec_a = k_vec_a[..., np.newaxis, :]  # (...,1,3)
     k_vec_b = _kak_equivalent_vectors(k_vec_b)  # (...,192,3)

cirq/transformers/heuristic_decompositions/two_qubit_gate_tabulation.py

@@ -407,8 +407,7 @@ def two_qubit_gate_product_tabulation(
     # If all KAK vectors in the mesh have been tabulated, return.
     missing_vec_inds = np.logical_not(tabulated_kak_inds).nonzero()[0]
 
-    if not np.any(missing_vec_inds):
-        # coverage: ignore
+    if not np.any(missing_vec_inds):  # pragma: no cover
         return TwoQubitGateTabulation(
             base_gate, np.array(kak_vecs), sq_cycles, max_infidelity, summary, ()
         )

cirq/transformers/merge_k_qubit_gates_test.py

@@ -74,10 +74,10 @@ def test_ignores_2qubit_target():
 
 
 def test_ignore_unsupported_gate():
-    class UnsupportedDummy(cirq.testing.SingleQubitGate):
+    class UnsupportedExample(cirq.testing.SingleQubitGate):
         pass
 
-    c = cirq.Circuit(UnsupportedDummy()(cirq.LineQubit(0)))
+    c = cirq.Circuit(UnsupportedExample()(cirq.LineQubit(0)))
     assert_optimizes(optimized=cirq.merge_k_qubit_unitaries(c, k=1), expected=c)
 
 

cirq/transformers/qubit_management_transformers.py

@@ -0,0 +1,177 @@
+# Copyright 2023 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 Dict, Optional, Set, Tuple, TYPE_CHECKING
+
+from cirq import circuits, ops
+
+if TYPE_CHECKING:
+    import cirq
+
+
+def _get_qubit_mapping_first_and_last_moment(
+    circuit: 'cirq.AbstractCircuit',
+) -> Dict['cirq.Qid', Tuple[int, int]]:
+    """Computes `(first_moment_idx, last_moment_idx)` tuple for each qubit in the input circuit.
+
+    Args:
+        circuit: An input cirq circuit to analyze.
+
+    Returns:
+        A dict mapping each qubit `q` in the input circuit to a tuple of integers
+        `(first_moment_idx, last_moment_idx)` where
+         - first_moment_idx: Index of leftmost moment containing an operation that acts on `q`.
+         - last_moment_idx: Index of rightmost moment containing an operation that acts on `q`.
+    """
+    ret = {q: (len(circuit), 0) for q in circuit.all_qubits()}
+    for i, moment in enumerate(circuit):
+        for q in moment.qubits:
+            ret[q] = (min(ret[q][0], i), max(ret[q][1], i))
+    return ret
+
+
+def _is_temp(q: 'cirq.Qid') -> bool:
+    return isinstance(q, (ops.CleanQubit, ops.BorrowableQubit))
+
+
+def map_clean_and_borrowable_qubits(
+    circuit: 'cirq.AbstractCircuit', *, qm: Optional['cirq.QubitManager'] = None
+) -> 'cirq.Circuit':
+    """Uses `qm: QubitManager` to map all `CleanQubit`/`BorrowableQubit`s to system qubits.
+
+    `CleanQubit` and `BorrowableQubit` are internal qubit types that are used as placeholder qubits
+    to record a clean / dirty ancilla allocation request.
+
+    This transformer uses the `QubitManager` provided in the input to:
+     - Allocate clean ancilla qubits by delegating to `qm.qalloc` for all `CleanQubit`s.
+     - Allocate dirty qubits for all `BorrowableQubit` types via the following two steps:
+         1. First analyse the input circuit and check if there are any suitable system qubits
+            that can be borrowed, i.e. ones which do not have any overlapping operations
+            between circuit[start_index : end_index] where `(start_index, end_index)` is the
+            lifespan of temporary borrowable qubit under consideration. If yes, borrow the system
+            qubits to replace the temporary `BorrowableQubit`.
+         2. If no system qubits can be borrowed, delegate the request to `qm.qborrow`.
+
+    Notes:
+        1. The borrow protocol can be made more efficient by also considering the newly
+    allocated clean ancilla qubits in step-1 before delegating to `qm.borrow`, but this
+    optimization is left as a future improvement.
+        2. As of now, the transformer does not preserve moment structure and defaults to
+    inserting all mapped operations in a resulting circuit using EARLIEST strategy. The reason
+    is that preserving moment structure forces additional constraints on the qubit allocation
+    strategy (i.e. if two operations `op1` and `op2` are in the same moment, then we cannot
+    reuse ancilla across `op1` and `op2`). We leave it upto the user to force such constraints
+    using the qubit manager instead of making it part of the transformer.
+        3. However, for borrowable system qubits managed by the transformer, we do not reuse qubits
+    within the same moment.
+        4. Since this is not implemented using the cirq transformers infrastructure, we currently
+    do not support recursive mapping within sub-circuits and that is left as a future TODO.
+
+    Args:
+        circuit: Input `cirq.Circuit` containing temporarily allocated
+            `CleanQubit`/`BorrowableQubit`s.
+        qm: An instance of `cirq.QubitManager` specifying the strategy to use for allocating /
+            / deallocating new ancilla qubits to replace the temporary qubits.
+
+    Returns:
+        An updated `cirq.Circuit` with all `CleanQubit`/`BorrowableQubit` mapped to either existing
+        system qubits or new ancilla qubits allocated using the `qm` qubit manager.
+    """
+    if qm is None:
+        qm = ops.GreedyQubitManager(prefix="ancilla")
+
+    allocated_qubits = {q for q in circuit.all_qubits() if _is_temp(q)}
+    qubits_lifespan = _get_qubit_mapping_first_and_last_moment(circuit)
+    all_qubits = frozenset(circuit.all_qubits() - allocated_qubits)
+    trivial_map = {q: q for q in all_qubits}
+    # `allocated_map` maintains the mapping of all temporary qubits seen so far, mapping each of
+    # them to either a newly allocated managed ancilla or an existing borrowed system qubit.
+    allocated_map: Dict['cirq.Qid', 'cirq.Qid'] = {}
+    to_free: Set['cirq.Qid'] = set()
+    last_op_idx = -1
+
+    def map_func(op: 'cirq.Operation', idx: int) -> 'cirq.OP_TREE':
+        nonlocal last_op_idx, to_free
+        assert isinstance(qm, ops.QubitManager)
+
+        for q in sorted(to_free):
+            is_managed_qubit = allocated_map[q] not in all_qubits
+            if idx > last_op_idx or is_managed_qubit:
+                # is_managed_qubit: if `q` is mapped to a newly allocated qubit managed by the qubit
+                #   manager, we can free it immediately after the previous operation ends. This
+                #   assumes that a managed qubit is not considered by the transformer as part of
+                #   borrowing qubits (first point of the notes above).
+                # idx > last_op_idx: if `q` is mapped to a system qubit, which is not managed by the
+                #   qubit manager, we free it only at the end of the moment.
+                if is_managed_qubit:
+                    qm.qfree([allocated_map[q]])
+                allocated_map.pop(q)
+                to_free.remove(q)
+
+        last_op_idx = idx
+
+        # To check borrowable qubits, we manually manage only the original system qubits
+        # that are not managed by the qubit manager. If any of the system qubits cannot be
+        # borrowed, we defer to the qubit manager to allocate a new clean qubit for us.
+        # This is a heuristic and can be improved by also checking if any allocated but not
+        # yet freed managed qubit can be borrowed for the shorter scope, but we ignore the
+        # optimization for the sake of simplicity here.
+        borrowable_qubits = set(all_qubits) - set(allocated_map.values())
+
+        op_temp_qubits = (q for q in op.qubits if _is_temp(q))
+        for q in op_temp_qubits:
+            # Get the lifespan of this temporarily allocated ancilla qubit `q`.
+            st, en = qubits_lifespan[q]
+            assert st <= idx <= en
+            if en == idx:
+                # Mark that this temporarily allocated qubit can be freed after this moment ends.
+                to_free.add(q)
+            if q in allocated_map or st < idx:
+                # The qubit already has a mapping iff we have seen it before.
+                assert st < idx and q in allocated_map
+                # This line is actually covered by
+                # `test_map_clean_and_borrowable_qubits_deallocates_only_once` but pytest-cov seems
+                # to not recognize it and hence the pragma: no cover.
+                continue  # pragma: no cover
+
+            # This is the first time we are seeing this temporary qubit and need to find a mapping.
+            if isinstance(q, ops.CleanQubit):
+                # Allocate a new clean qubit if `q` using the qubit manager.
+                allocated_map[q] = qm.qalloc(1)[0]
+            elif isinstance(q, ops.BorrowableQubit):
+                # For each of the system qubits that can be borrowed, check whether they have a
+                # conflicting operation in the range [st, en]; which is the scope for which the
+                # borrower needs the borrowed qubit for.
+                start_frontier = {q: st for q in borrowable_qubits}
+                end_frontier = {q: en + 1 for q in borrowable_qubits}
+                ops_in_between = circuit.findall_operations_between(start_frontier, end_frontier)
+                # Filter the set of borrowable qubits which do not have any conflicting operations.
+                filtered_borrowable_qubits = borrowable_qubits - set(
+                    q for _, op in ops_in_between for q in op.qubits
+                )
+                if filtered_borrowable_qubits:
+                    # Allocate a borrowable qubit and remove it from the pool of available qubits.
+                    allocated_map[q] = min(filtered_borrowable_qubits)
+                    borrowable_qubits.remove(allocated_map[q])
+                else:
+                    # Use the qubit manager to get a new borrowable qubit, since we couldn't find
+                    # one from the original system qubits.
+                    allocated_map[q] = qm.qborrow(1)[0]
+            else:
+                assert False, f"Unknown temporary qubit type {q}"
+
+        # Return the transformed operation / decomposed op-tree.
+        return op.transform_qubits({**allocated_map, **trivial_map})
+
+    return circuits.Circuit(map_func(op, idx) for idx, m in enumerate(circuit) for op in m)