arXiv CSopen access

Transpiler Autotuning with Predictive Models for Quantum Circuit Optimization

Transpiler Autotuning with Predictive Models for Quantum Circuit Optimization

arXiv:2607.29145v1 [quant-ph] 31 Jul 2026

PIOTR MALKOWSKI✉ , Karlsruhe Institute of Technology, Germany DOMENIK EICHHORN✉ , Karlsruhe Institute of Technology, Germany JOSHUA AMMERMANN, Karlsruhe Institute of Technology, Germany RINOR KELMENDI, Karlsruhe Institute of Technology, Germany NICK POSER, Karlsruhe Institute of Technology, Germany PATRICK HOPF, Technical University of Munich, Germany INA SCHAEFER, Karlsruhe Institute of Technology, Germany Quantum software engineering is an emerging research field focusing on efficiently embedding the quantum programming paradigm into existing software ecosystems. A key aspect of this field is the realization of quantum algorithms using gate-based programming and the subsequent low-level optimization of the resulting quantum circuits, a process that is commonly performed by so-called transpilation pipelines. One significant challenge in these pipelines is determining which optimizations to apply to a given circuit. This decision is usually based on fixed default configurations that are uniformly applied to all circuits, frequently resulting in missed opportunities for more aggressive circuit optimization. In this work, we tackle this challenge by applying autotuning with supervised machine learning to develop an automated method for selection of transpiler passes. To train our machine-learning models, we employ feature-model based sampling to generate a representative dataset that examines how different combinations of Qiskit transpiler passes perform across thousands of circuits drawn from the state-of-the-art benchmarking suite MQT Bench. Using these data, we build a predictive model extension for the Qiskit transpilation pipeline that uses a machine learning model to automatically select combinations of transpiler passes aiming to achieve a maximum reduction in two-qubit gates. Our empirical evaluation shows that the combinations selected by our model are never outperformed by Qiskit’s optimization levels, achieve on average an additional 19.1% - 32.4% reduction in two-qubit gates, and for some circuits finds reductions of up to 95.8% in cases where Qiskit achieves no reduction at all.

1

Introduction

Quantum computing represents a novel paradigm that can strongly impact the field of modern computer science by providing up to superpolynomial speedups for well-structured problems [1]. In the current Noisy Intermediate-Scale Quantum (NISQ) era, early quantum devices with relatively few qubits are available, but they are not yet mature enough to be scaled to deliver advantages in practical, real-world applications [70]. A key challenge in quantum computing is the creation of new software technologies that can embed this emerging quantum paradigm into existing classical infrastructures, giving us the potential to exploit these up to superpolynomial speedups in practice once major advances in quantum hardware are achieved [15]. To prevent a quantum software crisis analogous to the classical software crisis of the 1960s, the systematic development of quantum software has emerged as a rapidly evolving research area [50]. A central concern in quantum software engineering is the design of programming languages and libraries that can accommodate this novel technological landscape. One prominent example of a quantum software framework is Qiskit, a language and ecosystem developed by IBM [5], which is currently considered as the most influential quantum programming framework [81]. Qiskit lowers Authors’ Contact Information: Piotr Malkowski, [email protected], Karlsruhe Institute of Technology, Germany; Domenik Eichhorn, [email protected], Karlsruhe Institute of Technology, Germany; Joshua Ammermann, [email protected], Karlsruhe Institute of Technology, Germany; Rinor Kelmendi, [email protected], Karlsruhe Institute of Technology, Germany; Nick Poser, [email protected], Karlsruhe Institute of Technology, Germany; Patrick Hopf, [email protected], Technical University of Munich, Germany; Ina Schaefer, [email protected], Karlsruhe Institute of Technology, Germany.

2

Malkowski et al.

the barrier to entry for quantum computing by enabling users to construct and deploy quantum circuits, thereby expressing the manipulation of quantum mechanical systems via a gate-based programming model [45]. Quantum circuits are analogous to classical logic circuits, consisting of a sequence of quantum gates that are applied to qubits [30]. They constitute the fundamental representation used to instruct Quantum Processing Units (QPUs) to perform computational tasks. Similarly to compiling for a CPU, compiling for a specific QPU requires consideration of the device’s characteristics regarding specific figures of merit, such as circuit depth and the number of available gates [31]. Currently, the majority of quantum circuit compilation is performed by transpilation pipelines provided by frameworks like Qiskit [5] and Tket [73]. These frameworks provide a large set of so-called transpiler passes, which modify circuits so that they match the characteristics required by a particular quantum device, or adjust them to meet pre-defined optimization goals, such as the reduction of two-qubit gates, which is the primary source of errors on NISQ devices [60]. A recurring challenge of quantum circuit transpilation is that it is typically not know in advance which configuration of transpilation passes will yield the best outcome. As a result, frameworks such as Qiskit [5] and Tket [73] generally rely on predefined optimization levels, each corresponding to a progressively more resource-intensive, fixed set of optimization passes. Although this strategy is pragmatic, it often fails to exploit opportunities for more aggressive optimization, leading to a less efficient use of costly quantum computing resources. Addressing this challenge requires understanding which combinations of transpilation passes are likely to be most effective for a specific quantum circuit instance. However, this is difficult to decide because the large number of available passes creates a combinatorial explosion in the search space. To overcome this, we must devise a systematic approach that supports efficient exploration of this search space, allowing a circuit-aware selection of optimization passes tailored to different circuit classes, thus replacing today’s fixed optimization levels. In this work, we tackle this challenge by presenting a methodology that leverages autotuning [8] to build a machine learning predictor capable of reliably recommending combinations of transpiler passes for a given circuit, with the goal of maximizing the reduction in two-qubit gates. This paper describes the multiple steps that were necessary to implement this methodology within a real-world quantum computing framework (Qiskit). In addition, we provide detailed evaluations demonstrating that our approach can reliably surpass the existing optimization levels of the Qiskit transpilation pipeline regarding hardware-independent optimizations, and that we are competitive with other state-of-the-art machine learning methods such as the MQT Predictor [65]. To realize our methodology, we make the following three contributions: (1) We construct a novel data set that allows us to analyze the behavior and efficiency of transpilation passes across various classes of quantum algorithms, including the Quantum Approximate Optimization Algorithm (QAOA) [21], the Variational Quantum Eigensolver (VQE) [37], and Quantum Neural Networks (QNNs) [44]. To build this data set, we draw 1,943 quantum circuit instances from the well-established MQT Bench [62] library and then examine how the optimization passes available in the Qiskit perform on them. To manage the combinatorial blow-up inherent in this setting, we design a feature model [38] that captures the configurability of the Qiskit transpilation pipeline and apply 3-wise interaction sampling [42] to derive a representative subset of 62 combinations of transpilation passes. We then run these 62 configurations on all 1,943 circuits, creating a large scale data set that can be used to analyze transpilation passes. (2) We use this newly constructed data set to train a stateof-the-art machine learning model using XGBoost [12] with a learning-to-rank approach [53]. For a new, unseen circuit, this predictive model then serves as a fast surrogate by predicting the configuration that is expected to yield the largest reduction in two-qubit gates. (3) We determine which combinations of transpilation passes are helpful, harmful, or neutral for each distinct quantum

Transpiler Autotuning with Predictive Models for Quantum Circuit Optimization

3

circuit problem class by applying a SHapley Additive exPlanations (SHAP) analysis [48] to our predictive model. From this, we identify transpilation passes that, on average, provide the greatest benefit across all problem classes, as well as those that are especially effective for particular classes. These findings can influence how end-users approach their own quantum compilation tasks and how quantum transpilation frameworks design heuristic strategies to maximize optimization potential. 2

Background

This section provides background information on quantum compilation with a strong focus on the transpilation pipeline of Qiskit, which we improve later in this work. Furthermore, we give a general overview of compiler autotuning approaches and supervised machine learning, which are concepts on which we later base our methodology. 2.1

Quantum Compilation and the Qiskit Compiler Pipeline

In the current NISQ era, quantum algorithms are typically expressed using a gate-based programming model [45] and implemented in domain-specific quantum programming languages such as Q# [74], or through quantum computing frameworks that extend existing languages, such as Qiskit [5] and Qrisp [69], which support gate-based programming via Python and similar interfaces. Similar to classical computer architectures, these gate-based quantum circuits rely on compilers to translate high-level program descriptions into an instruction set that can be executed on a QPU. A key challenge in quantum computing is that current quantum compilers must perform extensive circuit optimizations to adapt circuits for hardware devices that offer only a small number of noisy qubits with restricted connectivity. Consequently, a central component of any quantum compiler pipeline is circuit transpilation, a subroutine that transforms and optimizes circuits so they are compatible with a given quantum device and use fewer error-prone gates, such as 2-qubit gates. In this paper, our aim is to improve the optimizations that a transpilation pipeline can perform by proposing a concept for the automatic selection of transpilation passes. To realize this concept, we extend the existing quantum programming framework Qiskit [5]. The Qiskit transpilation pipeline is divided into six stages, where each stage comprises several transpilation passes that can be combined to carry out transpilation. Figure 1 shows a visual overview of this transpilation pipeline. Initialization Stage :

H

:

H

H

Layout Stage

RZZ

:

:

H

:

H

Routing Stage

Translation Stage

H

H

:

X

CX

CX RZZ

CX

:

X

:

H

CX CX

RZ

CX

CX CX

Hardware Qubit Topology

0

3

1

4

2

5

6

U2

:

U2

Scheduling Stage :

U2

:

:

:

:

:

Optimization Stage

U1

U1

U2

:

:

X

:

U2

CX CX

U1

CX

CX CX

Translation Table

:

X

:

U2

U1 CX

Redundancies

H

U2

X

X

RZ

U1

CX

CX

U2

U2

=

1

=

1

CX

Fig. 1. Overview of Qiskit’s transpiler pipeline that illustrates how every stage may transform a given circuit.

Within Qiskit’s transpilation pipeline, the stages serve two primary purposes: (1) adapting a circuit to a specific device through layout, routing, scheduling, and translation stages, and (2) optimizing circuits, most notably by decreasing the number of two qubit gates in the init and optimization stages, which are the main contributors to error on NISQ devices. The init-stage,

4

Malkowski et al.

for example, carries out logical optimizations on abstract circuits and breaks down multi-qubit and custom gates into one- and two-qubit operations. This decomposition is necessary because most layout and routing algorithms are based on these gates. In this work, we will set a focus on transpilation passes from the init-stage, which can be grouped into two basic categories: • Analysis passes, which traverse the circuit’s Directed Acyclic Graph (DAG) representation to infer properties, such as commutation relations and block collections, without altering the original circuit. The results of these analyses are stored in a shared property set. • Transformation passes, which operate on the DAG to improve the circuit structure. They typically depend on the property set generated by preceding analysis passes. A key aspect to emphasize is that the information stored in the property set is, however, not reused across multiple transformation passes. Instead, the required analysis passes are hard-coded and re-executed within each transformation pass [34]. 2.2

Compiler Autotuning and Supervised Machine Learning

To avoid the manual trial-and-error exploration of different configurations in transpilation pipelines, autotuning [8] is employed to automate this search process [6]. Autotuning consists of applying various compiler optimizations on a program, evaluating their performance, and then choosing the best-performing option. Key challenges for autotuning include determining which optimizations to consider, which parameter to explore, and in what sequence to apply the optimizations [8]. Traditionally, autotuners relied on iterative compilation, where the code had to be repeatedly compiled and executed to assess the benefit of each optimization, making the procedure slow and computationally expensive. Modern autotuners instead employ predictive models, i.e., machine learning models that act as fast surrogates, providing performance predictions without iterative compilation [6, 84]. In this work, we integrate supervised machine learning within the autotuning framework to estimate effective combinations of transpilation passes for a given quantum circuit. The workflow for supervised machine learning consists of three stages: engineering the explanatory variables, training the model, and deploying the model [36]. The success of a machine learning project is largely determined by the choice of explanatory variables, sometimes also called features [17]. These are quantifiable and meaningful attributes of the underlying problem that act as inputs to machine learning models. In the context of this paper, explanatory variables could, for instance, encode properties of quantum circuit intermediate representations, and are typically expressed as integer, real-valued, or boolean quantities. The learning process can be broken down into three core elements [17]: (1) a decision component that generates a labeled dataset by mapping input data to either a continuous output value or a discrete class label, along with an associated error or loss function; (2) an evaluation procedure that measures how effectively the model performs on previously unseen data; and (3) an iterative training phase that updates the model’s tunable parameters to minimize error and thereby optimize performance. During deployment, the iteratively trained model is put into use: end-users or systems submit their problem instance, the corresponding explanatory variables are computed for that instance and fed into the model, which then produces the prediction. x 3

Overview and Preliminaries of our Autotuning Approach

In this section, we present an overview and the necessary preliminaries of our contribution. To improve the effectiveness of optimizations performed in a transpiler pipeline, we propose a methodology in which machine-learning predictor is trained on a new dataset, that we generated by applying optimization passes to a diverse collection of quantum circuits. The concrete goal for the optimizations proposed in this paper is to reduce the number of two-qubit gates, which are the

Transpiler Autotuning with Predictive Models for Quantum Circuit Optimization

5

highest cause for noise in NISQ quantum devices. Thus, the reduction of two-qubit gates is often used in our reasoning, and later also a major focus in our evaluation. A major advantage of our approach is that it enables the automatic selection of effective optimization passes for individual circuits, without demanding extensive domain expertise and remaining device-agnostic. 3.1

Methodology

A visualized overview of our complete methodology, which we call an autotuning pipeline, is shown in Figure 2. Our contribution is divided into the following six steps: (1) Search Space Formalization: To propose suitable optimization passes, we must first search for and understand how different combinations of these passes operate for a particular class of quantum circuits. The Qiskit transpiler pipeline, for instance, offers 33 optimization passes for both init and optimization stages. All 33 passes can theoretically be flexibly combined, leading to a combinatorial explosion in the search space. However, some optimization passes are abstract and cannot be directly applied to a circuit, and many passes are interdependent (certain passes must be executed together because one generates results required by another). Consequently, naively assembling passes without considering such dependencies can result in invalid combinations of optimization passes. To address this, we first formalize the space of valid combinations of optimization passes using feature modeling, which captures variability through features and their relationships [38] and allows us to encode selectable passes together with their dependencies expressed as cross-tree constraints. This approach

1. Search Space Formalization

4. Dataset Grover Root

Pass A

Pass B

Group A

Feature Modelling

Pass C

VQE

Pass A

Quantum Circuit Dataset

Group B

Pass B

Pass C

Abstract Pass

Pass E Cross Tree Constraints

Pass D

A⇒B C⇒E

Pass D

Gather Circuit Data

Pass E

Transpile & Gather 2-Qubit-Count for each

ordered configuration

transpile each

Explanatory Variables

2. Optimization Passes Sampling {

Root

Root

Group B

Group A

"gate-count": 13, "circuit-depth": 42, ...

}

Group A

circuit

Transpilation

"parallelism": 0.35

2-Qubit-Count

Group B

Labeled Dataset-Tuples Pass A

Pass B

Pass C

Abstract Pass

Pass D

Pass A

Pass B

Pass E

Pass C

Abstract Pass

Pass D

(

Pass E

{

"gate-count": 13, "circuit-depth": 42, ...

}

"parallelism": 0.35

, |

2-Qubit-Count

5. Machine Learning Predictor

) 6. SHAP

Learning-to-Rank

3. Pass Ordering Y X

=

Pass D

Pass E

Y

=

Pass B

Pass A

Pass E

X

Fig. 2. Overview of our autotuning pipeline. This figures includes all six steps that we performed to create this contribution, including the creation of a dataset via a formalization and sampling and pass ordering (1-4), the training of a machine learning predictor (5), and an evaluation of our results via a SHAP analysis (6).

6

Malkowski et al.

formalizes the search space as the set of all combinations of optimization passes that satisfy the feature model (shown in yellow in Figure 2). (2) Optimization Passes Sampling: The feature model formalization captures the search space, but does not mitigate its combinatorial explosion. To mitigate the combinatorial explosion, we use the feature model as the foundation for sampling, a method that reduces the search space to a representative subset of combinations of optimization passes. Given our feature model and cross-tree constraints, sampling selects passes to form sampled combinations of optimization passes, denoted as configurations (shown in green in Figure 2). (3) Pass Ordering: Transpiler pipelines are highly sensitive to how passes are ordered. Consequently, executing the same set of passes in different sequences can yield different results. The order in which passes need to be executed is something that our feature model, nor our configurations, do not yet express. To tackle this, we introduce an Execution Order, which specifies a concrete ordering that can be applied to configurations, illustrated as numbered blue cogs in Figure 2. (4) Dataset: The ordered configurations now represent concrete combinations of optimization passes, together with the sequence in which they are to be applied to a quantum circuit. We next apply these ordered configurations to a variety of quantum circuit classes from the quantum benchmarking suite MQT Bench [62] to quantify how effectively each ordered configuration reduces the two-qubit gate count. The resulting reduction serves as a label indicating the performance of each ordered configuration on each circuit. We additionally compute explanatory variables that extract the characteristics of the circuits and together with configurations can serve as suitable input for a machine learning predictor, which learns for quantum circuit which configurations reduce the two-qubit gate count the most. We combine these labeling and explanatory-variable extraction steps into an automated data generation pipeline, which produces a labeled dataset tailored for training the machine learning predictor. (5) Machine Learning Predictor: The labeled dataset captures how different quantum circuits respond to each ordered sample of optimization passes. Our aim is to generalize these observations so that, after training, the predictor can be used to predict suitable ordered configurations for previously unseen circuits without actually executing the ordered configurations. To this end, we train our machine learning model in a learning-to-rank setting [53]: given a new circuit expressed with explanatory variables, the model produces an two-qubit-gate count reduction ranking over all candidate ordered configurations found during Optimization Passes Sampling step, effectively predicting which ordered combination of optimization passes is most likely to yield the largest reduction in two-qubit gate count. (6) SHAP: While our machine learning predictor serves as a fast surrogate that, for a given circuit, recommends ordered samples of optimization passes expected to yield the largest reduction in two-qubit gates, its internal decision process remains opaque: it is not directly clear why a particular ranking is produced. In addition to accurate predictions, we therefore aim to explain why specific optimization passes tend to enhance (blue) or degrade (red) performance, measured in two-qubit-gate reduction, for different classes of circuits, as illustrated in Figure 2. To this end, we employ SHAP [48], an interpretability framework that quantifies the contribution of each explanatory variable and each chosen optimization pass, aggregated over circuit classes, to the rankings produced by our predictive model. Such insights can inform the design of more fine-grained strategies for selecting optimization passes in future work.

Transpiler Autotuning with Predictive Models for Quantum Circuit Optimization

3.2

7

Application Scenario

Our contribution is not only purely methodological but also implemented for the actual quantum transpilation pipeline from Qiskit. When describing the details of our autotuning approach, we try to keep explanations abstract so that they can be understood without knowing the details of Qiskit’s implementation, but sometimes reasoning with actual implementation details is necessary to explain certain design decisions. Below we motivate the scope of the application scenario in our implementation. As described in Subsection 2.1, the Qiskit transpiler pipeline consists of six stages, two of which, the init and optimization stages, are dedicated to circuit optimization, primarily by reducing the number of two-qubit gates, which we use as our primary performance metric. In this work, we restrict our attention to optimizations applied in the init stage. We impose this restriction because, in Qiskit’s default transpiler pipeline, by the time a circuit reaches the optimization stage, it has already been adapted to a specific device’s topology, connectivity constraints, and Instruction Set Architecture (ISA). In contrast, init-stage optimizations operate on device-agnostic circuits and are therefore unaffected by device-specific biases. By focusing on the init stage, we can attribute any reductions in two-qubit gate count directly to the optimizations themselves and to our methodology for choosing them. This, in turn, provides insights that future work could extend to later stages of the pipeline and to scenarios in which the target hardware is selected. 3.3

Optimization Target

As described in Section 4, our primary metric is the reduction in the number of two-qubit gates, which is only well-defined once the circuit is expressed in terms of explicit, concrete gates. However, the optimizations in the init stage are ISA- and hardware-agnostic, and they allow the circuits to be represented in any form suitable for transpilation. In such representations, two-qubit gates may be concealed within more abstract constructs, reflecting how circuits are typically specified before entering the transpilation pipeline. To evaluate our metric, the reduction of two-qubit gates, in a way that is both meaningful and realistic, we must therefore introduce a translation stage to a concrete target gate basis before running the optimizations, in order to record the baseline for comparison, and again after the optimizations have completed, to quantify the improvement. We choose the following target gate basis for this translation: B = {𝑅𝑧 , 𝑆𝑋, 𝑋, 𝐶𝑋 }.

(1)

The basis B is a universal quantum gate set, meaning that any quantum circuit can be decomposed into circuits using only these gates [3]. For this to be possible, the gate set must be capable of generating all quantum superpositions as well as quantum entanglement. To do this, the basis B includes the RZ, SX, and X gates. These gates implement rotations around the Z and X axes by fixed angles. The RZ gate supports rotations by any chosen angle, whereas the SX gate performs only 90◦ rotations and the X gate performs 180◦ rotations, which corresponds to flipping the qubit state (a bit flip). Other superposition-generating gates, such as the Hadamard gate, can be constructed using combinations of these basic gates. Quantum entanglement is provided by the CX gate, which acts on two qubits, one serving as the control and the other as the target. When the control qubit is in the state |1⟩, the gate flips the state of the target qubit. In this way, it can create entanglement between the two qubits. Our choice for this specific gate set is further motivated by the fact that it matches the native ISA of current state-of-the-art IBM superconducting quantum processors [3]. Moreover, this basis is in line with the evaluation typically used in quantum transpiler research [63–65], enabling us to evaluate our research against previous contributions with similar goals.

8

4

Malkowski et al.

Applying Autotuning to Quantum Transpiler Pipelines

With the scope defined, and thus a clear focus on a specific segment of the Qiskit transpilation pipeline, we now describe the six phases of our autotuning approach (see Figure 2) in detail. 4.1

Search Space Formalization

The first step of our autotuning pipeline is a formalization that captures the variability of quantum transpiler pipelines, which, in our case, need to capture possible combinations of Qiskit’s optimization passes. The formalization later allows us to analyze how various combinations of optimization passes influence the circuits and gives us a systematic method to represent valid combinations of passes. In this context, valid means that passes that depend on each other are always selected together and that we avoid the selection of passes that are mutually exclusive. Formalizing this validity is necessary because we want to avoid that our autotuning approach predicts incorrect combinations. Additionally, the formal representation gives us the possibility to automatically generate valid combinations of passes, which will be essential in later parts of our contribution, especially in the sampling and the data set creation. To create the formalization, we decided to use a feature modeling approach [38], which allows us to capture the variability of the Qiskit transpiler pipeline within a feature diagram and additional cross-tree constraints. Feature models have the advantage that their formalization is visually appealing and easy to understand. Additionally, they can be transformed into boolean satisfiability problems, allowing us to perform SAT-based analysis and sampling algorithms on them [18]. Formally, a feature model can be defined as: Definition 4.1 (Feature Model). A feature model FM = (F, D) is a tuple that consists of a set of features F = {𝑓1, . . . , 𝑓𝑛 } and a set of dependencies D = {𝑑 1, . . . , 𝑑𝑚 }. In the context of this paper, features correspond to transpiler passes, and dependencies correspond to propositional formulas that express the relations between them. An important aspect of feature models is the creation of so-called configurations, which are instances of a feature model where features are either selected or not selected. In our context, we want to map a configuration to a set of transpiler passes that we select to create a transpiler pipeline. Formally, we can define a configuration as follows: Definition 4.2 (Configuration). A configuration 𝑐 is a function that maps a set of features F to 0 (not selected) or 1 (selected): ( 1, 𝑓𝑖 is selected 𝑐 : F → {0, 1}, so that 𝑐 (𝑓𝑖 ) = 0, 𝑓𝑖 not selected We call a configuration valid iff it satisfies all dependencies D. We denote the set of valid configurations as: C(F) = {𝑐 | 𝑐 satisfies D}. Based on this formal framework, we can now proceed to formalize the configurability of the Qiskit transpiler pipeline. The outcome of this process is presented in Figure 3 and shows a comprehensive feature model that formalizes the Qiskit transpiler passes appropriate for the init stage. The core aspect that our formalization, and therefore the feature model, has to describe, is the complete set of transpiler passes available for our context. Note that in our subject system, we only consider optimization passes and a single basis-change pass appropriate for the init stage. Therefore, our feature model excludes any passes that apply transformations for QPU-specific layouts. To create this formalization, we used the information available in the official Qiskit documentation [33], and intensively studied the code of the open source implementation of the Qiskit transpiler pipeline

Transpiler Autotuning with Predictive Models for Quantum Circuit Optimization

9

Fig. 3. A feature model that represents the configurability of the transpiler passes appropriate for Qiskit’s init stage. To improve the readability of the figure we had to collapse some nodes of features, a complete figure as well as a complete expression of the feature model in the Universal Variability Language can be found in our supplementary material [80].

from Qiskit version 2.3.0 [61]. To denote all relevant passes, our feature model contains one concrete feature for each transpilation pass. Thus, every such concrete feature corresponds to exactly one transpiler pass. To ensure our formalization captures only optimizations relevant to our subject system and remains compatible with modern NISQ devices, we restrict it to concrete passes that optimize circuits so that translation to the basis B defined in Subsection 3.3 accurately reflects the reduction in two-qubit gates. In addition, the feature model includes several abstract features that capture further logical aspects. These additional aspects describe, for example, compiler pass groups, which combine passes that pursue related objectives. Concretely, we define eight such groups: OptimizationPasses, Analysis, LocalCleanup, Commutation, Aggregation, GlobalOptimization, OneQubitOptimization and Decomposition. Each of these categories aggregates passes that share a common high-level optimization goal, even though they may realize this goal through different techniques. So far, our formalization denotes and groups the available passes, but it not yet covers which valid pass combinations can be created. To add this validity aspect, we now need to ensure that our feature model covers the dependencies that are associated between these passes. This can be achieved by using the structure of the feature diagram, and by defining additional cross-tree constraints to encode dependencies that cannot be covered by the feature diagram. The feature diagram gives us the following possibilities to express dependencies: Mandatory indicates that a child feature is included in every configuration that contains its parent feature; Optional indicates that the child feature may or may not be present in a configuration when the parent is selected; Alternative Group specifies that exactly one of the child features can be included in a configuration if the parent feature is present; and Or requires that, if the parent is selected, at least one of its child features must be included in the configuration. As shown in Figure 3, we define a single mandatory relationship, namely between the root feature Qiskit and the logical group OptimizationPasses. The abstract root feature Qiskit represents the overall system under study. The mandatory relation to OptimizationPasses narrows the scope of our model to the optimization passes offered by Qiskit, meaning that every configuration is derived exclusively from the optimization-pass search space. Furthermore, the model contains only one Alternative Group, linking the general feature CollectAndCollapse to its

10

Malkowski et al.

two concrete realizations, CollectCliffords and CollectLinearFunctions. These two features represent different implementations of the same abstract operation, but encode mutually exclusive strategies. The remainder of the model is composed of Optional relationships. Although some passes could in principle be modeled as mandatory children of others to capture internal dependencies, we avoid doing so in order to preserve the grouping of the features we introduced, rather than implementation-level dependencies between passes. Using mandatory-child relationships for this purpose would compromise the intended meaning of these logical groupings, so we instead encode most dependencies as cross-tree constraints. To express dependencies without using the hierarchy of the feature diagram, feature models also allow the definition of additional cross-tree constraints. These cross-tree constraints are expressed as additional propositional formulas. In Figure 3 they are listed below the feature diagram. In our case, we use the cross-tree constraints to express (a) transformation passes that depend on specific analysis passes, and (b) transformation passes that must be preceded by other transformation passes that first rewrite gate-level circuits into more abstract forms. This is crucial for modeling optimization in Qiskit, where we identified three such dependencies. All three are Requires crosstree constraints, meaning that the selection of one feature mandates the inclusion of another. Following we give one example where we describe the reasoning for the constraint in detail: Example 4.1. ConsolidateBlocks is a transformation pass that replaces sequences of consecutive gates with a Unitary object, which is an abstract representation of these gate blocks as a unitary matrix rather than as gate instructions. This abstraction facilitates re-synthesis aimed at minimizing the number of 2-qubit gates. ConsolidateBlocks consumes the precomputed block-list and run-list data and clears both once it completes. The block-list can originate from either of the analysis passes Collect2qBlocks or CollectMultiQBlocks. Since they both write to the same shared buffer under the block-list, the two passes cannot be applied together in any valid configuration. The run-list is generated by the Collect1qRuns pass. Formally, this can be expressed as follows: ConsolidateBlocks ⇒ Collect1qRuns ∧ (Collect2qBlocks ⊕ CollectMultiQBlocks)

(2)

Adding this constraint to the feature model ensures that, in every valid configuration, whenever consolidation is enabled, each of the required buffers is written to exactly once. 4.2

Configuration Sampling

Although the formalized feature model representation of the search space captures dependencies between optimization passes, it alone does not yet resolve the combinatorial explosion present in the search space. Exhaustively evaluating every valid configuration is computationally infeasible, and manually deciding, for each circuit, which passes are likely to be advantageous is time-consuming and usually limited to domain experts. Therefore, autotuning focuses on exploring only a representative subset of the overall search space [6]. Exploration of this subset can be done with sampling, which refers to a process of selecting a subset of candidate configurations from the search space whose performance, in our case the reduction of 2-qubit gates, will be evaluated [7]. In traditional compiler optimization [6], the search space is usually explored via iterative compilation, which employs search heuristics such as random sampling, genetic algorithms, or simulated annealing [9, 13, 39]. Although these iterative compilation strategies can mitigate the combinatorial explosion of the search space, they do not account for dependencies and constraints. As our methodology with feature models enables capturing the variability of transpilation pipelines, and thus the dependencies and constraints, we aim to use an appropriate sampling strategy that explicitly takes these defined variabilities into account. To tackle this challenge, we employ a t-wise interaction sampling strategy, where the objective is to cover all t-wise interactions between selectable features using as few configurations as

Transpiler Autotuning with Predictive Models for Quantum Circuit Optimization

11

possible [16]. When applied to our application scenario where the search space is represented as a feature model, t-wise interaction sampling guarantees that every valid t-way combination of features, i.e., optimization passes, occurs in at least one configuration. This ensures that specific combinations of optimization passes, whose interactions may be advantageous or harmful, are systematically represented in the sampled configurations. To apply sampling to the feature model, we use the YASA algorithm that was introduced by Krieter et al. [42] and is considered a state-ofthe-art approach [29]. Using this approach, our goal is to generate a Configuration Set S: Definition 4.3 (Configuration Set). A configuration set S ⊆ 𝐶 (𝐹 ) is a set of sampled configurations {𝑐 1, . . . , 𝑐𝑛 }, where each configuration is valid according to Definition 4.2 and each transpiler pass corresponds to a concrete feature described in Subsection 4.1. To construct S, YASA systematically enumerates all t-wise feature interactions, uses SAT solving to filter out invalid interactions, and incrementally builds a compact set of valid configurations that cover all remaining interactions. Because it relies on SAT solving, YASA ensures that every selected configuration adheres to the feature-tree hierarchies and cross-tree constraints defined in our formalized feature model, while omitting abstract features, since these cannot be applied to a transpilation pipeline. Empirical studies suggest that 2- or 3-wise interaction sampling is typically sufficient to expose most relevant interactions [2, 10, 42]. In this work, given the size of our dataset and our available computational budget, we use 3-wise interaction sampling to generate a larger set of configurations, enabling us to uncover more interactions than a 2-wise strategy would. 4.3

Pass Ordering

With the set of sampled configurations S ⊆ 𝐶 (𝐹 ) established, we can now tackle the ordering problem by introducing an execution order. Defining such an execution order is essential because quantum transpiler pipelines depend on the sequence in which their passes are applied. Consequently, applying the same collection of passes in different sequences can lead to different outcomes. As per Definition 4.2, 𝐶 (𝐹 ) currently denotes only a set, implying that S specifies which passes are applied to circuits, but not the order in which they are executed. Consequently, we must extend the current definition of configurations with the notion of ordering. To achieve this, we introduce the following execution order that has to be applied to every 𝑐 ∈ S: Definition 4.4 (Execution Order). Given a configuration 𝑐 ∈ S with a set of transpilation passes {𝑝 1, . . . , 𝑝𝑛 } that are selected in 𝑐 (meaning that 𝑐 (𝑝) = 1), then the execution order 𝜙 of 𝑐 is defined as a sequence 𝜙𝑐 = [𝑝𝜎 (1) , . . . , 𝑝𝜎 (𝑛) ], where 𝜎 is a permutation of the selected transpiler passes that is determined by applying the following rules: (1) Strategy Rule: transpilation passes that follow shared objectives should be grouped and the groups executed in a order that maximizes optimization potential. (2) Dependency Chain Rule: transpilation passes that depend on each other must execute sequentially, immediately one after another. (3) Mandatory Translation Rule: final occurrence of a transpilation pass that creates or works on abstract representations, not suitable for subsequent transpilation passes, must be followed by a corresponding translation to a suitable representation. To define the rules that create the execution order, in the following, we refer to the specific transpilation passes involved. However, a detailed understanding of each individual transpiler pass is not required in order to grasp why these rules are needed. The strategy rule addresses problems that arise when deciding the order in which to apply passes contained in logical groups from our feature model. If these logically grouped passes, with each group reflecting a distinct underlying optimization goal, are executed in an arbitrary sequence, the

12

Malkowski et al.

resulting order of groups, and thus of their passes, can lead to different outcomes. In particular, it may cause lost optimization opportunities, because some objectives are best pursued early in the circuit optimization process, while others are more effectively addressed at later stages. The strategy rule solves this issue by prescribing a fixed ordering for all logical groups. To construct this ordering for our application scenario, we drew inspiration from how Qiskit arranges its optimization passes during the init stage [61]. Considering both the function of optimization passes selected by Qiskit and their ordering, we derive an analogous ordering for our own methodology, where the concrete ordering enforced by the strategy rule is defined as follows: Definition 4.5 (Strategy Rule). Passes are executed based on their category, in the order: 1. Decomposition → 2. Analysis → 3. LocalCleanup → 4. Commutation → 5. Aggregation → 6. GlobalOptimization → 7. OneQubitOptimization. Inside each of these categories, passes are arranged according to a simple lexicographic ordering. The dependency chain rule applies to situations in which one transpilation pass generates an intermediate artifact (such as a buffer or a modified circuit via abstract objects) that a later pass relies on. In these cases, the intermediate artifact must not be overwritten, ensuring that each pass works with a valid intermediate result. In our application scenario, the Qiskit transpiler pipeline, this problem occurs for sequences of passes that are mutually dependent, as specified by cross-tree constraints. The dependency chain rule solves this issue by enforcing a strict, sequential execution order on any passes that appear together in a given constraint. Definition 4.6 (Dependency Chain Rule). (1) ConsolidateBlocks, when enabled, shall be executed immediately after the analysis passes Collect1qRuns and either Collect2qBlocks or CollectMultiQBlocks. (2) Split2QUnitaries, when enabled, shall be executed immediately after ConsolidateBlocks. (3) OptimizeCliffords, when enabled, shall be executed immediately after CollectCliffords. Lastly, the mandatory translation rule covers issues that arise from transpilation passes that transform parts of a circuit into abstract representations that subsequent passes might be unable to interpret. The mandatory translation rule avoids possible issues by ensuring that the final occurrence of any pass that generates an abstract representation, or final occurrence of any pass that consumes these representations, must be directly followed by a matching translation pass that converts the circuit back to a representation expressed in quantum gates. In our application scenario, this rule can be implemented by enforcing the ordering based on the following definition: Definition 4.7 (Mandatory Translation Rule). (1) If ConsolidateBlocks is selected and Split2QUnitaries is not selected in a configuration, then ConsolidateBlocks must be immediately followed by UnitarySynthesis. (2) If Split2QUnitaries is selected in a configuration, then Split2QUnitaries must be immediately followed by UnitarySynthesis. (3) If CollectCliffords is selected and OptimizeCliffords is not selected in a configuration, then CollectCliffords must be immediately followed by HighLevelSynthesis. (4) If OptimizeCliffords is selected in a configuration, then OptimizeCliffords must be immediately followed by HighLevelSynthesis. (5) If CollectLinearFunctions is enabled in a configuration, it must always be immediately followed by HighLevelSynthesis.

Transpiler Autotuning with Predictive Models for Quantum Circuit Optimization

13

With the ordering rules in place, we can now apply the execution order to our configuration set S. This yields an ordered configuration set Sordered , which we can then use to construct the data set required to train our machine learning predictor. Definition 4.8 (Ordered Configuration Set). The ordered configuration set Sordered is derived by obtaining the execution order 𝜙 for every configuration 𝑐 of the configuration set S, i.e. Sordered = {𝜙𝑐 | 𝑐 ∈ 𝑆 }. 4.4

Dataset

After applying the execution order to our configuration set and deriving S𝑜𝑟𝑑𝑒𝑟𝑒𝑑 , we can now start creating the dataset necessary to train the machine learning predictor of our autotuning approach. In the following, we explain how we use our ordered configurations to construct a large-scale dataset that allows us to empirically analyze how various optimizations passes influence different quantum circuits, evaluated according to our optimization objective, the reduction in two-qubit gates. Furthermore, we determine the explanatory variables that characterize the underlying quantum circuits in a representation suitable for our machine learning predictor. A very important aspect when creating the dataset is to make it sufficiently large and diverse, because different classes of quantum computing problems may respond differently to the same optimizations. To achieve this goal, we obtain quantum circuits from the benchmark library MQT Bench [62]. The MQT Bench library contains thousands of quantum circuits spanning 26 different categories of quantum computing problems and corresponding algorithms including QAOA [21], VQE [37], and QNN [44], each offered at multiple abstraction levels tailored to various quantum tools and use cases. Here, the chosen abstraction level limits where a machine-learning predictor can be applied: If a model is trained on circuits already mapped to a particular device, it can only generate predictions at that specific level of abstraction. To match our intended application scenario, which is improving Qiskit’s init-stage optimization, we therefore need to restrict our dataset to abstraction level that correspond to the Target-Independent Level. Following this choice, we obtain a total of 1943 distinct circuits from MQT Bench that can be investigated without relying on any hardware-specific details. The next important aspect for the creation of our dataset is the definition of a metric that corresponds to our optimization objective, the reduction of two qubit gates, which we use to measure how well a specific combination of transpilation passes (e.g., one configuration of S𝑜𝑟𝑑𝑒𝑟𝑒𝑑 ) performed. This metric is subsequently used to guide the machine-learning predictor so that, for any given circuit, it prioritizes those ordered configurations that are most likely to produce the largest decrease in two-qubit gates. More precisely, the metric compares the number of two-qubit gates in a circuit after the ordered configurations from S𝑜𝑟𝑑𝑒𝑟𝑒𝑑 have been applied to the baseline two-qubit gate count obtained before any optimization. Both the pre- and post-optimization two-qubit gate counts are evaluated in the basis B, as justified in Subsection 3.3. In the following, we refer to this metric as the Optimization Ratio and define it as follows: Definition 4.9 (Optimization Ratio). Let 𝑏 (𝑞𝑖 ) be the baseline two-qubit gate count of a circuit 𝑞𝑖 obtained by translating 𝑞𝑖 into the basis B and counting its two-qubit gates and let 𝑜 (𝑞𝑖 , 𝜙𝑐 ) be the optimized two-qubit gate count, obtained by applying the ordered configuration 𝜙𝑐 ∈ S𝑜𝑟𝑑𝑒𝑟𝑒𝑑 to 𝑞𝑖 , translating the result into B, and counting its two-qubit gates. We define the Optimization Ratio as: optRatio(𝑞𝑖 , 𝜙𝑐 ) =

𝑏 (𝑞𝑖 ) , 𝑜 (𝑞𝑖 , 𝜙𝑐 )

where optRatio(𝑞𝑖 , 𝜙𝑐 ) > 1 indicates a reduction in two-qubit gates, with higher values corresponding to higher reductions.

14

Malkowski et al.

To train our machine learning predictor on the relationship between a circuit and its resulting Optimization Ratio, we now need a suitable representation of each circuit, denoted as explanatory variables and motivated in Subsection 2.2. Thus, we associate every quantum circuit with a vector of explanatory variables for a given circuit 𝑞𝑖 denoted with Exp𝑖 , defined as follows: Definition 4.10 (Explanatory Variables). For each circuit, the explanatory variables vector is defined as a 62-dimensional vector constructed from the following components: (1) 13 explanatory variables obtained using the Qiskit circuits properties, describing scalar circuit properties such as depth, width, and size [33], (2) 42 explanatory variables counting the occurrences of standard gates in the Target-Independent Level (e.g., 𝐶𝑋 ) as specified in the circuit’s OpenQASM 2 description [14], (3) 5 explanatory variables obtained from the SuperMarQ benchmarking framework [78], namely Program Communication, Critical Depth, Entanglement Ratio, Parallelism, and Liveness, (4) 2 explanatory variables we constructed ourselves: the number of gates acting on exactly 2 qubits and the number of gates acting on exactly 3 qubits. A complete listing of all explanatory variables is provided in our supplementary material [80]. In summary, to construct the dataset for our application scenario, we apply every ordered configuration 𝜙𝑐 ∈ S𝑜𝑟𝑑𝑒𝑟𝑒𝑑 to each of the 1943 quantum circuits obtained from MQT Bench, record the resulting Optimization Ratio, and compute the corresponding explanatory variables. This procedure yields all the information required to train our machine-learning predictor. As this dataset may also be useful for future related research and reproducibility, we make it publicly available in our supplementary material [80]. 4.5

Surrogate Machine Learning

With the labeled dataset established, we can specify our machine learning predictor with a supervised machine learning algorithm. Nair et al. [53] showed that compiler optimization is best framed as selecting the best configuration from a candidate set via ranking, rather than predicting a single configuration. Motivated by this, we model our machine learning predictor as a supervised learning-to-rank problem with the XGBoost machine learning algorithm [12]. Given a quantum circuit, this predictor induces a ranking for the configurations 𝑐 ∈ S from most to least promising. The highest-ranked configuration can then be selected to achieve the largest reduction in the 2-qubit gate count of the quantum circuit. In the following, we describe how each step of the machine learning works following the visualizations in Figure 4. First, our predictor requires an input that enables it to rank configurations from most to least promising, as depicted by the yellow bars in Figure 4. The explanatory variables defined in Definition 4.10 describe the circuit and are identical for every configuration, thus they alone do not allow to rank configuration from a pool of candidates. To support the ranking process, we additionally inform the machine learning predictor which configurations are currently being assessed for a given circuit, forming Input Groups: Definition 4.11 (Input Group). For a given circuit 𝑞𝑖 , we define the grouping of all configurations 𝑐 ∈ S as I𝑖 = {(𝐸𝑥𝑝𝑖 , 𝑐) | 𝑐 ∈ S}, i.e., the set of configuration pairs that share the explanatory variables vector 𝐸𝑥𝑝𝑖 of circuit 𝑞𝑖 . Note that each pair contains a binary configuration 𝑐 ∈ S rather than its ordered counterpart 𝜙𝑐 ∈ S𝑜𝑟𝑑𝑒𝑟𝑒𝑑 , since the predictor treats a configuration as a binary unordered selection of passes. Each pair is processed independently of each other in parallel by the predictor.

Transpiler Autotuning with Predictive Models for Quantum Circuit Optimization

15

Update Parameters

Predicted Ordering Most ➞ Least Promising

Explanatory Variables {

A Learning-to-Rank

Input Group

"gate-count": 13, "circuit-depth": 42, ...

}

"parallelism": 0.35 { {

Valid Configurations S }

Y

"gate-count": 13, "circuit-depth": 42,

Y

B

A

X

... "gate-count": 13, "circuit-depth": 42, "parallelism": 0.35 } ... "parallelism": 0.35

Gain X

X Z

NDCG Loss

C

Induced by Optimization Ratio

C B

✔ x x e

A B C

A

Y

Sort by optimization ratio

B C

Fig. 4. Overview of our machine learning predictor formulated as a learning-to-rank task. This figure presents a simplified illustration of the model input, the resulting ranking of configurations, and the way the model adjusts its parameters using a loss function.

With the Input Group specified, we now turn to the central aspect of any machine learning predictor: its output. As outlined above, each element of the Input Group is processed independently and in parallel. Consequently, the predictor cannot directly produce a ranking in the sense of a joint enumeration over integer values for all available configurations, since each prediction is made in isolation and the model has no explicit knowledge of the full set of candidate configurations. Instead, for each input pair (𝐸𝑥𝑝𝑖 , 𝑐) ∈ I𝑖 , our machine learning predictor outputs a Real-Valued Score denoted by 𝑣𝑖,𝑐 ∈ R. These scores can then be used to sort all configurations and thereby derive a Predicted Ordering: Definition 4.12 (Predicted Ordering). We define the Predicted Ordering for a circuit 𝑞𝑖 as a sequence of all configurations 𝑐 ∈ S: 𝜑𝑖 = [𝑐 𝜎 (1) , . . . , 𝑐 𝜎 (𝑘 ) ], where 𝜎 is a permutation of the configurations determined by their Real-Valued Score, such that: 𝑣𝑖,𝑐𝜎 (1) ≥ 𝑣𝑖,𝑐𝜎 (2) ≥ · · · ≥ 𝑣𝑖,𝑐𝜎 (𝑘 ) , where 𝑘 = |S| and ties are broken deterministically first by number of active passes and then by the configuration index. Thus, the place of a configuration in 𝜑𝑖 encodes its predicted rank, with 𝑐 𝜎 (1) denoting the most promising configuration for circuit 𝑞𝑖 . Subsequently, the model must be trained by updating its parameters, to refine the Predicted Ordering described above, via a loss function. As our goal is identifying the best-performing optimization configurations, rather than enforcing a precise ordering among clearly suboptimal ones, among loss functions available to learning-to-rank, we choose the loss based on Normalized Discounted Cumulative Gain (NDCG) [83]. This choice is motivated by the fact that NDCG assigns stronger penalties to misrankings in Predicted Ordering that affect the most beneficial optimization configurations for a given circuit, i.e., those that achieve the largest reduction in two-qubit gates. NDCG does this by comparing the Predicted Ordering of a Input Group against a set of Gains induced by Optimization Ratio, quantifying how valuable each configuration is and, thus, how severe it is to misplace it in the ordering. With the training concluded, we can employ our machine learning predictor to predict suitable optimizations for unseen circuits. For an unseen circuit, we compute the explanatory variables and configurations pairs as defined in Definition 4.11, run all the pairs through the machine learning predictor in parallel, obtaining one Real-Valued Score per circuit-configuration pair, sort the score and select the top-ranked configuration which can be then be applied to a circuit in the Qiskit transpilation pipeline to obtain an optimized circuit.

16

4.6

Malkowski et al.

SHAP Analysis

Beyond accurate prediction with our learning-to-rank model, our goal is to understand why particular optimization passes help or hinder the reduction of two-qubit gates across different classes of circuits. One of the main challenges motivating our autotuning approach is the complexity of the underlying problem. Different classes of quantum algorithms can respond very differently to the same transpiler passes, and choosing an appropriate set of passes for a given circuit often requires deep expertise in both the problem structure and the circuit optimization techniques available. Our predictor learns these relationships empirically from data, but its internal decision process remains opaque due to its black-box architecture [48]. SHAP provides the explainability in two ways. First, via Shapley values, it explains how each individual explanatory variable or applied optimization pass contributes to the predicted score, by quantifying its marginal effect relative to the predictors average output [51]. This indicates which aspects drive higher or lower ranking. Second, via the Shapley interaction index, SHAP captures how pairs of explanatory variables or passes interact, revealing synergies: (a) where two elements together correlate more than expected from their separate effects or (b) antagonistic behavior, where one element suppresses the benefit of another [51]. These interaction analyses reveal which concrete circuit properties affect the effectiveness of an optimization pass, offering data-driven guidance for assembling optimization configurations. In this work, we perform this analysis by providing our trained predictor to the SHAP [48] framework, which evaluates the inputs drawn from the training set, and then decomposes the predictor’s output into contributions from individual Shapley values and also into Shapley interaction effects. The results of this analysis are provided and discussed in Subsection 5.4. 5

Evaluation

In this section, we empirically evaluate our proposed autotuning methodology using the Qiskit transpiler as an application scenario. We will focus on the extend of the improvements that we were able to achieve, compare the performance of our approach on different circuit classes, and explain the behavior of our predictor by employing interpretability frameworks. To contextualize our results, we compare our machinelearning-based predictor with the heuristic optimization levels currently used in Qiskit’s init stage, and with the MQT Predictor [65], which is another well-established open-source framework that can perform automated transpiler pass selections. Specifically, we address the following research questions: (1) Predictability: Given explanatory variables that characterize a quantum circuit, how accurately can our predictor select, from all sampled configurations, the configuration that minimizes the circuit’s two-qubit gate count the most? (2) Reduction Improvements: How does the two-qubit gate reduction achieved by the predicted configuration compare, both overall and per algorithm class, to (i) Qiskit’s initstage optimization levels and (ii) a well-established reinforcement learning configuration selector MQT Predictor? (3) Explainability: Which selected optimization passes drive the two-qubit reductions, for which algorithm classes, and how can this knowledge be transferred into guidance for improving quantum transpilation pipelines? To answer these research questions, we first describe our experimental setup, then present the results and analyze them in a detailed discussion.

Transpiler Autotuning with Predictive Models for Quantum Circuit Optimization

5.1

17

Experiment Design

We evaluate our autotuning approach using a Docker-based environment. Reproducibility is ensured through straightforward commands that execute the respective pipeline stages with automatic persistence and the ability to resume interrupted runs. In this subsection, we describe the experimental setup and give an overview of the artifacts that were created during the steps described in our methodology. We also make the entire experimental pipeline publicly available in our supplementary material [80]. Search Space Formalization. The feature model introduced in Subsection 4.1 was defined in XML using FeatureIDE [77]. It contains 37 features in total, 27 of which correspond to concrete transpilation passes that can be applied to quantum circuits. Configuration Sampling. Using this feature model, configuration sampling with YASA, as described in Subsection 4.2, was performed with the FeatJAR framework [43]. Applying YASA to the feature model produced 62 configurations in total, where each configuration consists of up to 19 transpiler passes, with an average of approximately 10.9 applied passes per configuration. Dataset. The training circuits were sourced from MQT Bench [62] version 2.2.2, resulting in a collection of 1943 quantum circuits spanning 26 categories of quantum computing tasks, with circuit sizes ranging from 2 to 127 qubits at the Target-Independent Level. The circuits and configuration pairs described in Subsection 4.4 were transpiled using the Qiskit Transpilation Pipeline [61] from Qiskit version 2.3.0 on a system equipped with 128 GB of RAM and an AMD Ryzen Threadripper PRO 5955WX CPU featuring 16 physical and 32 logical cores. Due to the varying sizes of the MQT Bench circuits and the configurations, we imposed a timeout of 120 seconds for each circuit–configuration pair. In total, we evaluated 120466 circuit–configuration pairs, of which 109603 finished in time. Surrogate Machine Learning. Using the resulting labeled dataset, we trained our prediction model described in Subsection 4.5 with the XGBoost [12] machine learning algorithm. To reliably evaluate how well the trained model generalizes to entirely unseen circuits we adopt a group-aware train-test scheme. Concretely, we divide the available circuits such that no specific circuit–configuration pair is present in both the training and test sets within a single split. Furthermore, we apply group-aware stratification over quantum computing problems, as defined in MQT Bench [62] to guarantee that, for each group, some circuits are included in both the training and evaluation phases. In each split, roughly 80% of the circuits from all groups are allocated to training, with the remaining 20% reserved for testing. To tune the XGBoost machine learning model, we use the Optuna [4] framework, which automatically searches for hyperparameters that maximize model performance. The hyperparameter search used a GroupKFold cross-validation scheme provided by sklearn [57]. The resulting values and trained model are available in our supplementary material [80]. SHAP. For the SHAP analysis described in Subsection 4.6, we applied the TreeExplainer algorithms from the SHAP library [48] to the trained XGBoost model. Because the computation of Shapley interaction values scales quadratically with the number of elements defined in our Input Group (Definition 4.11), we sampled uniformly 500 datapoints for the interaction analysis. For the standard Shapley values, which scale linearly in the number of elements in the Input Group, we conducted the analysis on the complete set of available data-points. 5.2

Predictability

To answer the first research question, we examine whether given a circuit and sampled configurations, our predictor can correctly rank these configurations so as to select the one that removes the largest number of two-qubit gates for that circuit. To this end, we report the following metrics:

18

Malkowski et al.

(1) Top 1 and Top 3 Accuracy: Rate with which the best found sampled configuration is within the the top-1 or top-3 configurations the predictor proposes. (2) Mean Regret and Median Regret: Mean and Median difference in the Optimization Ratio achieved by our predictors proposed top-1 configuration, compared to sampled configuration that yields the highest Optimization Ratio for the given circuit. Table 1. Accuracy of the predictor.

Mean Regret

Median Regret

Top-1 Acc.

Top-3 Acc.

3.4 × 10−5

0.0

98.7%

99.5%

Table 1 summarizes the performance of our machine-learning-based predictor on the 20% test split, resulting in 391 test-circuits, stratified by the class of quantum algorithms. On average across all test-circuits, our predictor selects the Top 1 configuration in 98.7% of the cases out of the 62 configurations defined in Subsection 5.1, and in 99.5% of the cases its recommended configuration lies within the Top 3. The strength of our predictor is further highlighted by the Mean Regret and Median Regret values: whenever the our predictor does not select the best found configuration, the average missed optimization potential relative to the best configuration is negligible, and the median missed potential is zero. Answering RQ1. The results demonstrate that the predictor can very accurately predict the top-1 sampled configurations that achieve the largest reduction in two-qubit gate counts for a given circuit. In the few cases where our predictor does not identify the best sampled configuration, the resulting loss in optimization potential is negligible, indicating that the model has effectively learned from the dataset. Thus, end-users can rely on the ranking proposed by our predictor. 5.3

Reduction Improvements

To address the second research question, we evaluate whether using our predictor is indeed beneficial compared to Qiskit’s built-in init-stage optimization levels and the well-established MQT Predictor, with respect to the achieved two-qubit gate reductions. When comparing ourselves against Qiskit, we compare against the following three optimization levels: (O0) at optimization level 0, Qiskit applies no optimization passes; (O1) At optimization level 1, Qiskit applies two transpiler passes in the following order: InverseCancellation and thenContractIdleWiresInControlFlow; (O2) At optimization level 2, Qiskit applies the following transpiler passes in the order: Unroll3qOrMore → RemoveDiagonalGatesBeforeMeasure → RemoveIdentityEquivalent → InverseCancellation → ContractIdleWiresInControlFlow → CommutativeCancellation → ConsolidateBlocks → Split2QUnitaries. (O3) Optimization level 3 is currently identical to optimization level 2. We decided to still include the results in the evaluation to avoid intransparency. When comparing ourselves with the MQT Predictor reinforcement-learning approach [65] (RL), which we adapted to operate on the same search space of optimization passes as defined in Subsection 4.1 and to use the same two-qubit gate reduction metric as described in Subsection 4.4. For a fair, quantitative comparison, we report results for the following metrics:

Transpiler Autotuning with Predictive Models for Quantum Circuit Optimization

19

• Wins, Draws, and Losses: The number of test-set circuits for which the configuration predicted by our predictor achieves a better, equal, or worse reduction in two-qubit gates compared to the respective Qiskit optimization level or reinforcement-learning baseline. • Mean Relative Reduction and Median Relative Reduction: The mean and median fractions of removed two-qubit gates relative to the corresponding baseline. • Mean Absolute Reduction and Median Absolute Reduction: The mean and median absolute differences in the number of removed two-qubit gates relative to the corresponding baseline. Table 2. Head-to-head comparison of our predictor against Qiskit init-stage optimization levels O0–O3 and the MQT Predictor (RL). Numbers are rounded to 1 decimal place. Approach Wins Draws O0 O1 O2 O3 RL

248 248 110 110 55

143 143 281 281 329

Losses

Mean Rel. Red.

Median Rel. Red.

Mean Abs. Red.

Median Abs. Red.

0 0 0 0 7

32.4% 32.4% 19.1% 19.1% 0.7%

1.5% 1.5% 0.0% 0.0% 0.0%

2695.6 2695.6 1640.9 1640.9 27.6

42.0 42.0 0.0 0.0 0.0

As shown in Table 2, across 391 test-circuits our predictor selects configurations that yield stronger two-qubit gate reductions than Qiskit’s light-weight optimization levels (O0, O1) for 63.4% of the circuits and outperform the heavier optimization levels (O2, O3) for 28.1% of the circuits, while never producing a configuration that performs worse on any test-circuit. Compared to MQT Predictor, our predictor still performs favorably: it loses on only 1.8% of the circuits, but overall obtains very similar two-qubit gate reductions on a large fraction of the test set. Considering the Mean Relative Reduction, our approach removes on average 19.1–32.4% more two-qubit gates than Qiskit’s optimization levels. However, the Median Relative Reduction lies between 0 and 1.5%, indicating that these large improvements are not uniformly distributed across all circuits, but are instead concentrated on a subset of them. To pinpoint where our predictor provides the most benefit, we therefore analyze, in Figure 5, the fine-grained Mean Relative Reduction over circuits from each of the 26 quantum algorithm categories contained in MQT Bench. Figure 5 shows that the largest two-qubit gate reductions over Qiskit’s optimization levels are concentrated in three specific categories of quantum algorithms. Inspecting the Mean Relative Reduction achieved by Qiskit’s O2 and O3 levels (green and red), we observe that for most categories their performance is comparable to that of our predictor and the MQT Predictor reinforcement-learning approach. Notably, both our approach and the reinforcement learning approach consistently outperform Qiskit’s O0 and O1 levels (blue and orange). In contrast, for the realamprandom, su2random, and twolocalrandom categories, our predictor and MQT Predictor achieve 95.8%, 95.4% and 92.8% mean reductions in two-qubit gates, whereas all Qiskit optimization levels achieve 0.0%. Furthermore, in the qwalk-noancilla category, our machine-learning predictor identifies configurations that reduce two-qubit gate counts beyond what is achieved by both all Qiskit’s optimization levels and the reinforcement-learning-based MQT Predictor. Answering RQ2. In summary, these findings demonstrate that our predictor is not only accurate but also clearly advantageous in terms of two-qubit gate reduction, making it a practical surrogate for Qiskit’s built-in init-stage optimization levels. Our predictor never selects configurations that lead to worse two-qubit gate counts than any of Qiskit’s optimization levels on any test-circuits, a trait the reinforcement learning agent does not provide. Crucially, our machine learning predictor

20

Malkowski et al.

Fig. 5. Mean Relative Reduction of two-qubit gates across quantum circuit classes. Of the 26 total classes, only the 15 classes for which at least one method achieved a reduction are shown. The number of evaluated circuits for each class is denoted with n.

delivers what Qiskit’s predefined init-stage optimization levels do not: targeted reductions of up to 95.8% of two-qubit gates for specific classes of quantum algorithms by proposing circuit-specific optimization configurations. Thus, it can be reliably used in practice, even though for a substantial fraction of circuits the achieved improvements are relatively modest. When compared to the reinforcement learning MQT Predictor, our approach is able to identify on some circuit classes stronger optimization configurations, although its overall impact on two-qubit gate reduction is much smaller than the gains observed relative to Qiskit’s optimization levels. In the following, we use the SHAP explainability framework to make the optimization knowledge learned by our predictor persistent and transferable. Because our predictor evaluates every configuration for a given circuit, the SHAP framework enables a global interpretation of its predictions across all circuit classes simultaneously, an approach that is not available for a reinforcement learning agent, which makes decisions individually and in a sequential fashion. 5.4

Explainability

To answer the third research question, we now analyze which optimization passes, in combination with which circuit characteristics, drive the observed reductions in two-qubit gate counts. While the evaluation of the previous research questions has shown that our predictor is both highly accurate (RQ1 - Predictability) and capable of outperforming Qiskit and MQT Predictor in two-qubit gate reductions (RQ2 - Reduction Improvements), the focus here is on making the learned optimization knowledge explicit and interpretable. We report explainability results obtained with the SHAP framework using three types of plots: • Mean SHAP Plot: Shows the distribution of mean absolute Shapley values for selected optimization pass, thereby ranking them by their average influence on the predictor’s predictions. • SHAP Beeswarm Plot: Provides a comprehensive summary of the distribution of Shapley values for every selected optimization pass, highlighting how feature values affect the direction and magnitude of the prediction.

Transpiler Autotuning with Predictive Models for Quantum Circuit Optimization

21

• Cross-Group Interaction Plot: Summarizes Shapley interaction values to show how circuits explanatory variables that characterize particular classes of quantum algorithms interact to drive the selection of optimization passes. To connect directly to results for RQ2 (Reduction Improvements), we first present the Mean SHAP Plot and SHAP Beeswarm Plot for the realamprandom class of quantum circuits, where our method achieves substantial reductions and Qiskit finds no optimizations. The left plot in Figure 6 reports

Fig. 6. Mean |SHAP| and SHAP Beeswarm plots of Top 10 optimization passes influence for Real Amplitudes (Random) class of quantum computing problems.

the mean absolute Shapley values of the 10 most influential selected optimization passes for the realamprandom circuit class. The most important passes are CollectCliffords and CollectLinearFunctions, with mean absolute Shapley values of approximately 0.42 and 0.29, respectively, clearly dominating the contribution to the predictor output. The right plot in Figure 6 further decomposes these contributions into their positive and negative impact on the predictor output. For CollectCliffords, configurations in which this pass is absent (blue points) consistently exhibit negative Shapley values (approximately −0.5 to −0.1), indicating that the predictor is discouraged from selecting such configurations. In contrast, configurations that include CollectCliffords (red points) show strictly positive Shapley values (approximately 0.25 to 0.9), meaning that the presence of this pass strongly pushes the predictor towards choosing the corresponding configuration. A similar, though slightly weaker, pattern is visible for CollectLinearFunctions. Looking at all selected optimization passes in the right plot of Figure 6 reveal a consistent pattern: nearly all blue points are associated with negative Shapley values, whereas the red points correspond to positive Shapley values. This indicates, that choosing these optimization passes sends a strong signal to the predictor to select the corresponding configurations, as they correspond to a higher rank in the realamprandom circuit classes. However, the strength of this effect varies in magnitude across the passes, with CollectCliffords and CollectLinearFunctions driving the reduction of the two-qubit gates. Another way to render the acquired optimization knowledge more explicit and interpretable is to examine how these selected optimization passes affect the predictor in the general case, by aggregating their influence across all circuit classes, as shown in the left plot of Figure 7. Across this global view, LightCone and Unroll3qOrMore clearly dominate the predictor’s predictions, with mean absolute Shapley values of approximately 0.37 and 0.29, respectively. Other passes, such as TemplateOptimization, also contribute to two-qubit gate reductions, but on a smaller scale, while still remaining within the Top-10 most influential passes. However, these global importance scores alone do not reveal in which algorithmic contexts individual passes provide their strongest signal. Since, from the predictors’s perspective, circuit classes are distinguished only by their explanatory variables, we analyze how pass importance

22

Malkowski et al.

Fig. 7. The left plot shows mean absolute Shapley values displaying Top 10 optimization passes. Bigger mean |SHAP| corresponds to higher influence of the corresponding optimization pass on our predictor. The right plot shows a Cross-group Interaction Heatmap. Rows correspond to explanatory variables and columns correspond to optimization passes. Cells represent the magnitude of the mean absolute SHAP interaction between a pass and explanatory-variable. Lighter color indicates stronger interaction. Sorted from left to right by the mean |SHAP| importance.

depends on these variables using the cross-group interaction heatmap in the right plot of Figure 7. Each cell reports the mean absolute SHAP interaction between an optimization pass and an explanatory-variable, so reading reading columns from left to right shows which passes most affect the prediction overall, and reading a concrete cell in a column shows which circuit characteristics most strongly modulate the influence of a given pass. For example, LightCone not only ranks as the most influential pass globally, but its effect is particularly amplified when circuits contain cp or ry gates, while still being fairly uniformly relevant across other explanatory variables. In contrast, the CollectCliffords column shows weaker cumulative interaction values, with influence concentrated on a few specific variables such as liveness and parallelism. This aligns with the class-specific results shown in Figure 6, and indicates that CollectCliffords is a context-dependent pass that benefits only particular circuit families. Finally, the Split2QUnitaries column exhibits no strong interactions with any explanatory-variable, suggesting that this pass rarely drives substantial two-qubit gate reductions and is not amplified by identifiable circuit characteristics. Together, these explanations make the learned optimization behaviour explicit, revealing which passes matter, in which quantum circuit classes, and how they jointly drive two-qubit gate count reductions. Answering RQ3. Taken together, applying SHAP to our predictor yields persistent and transferable optimization knowledge. The results in Figure 6 clarify why our predictor achieves substantial two-qubit gate reductions on realamprandom circuits where Qiskit’s default optimization levels do not: the most influential passes highlighted by our predictor, most notably CollectCliffords and CollectLinearFunctions, are absent from Qiskit’s init-stage optimization configurations, causing Qiskit to miss optimization opportunities that our predictor successfully uncovers. In our supplementary material [80], we provide mean SHAP and beeswarm plots for all circuit classes, thereby pinpointing which specific passes, when applied to which circuit classes, drive the observed optimization gains. Subsequently, the results presented in the left plot of Figure 7 reveal, aggregated across all circuit classes, the most influential optimization passes. This empirical knowledge can be used to refine

Transpiler Autotuning with Predictive Models for Quantum Circuit Optimization

23

heuristic approaches, such as Qiskit’s predefined optimization levels, by including highly effective passes such as CollectCliffords, in order to recover optimization potential Qiskit currently misses on specific circuit classes. Finally, building on the identification of influential passes across all circuit classes, right plot of Figure 7 shows which easily computed explanatory variables amplify the relevance of specific optimization passes, laying the groundwork for designing even more sophisticated heuristic strategies. 5.5

Threats To Validity

In the following, we discuss internal and external threats that might impact the validity of the methodology and the evaluation that we presented. Internal Threats. Our method requires an explicit specification of the execution order of passes. Consequently, our reported results are dependent on the particular execution order we selected, and changes in this ordering could impact the performance of our predictor and thus the conclusions drawn in our evaluation. We mitigated potential threats to validity arising from this circumstance by deriving our ordering from a detailed analysis of the Qiskit transpiler pipeline implementation. As a result, the outcomes presented in our evaluation are more directly comparable, and the high performance of our predictor provides convincing evidence that the chosen ordering is appropriate. Our machine learning predictor relies on a corpus of quantum circuits intended to represent a broad range of quantum computing applications. The validity of our claims about generalization and the identification of effective optimization passes via SHAP depends on two key assumptions: (1) that this corpus adequately covers all major problem classes, and (2) that we have appropriately addressed potential overfitting and bias in the model training process. We mitigated this threat by using the well-established MQT Bench benchmarking suite, which spans 26 categories of quantum computing problems, and by following machine learning best practices for data handling, including stratified, group-aware train–test splits tailored to the learning-to-rank formulation. External Threats. Our experiments are conducted on a hardware-agnostic, noiseless simulator to isolate the effects of the optimization passes themselves. However, this environment may not fully capture the behavior of real quantum devices, which are constrained by limited qubit connectivity and affected by noise. Consequently, it is uncertain to what extent our results carry over to later stages in the Qiskit compilation pipeline that adapt circuits to specific quantum hardware. Nevertheless, our methodology, together with the explainability results from our SHAP analysis and our comparison against Qiskit init-stage optimizations in the same hardware-agnostic setting, provides valuable insights for this research area. Our methodology is transferable to other quantum transpilers, but the concrete artifacts produced in this work (e.g. feature model, execution order, and trained predictor) are tailored to the specific Qiskit version used in our experiments. They depend on the available passes and their implementation in that version, so changes in Qiskit (e.g., new or modified passes or defaults) may limit their direct applicability and require retraining or adaptation. We reduced the risk of limited transferability by using Qiskit, currently the most influential quantum programming framework [81], thereby ensuring that a broad segment of the quantum-computing community can benefit from our artifacts. Furthermore, we reduced the risk by publishing our full, reproducible experimental setup as open source with extensive supplementary documentation to support adaptation to future versions and other scenarios. The results we report are evaluated using a specific basis B, corresponding to the universal quantum gate set of IBM’s current superconducting quantum processors. This is only one of several gate sets compatible with the ISAs of existing quantum processors, which means that the artifacts produced by our methodology are closely tied to this particular basis. This creates a threat to the

24

Malkowski et al.

generalization of our findings. We mitigated this risk by choosing a basis that is widely used in quantum transpiler research [63–65] and by designing our open-source experimental pipeline so that the underlying basis can be easily adapted to other gate sets and platforms. 6

Related Work

In this section we discuss how our work relates to previous works employing machine learning in the fields of highly configurable systems and quantum compilation. Configuration Prioritization and Configuration Performance Learning. Prior work in configuration performance learning uses various machine learning approaches on small samples of software configuration spaces (i.e., search spaces) to address their combinatorial explosion, by following a sampling, measuring, learning pattern [58]. The aim of these models is to simplify the configuration of software systems by identifying configurations that perform optimally (i.e. prioritizing them over other configurations) [71]. For a detailed overview on configuration performance learning we refer to the surveys of Pereira et al. [58] and Gong and Chen [22]. Several studies use feature-coverage heuristics for configuration performance prediction [58]. Here, t-wise sampling is commonly employed or compared against [35, 68, 71, 72, 85]. Furthermore, configuration performance prediction models are used to address the variability of compiler infrastructure [58], making them a promising candidate also for quantum compilers. In particular, LLVM is a commonly used subject system [23, 24, 35, 40, 54, 55, 68, 71, 72, 86, 88]. Compiler autotuning is explicitly addressed by Optimization Space Learning [10], a supervised learning approach based on collaborative filtering shown to be a fast, noniterative method for the C compiler GCC. learning-to-rank approaches are often used in classical compiler optimization literature [6]. A learning-to-rank approach that motivated our choice of model was employed by Nair et al. [53], which showed that their model is cheaper to learn than residual-based configuration performance prediction models. To the best of our knowledge, no previous work has used learning-to-rank in a quantum compilation setting. Machine Learning for Quantum Compilation. Prior work on machine-learning applications for quantum compilation spans architecture-level decisions down to individual pass transformations. At the highest level, machine learning has been used for circuit-architecture and execution-target decisions. Prior work in this space either learns predictors or search policies for parameterized circuit structures, or predicts suitable hardware targets and target-dependent execution-quality estimates [26, 28, 31, 49, 65, 79, 82]. These decisions fix the input circuits, execution targets, and cost functions that lower-level transpilation and optimization then operate on. Once a circuit and target are fixed, machine learning has also been applied to individual transpilation subproblems and pass-level transformations. These works learn constructive policies for unitary synthesis, layout, placement, mapping, routing, circuit rewriting, or diagram simplification using neural predictors, sequence models, reinforcement learning, graph neural networks, or search-assisted variants [11, 19, 20, 27, 32, 41, 46, 52, 56, 59, 66, 67, 75, 76, 87]. At the compiler-flow level, existing methods primarily differ in whether they learn an online policy or an offline predictor over already evaluated compilation choices. Online reinforcementlearning methods treat compilation as a sequential control problem. Quetschlich et al. [64] model quantum compilation as a Markov decision process in which actions apply compilation passes or move between compilation states, enabling flows that combine passes from Qiskit and TKET. Liu et al. [47] propose a portable auto-tuning framework based on Double Dueling Deep Q-Networks for quantum compilation optimization. TuniQ [25] instead operates inside Qiskit’s staged transpilation pipeline and learns a MaskablePPO policy that selects or skips passes across the initialization, layout,

Transpiler Autotuning with Predictive Models for Quantum Circuit Optimization

25

routing, translation, optimization, and cleanup stages, using action masks to enforce valid stagedependent choices and reward shaping to propagate end-to-end compilation quality. These methods learn policies whose training signal comes from interaction with a compilation environment. This makes them well suited to adaptive pass ordering and cross-stage dependencies, but ties learning to repeated and computationally expensive environment rollouts and to the stability, and interpretability limitations of reinforcement-learning. Our approach instead uses supervised learning on an offline dataset of scored pass combinations. This fixes the training data and makes the relative performance of multiple candidate pass combinations available for each circuit. Offline supervised approaches differ in how much of this autotuning data they retain. Classificationbased compiler prediction treats compilation-option selection as a single-label prediction problem and learns from the best observed option combination for each circuit [63]. This formulation is useful when the goal is to predict one high-level option tuple, but it compresses the evaluated candidate set to a single target label. Thus, it does not use the relative ordering of non-optimal candidates, which can in principle be retained when the candidate configurations are evaluated offline. Prior work on rank-based configuration selection argues that exact performance prediction is not necessary when the goal is to identify good configurations; it can be sufficient to train a model that ranks candidate configurations [53]. Motivated by these observations, we formulate compiler-pass prediction as a supervised learning-to-rank problem over valid ordered pass combinations. 7

Conclusion and Future Work

In this work, we addressed an important challenge of current quantum compiler-pipeline optimization approaches, which typically rely on manually designed heuristics and developer intuition to decide which optimization passes to apply. To overcome this, we proposed an autotuning-based methodology that uses supervised machine learning to automatically learn which combinations of optimization passes are most effective for a given quantum circuit. Specifically, we trained a predictor that, given a circuit and sampled configurations of optimization passes, ranks these configurations by their expected ability to reduce the main source of error on NISQ devices: the number of noisy two-qubit gates. To implement our predictor, we made several contributions to the use of machine learning in quantum compilation pipelines. We analyzed and formalized Qiskit’s init-stage optimization search space, enabling smart sampling strategies that mitigate combinatorial-explosion of this space and produce a representative subset of valid optimization configurations. With valid optimization configurations, we carried out what was, to the best of our knowledge, the largest empirical study of the behavior and efficiency of the selected transpilation passes: we built a dataset by applying 62 different combinations of transpiler passes to 1,943 quantum circuits spanning several categories of quantum computing problems, recorded the resulting reductions in two-qubit gate counts, and thus created a self-contained artifact for future research in quantum compilation and autotuning. Using this dataset, we used state-of-the-art methods to train a machine learning predictor that correlates quantum circuit structure to the optimization potential of different configurations, enabling circuit-dependent configuration ranking. The experimental results from our evaluation show that our predictor has a high accuracy and correctly selects the best sampled configuration (out of the 62 considered configurations) for 98.7% of test-circuits. Additionally, the configurations it recommends never yield a smaller two-qubit gate reduction than any of Qiskit’s heuristic optimization levels. On average over all test circuits, the predicted configurations achieve an additional 19.1%–32.4% relative reduction in two-qubit gates, and for circuit families where Qiskit’s preset optimization levels offer 0% improvement, our approach reaches reductions of up to 95.8%. Compared to the well-established MQT Predictor framework, our predictor generally finds similar or better configurations and achieves a comparable

26

Malkowski et al.

overall two-qubit gate reductions. However, the most informative results from our predictor stem from the explainability analysis that we performed. Thanks to the methodology that we chose in our implementation, we were able to perform a SHAP analysis to explain why our predictor performs better than Qiskit’s optimization levels. In this analysis, we determined which passes have the greatest impact on configuration rankings, and thus offer the highest overall optimization potential, considering both (a) all quantum circuits collectively and (b) each individual class of quantum computing problems. As a result, we were able to provide a novel and extensive data-driven study that gives empirical insights on the performance of different transpiler passes, which could be used to refine heuristic strategies, including Qiskit’s predefined optimization levels. As future work, we plan to integrate our predictor in our own production tools as well as try to create a publicly available extension of the Qiskit transpilation pipeline that allows to use our predictor directly within Qiskit. Acknowledgments This work was funded by the German Federal Ministry of Research, Technology and Space (BMFTR) in the project QuSol (Grant No. 13N17170) and the German Research Foundation (DFG) in the project MoQel (Grant No. SCHA 1635/20-1). We thank IBM and Marcel Pfaffhauser for hosting the IBM Hackathon in Munich, where the idea for this work originated. We further thank Robert Wille for encouraging us to extend the Hackathon idea into a full paper, and Sebastian Krieter for his help with YASA. References [1] Scott Aaronson. 2022. How Much Structure Is Needed for Huge Quantum Speedups? arXiv:2209.06930 [quant-ph] https://arxiv.org/abs/2209.06930 [2] Iago Abal, Jean Melo, Ştefan Stănciulescu, Claus Brabrand, Márcio Ribeiro, and Andrzej Wasowski. 2018. Variability Bugs in Highly Configurable Systems: A Qualitative Analysis. ACM Transactions on Software Engineering and Methodology 26 (01 2018), 1–34. doi:10.1145/3149119 [3] Muhammad AbuGhanem. 2026. Early IBM quantum computers: architectural analysis and performance benchmarks. The Journal of Supercomputing 82, 8 (2026), 422. [4] Takuya Akiba, Shotaro Sano, Toshihiko Yanase, Takeru Ohta, and Masanori Koyama. 2019. Optuna: A Next-generation Hyperparameter Optimization Framework. arXiv:1907.10902 [cs.LG] https://arxiv.org/abs/1907.10902 [5] Gadi Aleksandrowicz, Thomas Alexander, Panagiotis Barkoutsos, et al. 2019. Qiskit: An Open-source Framework for Quantum Computing. doi:10.5281/zenodo.2562111 [6] Amir H. Ashouri, William Killian, John Cavazos, Gianluca Palermo, and Cristina Silvano. 2018. A Survey on Compiler Autotuning using Machine Learning. ACM Comput. Surv. 51, 5, Article 96 (Sept. 2018), 42 pages. doi:10.1145/3197978 [7] Prasanna Balaprakash, Jack Dongarra, Todd Gamblin, Mary Hall, Jeffrey K. Hollingsworth, Boyana Norris, and Richard Vuduc. 2018. Autotuning in High-Performance Computing Applications. Proc. IEEE 106, 11 (2018), 2068–2083. doi:10.1109/JPROC.2018.2841200 [8] Protonu Basu, Mary W. Hall, Malik Murtaza Khan, Suchit Maindola, Saurav Muralidharan, Shreyas Ramalingam, Axel Rivera, Manu Shantharam, and Anand Venkat. 2013. Towards making autotuning mainstream. The International Journal of High Performance Computing Applications 27 (2013), 379 – 393. https://api.semanticscholar.org/CorpusID:46358633 [9] François Bodin, Toru Kisuki, Peter Knijnenburg, Mike O’ Boyle, and Erven Rohou. 1998. Iterative compilation in a non-linear optimisation space. In Workshop on Profile and Feedback-Directed Compilation. HAL open science, Paris, France. https://inria.hal.science/inria-00475919 [10] Tamim Burgstaller, Damian Garber, Viet-Man Le, and Alexander Felfernig. 2024. Optimization Space Learning: A Lightweight, Noniterative Technique for Compiler Autotuning. In Proceedings of the 28th ACM International Systems and Software Product Line Conference (SPLC ’24). Association for Computing Machinery, New York, NY, USA, 36–46. doi:10.1145/3646548.3672588 [11] Qiuhao Chen, Yuxuan Du, Yuliang Jiao, Xiliang Lu, Xingyao Wu, and Qi Zhao. 2024. Efficient and practical quantum compiler towards multi-qubit systems with deep reinforcement learning. Quantum Science and Technology 9, 4 (jul 2024), 045002. doi:10.1088/2058-9565/ad420a [12] Tianqi Chen and Carlos Guestrin. 2016. XGBoost: A Scalable Tree Boosting System. In Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining (San Francisco, California, USA) (KDD ’16).

Transpiler Autotuning with Predictive Models for Quantum Circuit Optimization

27

Association for Computing Machinery, New York, NY, USA, 785–794. doi:10.1145/2939672.2939785 [13] Keith D. Cooper, Philip J. Schielke, and Devika Subramanian. 1999. Optimizing for reduced code space using genetic algorithms. SIGPLAN Not. 34, 7 (May 1999), 1–9. doi:10.1145/315253.314414 [14] Andrew W. Cross, Lev S. Bishop, John A. Smolin, and Jay M. Gambetta. 2017. Open Quantum Assembly Language. arXiv:1707.03429 [quant-ph] https://arxiv.org/abs/1707.03429 [15] Elena Desdentado, Coral Calero, M Ángeles Moraga, and Félix García. 2025. Quantum computing software solutions, technologies, evaluation and limitations: a systematic mapping study: E. Desdentado et al. Computing 107, 5 (2025), 110. [16] Ivan do Carmo Machado, John D. McGregor, Yguaratã Cerqueira Cavalcanti, and Eduardo Santana de Almeida. 2014. On strategies for testing software product lines: A systematic literature review. Information and Software Technology 56, 10 (2014), 1183–1199. doi:10.1016/j.infsof.2014.04.002 [17] Pedro Domingos. 2012. A few useful things to know about machine learning. Commun. ACM 55, 10 (Oct. 2012), 78–87. doi:10.1145/2347736.2347755 [18] Domenik Eichhorn, Tobias Pett, Tobias Osborne, and Ina Schaefer. 2023. Quantum Computing for Feature Model Analysis: Potentials and Challenges. In Proceedings of the 27th ACM International Systems and Software Product Line Conference - Volume A (Tokyo, Japan) (SPLC ’23). Association for Computing Machinery, New York, NY, USA, 1–7. doi:10.1145/3579027.3608971 [19] Norhan Elsayed Amer, Walid Gomaa, Keiji Kimura, Kazunori Ueda, and Ahmed El-Mahdy. 2024. On the optimality of quantum circuit initial mapping using reinforcement learning. EPJ Quantum Technology 11 (03 2024). doi:10.1140/ epjqt/s40507-024-00225-1 [20] Hongxiang Fan, Ce Guo, and Wayne Luk. 2022. Optimizing quantum circuit placement via machine learning. In Proceedings of the 59th ACM/IEEE Design Automation Conference (San Francisco, California) (DAC ’22). Association for Computing Machinery, New York, NY, USA, 19–24. doi:10.1145/3489517.3530403 [21] Edward Farhi, Jeffrey Goldstone, and Sam Gutmann. 2014. A Quantum Approximate Optimization Algorithm. arXiv:1411.4028 [quant-ph] https://arxiv.org/abs/1411.4028 [22] Jingzhi Gong and Tao Chen. 2024. Deep Configuration Performance Learning: A Systematic Survey and Taxonomy. ACM Trans. Softw. Eng. Methodol. 34, 1 (Dec. 2024), 25:1–25:62. doi:10.1145/3702986 [23] Jianmei Guo, Krzysztof Czarnecki, Sven Apel, Norbert Siegmund, and Andrzej Wąsowski. 2013. Variability-Aware Performance Prediction: A Statistical Learning Approach. In 2013 28th IEEE/ACM International Conference on Automated Software Engineering (ASE). IEEE, Palo Alto, CA, USA, 301–311. doi:10.1109/ASE.2013.6693089 [24] Lukas Güthing, Tobias Pett, and Ina Schaefer. 2024. Out-of-the-Box Prediction of Non-Functional Variant Properties Using Automated Machine Learning. In Proceedings of the 28th ACM International Systems and Software Product Line Conference (Dommeldange, Luxembourg) (SPLC ’24). Association for Computing Machinery, New York, NY, USA, 82–87. doi:10.1145/3646548.3676546 [25] Mohammad Abrarul Hasanat, Jason Ludmir, Tirthak Patel, and Rohan Basu Roy. 2026. TuniQ: Autotuning Compilation Passes for Quantum Workloads at Scale for Effectiveness and Efficiency. In Proceedings of the 40th ACM International Conference on Supercomputing (ICS ’26). Association for Computing Machinery, New York, NY, USA, 1322–1336. doi:10.1145/3797905.3807862 [26] Zhimin He, Maijie Deng, Shenggen Zheng, Lvzhou Li, and Haozhen Situ. 2023. GSQAS: Graph Self-supervised Quantum Architecture Search. Physica A: Statistical Mechanics and its Applications 630 (2023), 129286. doi:10.1016/j. physa.2023.129286 [27] Zhimin He, Lvzhou Li, Shenggen Zheng, Yongyao Li, and Haozhen Situ. 2021. Variational quantum compiling with double Q-learning. New Journal of Physics 23, 3 (March 2021), 033002. doi:10.1088/1367-2630/abe0ae [28] Zhimin He, Xuefen Zhang, Chuangtao Chen, Zhiming Huang, Yan Zhou, and Haozhen Situ. 2023. A GNN-based Predictor for Quantum Architecture Search. Quantum Information Processing 22, 2 (2023), 128. doi:10.1007/s11128023-03881-x [29] Tobias Heß, Tim Jannik Schmidt, Lukas Ostheimer, Sebastian Krieter, and Thomas Thüm. 2024. UnWise: High T-Wise Coverage from Uniform Sampling. In Proceedings of the 18th International Working Conference on Variability Modelling of Software-Intensive Systems (Bern, Switzerland) (VaMoS ’24). Association for Computing Machinery, New York, NY, USA, 37–45. doi:10.1145/3634713.3634716 [30] Jack D. Hidary. 2019. Quantum Computing: An Applied Approach (1st ed.). Springer Publishing Company, Incorporated, New York, USA. [31] Patrick Hopf, Nils Quetschlich, Laura Schulz, and Robert Wille. 2025. Improving figures of merit for quantum circuit compilation. In 2025 Design, Automation & Test in Europe Conference (DATE). IEEE, Lyon, France, 1–7. [32] Ching-Yao Huang, Chi-Hsiang Lien, and Wai-Kei Mak. 2022. Reinforcement Learning and DEAR Framework for Solving the Qubit Mapping Problem. In Proceedings of the 41st IEEE/ACM International Conference on Computer-Aided Design (San Diego, California) (ICCAD ’22). Association for Computing Machinery, New York, NY, USA, Article 106,

28

Malkowski et al.

9 pages. doi:10.1145/3508352.3549472 [33] IBM Quantum Platform. 2026. "Official Documentation of the Qiskit Transpiler (Qiskit Version 2.3)". https://web.archive. org/web/20260706115018/https://quantum.cloud.ibm.com/docs/de/api/qiskit/2.3/transpiler. accessed 2026-06-15. [34] Ali Javadi-Abhari, Matthew Treinish, Kevin Krsulich, Christopher J. Wood, Jake Lishman, Julien Gacon, Simon Martiel, Paul D. Nation, Lev S. Bishop, Andrew W. Cross, Blake R. Johnson, and Jay M. Gambetta. 2024. Quantum computing with Qiskit. arXiv:2405.08810 [quant-ph] https://arxiv.org/abs/2405.08810 [35] Christian Kaltenecker, Alexander Grebhahn, Norbert Siegmund, Jianmei Guo, and Sven Apel. 2019. Distance-Based Sampling of Software Configuration Spaces. In 2019 IEEE/ACM 41st International Conference on Software Engineering (ICSE). ACM, Montréal, Canada, 1084–1094. doi:10.1109/ICSE.2019.00112 [36] Styliani I. Kampezidou, Archana Tikayat Ray, Anirudh Prabhakara Bhat, Olivia J. Pinon Fischer, and Dimitri N. Mavris. 2024. Fundamental Components and Principles of Supervised Machine Learning Workflows with Numerical and Categorical Data. Eng 5, 1 (2024), 384–416. doi:10.3390/eng5010021 [37] Abhinav Kandala, Antonio Mezzacapo, Kristan Temme, Maika Takita, Markus Brink, Jerry M Chow, and Jay M Gambetta. 2017. Hardware-efficient variational quantum eigensolver for small molecules and quantum magnets. nature 549, 7671 (2017), 242–246. [38] K KANG. 1990. Feature-Oriented Domain Analysis (FODA) Feasibility Study. [39] Peter M. W. Knijnenburg, Toru Kisuki, and Michael F. P. O’Boyle. 2000. Combined Selection of Tile Sizes and Unroll Factors Using Iterative Compilation. The Journal of Supercomputing 24 (2000), 43–67. https://api.semanticscholar.org/ CorpusID:5831359 [40] Sergiy Kolesnikov, Norbert Siegmund, Christian Kästner, Alexander Grebhahn, and Sven Apel. 2019. Tradeoffs in Modeling Performance of Highly Configurable Software Systems. Software & Systems Modeling 18, 3 (June 2019), 2265–2283. doi:10.1007/s10270-018-0662-9 [41] David Kremer, Victor Villar, Hanhee Paik, Ivan Duran, Ismael Faro, and Juan Cruz-Benito. 2025. Practical and efficient quantum circuit synthesis and transpiling with Reinforcement Learning. arXiv:2405.13196 [quant-ph] https://arxiv.org/abs/2405.13196 [42] Sebastian Krieter, Thomas Thüm, Sandro Schulze, Gunter Saake, and Thomas Leich. 2020. YASA: yet another sampling algorithm. In Proceedings of the 14th International Working Conference on Variability Modelling of Software-Intensive Systems. ACM, Magdeburg Germany, 1–10. doi:10.1145/3377024.3377042 [43] Krieter, Sebastian and Kuiter, Elias and others. 2026. "FeatJAR". https://github.com/FeatureIDE/FeatJAR. accessed 2026-07-06, commit 23f0262. [44] Yunseok Kwak, Won Joon Yun, Soyi Jung, and Joongheon Kim. 2021. Quantum Neural Networks: Concepts, Applications, and Challenges. arXiv:2108.01468 [quant-ph] https://arxiv.org/abs/2108.01468 [45] Sangil Kwon, Akiyoshi Tomonaga, Gopika Lakshmi Bhai, Simon J. Devitt, and Jaw-Shen Tsai. 2021. Gate-based superconducting quantum computing. Journal of Applied Physics 129, 4 (01 2021), 041102. doi:10.1063/5.0029735 [46] Zikun Li, Jinjun Peng, Yixuan Mei, Sina Lin, Yi Wu, Oded Padon, and Zhihao Jia. 2024. Quarl: A Learning-Based Quantum Circuit Optimizer. Proc. ACM Program. Lang. 8, OOPSLA1, Article 114 (April 2024), 28 pages. doi:10.1145/ 3649831 [47] Yi Liu, Yuqiong Jin, and Jinchen Xu. 2025. A Portable Auto-Tuning Framework for Quantum Compilation Optimization Based on D3QN. In Proceedings of the 2025 6th International Conference on Computer Information and Big Data Applications (CIBDA ’25). Association for Computing Machinery, New York, NY, USA, 1422–1428. doi:10.1145/3746709. 3746950 [48] Scott M. Lundberg and Su-In Lee. 2017. A unified approach to interpreting model predictions. In Proceedings of the 31st International Conference on Neural Information Processing Systems (Long Beach, California, USA) (NIPS’17). Curran Associates Inc., Red Hook, NY, USA, 4768–4777. [49] Fan-Xu Meng, Ze-Tong Li, Xu-Tao Yu, and Zai-Chen Zhang. 2021. Quantum Circuit Architecture Optimization for Variational Quantum Eigensolver via Monto Carlo Tree Search. IEEE Transactions on Quantum Engineering 2 (2021), 1–10. doi:10.1109/TQE.2021.3119010 [50] Enrique Moguel, Javier Berrocal, José García-Alonso, and Juan Manuel Murillo. 2020. A Roadmap for Quantum Software Engineering: Applying the Lessons Learned from the Classics.. In Q-Set@QCE. IEEE, conference was held virtually, 5–13. [51] Christoph Molnar. 2025. Interpretable Machine Learning. https://christophm.github.io/interpretable-ml-book [52] Lorenzo Moro, Matteo G. A. Paris, Marcello Restelli, and Enrico Prati. 2021. Quantum compiling by deep reinforcement learning. Communications Physics 4, 1 (Aug. 2021), 1–8. doi:10.1038/s42005-021-00684-3 [53] Vivek Nair, Tim Menzies, Norbert Siegmund, and Sven Apel. 2017. Using bad learners to find good configurations. In Proceedings of the 2017 11th Joint Meeting on Foundations of Software Engineering (Paderborn, Germany) (ESEC/FSE 2017). Association for Computing Machinery, New York, NY, USA, 257–267. doi:10.1145/3106237.3106238

Transpiler Autotuning with Predictive Models for Quantum Circuit Optimization

29

[54] Vivek Nair, Zhe Yu, Tim Menzies, Norbert Siegmund, and Sven Apel. 2020. Finding Faster Configurations Using FLASH. IEEE Transactions on Software Engineering 46, 7 (July 2020), 794–811. doi:10.1109/TSE.2018.2870895 [55] Jeho Oh, Don Batory, Margaret Myers, and Norbert Siegmund. 2017. Finding Near-Optimal Configurations in Product Lines by Random Sampling. In Proceedings of the 2017 11th Joint Meeting on Foundations of Software Engineering (ESEC/FSE 2017). Association for Computing Machinery, New York, NY, USA, 61–71. doi:10.1145/3106237.3106273 [56] Alexandru Paler, Lucian Sasu, Adrian-Catalin Florea, and Razvan Andonie. 2023. Machine Learning Optimization of Quantum Circuit Layouts. ACM Transactions on Quantum Computing 4, 2 (24 Feb. 2023), 1–25. doi:10.1145/3565271 [57] Fabian Pedregosa, Gaël Varoquaux, Alexandre Gramfort, Vincent Michel, Bertrand Thirion, Olivier Grisel, Mathieu Blondel, Peter Prettenhofer, Ron Weiss, Vincent Dubourg, Jake Vanderplas, Alexandre Passos, David Cournapeau, Matthieu Brucher, Matthieu Perrot, and Édouard Duchesnay. 2011. Scikit-learn: Machine Learning in Python. J. Mach. Learn. Res. 12, null (Nov. 2011), 2825–2830. [58] Juliana Alves Pereira, Hugo Martin, Mathieu Acher, Jean-Marc Jézéquel, Goetz Botterweck, and Anthony Ventresque. 2019. Learning Software Configuration Spaces: A Systematic Literature Review. arXiv:1906.03018 [cs] [59] Matteo G. Pozzi, Steven J. Herbert, Akash Sengupta, and Robert D. Mullins. 2022. Using Reinforcement Learning to Perform Qubit Routing in Quantum Compilers. ACM Transactions on Quantum Computing 3, 2, Article 10 (May 2022), 25 pages. doi:10.1145/3520434 [60] John Preskill. 2018. Quantum Computing in the NISQ era and beyond. Quantum 2 (Aug. 2018), 79. doi:10.22331/q2018-08-06-79 [61] Qiskit Github Contributors. 2026. "GitHub Repository for Qiskit Version 2.3.0". https://github.com/Qiskit/qiskit/tree/2. 3.0. accessed 2026-06-15. [62] Nils Quetschlich, Lukas Burgholzer, and Robert Wille. 2023. MQT Bench: Benchmarking Software and Design Automation Tools for Quantum Computing. Quantum 7 (2023), 1062. MQT Bench is available at https://mqt-bench.app/. arXiv:2204.13719 doi:10.22331/q-2023-07-20-1062 [63] Nils Quetschlich, Lukas Burgholzer, and Robert Wille. 2023. Predicting Good Quantum Circuit Compilation Options. In 2023 IEEE International Conference on Quantum Software (QSW). IEEE, Chicago, USA, 43–53. doi:10.1109/qsw59989. 2023.00015 [64] Nils Quetschlich, Lukas Burgholzer, and Robert Wille. 2025. Compiler Optimization for Quantum Computing Using Reinforcement Learning. In Proceedings of the 60th Annual ACM/IEEE Design Automation Conference (DAC ’23). IEEE Press, San Francisco, California, United States, 1–6. doi:10.1109/DAC56929.2023.10248002 [65] Nils Quetschlich, Lukas Burgholzer, and Robert Wille. 2025. MQT Predictor: Automatic Device Selection with DeviceSpecific Circuit Compilation for Quantum Computing. ACM Transactions on Quantum Computing 6, 1, Article 10 (Jan. 2025), 26 pages. doi:10.1145/3673241 [66] Xiangyu Ren, Tianyu Zhang, Xiong Xu, Yi-Cong Zheng, and Shengyu Zhang. 2024. Invited: Leveraging Machine Learning for Quantum Compilation Optimization. In Proceedings of the 61st ACM/IEEE Design Automation Conference (San Francisco, CA, USA) (DAC ’24). Association for Computing Machinery, New York, NY, USA, Article 360, 4 pages. doi:10.1145/3649329.3663510 [67] Jordi Riu, Jan Nogué, Gerard Vilaplana, Artur Garcia-Saez, and Marta P. Estarellas. 2025. Reinforcement Learning Based Quantum Circuit Optimization via ZX-Calculus. Quantum 9 (May 2025), 1758. doi:10.22331/q-2025-05-28-1758 [68] Atrisha Sarkar, Jianmei Guo, Norbert Siegmund, Sven Apel, and Krzysztof Czarnecki. 2015. Cost-Efficient Sampling for Performance Prediction of Configurable Systems (T). In 2015 30th IEEE/ACM International Conference on Automated Software Engineering (ASE). IEEE, Lincoln, USA, 342–352. doi:10.1109/ASE.2015.45 [69] Raphael Seidel, Sebastian Bock, René Zander, Matic Petrič, Niklas Steinmann, Nikolay Tcholtchev, and Manfred Hauswirth. 2024. Qrisp: A Framework for Compilable High-Level Programming of Gate-Based Quantum Computers. arXiv:2406.14792 [quant-ph] https://arxiv.org/abs/2406.14792 [70] Ruslan Shaydulin, Changhao Li, Shouvanik Chakrabarti, Matthew DeCross, Dylan Herman, Niraj Kumar, Jeffrey Larson, Danylo Lykov, Pierre Minssen, Yue Sun, et al. 2024. Evidence of scaling advantage for the quantum approximate optimization algorithm on a classically intractable problem. Science Advances 10, 22 (2024), eadm6761. [71] Norbert Siegmund, Alexander Grebhahn, Sven Apel, and Christian Kästner. 2015. Performance-Influence Models for Highly Configurable Systems. In Proceedings of the 2015 10th Joint Meeting on Foundations of Software Engineering (ESEC/FSE 2015). Association for Computing Machinery, New York, NY, USA, 284–294. doi:10.1145/2786805.2786845 [72] Norbert Siegmund, Sergiy S. Kolesnikov, Christian Kästner, Sven Apel, Don Batory, Marko Rosenmüller, and Gunter Saake. 2012. Predicting Performance via Automated Feature-Interaction Detection. In 2012 34th International Conference on Software Engineering (ICSE). IEEE, Zurich, Switzerland, 167–177. doi:10.1109/ICSE.2012.6227196 [73] Seyon Sivarajah, Silas Dilkes, Alexander Cowtan, Will Simmons, Alec Edgington, and Ross Duncan. 2020. t|ket〉: a retargetable compiler for NISQ devices. Quantum Science and Technology 6, 1 (Nov. 2020), 014003. doi:10.1088/20589565/ab8e92

30

Malkowski et al.

[74] Krysta Svore, Alan Geller, Matthias Troyer, John Azariah, Christopher Granade, Bettina Heim, Vadym Kliuchnikov, Mariia Mykhailova, Andres Paz, and Martin Roetteler. 2018. Q#: Enabling Scalable Quantum Computing and Development with a High-level DSL. In Proceedings of the Real World Domain Specific Languages Workshop 2018 (Vienna, Austria) (RWDSL2018). Association for Computing Machinery, New York, NY, USA, Article 7, 10 pages. doi:10.1145/3183895.3183901 [75] Michael Swaddle, Lyle Noakes, Harry Smallbone, Liam Salter, and Jingbo Wang. 2017. Generating three-qubit quantum circuits with neural networks. Physics Letters A 381, 39 (2017), 3391–3395. doi:10.1016/j.physleta.2017.08.043 [76] Wei Tang, Yiheng Duan, Yaroslav Kharkov, Rasool Fakoor, Eric Kessler, and Yunong Shi. 2024. AlphaRouter: Quantum Circuit Routing with Reinforcement Learning and Tree Search. arXiv:2410.05115 [quant-ph] https://arxiv.org/abs/ 2410.05115 [77] Thomas Thüm, Christian Kästner, Fabian Benduhn, Jens Meinicke, Gunter Saake, and Thomas Leich. 2014. FeatureIDE: An extensible framework for feature-oriented software development. Science of Computer Programming 79 (2014), 70– 85. Experimental Software and Toolkits (EST 4): A special issue of the Workshop on Academic Software Development Tools and Techniques (WASDeTT-3 2010). doi:10.1016/j.scico.2012.06.002 [78] Teague Tomesh, Pranav Gokhale, Victory Omole, Gokul Subramanian Ravi, Kaitlin N. Smith, Joshua Viszlai, XinChuan Wu, Nikos Hardavellas, Margaret R. Martonosi, and Frederic T. Chong. 2022. SupermarQ: A Scalable Quantum Benchmark Suite. arXiv:2202.11045 [quant-ph]. doi:10.48550/arXiv.2202.11045 [79] Antonio Tudisco, Deborah Volpe, Giacomo Orlandi, and Giovanna Turvani. 2025. Graph Neural Network-Based Predictor for Optimal Quantum Hardware Selection. In 2025 IEEE International Conference on Quantum Computing and Engineering (QCE). IEEE, Albuquerque, USA, 296–301. doi:10.1109/qce65121.2025.10339 [80] Unnamed Contributors. 2026. "Supplementary Material for the publication called Transpiler Autotuning with Predictive Models for Quantum Circuit Optimizations". https://github.com/poplrandomauthor/popl-quantum-transpilerautotuning. accessed 2026-07-09. [81] Krishna Upadhyay, Vinaik Chhetri, AB Siddique, and Umar Farooq. 2025. Analyzing the Evolution and Maintenance of Quantum Software Repositories. In 2025 IEEE International Conference on Quantum Software (QSW). IEEE, Helsinki, Finland, 173–184. [82] Hanrui Wang, Yongshan Ding, Jiaqi Gu, Yujun Lin, David Z. Pan, Frederic T. Chong, and Song Han. 2022. QuantumNAS: Noise-Adaptive Search for Robust Quantum Circuits. In 2022 IEEE International Symposium on High-Performance Computer Architecture (HPCA). IEEE, Seoul, South Korea, 692–708. doi:10.1109/HPCA53966.2022.00057 [83] Xuanhui Wang, Cheng Li, Nadav Golbandi, Michael Bendersky, and Marc Najork. 2018. The LambdaLoss Framework for Ranking Metric Optimization. In Proceedings of the 27th ACM International Conference on Information and Knowledge Management (Torino, Italy) (CIKM ’18). Association for Computing Machinery, New York, NY, USA, 1313–1322. doi:10.1145/3269206.3271784 [84] Zheng Wang and Michael O’Boyle. 2018. Machine Learning in Compiler Optimization. Proc. IEEE 106, 11 (2018), 1879–1901. doi:10.1109/JPROC.2018.2817118 [85] C. Yilmaz, M.B. Cohen, and A.A. Porter. 2006. Covering Arrays for Efficient Fault Characterization in Complex Configuration Spaces. IEEE Transactions on Software Engineering 32, 1 (Jan. 2006), 20–34. doi:10.1109/TSE.2006.8 [86] Yi Zhang, Jianmei Guo, Eric Blais, and Krzysztof Czarnecki. 2015. Performance prediction of configurable software systems by fourier learning. In Proceedings of the 30th IEEE/ACM International Conference on Automated Software Engineering (ASE ’15). IEEE Press, Lincoln, Nebraska, USA, 365–373. doi:10.1109/ASE.2015.15 [87] Yuan-Hang Zhang, Pei-Lin Zheng, Yi Zhang, and Dong-Ling Deng. 2020. Topological Quantum Compiling with Reinforcement Learning. Phys. Rev. Lett. 125 (Oct 2020), 170501. Issue 17. doi:10.1103/PhysRevLett.125.170501 [88] Marcela Zuluaga, Andreas Krause, and Markus Püschel. 2016. E-PAL: An Active Learning Approach to the MultiObjective Optimization Problem. Journal of Machine Learning Research 17, 104 (2016), 1–32.

Related documents

• Shortcutting the Fix: Identifying and Categorizing Agentic Exploits in Software Engineering Benchmarks#668134
• CAROL: Context-Aware Online Learning for Fuzzer Scheduling#668135
• An Autonomy Aware Metamodel for Human AI Collaboration in Software Engineering#668136
• A Unified Policy Architecture (UPA): The Governance Kernel for Enterprise AI Operating Systems#668137
• From Reading Code to Reading Spec: A Verified Layer for LLM-Driven Codebase Maintenance#668138