Make CXMappingPass a StandardPass with round-trip serialization and deserialization

[cqc-alec]

Description

Use AutoRebase instead of RebaseCustom in the pass; and wrap up the SequencePass in a StandardPass so that serialization and deserialization are inverse.

Related issues

Fixes #1573 .

Checklist

• I have performed a self-review of my code.
• I have commented hard-to-understand parts of my code.
• I have made corresponding changes to the public API documentation.
• I have added tests that prove my fix is effective or that my feature works.
• I have updated the changelog with any user-facing changes.

[cqc-alec]

I am not totally confident in this: should we be passing a std::shared_ptr<unit_bimaps_t> as well as a Circuit& to the Transform constructor? If so what should we do with it?

[sjdilkes]

What would the unit_bimaps_t object be for? I might be forgetting some TKET infrastructure here. Certainly we don't need to pass any kind of qubit placement if that's what it's referring to (as the circuit UnitID are updated).

[cqc-alec]

Wasn't sure myself. Seems to be used in placement passes where units are renamed (e.g. gen_placement_pass()). So I assume not necessary here.

[sjdilkes]

Hmm - I'm now not sure. Just double checking, the unit_bimaps_t object tracks how qubits are re-labelled/permuted by optimisation? I'm now wondering if we should have always had them and not having them was an oversight? gen_routing_pass does seem to have them, so I think in-fact we do need them?

[cqc-alec]

Please check my last commit. I don't know if this is correct, but I don't know what else to do with the maps either!

[sjdilkes]

      // Relabel all two-qubit gates
      CompilationUnit cu(circ);
      bool changed = rebase_pass->apply(cu);
      circ = cu.get_circ_ref();
      // Now try placement, falling back on "LinePlacement" if "GraphPlacement" fails
      try {
        changed = changed | placement_ptr->place(circ, maps);
      } catch (const std::runtime_error& e) {
        std::stringstream ss;
        ss << "PlacementPass failed with message: " << e.what()
          << " Fall back to LinePlacement.";
        tket_log()->warn(ss.str());
        Placement::Ptr line_placement_ptr = std::make_shared<LinePlacement>(
            placement_ptr->get_architecture_ref());
        changed = changed | line_placement_ptr->place(circ, maps);

      }
      // Now route
      MappingManager mm(std::make_shared<Architecture>(arc));
      changed = changed | mm.route_circuit_with_maps(circ, config, maps);
      
      // Now decompose routing gates to cx gates (this won't change maps)
      cu(circ);
      if(delay_measures){
        DelayMeasures()->apply(cu);
      }
      gen_decompose_routing_gates_to_cxs_pass(arc, directed_cx)->apply(cu);
      circ = cu.get_circ_ref();
      return changed;
  }```

[sjdilkes]

Looks fine to me, but I've asked for some clarification on the question.

[sjdilkes]

What would the unit_bimaps_t object be for? I might be forgetting some TKET infrastructure here. Certainly we don't need to pass any kind of qubit placement if that's what it's referring to (as the circuit UnitID are updated).

[sjdilkes]

Hmm - I'm now not sure. Just double checking, the unit_bimaps_t object tracks how qubits are re-labelled/permuted by optimisation? I'm now wondering if we should have always had them and not having them was an oversight? gen_routing_pass does seem to have them, so I think in-fact we do need them?

[sjdilkes]

Does this work?
`Transform t{[=](Circuit& circ, std::shared_ptr<unit_bimaps_t> maps) {

  // Relabel all two-qubit gates
  CompilationUnit cu(circ);
  bool changed = rebase_pass->apply(cu);
  circ = cu.get_circ_ref();
  // Now try placement, falling back on "LinePlacement" if "GraphPlacement" fails
  try {
    changed = changed | placement_ptr->place(circ, maps);
  } catch (const std::runtime_error& e) {
    std::stringstream ss;
    ss << "PlacementPass failed with message: " << e.what()
      << " Fall back to LinePlacement.";
    tket_log()->warn(ss.str());
    Placement::Ptr line_placement_ptr = std::make_shared<LinePlacement>(
        placement_ptr->get_architecture_ref());
    changed = changed | line_placement_ptr->place(circ, maps);

  }
  // Now route
  MappingManager mm(std::make_shared<Architecture>(arc));
  changed = changed | mm.route_circuit_with_maps(circ, config, maps);
  
  // Now decompose routing gates to cx gates (this won't change maps)
  cu(circ);
  if(delay_measures){
    DelayMeasures()->apply(cu);
  }
  gen_decompose_routing_gates_to_cxs_pass(arc, directed_cx)->apply(cu);
  circ = cu.get_circ_ref();
  return changed;

}`

[sjdilkes]

      // Relabel all two-qubit gates
      CompilationUnit cu(circ);
      bool changed = rebase_pass->apply(cu);
      circ = cu.get_circ_ref();
      // Now try placement, falling back on "LinePlacement" if "GraphPlacement" fails
      try {
        changed = changed | placement_ptr->place(circ, maps);
      } catch (const std::runtime_error& e) {
        std::stringstream ss;
        ss << "PlacementPass failed with message: " << e.what()
          << " Fall back to LinePlacement.";
        tket_log()->warn(ss.str());
        Placement::Ptr line_placement_ptr = std::make_shared<LinePlacement>(
            placement_ptr->get_architecture_ref());
        changed = changed | line_placement_ptr->place(circ, maps);

      }
      // Now route
      MappingManager mm(std::make_shared<Architecture>(arc));
      changed = changed | mm.route_circuit_with_maps(circ, config, maps);
      
      // Now decompose routing gates to cx gates (this won't change maps)
      cu(circ);
      if(delay_measures){
        DelayMeasures()->apply(cu);
      }
      gen_decompose_routing_gates_to_cxs_pass(arc, directed_cx)->apply(cu);
      circ = cu.get_circ_ref();
      return changed;
  }```

[sjdilkes]

We can remove the references to return pass here I think

[cqc-alec]

It's used below in the line

  PassConditions conditions = return_pass->get_conditions();

[cqc-alec]

...which I think is still correct, although there may be an easier way to construct these conditions.