Simplifying CX pairs

[daniel-mills-cqc]

I am running the following, and noticed some surprising outputs.

from bqskit.ext import pytket_to_bqskit, bqskit_to_pytket
from pytket import Circuit
from bqskit.compiler import Compiler
from bqskit.passes import ScanningGateRemovalPass, UnfoldPass, LEAPSynthesisPass, ForEachBlockPass, QFASTDecompositionPass


workflow = [
    QFASTDecompositionPass(),
    ForEachBlockPass([
        LEAPSynthesisPass(),  # LEAP performs native gate instantiation
        ScanningGateRemovalPass(),  # Gate removal optimizing gate counts
    ]),
    UnfoldPass(),
]

circuit = Circuit(3).CX(0,2).CX(0,2)

bqskit_circuit = pytket_to_bqskit(circuit)
with Compiler(num_workers=1) as comp:
    bqskit_circuit = comp.compile(circuit=bqskit_circuit, workflow=workflow)
circuit = bqskit_to_pytket(bqskit_circuit)

circuit.get_commands()

I expect the circuit to compile down to the identity but I only see that ~50% of the time. One surprising output I have seen is the following, which seems to be incorrect, if I've understood the definition of U3.

[U3(0, 1.50887, 0.491132) q[1];, U3(0, 0.756544, 1.24346) q[2];]

Outputs such as the following are also common

[CX q[1], q[2];, CX q[1], q[2];]

I've also tested with circuits such as

circuit = Circuit(3).CX(0,1).CX(0,2).CX(0,2)

and in that case I relatively often get results such as the following.

[CX q[1], q[2];,
 Ry(1.80046e-05) q[1];,
 Rx(2.21793) q[2];,
 Rz(1.94608) q[1];,
 CX q[1], q[2];,
 Ry(1.42662) q[1];,
 Ry(0.40044) q[2];,
 Rz(3.05392) q[1];,
 Rx(0.782047) q[2];,
 U3(1.49823, 0.909274, 1.24748) q[1];,
 U3(2.73257, 1.95412, 0.582284) q[2];,
 CX q[0], q[2];,
 Rz(1.79467) q[0];,
 CX q[0], q[2];,
 Ry(1.45526) q[0];,
 Rx(0.217925) q[2];,
 Rz(1.20533) q[0];,
 U3(0.544735, 0.205329, 0.794671) q[0];,
 CX q[0], q[1];,
 Rx(0.69209) q[1];]

I just wanted to clarify if I should be surprised by this, or if there are some parameters that I can set to help the workflow identify identities. I have taken this workflow from this example -> https://github.com/BQSKit/bqskit/blob/main/examples/qfast.py. Perhaps there is a better workflow for this use case?
Many thanks for your help, and for providing this nice package!

[edyounis]

You should try QSearch synthesis for small (3 or fewer qubits) circuits; it will lead to the best results. Nevertheless, identity or extremely close to identity synthesis is actually very difficult for our tools, as they are not optimized for that. If this is an important use case for you, then there is probably some modified synthesis method that we can cook up to solve it more efficiently, but it isn't as simple as using different settings. From your comment, it seems more like you are using these examples to benchmark/experiment, which then to answer your question directly, no, these results are not surprising.

[daniel-mills-cqc]

Many thanks @edyounis. If that is the expected behaviour then thats all understood.
Just for clarity, am I correct to say that the case of

[U3(0, 1.50887, 0.491132) q[1];, U3(0, 0.756544, 1.24346) q[2];]

mentioned above is quite far from the identity? Might there be any tools to quantifying how close the result is from the original circuit?
Many thanks.

[WolfLink]

That circuit is in PyTKet's format, and those values are extremely close to the identity. Those angles are in units of half rotations aka multiple of pi radians. If you look at the matrix for U3, an identity is any set of angles where the first angle is a multiple of 2pi and the sum of the other two angles is a multiple of 2pi.

You can check the distance between two circuits using:

distance = circuit_a.get_unitary().get_distance_from(circuit_b.get_unitary())

This value will be small (e.g. <0.0001) for circuits that are very similar and large (e.g. >0.5) for circuits that are very different. Most BQSKit operations will gurantee that the result is within a matrix distance threshold of the given target.

[daniel-mills-cqc]

Ah yes, many thanks @WolfLink. Thanks all makes sense.
Thanks for your help!