QuMeld: A Modular Framework for Benchmarking Qubit Mapping Algorithms

1. Problem Statement

The qubit mapping problem is a critical bottleneck in executing quantum algorithms on current Noisy Intermediate-Scale Quantum (NISQ) devices.

• The Challenge: Quantum algorithms are designed assuming fully connected qubits, but physical hardware imposes strict connectivity constraints (coupling graphs). When a logical gate requires interaction between non-adjacent physical qubits, the circuit must be transformed by inserting SWAP gates to move quantum states.
• The Trade-off: This transformation increases the SWAP count, two-qubit gate count, circuit depth, and execution time, all of which degrade the fidelity of the computation due to noise.
• The Gap: While numerous mapping algorithms exist (heuristic, synthesis-first, time-aware, machine learning), there is no unified framework to systematically evaluate and compare them across different hardware topologies and circuit types. Researchers currently rely on default transpilers (e.g., in Qiskit) or struggle to implement and compare new algorithms manually, leading to inconsistent results and suboptimal algorithm selection.

2. Methodology: The QuMeld Framework

The authors present QuMeld, an open-source, modular Python framework designed to automate the benchmarking and comparison of qubit mapping algorithms.

A. Architecture

QuMeld utilizes a star architecture centered around an ExperimentRunner orchestrator to minimize coupling between components. Key design patterns include:

• Interfaces: A unified QubitMapper abstract base class defines standard methods (run_circuit and run_hamiltonian) to handle both standard circuits and Pauli string synthesis (for VQE/QAOA).
• Registry Pattern: The MapperRegistry and BackendFactory allow for dynamic discovery and loading of algorithms and hardware topologies without hardcoding.
• Provider Pattern: AlgorithmProvider and HamiltonianProvider decouple data sources (circuits/Pauli strings) from the mapping logic.
• Integration Flexibility: The framework supports diverse implementation languages:
  • Native Python: Integrated via Qiskit pass managers (e.g., LightSABRE, Rustiq).
  • Subprocess (C++): Invokes external tools like Doustra via OpenQASM conversion.
  • Isolated Environments: Handles dependency conflicts (e.g., Qiskit AI) by running in separate virtual environments.

B. Supported Components

The framework currently integrates:

1. Six State-of-the-Art Algorithms:
   • LightSABRE: Bidirectional heuristic search with lookahead and decay heuristics.
   • Rustiq: Synthesis-first compilation for Pauli-based algorithms using Clifford circuits.
   • Doustra: Time-aware routing using dual-source Dijkstra to consider qubit occupancy.
   • PauliForest: Static mapping for Pauli strings using feature matrices.
   • Qiskit AI: Reinforcement learning-based transpilation.
2. Sixteen Hardware Topologies: Ranging from 9 to 256 qubits, including IBM Heavy Hex variants (Eagle, Heron), Google Willow, IonQ (fully connected), Rigetti, and synthetic lattices.
3. Six Benchmark Circuits: Covering VQE (molecular Hamiltonians like H2, LiH) and QAOA (Max-Cut, ansatz structures).

C. Evaluation Metrics

The framework automatically collects and stores:

• SWAP count
• Two-qubit gate (CNOT) count
• Circuit depth
• Optimization time
• Failure reasons (if mapping fails)

3. Key Contributions

• Unified Benchmarking Platform: QuMeld is the first framework to provide a standardized, automated environment for comparing diverse mapping strategies across a wide range of topologies and circuits.
• Modular Extensibility: The design allows researchers to easily plug in new algorithms, topologies, or metrics by implementing specific interfaces, ensuring the framework remains future-proof.
• Algorithm Selection Tool: Beyond benchmarking, QuMeld includes a MapperSelector that can automatically identify the optimal mapping algorithm for a specific circuit-topology combination based on user-defined criteria (e.g., minimizing depth vs. minimizing SWAPs).
• Reproducibility: By standardizing noise characteristics (randomized T1/T2 times, gate errors) and result storage (timestamped JSON hierarchies), it enables reproducible research.

4. Results and Capabilities

While the paper focuses on the framework's design rather than a specific empirical study, it demonstrates the following capabilities:

• Scalability: Successfully handles topologies up to 256 qubits (Riken Fujitsu) and large circuits (LiH with 6,000+ two-qubit gates).
• Diversity: Successfully integrates algorithms written in Python, C++, and isolated environments, proving its ability to bridge different quantum software stacks.
• Automation: The ExperimentRunner automates the entire pipeline: loading configurations, executing mappings, collecting metrics, and storing results for post-processing via Jupyter notebooks.

5. Significance and Future Work

Significance:
QuMeld addresses a critical gap in the NISQ era by moving beyond "one-size-fits-all" transpilation. It empowers researchers to:

• Systematically determine which mapping algorithm is best suited for specific hardware constraints.
• Accelerate the development of new mapping algorithms by providing immediate baselines for comparison.
• Analyze how hardware connectivity patterns (e.g., Heavy Hex vs. Grid) impact algorithm performance.

Future Directions:
The authors plan to:

• Integrate additional optimization algorithms (EffectiveQM, SWin, Tabu Search).
• Incorporate error correction support into the evaluation metrics.
• Enhance automatic algorithm selection using advanced decision trees or machine learning.
• Scale to larger circuits and optimize framework performance via parallel execution.

Availability:
The framework is open-source and available at https://github.com/gabkeib/qumeld.