No return

No-return placement strategy using the loose-goal entangling solver.

Instead of fixed target positions, this strategy passes CZ pair constraints to the Rust solve_entangling solver, which simultaneously discovers both the entangling placement and the routing. Layers are chained: the output configuration of one CZ layer becomes the input for the next, so atoms do not return to their home positions between CZ gates.

NoReturnPlacementStrategy dataclass

NoReturnPlacementStrategy(
    arch_spec: ArchSpec,
    strategy: SearchStrategy = (
        lambda: SearchStrategy.IDS
    )(),
    max_expansions: int | None = 100,
    restarts: int = 20,
    deadlock_policy: DeadlockPolicy = (
        lambda: DeadlockPolicy.MOVE_BLOCKERS
    )(),
    top_c: int | None = 3,
    congestion_weight: float = 0.0,
    occupancy_penalty: float = 1.0,
    hungarian_horizon: int | None = 4,
)

Bases: NoReturnStrategyBase

              flowchart TD
              bloqade.lanes.heuristics.physical.no_return.NoReturnPlacementStrategy[NoReturnPlacementStrategy]
              bloqade.lanes.heuristics.physical._no_return_base.NoReturnStrategyBase[NoReturnStrategyBase]
              bloqade.lanes.analysis.placement.strategy.PlacementStrategyABC[PlacementStrategyABC]

                              bloqade.lanes.heuristics.physical._no_return_base.NoReturnStrategyBase --> bloqade.lanes.heuristics.physical.no_return.NoReturnPlacementStrategy
                                bloqade.lanes.analysis.placement.strategy.PlacementStrategyABC --> bloqade.lanes.heuristics.physical._no_return_base.NoReturnStrategyBase
                



              click bloqade.lanes.heuristics.physical.no_return.NoReturnPlacementStrategy href "" "bloqade.lanes.heuristics.physical.no_return.NoReturnPlacementStrategy"
              click bloqade.lanes.heuristics.physical._no_return_base.NoReturnStrategyBase href "" "bloqade.lanes.heuristics.physical._no_return_base.NoReturnStrategyBase"
              click bloqade.lanes.analysis.placement.strategy.PlacementStrategyABC href "" "bloqade.lanes.analysis.placement.strategy.PlacementStrategyABC"
            

No-return placement via the loose-goal entangling constraint solver.

Calls :pymethod:MoveSolver.solve_entangling once per CZ layer to find both the entangling placement and the routing simultaneously. Each layer's output layout is passed as the next layer's input, saving the cost of palindrome return moves.

Parameters

arch_spec: Architecture specification. strategy: Inner search strategy as a :class:SearchStrategy enum (e.g. attr:SearchStrategy.IDS (default), attr:SearchStrategy.ASTAR, attr:SearchStrategy.ENTROPY). max_expansions: Maximum node expansions per solve call. restarts: Number of parallel restarts with perturbed scoring. Each restart gets a different seed for the greedy CZ-pair-to-slot assignment, producing diverse target layouts; pick_best keeps the lowest- cost result. Default 20. deadlock_policy: :class:DeadlockPolicy enum value (default attr:DeadlockPolicy.MOVE_BLOCKERS). top_c: Per-qubit move-candidate pruning cap inside HeuristicGenerator. None keeps all scored bus options. Default 3 matches the previously-hardcoded behaviour. Larger values broaden the search but slow per-node expansion. congestion_weight: Penalty weight for the entangling Hungarian assignment to spread CZ pairs across word pairs. 0.0 (default) uses standard min-sum assignment; positive values reduce routing serialization at high occupancy at some cost in total atom moves. occupancy_penalty: Per-slot-half penalty (in lane-hop units) added to the Hungarian cost for slots currently held by spectator atoms (atoms not in any CZ pair of the current layer). Steers the assignment away from slots that would force the search to evict a non-participating atom. 0.0 recovers the legacy occupancy-blind behaviour. Default 1.0 was tuned on the 80q / depth 3 / max_pairs 10 regime; deeper sparse-pair circuits prefer larger values (~2–3). hungarian_horizon: Cap on the number of future CZ layers fed to the Hungarian forward/backward sweep. 0 disables lookahead entirely; None is unbounded (all future layers). Default 4 keeps solve time bounded regardless of circuit depth.