qubit map in pytket.routing.route()? about pytket-docs HOT 4 CLOSED

Hi Michael,

Thanks for making us aware of that broken link. It looks like our README.md file was not updated properly in our latest release. The cirq routing example notebook was removed from the repository as it was out of date but our new routing example notebook, https://github.com/CQCL/pytket/blob/master/examples/routing_example.ipynb, should cover everything the previous notebook did and more.

In 0.4 we have separated the Placement and Routing methods. The 'pytket.routing.route()’ method uses no default placement method, instead starting with no logical qubits placed on physical qubits and setting the initial placement of logical qubits as they are encountered in gates in the circuit.

This functionality you describe is possible though by using our Placement methods. Cells 32, 33 and 34 in our routing example notebook show how these methods can be used to create qubit mapping objects and reassign circuit boundaries.

Alternatively, if you use the CompilationUnit framework for optimisation and routing of circuits the initial and final maps are tracked and retrievable - https://cqcl.github.io/pytket/build/html/predicates.html?highlight=compilationunit#pytket.predicates.CompilationUnit. Our compilation example notebook gives an introduction to the passes available and how to combine them https://github.com/CQCL/pytket/blob/master/examples/compilation_example.ipynb. The routing notebook gives an introduction on using the CompilationUnit framework for routing circuits with predicates in cells 36-42.

Thanks,

Silas

from pytket-docs.

Hi Silas,

thanks for your answer!

I struggle a bit to understand the Placement methods (cells 32,33 and 34). In the example, they are used before calling the route function, so I guess the Placement is finding the initial mapping, is that right? How would I get the final mapping then? If this is already the final mapping, what does "unplaced" mean then?

I also tried using the CompilationUnit with the passes "gen_default_mapping_pass()" to route the circuits and "RebasePyZX()" to get rid of the BRIDGE gates. Whenever there is no BRIDGE gate (after using the first pass), the results are correct (compared to the same circuit on a fully-connected device). However, if there is a BRIDGE, this seems not to be true anymore. As I understood, the BRIDGE gate is a distributed CX-gate, which should not change the final qubit mapping. The same happens if I use 'pytket.transform.Transform.DecomposeBRIDGE()'. Are you aware of this problem or do you know what reason this could have? Can I provide the "gen_default_mapping_pass()" a parameter telling it not to uses BRIDGEs, similar as the bridge_interactions parameter in the route function?

Thanks a lot,
Michael

from pytket-docs.

Hi Michael,

Yes, each placement method finds an initial map for the circuit depending on the device connectivity constraints. This map can be partial - some placement methods may opt to not assign all logical qubits to physical nodes. This may be because a logical qubit has its first two-qubit interaction deep in to the circuits execution, and so the placement method can’t accurately predict how the initial map will have changed by the time this two-qubit interaction is encountered. Allowing the routing method to deal with unplaced qubits as it routes the circuit leads to result improvements. The place() method reassigns qubits in a Circuits boundary to Nodes of a Device object. If a full initial map is desired, values in the partial initial map can be manually converted to nodes in the device. I have inserted a sample code snippet here that shows one way of doing this.

def find_adjacent_node(used_nodes, coupling_map):
    for couple in coupling_map:
        if couple[0] in used_nodes and couple[1] not in used_nodes:
            return couple[1]
        if couple[0] not in used_nodes and couple[1] in used_nodes:
            return couple[0]

def fill_partial_mapping(dev, partial_map):
    used_nodes = set()
    unplaced_qubits = set()
    new_map = partial_map
    for k, v in partial_map.items():
        if v.reg_name != 'unplaced':
            used_nodes.add(v)
        if v.reg_name == 'unplaced':
            unplaced_qubits.add(k)
            
    for q in unplaced_qubits:
        n = find_adjacent_node(used_nodes, dev.get_coupling())
        used_nodes.add(n)
        new_map[q] = n
    return new_map

my_placer = GraphPlacement(my_device)
partial_initial_mapping = my_placer.get_placement_map(my_circuit)
full_initial_mapping = fill_partial_mapping(my_device, partial_initial_mapping)

To return the final mapping outside of the CompilationUnit framework, the method _route_return_map can be imported from pytket.routing, which takes the same arguments as “route” but returns a pair of {Circuit, final_map}. A combination of filling the partial mapping and returning the final map here should emulate the previous behaviour you desired.

The BRIDGE gate is a distributed-CX gate and so shouldn’t change the final qubit mapping. I am not aware of a problem but I will investigate and keep you updated. It is currently not possible to change the routing parameters using “gen_default_mapping_pass”, but I shall add this functionality for our next release.

Thanks,
Silas

from pytket-docs.

Hi Silas,

thanks a lot for your detailed answer and thanks for explaining to me how the Placement methods work!

The method "_route_return_map" is exactly doing what I was looking for and returns the correct final mapping.

Best regards,
Michael

from pytket-docs.