Metrics

KernelFidelityMetrics dataclass

KernelFidelityMetrics(
    gate_fidelities: list[float],
    gate_fidelity_product: float,
)

Fidelity metrics computed from a physical noisy SQuin kernel.

KernelMoveMetrics dataclass

KernelMoveMetrics(
    approx_lane_parallelism: float, moved_lane_count: int
)

Move metadata computed from a compiled Move kernel.

KernelMoveTimeMetrics dataclass

KernelMoveTimeMetrics(
    total_move_time_us: float,
    events: list[MoveTimeEvent],
    timing_model: str,
)

Move timing metrics computed from a compiled Move kernel.

Metrics dataclass

Metrics(
    arch_spec: Any,
    noise_model: LogicalNoiseModelABC | None = None,
)

Unified metrics computation for the lanes pipeline.

Owns kernel-level analysis methods and delegates all move-metric computation (lane durations, costs, distances) to a MoveMetricCalculator instance.

analyze_per_cz_motion

analyze_per_cz_motion(
    move_mt: Method,
) -> tuple[float, float]

Average hops and traveled distance per moving qubit per CZ episode.

Raises:

Type	Description
MoveValidationError	If any move statement cannot execute against the atom state it is applied to.

Source code in .venv/lib/python3.12/site-packages/bloqade/lanes/metrics.py

def analyze_per_cz_motion(
    self,
    move_mt: ir.Method,
) -> tuple[float, float]:
    """Average hops and traveled distance per moving qubit per CZ episode.

    Raises:
        MoveValidationError: If any move statement cannot execute
            against the atom state it is applied to.
    """
    initial_layout = _infer_initial_qubit_layout(move_mt)
    if initial_layout is None or len(initial_layout) == 0:
        return 0.0, 0.0

    state = AtomStateData.new(initial_layout)

    per_cz_hops: list[float] = []
    per_cz_distance_um: list[float] = []
    episode_stats: dict[int, tuple[int, float]] = {}

    for stmt in move_mt.callable_region.walk():
        if isinstance(stmt, move.Move):
            # Delegate move semantics to the canonical execution model:
            # ``validate_moves`` rejects a group that cannot execute
            # (destination held by an atom that does not move in the
            # same group, or two lanes contesting one destination), and
            # ``apply_validated`` commits every lane simultaneously
            # against the pre-move occupancy. ``prev_lanes`` is exactly
            # the set of atoms that moved in this step.
            state = state.apply_validated(
                state.validate_moves(stmt.lanes, self.arch_spec)
            )
            for qubit_id, lane in state.prev_lanes.items():
                hop_count, distance_um = episode_stats.get(qubit_id, (0, 0.0))
                episode_stats[qubit_id] = (
                    hop_count + 1,
                    distance_um + self.move_calc.lane_distance_um(lane),
                )
            continue

        if isinstance(stmt, move.CZ):
            if len(episode_stats) > 0:
                for hop_count, distance_um in episode_stats.values():
                    per_cz_hops.append(float(hop_count))
                    per_cz_distance_um.append(distance_um)
            episode_stats = {}

    if len(per_cz_hops) == 0:
        return 0.0, 0.0
    return (
        sum(per_cz_hops) / len(per_cz_hops),
        sum(per_cz_distance_um) / len(per_cz_distance_um),
    )

MoveTimeEvent dataclass

MoveTimeEvent(
    event_index: int,
    lane_count: int,
    move_type: str,
    bus_id: int,
    direction: str,
    lane_durations_us: list[float],
    event_duration_us: float,
    segment_distances_um: list[float],
    segment_durations_us: list[float],
    pick_time_us: float,
    drop_time_us: float,
    timing_model: str,
)

Per-move event timing details in microseconds.