Decomposition of arbitrary two-qubit unitaries. #1552

glassnotes · 2021-08-18T13:06:32Z

Context: Addition of compilation tools to PennyLane.

Description of the Change: Adds a decomposition method for arbitrary two-qubit unitary operations.

Benefits: Any two-qubit unitary in a circuit can now be decomposed into elementary operations, in all interfaces.

Possible Drawbacks: This method was very very challenging to implement. I was not able to get full differentiability (there are some notes in the two_qubit_unitary.pyfile about this). It is possible to take gradients when the two-qubit unitaries that are decomposed are constant (i.e., do not depend on the QNode parameters), but not when they do depend on the QNode parameters.

Related GitHub Issues: None

github-actions · 2021-08-18T13:06:55Z

Hello. You may have forgotten to update the changelog!
Please edit .github/CHANGELOG.md with:

A one-to-two sentence description of the change. You may include a small working example for new features.
A link back to this PR.
Your name (or GitHub username) in the contributors section.

…qubitunitary

glassnotes · 2021-08-31T19:55:31Z

@josh146 this is ready for a first look. I am just having trouble getting the differentiability working.

josh146

This is an awesome new feature @glassnotes!

josh146 · 2021-09-01T05:15:05Z

pennylane/ops/qubit/matrix_ops.py

+        if qml.math.shape(U) == (4, 4):
+            wires = Wires(wires)
+            decomp_ops = qml.transforms.decompositions.two_qubit_decomposition(U, wires)
+            return decomp_ops


Nice 👍 This is super cool.

I must admit though, after writing the tracing ADR, everywhere I look I see things that won't be supported by tracing 😆 If we decide to go down that route, it means we will have to rethink a lot of the code base (or retrace any time argument shapes change).

pennylane/transforms/decompositions/two_qubit_unitary.py

josh146 · 2021-09-01T05:17:17Z

pennylane/transforms/decompositions/two_qubit_unitary.py

+
+# This gate E is called the "magic basis". It can be used to convert between
+# SO(4) and SU(2) x SU(2). For A in SO(4), E A E^\dag is in SU(2) x SU(2).
+E = qml.math.array([[1, 1j, 0, 0], [0, 0, 1j, 1], [0, 0, 1j, -1], [1, -1j, 0, 0]]) / np.sqrt(2)


I have a feeling that qml.math.array() simply dispatches to np.array? Would it make more sense to just use NumPy here, so that it is clear that these are non-differentiable constants?

Then you would be able to do

E = np.array([[1, 1j, 0, 0], [0, 0, 1j, 1], [0, 0, 1j, -1], [1, -1j, 0, 0]]) / np.sqrt(2) Et = E.T Edag = Et.conj()

josh146 · 2021-09-01T06:19:55Z

pennylane/transforms/decompositions/two_qubit_unitary.py

+    mat = qml.math.zeros((4, 4))
+
+    for row_idx in range(4):
+        mat[row_idx, seq[row_idx]] = 1
+
+    return mat


This can be vectorized for performance:

>>> seq = np.array([0, 1, 4, 3, 2]) >>> mat = np.identity(5) >>> mat[:, seq] array([[1., 0., 0., 0., 0.], [0., 1., 0., 0., 0.], [0., 0., 0., 0., 1.], [0., 0., 0., 1., 0.], [0., 0., 1., 0., 0.]])

I think this is also a case where you can just use plain NumPy?

Oh sweet - when streamlined like this, it doesn't even need to be in its own function. Thanks!

pennylane/transforms/decompositions/two_qubit_unitary.py

josh146 · 2021-09-01T06:39:23Z

pennylane/transforms/decompositions/two_qubit_unitary.py

+    D_ops = zyz_decomposition(D, wires[1])
+
+    # Return the full decomposition
+    return C_ops + D_ops + interior_decomp + A_ops + B_ops


josh146 · 2021-09-01T06:41:52Z

tests/transforms/test_decompositions.py

+        assert check_matrix_equivalence(U, obtained_matrix, atol=1e-7)
+
+
+class TestTwoQubitUnitaryDecompositionInterfaces:


It might be the case that gradient tests, when added here, might expose issues (e.g., the array assignment)

tests/transforms/test_unitary_to_rot.py

josh146 · 2021-09-01T06:46:22Z

tests/transforms/test_unitary_to_rot.py

+        assert qml.math.allclose(original_grad, transformed_grad, atol=1e-6)
+
+    @pytest.mark.parametrize("U", test_u4_unitaries)
+    def test_gradient_unitary_to_rot_torch_two_qubit(self, U):


From looking at the CI, it seems that the (current) reasons Torch is failing is qml.math.linalg.multi_dot([Edag, U, E]). It seems that Torch has no equivalent to this, so qml.math is seeing a list input and simply attempting to dispatch to vanilla NumPy :(

This is probably a case of multi-dispatch - we need to look at the types of Edag, U, and E, and determine which interface to dispatch to based on that. So we have two options:

Add qml.math.multi_dot to multi_dispatch.py

Chain qml.math.dot instead

The first one seems like the nicer solution, though maybe something out of scope of this PR. For now I will chain dots just for the purpose of getting a differentiable version working, and then I will look into this 👍

Co-authored-by: Josh Izaac <josh146@gmail.com>

glassnotes · 2021-09-16T15:25:23Z

pennylane/ops/qubit/matrix_ops.py

-        raise NotImplementedError("Decompositions only supported for single-qubit unitaries")
+        if qml.math.shape(U) == (4, 4):
+            wires = Wires(wires)
+            decomp_ops = qml.transforms.decompositions.two_qubit_decomposition(U, wires)


@josh146 so doing this here actually messes up the behaviour when tape.expand() is called, because of the order in which the operations are created (the centre part gets computed before the SU(2) stuff around). However if I call this with invisible around it, nothing happens during expand because nothing gets queue. It seems kind of weird to loop through the decomp_ops and queue them here, is there a different workaround for this?

Huh, this is a really good question 🤔

if qml.math.shape(U) == (4, 4): wires = Wires(wires) decomp_ops = qml.transforms.invisible( qml.transforms.two_qubit_decomposition )(U, wires) current_tape = qml.tape.get_active_tape() if current_tape: for op in decomp_ops: qml.apply(op, current_tape) return decomp_ops

Huh, this feels gross, but it works.

My mind is going blank, all I can think about is

loop through the decomp_ops and queue them here

Also, it means that users won't be able to use qml.transforms.decompositions.two_qubit_decomposition(U, wires) directly either, since the order will be wrong.

I suppose what you could do is call the utility functions invisibly, inside two_qubit_decomposition, in order to generate a list of operators in the correct order. And then, right before returning, apply() each op in order? This is exactly the same as what you suggest above, just 'inside' two_qubit_decomposition.

Huh, this feels gross, but it works.

😆

^ What you suggest is the nicest. It further simplifies unitary_to_rot so that the 2-qubit case looks just like the 1-qubit case.

glassnotes · 2021-09-16T15:28:20Z

pennylane/transforms/decompositions/two_qubit_unitary.py

+
+
+###################################################################################
+# Developer notes:


This is the best info I can get right now; it doesn't seem like there is a straightforward fix so I will leave this to future work.

This is super useful to have 💯

pennylane/transforms/decompositions/two_qubit_unitary.py

… of https://github.com/PennyLaneAI/pennylane into ch7103-implement-differentiable-two-qubit-qubitunitary

josh146

💯

doc/releases/changelog-dev.md

josh146 · 2021-09-16T17:20:05Z

pennylane/ops/qubit/matrix_ops.py

@@ -88,7 +88,7 @@ def decomposition(U, wires):

        if qml.math.shape(U) == (4, 4):
            wires = Wires(wires)
-            decomp_ops = qml.transforms.decompositions.two_qubit_decomposition(U, wires)
+            decomp_ops = qml.transforms.two_qubit_decomposition(U, wires)


👨‍🍳

josh146 · 2021-09-16T17:20:29Z

pennylane/transforms/decompositions/two_qubit_unitary.py

+     -╭U- = -A-
+     -╰U- = -B-


josh146 · 2021-09-16T17:20:38Z

pennylane/transforms/decompositions/two_qubit_unitary.py

+     -╭U- = -C--╭C--A-
+     -╰U- = -D--╰X--B-


much easier to read!

pennylane/transforms/decompositions/two_qubit_unitary.py

josh146 · 2021-09-16T17:23:49Z

pennylane/transforms/unitary_to_rot.py

+                # U depends on the input parameters
+                qml.QubitUnitary(U, wires=["a", "b"])


Ah, I think I get this now - U cannot depend on trainable parameters, it must be constant

glassnotes · 2021-09-16T17:29:08Z

pennylane/transforms/unitary_to_rot.py

+            elif qml.math.shape(op.parameters[0]) == (4, 4):
+                two_qubit_decomposition(op.parameters[0], op.wires)
+            else:
+                qml.apply(op)


~~This is definitely covered in tests; the circuits run through the transform consist of more than just QubitUnitary operations.~~ Never mind, I see the issue.

Co-authored-by: Josh Izaac <josh146@gmail.com>

glassnotes · 2021-09-16T17:35:05Z

pennylane/transforms/decompositions/two_qubit_unitary.py

+    if not math.allclose(ev_p, ev_q):
+        new_q_order = []
+        for _, eigval in enumerate(ev_p):
+            are_close = [math.allclose(x, eigval) for x in ev_q]


I am not sure why these 3 lines are not showing as covered; the 2- and 3-CNOT test cases should all be going through this portion.

… of https://github.com/PennyLaneAI/pennylane into ch7103-implement-differentiable-two-qubit-qubitunitary

* sort qubit ops tests * remove imports * pr #1552 update * move into folder. update some docstrings * black and changelog * oops. * Apply suggestions from code review Co-authored-by: antalszava <antalszava@gmail.com> * respond to review * rename file * complete renaming Co-authored-by: antalszava <antalszava@gmail.com>

Initial commit.

82ce28a

Olivia Di Matteo and others added 16 commits August 18, 2021 09:38

Add scaffolding and helper function.

00e7d39

Temp commit.

5e5f723

Progress!!

53cd6dc

Update su2su2 implementation.

7420283

Temp commit.

93e1a54

Implementation that essentially works. Need testing.

3a7b920

Remove perms.

9d603bc

Works about half the time.

33acb87

Tidy a bit.

7b75d65

Small tweaks.

02e45eb

Temporary work.

aee732e

Working version, minus tests.

cf61a09

Fix compute matrix in tests. Add check for tensor product structure.

f3a133e

Move decomposition tests to decomposition.

8a34c83

Update some tests. Add to docs.

81c1fb7

Merge branch 'master' into ch7103-implement-differentiable-two-qubit-…

2f66c2c

…qubitunitary

glassnotes marked this pull request as ready for review August 31, 2021 19:49

Remove old test file.

285357b

glassnotes changed the title ~~[WIP] Decomposition of arbitrary two-qubit unitaries.~~ Decomposition of arbitrary two-qubit unitaries. Aug 31, 2021

glassnotes requested a review from josh146 August 31, 2021 19:54

Merge branch 'master' into ch7103-implement-differentiable-two-qubit-…

e41ddbc

…qubitunitary

Run black.

83e617e

josh146 requested changes Sep 1, 2021

View reviewed changes

glassnotes and others added 4 commits September 1, 2021 08:04

Apply suggestions from code review

8794e1e

Co-authored-by: Josh Izaac <josh146@gmail.com>

Make E matrix numpy constant.

954e69f

Vectorize permutation matrix construction.

a0bb0f0

Replace column negation with matrix multiplication.

b91a2d6

Fix docstring.

3746937

glassnotes commented Sep 16, 2021

View reviewed changes

Olivia Di Matteo added 5 commits September 16, 2021 11:41

Fix decomposition so expansion works.

19a6d04

Fix QMC test.

8930f2c

Fix transform so expand works.

2bc2ed5

Remove unused import.

8a2ec08

Add length checks.

2c307e8

glassnotes commented Sep 16, 2021

View reviewed changes

pennylane/transforms/decompositions/two_qubit_unitary.py Outdated Show resolved Hide resolved

glassnotes commented Sep 16, 2021

View reviewed changes

pennylane/transforms/decompositions/two_qubit_unitary.py Outdated Show resolved Hide resolved

glassnotes and others added 5 commits September 16, 2021 12:57

Apply suggestions from code review

587160d

Merge branch 'ch7103-implement-differentiable-two-qubit-qubitunitary'…

695a27e

… of https://github.com/PennyLaneAI/pennylane into ch7103-implement-differentiable-two-qubit-qubitunitary

Update changelog.

63c11bb

Remove parameter shift test case.

ce5510c

Tweak docstring.

db45dc4

glassnotes mentioned this pull request Sep 16, 2021

Jax with diff_method "parameter-shift", "finite-diff" and non-trainable parameters #1412

Closed

josh146 approved these changes Sep 16, 2021

View reviewed changes

glassnotes commented Sep 16, 2021

View reviewed changes

glassnotes and others added 2 commits September 16, 2021 13:31

Apply suggestions from code review

36bf33b

Co-authored-by: Josh Izaac <josh146@gmail.com>

Add SU(4) invalid check.

45e76f2

glassnotes commented Sep 16, 2021

View reviewed changes

Olivia Di Matteo added 3 commits September 16, 2021 13:35

Merge branch 'ch7103-implement-differentiable-two-qubit-qubitunitary'…

d47f894

… of https://github.com/PennyLaneAI/pennylane into ch7103-implement-differentiable-two-qubit-qubitunitary

Add test case for 3-qubit QubitUnitary in unitary_to_rot.

13832c3

Massive simplification.

daaff43

glassnotes merged commit 3871332 into master Sep 16, 2021

glassnotes deleted the ch7103-implement-differentiable-two-qubit-qubitunitary branch September 16, 2021 19:07

josh146 mentioned this pull request Sep 17, 2021

Add a transform get_unitary_matrix to obtain matrix representations of circuits #1609

Merged

albi3ro added a commit that referenced this pull request Sep 20, 2021

pr #1552 update

05d8412

antalszava mentioned this pull request Oct 18, 2022

Use param-shift too for test_gradient_unitary_to_rot_two_qubit_jax #3183

Merged

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Decomposition of arbitrary two-qubit unitaries. #1552

Decomposition of arbitrary two-qubit unitaries. #1552

glassnotes commented Aug 18, 2021 •

edited

Loading

github-actions bot commented Aug 18, 2021

glassnotes commented Aug 31, 2021

josh146 left a comment

josh146 Sep 1, 2021

josh146 Sep 1, 2021

josh146 Sep 1, 2021

glassnotes Sep 1, 2021

josh146 Sep 1, 2021

josh146 Sep 1, 2021

josh146 Sep 1, 2021

glassnotes Sep 1, 2021

glassnotes Sep 16, 2021

josh146 Sep 16, 2021

glassnotes Sep 16, 2021

josh146 Sep 16, 2021

josh146 Sep 16, 2021

glassnotes Sep 16, 2021

glassnotes Sep 16, 2021

josh146 Sep 16, 2021

josh146 left a comment

josh146 Sep 16, 2021

josh146 Sep 16, 2021

josh146 Sep 16, 2021

josh146 Sep 16, 2021

glassnotes Sep 16, 2021 •

edited

Loading

glassnotes Sep 16, 2021

		assert check_matrix_equivalence(U, obtained_matrix, atol=1e-7)


		class TestTwoQubitUnitaryDecompositionInterfaces:



		###################################################################################
		# Developer notes:

		# U depends on the input parameters
		qml.QubitUnitary(U, wires=["a", "b"])

Decomposition of arbitrary two-qubit unitaries. #1552

Decomposition of arbitrary two-qubit unitaries. #1552

Conversation

glassnotes commented Aug 18, 2021 • edited Loading

github-actions bot commented Aug 18, 2021

glassnotes commented Aug 31, 2021

josh146 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

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

josh146 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

glassnotes Sep 16, 2021 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

glassnotes commented Aug 18, 2021 •

edited

Loading

glassnotes Sep 16, 2021 •

edited

Loading