✨ Add Native Gate Decomposer to Zoned Neutral Atom Compiler

bindings/na/register_zoned.cpp

@@ -371,6 +371,169 @@ void registerZoned(nb::module_& m) {
       },
       R"pb(Get the statistics of the last compilation.
 
+Returns:
+    The statistics as a dictionary)pb");
+
+  //===--------------------------------------------------------------------===//
+  // Routing-aware Native Gate Compiler
+  //===--------------------------------------------------------------------===//
+  nb::class_<na::zoned::RoutingAwareNativeGateCompiler>
+      routingAwareNativeGateCompiler(
+          m, "RoutingAwareNativeGateCompiler",
+          "Routing-aware native gate zoned neutral atom compiler.");
+  {
+    const na::zoned::RoutingAwareNativeGateCompiler::Config defaultConfig;
+    routingAwareNativeGateCompiler.def(
+        "__init__",
+        [](na::zoned::RoutingAwareNativeGateCompiler* self,
+           const na::zoned::Architecture& arch, const std::string& logLevel,
+           const double maxFillingFactor, const bool thetaOptSchedule,
+           const bool checkFinalCond, const bool useWindow,
+           const size_t windowMinWidth, const double windowRatio,
+           const double windowShare,
+           const na::zoned::HeuristicPlacer::Config::Method placementMethod,
+           const float deepeningFactor, const float deepeningValue,
+           const float lookaheadFactor, const float reuseLevel,
+           const size_t maxNodes, const size_t trials,
+           const size_t queueCapacity,
+           const na::zoned::IndependentSetRouter::Config::Method routingMethod,
+           const double preferSplit, const bool warnUnsupportedGates) {
+          na::zoned::RoutingAwareNativeGateCompiler::Config config;
+          config.logLevel = spdlog::level::from_str(logLevel);
+          config.schedulerConfig.maxFillingFactor = maxFillingFactor;
+          config.decomposerConfig = {.thetaOptSchedule = thetaOptSchedule,
+                                     .checkFinalCond = checkFinalCond};
+          config.layoutSynthesizerConfig.placerConfig = {
+              .useWindow = useWindow,
+              .windowMinWidth = windowMinWidth,
+              .windowRatio = windowRatio,
+              .windowShare = windowShare,
+              .method = placementMethod,
+              .deepeningFactor = deepeningFactor,
+              .deepeningValue = deepeningValue,
+              .lookaheadFactor = lookaheadFactor,
+              .reuseLevel = reuseLevel,
+              .maxNodes = maxNodes,
+              .trials = trials,
+              .queueCapacity = queueCapacity,
+          };
+          config.layoutSynthesizerConfig.routerConfig = {
+              .method = routingMethod, .preferSplit = preferSplit};
+          config.codeGeneratorConfig = {.warnUnsupportedGates =
+                                            warnUnsupportedGates};
+          new (self) na::zoned::RoutingAwareNativeGateCompiler{arch, config};
+        },
+        nb::keep_alive<1, 2>(), "arch"_a,
+        "log_level"_a = spdlog::level::to_short_c_str(defaultConfig.logLevel),
+        "max_filling_factor"_a = defaultConfig.schedulerConfig.maxFillingFactor,
+        "theta_opt_schedule"_a =
+            defaultConfig.decomposerConfig.thetaOptSchedule,
+        "check_final_cond"_a = defaultConfig.decomposerConfig.checkFinalCond,
+        "use_window"_a =
+            defaultConfig.layoutSynthesizerConfig.placerConfig.useWindow,
+        "window_min_width"_a =
+            defaultConfig.layoutSynthesizerConfig.placerConfig.windowMinWidth,
+        "window_ratio"_a =
+            defaultConfig.layoutSynthesizerConfig.placerConfig.windowRatio,
+        "window_share"_a =
+            defaultConfig.layoutSynthesizerConfig.placerConfig.windowShare,
+        "placement_method"_a =
+            defaultConfig.layoutSynthesizerConfig.placerConfig.method,
+        "deepening_factor"_a =
+            defaultConfig.layoutSynthesizerConfig.placerConfig.deepeningFactor,
+        "deepening_value"_a =
+            defaultConfig.layoutSynthesizerConfig.placerConfig.deepeningValue,
+        "lookahead_factor"_a =
+            defaultConfig.layoutSynthesizerConfig.placerConfig.lookaheadFactor,
+        "reuse_level"_a =
+            defaultConfig.layoutSynthesizerConfig.placerConfig.reuseLevel,
+        "max_nodes"_a =
+            defaultConfig.layoutSynthesizerConfig.placerConfig.maxNodes,
+        "trials"_a = defaultConfig.layoutSynthesizerConfig.placerConfig.trials,
+        "queue_capacity"_a =
+            defaultConfig.layoutSynthesizerConfig.placerConfig.queueCapacity,
+        "routing_method"_a =
+            defaultConfig.layoutSynthesizerConfig.routerConfig.method,
+        "prefer_split"_a =
+            defaultConfig.layoutSynthesizerConfig.routerConfig.preferSplit,
+        "warn_unsupported_gates"_a =
+            defaultConfig.codeGeneratorConfig.warnUnsupportedGates,
+        R"pb(Create a routing-aware native gate compiler for the given architecture and configurations.
+
+Args:
+    arch: The zoned neutral atom architecture
+    log_level: The log level for the compiler, possible values are "debug"/"D", "info"/"I", "warning"/"W", "error"/"E", and "critical"/"C"
+    max_filling_factor: The maximum filling factor for the entanglement zone, i.e., it sets the limit for the maximum number of entangling gates that are scheduled in parallel
+    theta_opt_schedule: If this setting is turned on, a re-scheduling pass is executed immediately after translating the gates into their U3 representation. The theta optimization tries to minimize the maximum theta per layer by possibly scheduling single-qubit gates in later layers.
+    check_final_cond: If enabled the theta optimization checks if the sum of the resulting layer's maximum theta and the next layer's maximum theta is strictly less than the sum of previous maximum thetas. This does not guarantee that the total schedule is the one with minimal cost but reduces the recursive calls by excluding some subsets.
+    use_window: Whether to use a window for the placer
+    window_min_width: The minimum width of the window for the placer
+    window_ratio: The ratio between the height and the width of the window
+    window_share: The share of free sites in the window in relation to the number of atoms to be moved in this step
+    placement_method: The placement method that should be used for the heuristic placer
+    deepening_factor: Controls the impact of the term in the heuristic of the A* search that resembles the standard deviation of the differences between the current and target sites of the atoms to be moved in every orientation
+    deepening_value: Is added to the sum of standard deviations before it is multiplied with the number of unplaced nodes and :attr:`deepening_factor`
+    lookahead_factor: Controls the lookahead's influence that considers the distance of atoms to their interaction partner in the next layer
+    reuse_level: The reuse level that corresponds to the estimated extra fidelity loss due to the extra trap transfers when the atom is not reused and instead moved to the storage zone and back to the entanglement zone
+    max_nodes: The maximum number of nodes that are considered in the A* search.
+        If this number is exceeded, the search is aborted and an error is raised.
+        In the current implementation, one node roughly consumes 120 Byte.
+        Hence, allowing 50,000,000 nodes results in memory consumption of about 6 GB plus the size of the rest of the data structures.
+    trials: The number of restarts during IDS.
+    queue_capacity: The maximum capacity of the priority queue used during IDS.
+    routing_method: The routing method that should be used for the independent set router
+    prefer_split: The threshold factor for group merging decisions during routing.
+    warn_unsupported_gates: Whether to warn about unsupported gates in the code generator)pb");
+  }
+
+  routingAwareNativeGateCompiler.def_static(
+      "from_json_string",
+      [](const na::zoned::Architecture& arch,
+         const std::string& json) -> na::zoned::RoutingAwareNativeGateCompiler {
+        // The correct header <nlohmann/json.hpp> is included, but clang-tidy
+        // confuses it with the wrong forward header <nlohmann/json_fwd.hpp>
+        // NOLINTNEXTLINE(misc-include-cleaner)
+        return {arch, nlohmann::json::parse(json)};
+      },
+      "arch"_a, "json"_a,
+      R"pb(Create a compiler for the given architecture and configurations from a JSON string.
+
+Args:
+    arch: The zoned neutral atom architecture
+    json: The JSON string
+
+Returns:
+    The initialized compiler
+
+Raises:
+    ValueError: If the string is not a valid JSON string)pb");
+
+  routingAwareNativeGateCompiler.def(
+      "compile",
+      [](na::zoned::RoutingAwareNativeGateCompiler& self,
+         const qc::QuantumComputation& qc) -> std::string {
+        return self.compile(qc).toString();
+      },
+      "qc"_a,
+      R"pb(Compile a quantum circuit for the zoned neutral atom architecture.
+
+Args:
+    qc: The quantum circuit
+
+Returns:
+    The compilation result as a string in the .naviz format.)pb");
+
+  routingAwareNativeGateCompiler.def(
+      "stats",
+      [](const na::zoned::RoutingAwareNativeGateCompiler& self) {
+        const auto json = nb::module_::import_("json");
+        const auto loads = json.attr("loads");
+        const nlohmann::json stats = self.getStatistics();
+        const auto dict = loads(stats.dump());
+        return nb::cast<nb::typed<nb::dict, nb::str, nb::float_>>(dict);
+      },
+      R"pb(Get the statistics of the last compilation.
+
 Returns:
     The statistics as a dictionary)pb");
 }