Update Split2QUnitaries to handle SWAP unitary gates #13531

gadial · 2024-12-05T15:28:05Z

Summary

Updates the Split2QUnitaries transpiler pass to handle 2-qubit unitary gates which can be decomposed as a swap gate and 1-qubit gates.

Closes #13476

Details and comments

This PR extends the Split2QUnitaries in the following manner:

During the initial pass Split2QUnitaries performs, it checks whether any unitary encountered is a SWAP gate.
If SWAP gates were found, another pass is performed on the DAG, replacing SWAP gates by the 1-qubit unitary gates in their decomposition (as is currently done in Split2QUnitaries) and instead of adding SWAP gates, performs a virtual swap by dynamically changing the qubit layout (affecting subsequent gates and the final layout) similar to what the ElidePermutations does.

Since step 2 requires generating a new DAG (as opposed to what Split2QUnitaries does to identity-equivalent unitary gates), it is not performed during the initial pass, only if SWAP gates were detected.

qiskit-bot · 2024-12-05T15:28:10Z

One or more of the following people are relevant to this code:

@Qiskit/terra-core

coveralls · 2024-12-05T15:52:49Z

Pull Request Test Coverage Report for Build 13158018594

Warning: This coverage report may be inaccurate.

This pull request's base commit is no longer the HEAD commit of its target branch. This means it includes changes from outside the original pull request, including, potentially, unrelated coverage changes.

For more information on this, see Tracking coverage changes with pull request builds.
To avoid this issue with future PRs, see these Recommended CI Configurations.
For a quick fix, rebase this PR at GitHub. Your next report should be accurate.

Details

133 of 139 (95.68%) changed or added relevant lines in 3 files are covered.
823 unchanged lines in 35 files lost coverage.
Overall coverage decreased (-0.3%) to 88.66%

Changes Missing Coverage	Covered Lines	Changed/Added Lines	%
qiskit/transpiler/passes/optimization/split_2q_unitaries.py	15	16	93.75%
qiskit/transpiler/preset_passmanagers/builtin_plugins.py	4	5	80.0%
crates/accelerate/src/split_2q_unitaries.rs	114	118	96.61%

Files with Coverage Reduction	New Missed Lines	%
qiskit/synthesis/linear/linear_depth_lnn.py	1	90.91%
qiskit/providers/fake_provider/fake_backend.py	1	85.51%
qiskit/providers/basic_provider/basic_provider_tools.py	1	83.33%
crates/circuit/src/operations.rs	1	89.61%
crates/accelerate/src/split_2q_unitaries.rs	1	96.27%
qiskit/pulse/transforms/canonicalization.py	1	93.44%
qiskit/pulse/transforms/base_transforms.py	2	86.96%
qiskit/dagcircuit/collect_blocks.py	2	98.34%
qiskit/transpiler/passes/optimization/collect_cliffords.py	2	92.0%
qiskit/pulse/schedule.py	3	88.6%

Totals
Change from base Build 12905478077:	-0.3%
Covered Lines:	79062
Relevant Lines:	89174

💛 - Coveralls

mtreinish

Thanks for doing this, from a quick glance the code looks good (but I only quickly skimmed it on my phone, I'll do a deeper reviewer later). But I had some quick comments on the tests to start.

mtreinish · 2024-12-05T23:18:26Z

test/python/transpiler/test_split_2q_unitaries.py

+    def test_2q_swap_with_1_qubit_gates(self):
+        """Test that a 2q unitary matching a swap gate with 1-qubit gates before and after is correctly processed."""
+        qc = QuantumCircuit(2)
+        qc.h(0)
+        qc.x(1)
+        qc.swap(0,1)
+        qc.sx(0)
+        qc.sdg(1)
+        qc.global_phase += 1.2345
+        qc_split = QuantumCircuit(2)
+        qc_split.append(UnitaryGate(Operator(qc)), [0, 1])
+
+        pm = PassManager()
+        pm.append(Collect2qBlocks())
+        pm.append(ConsolidateBlocks())
+        pm.append(Split2QUnitaries())
+        res = pm.run(qc_split)
+        res_op = Operator.from_circuit(res, final_layout=res.layout.final_layout)


Can you add a test that has this in it as part of a larger circuit that runs through the full transpilation pipeline? I want to make sure that we validating that we're tracking and composing the final permutations correctly.

Done. Also added a smaller test which does non-trivial swapping (with swap gates removed using the elide permutation pass) before the unitary test which surfaced a possible bug in the layout composition phase. We need to discuss whether in this phase we should compose on the existing layout or (as was the case before my change) on its inverse.

mtreinish · 2024-12-05T23:18:55Z

test/python/transpiler/test_split_2q_unitaries.py

+        self.assertTrue(expected_op.equiv(res_op))
+        self.assertTrue(
+            matrix_equal(expected_op.data, res_op.data, ignore_phase=False)
+        )


Can we add an assertion here that swap has been removed from the output?

I've added self.assertNotIn("swap", res.count_ops()) but I don't think it's enough - there's also the possibility that we didn't split the unitary at all (note that it's also not being checked in the tests relating to the original split unitary code).

Any idea how to easily verify that the unitary was removed? Note that just using count_ops is tricky since we have a unitary both before (as the 2-qubit unitary) and after (as two individual 1-qubit unitaries). I can compare the count itself (1 before vs 2 after) but it feel less robust than it should.

mtreinish · 2024-12-05T23:19:57Z

test/python/transpiler/test_split_2q_unitaries.py

+        self.assertTrue(expected_op.equiv(res_op))
+        self.assertTrue(
+            matrix_equal(expected_op.data, res_op.data, ignore_phase=False)
+        )


I would add an assertion that we've removed the swap gate from the circuit. This test could still pass if there was no transformation on the input circuit.

alexanderivrii · 2024-12-06T07:58:27Z

If I recall correctly, we don't run the ElidePermutations pass if the user explicitly sets the initial layout (to prevent the transpiler from messing up circuits that are already routed). Is this something we should worry about for this pass as well? Would it make sense to have an additional flow where the pass would replace a 2-qubit unitary by a SWAP + 1-qubit unitaries without merging the SWAP into the final permutation?

ShellyGarion

Thanks for your contribution. I have a few minor comments.

crates/accelerate/src/split_2q_unitaries.rs

test/python/transpiler/test_split_2q_unitaries.py

qiskit/transpiler/passes/optimization/split_2q_unitaries.py

mtreinish

Overall this looks excellent thanks for doing this, this looks about ready now. I just have a few small comments and questions inline. The biggest one I think is over how/when you're thinking we should integrate this new feature into the preset pass managers. It's fine if you'd like to do that in a separate follow-up PR to keep this PR to a single logical change (that's probably preferable actually). I just wanted to understand your thinking on that.

mtreinish · 2025-01-31T12:10:03Z

crates/accelerate/src/split_2q_unitaries.rs

+        params: (!new_op.params.is_empty()).then(|| Box::new(new_op.params)),
+        extra_attrs: new_op.extra_attrs,
+        #[cfg(feature = "cache_pygates")]
+        py_op: std::sync::OnceLock::new(),


You do have the py op available for caching here since you are generating this via python. But in this case it doesn't actually matter too much because this is always going to be a PyGate and if the cache is None the python object reference will just be taken from that.

So, do you think something needs to change here?

I think this is fine as is. This was just more my idle musings.

mtreinish · 2025-01-31T12:16:57Z

crates/accelerate/src/split_2q_unitaries.rs

+                    new_dag.add_global_phase(py, &Param::Float(decomp.global_phase + PI4))?;
+                }
+            }
+            if !is_swap {


Instead of doing this with a mutable is_swap boolean variable, couldn't you just add a continue inside the if block for a swap equivalent unitary? and remove this !is_swap if statement. I feel like that might be a bit preferable because it reduce a layer of indentation here if nothing else. Although I suspect the compiler might be able to reason about the flow a bit better with a continue, but that would need to be validated and if true is of very minimal relevance to not be worth validating or benchmarking.

Done in a9bc3e1

mtreinish · 2025-01-31T12:20:30Z

qiskit/transpiler/passes/optimization/split_2q_unitaries.py

    """

-    def __init__(self, fidelity: float = 1.0 - 1e-16):
+    def __init__(self, fidelity: float = 1.0 - 1e-16, split_swap: bool = False):


By default this means we don't run the swap splitting, are you planning a follow-up where you update https://github.com/Qiskit/qiskit/blob/main/qiskit/transpiler/preset_passmanagers/builtin_plugins.py#L192-L194 to set it to True unless routing=None is specified?

That's exactly what I'm wondering about. If you think the specific logic you suggested here suffices, I'll add this as part of this PR.

Yeah I think that's sufficient. You can mirror the exact logic that conditions the execution of ElidePermutations .

Done in a9bc3e1

mtreinish · 2025-01-31T12:23:46Z

qiskit/transpiler/passes/optimization/split_2q_unitaries.py

+
+        (new_dag, qubit_mapping) = result
+        input_qubit_mapping = {qubit: index for index, qubit in enumerate(dag.qubits)}
+        self.property_set["original_layout"] = Layout(input_qubit_mapping)


Does this behave correctly if we run elide permutations first? I realize this is just a straight copy of what elide permutations is doing, but I'm wondering if we need to check that we're not doing multiple permutations before applying the layout or do some other storing if we run these together.

It should work - in theory. in split_2q_unitaries.py we have

if current_layout := self.property_set["virtual_permutation_layout"]: self.property_set["virtual_permutation_layout"] = new_layout.compose( current_layout, dag.qubits )

And compose works, if I recall correctly. However, this is not covered by the current test suite, and that's one of the things I wanted to ask about - should the "joint" test be placed in TestSplit2QUnitaries or perhaps a different location? What flows should we check, other than adding Split2QUnitaries before and after ElidePermutations?

mtreinish · 2025-01-31T12:26:20Z

releasenotes/notes/update-split-2q-unitaries-with-swap-557a1252e3208257.yaml

+    handle the case where the unitary in consideration can be written
+    as a SWAP gate and two 1-qubit gates. In this case, it splits the
+    unitary and also applies virtual swapping similar to what is done in
+    :class:`.ElidePermutations`.


I would probably mention the new argument here to document that it is being introduced. Something like:

Suggested change

:class:`.ElidePermutations`.

:class:`.ElidePermutations`. This functionality can be controlled with a new argument,

``split_swap``, on the constructor of :class`.Split2QUnitaries` which can be used to disable

splitting swap equivalent gates.

Done in a9bc3e1

Update Split2QUnitaries to handle SWAP unitaries as well

53817b5

gadial requested a review from a team as a code owner December 5, 2024 15:28

ShellyGarion added this to the 2.0.0 milestone Dec 5, 2024

mtreinish reviewed Dec 5, 2024

View reviewed changes

Linting, additional test, bugfix in layout composition

0bdba2a

ShellyGarion reviewed Jan 1, 2025

View reviewed changes

gadial added 4 commits January 2, 2025 11:14

Docstring updates

1d7b4f6

Merge branch 'main' into split_2q_swap_unitaries

ea5e164

Merge branch 'main' into split_2q_swap_unitaries

e30b617

Add a flag for toggling swap split

93b59f9

1ucian0 assigned mtreinish Jan 30, 2025

mtreinish reviewed Jan 31, 2025

View reviewed changes

Changes according to PR review

a9bc3e1

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Update Split2QUnitaries to handle SWAP unitary gates #13531

Update Split2QUnitaries to handle SWAP unitary gates #13531

gadial commented Dec 5, 2024

qiskit-bot commented Dec 5, 2024

coveralls commented Dec 5, 2024 •

edited

Loading

mtreinish left a comment

mtreinish Dec 5, 2024

gadial Dec 11, 2024

mtreinish Dec 5, 2024

gadial Dec 9, 2024

mtreinish Dec 5, 2024

gadial Dec 11, 2024

alexanderivrii commented Dec 6, 2024

ShellyGarion left a comment

mtreinish left a comment

mtreinish Jan 31, 2025

gadial Feb 4, 2025

mtreinish Feb 5, 2025

mtreinish Jan 31, 2025

gadial Feb 5, 2025

mtreinish Jan 31, 2025

gadial Feb 4, 2025

mtreinish Feb 5, 2025

gadial Feb 5, 2025

mtreinish Jan 31, 2025

gadial Feb 5, 2025

mtreinish Jan 31, 2025

gadial Feb 5, 2025

-    :class:`.ElidePermutations`.
+    :class:`.ElidePermutations`. This functionality can be controlled with a new argument,
+    ``split_swap``, on the constructor of :class`.Split2QUnitaries` which can be used to disable
+    splitting swap equivalent gates.

Update Split2QUnitaries to handle SWAP unitary gates #13531

Are you sure you want to change the base?

Update Split2QUnitaries to handle SWAP unitary gates #13531

Conversation

gadial commented Dec 5, 2024

Summary

Details and comments

qiskit-bot commented Dec 5, 2024

coveralls commented Dec 5, 2024 • edited Loading

Pull Request Test Coverage Report for Build 13158018594

Warning: This coverage report may be inaccurate.

Details

💛 - Coveralls

mtreinish left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

alexanderivrii commented Dec 6, 2024

ShellyGarion left a comment

Choose a reason for hiding this comment

mtreinish left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

coveralls commented Dec 5, 2024 •

edited

Loading