Quantum Circuit Synthesis Using Fuzzy-Logic-Assisted Genetic Algorithms

Abstract

Quantum algorithms will likely play a key role in future high-performance-computing (HPC) environments. These algorithms are typically expressed as quantum circuits composed of arbitrary gates or as unitary matrices. Executing these on physical devices, however, requires translation to device-compatible circuits, in a process called quantum compilation or circuit synthesis, since these devices support a limited number of native gates. Moreover, these devices typically have specific qubit topologies, which constrain how and where gates can be applied. Consequently, logical qubits in input circuits and unitaries may need to be mapped to and routed between physical qubits. Furthermore, current Noisy Intermediate-Scale Quantum (NISQ) devices present additional constraints. They are vulnerable to errors during gate application and their short decoherence times lead to qubits rapidly succumbing to accumulated noise and possibly corrupting computations. Therefore, circuits synthesized for NISQ devices need to minimize gates and execution times. The problem of synthesizing device-compatible circuits, while optimizing for low gate count and short execution times, can be shown to be computationally intractable using analytical methods. Therefore, interest has grown towards heuristics-based synthesis techniques, which are able to produce approximations of the desired algorithm, while optimizing depth and gate-count. In this work, we investigate using genetic algorithms (GA)—a proven gradient-free optimization technique based on natural selection—for circuit synthesis. In particular, we formulate the quantum synthesis problem as a multi-objective optimization (MOO) problem, with the objectives of minimizing the approximation error, number of multi-qubit gates, and circuit depth. We also employ fuzzy logic for runtime parameter adaptation of GA to enhance search efficiency and solution quality in our proposed method.

1. Introduction

Among several potential post-Moore technologies, quantum computing has emerged as a promising candidate, showing significant theoretical speedups in certain workloads compared to classical computers [1,2,3]. As a result, quantum computing has received significant interest from researchers in many diverse fields [4], including the high-performance-computing (HPC) community. However, executing quantum algorithms on physical devices remains a challenge. Quantum algorithms, once developed, need to be converted into a quantum circuit compatible with the target device on which it will be executed. This is because physical devices typically support a limited number of gates, and all circuits executed on them must be expressed using only these gates. The process of converting an input quantum algorithm to a machine’s native basis gate-set, is termed quantum compilation or quantum circuit synthesis. Circuit synthesis is also subject to additional constraints. In a given quantum device, multi-qubit gates may only be applicable between a limited set of qubits [5], determined by the connectivity or topology of the qubits. Thus, routing and mapping of logical qubits between physical qubits on the machine may be required. Since routing is typically achieved using gates during execution, it becomes desirable to optimize routing to minimize gate overhead.

Moreover, current generation Noisy Intermediate-Scale Quantum (NISQ) [6] devices are very susceptible to environmental noise. The state of qubits can rapidly become corrupted, in a process called decoherence [7,8], causing errors in any running computation. Thus, circuits need to be designed with sufficiently short execution times, measured by circuit depth, to ensure acceptable fidelity of results. In addition, the application of gates, particularly multi-qubit gates such as CNOT, can also introduce errors [9]. Therefore, it is beneficial to have circuits with as few gates as possible.

The process of synthesizing a circuit for a target machine, while accounting for the machine-dependent constraints mentioned above, can be shown to be a computationally difficult problem and in some cases intractable [10]. Analytical methods are, therefore, unsuitable in the general case for all but the smallest qubit counts. Practical state-of-the-art optimizing compilers that seek to address these constraints attempt to produce approximate results, often using heuristics-based techniques, in order to generate circuits optimized for NISQ device constraints at the cost of some compilation error [11]. However, one key challenge approximate compilers face when synthesizing quantum circuits for NISQ devices is that the imposed constraints can be in conflict with each other. For example, better approximations may be achieved with longer circuits, increasing risk of decoherence, while shorter depth targets reduce flexibility for the compiler, making it difficult to achieve compilation error targets.

To address this challenge, in this work, we model quantum circuit synthesis for NISQ devices as a multi-objective optimization (MOO) problem and propose a genetic-algorithm-based (GA) [12,13] synthesis technique. In particular, we leverage the Non-dominated Sorting Genetic Algorithm variant II (NSGA-II) [14], a MOO-specific GA, for the simultaneous optimization of approximation error, circuit depth and number of CNOT gates in synthesized circuits. GAs are a class of gradient-free optimization techniques inspired by the process of natural selection and known for their guaranteed convergence [15], ability to escape local minima and inherent parallelization potential. We also propose a runtime parameter adaptation mechanism leveraging fuzzy logic [16] to improve GA efficiency. Fuzzy logic enables us to formulate the GA runtime parameter update mechanism using sophisticated linguistically defined variables and relationships, with the ability to tune how these are interpreted. Our contributions in this work can be summarized as follows:

• Propose a GA-based quantum circuit synthesis algorithm which synthesizes machine-compatible circuits from a given unitary.
• Leverage existing MOO techniques to optimize multiple synthesis objectives simultaneously, minimizing approximation error, circuit depth and number of gates, specifically multi-qubit gates such as CNOTs.
• Propose a fuzzy logic based runtime parameter adaptation method for our GA to improve search efficiency and solution quality.
• Accelerate GA implementation through parallelization.

The remaining sections in this paper are structured as follows: Section 2 presents brief descriptions of necessary background material, while Section 3 discusses related existing literature. Section 4 details the proposed algorithm, Section 5 presents experimental evaluation results and finally, Section 6 and Section 7 provide closing discussions, future work directions and conclusions.

2. Background

In this section, we first take a look at key background material needed to understand quantum circuit synthesis. Following that, we present brief introductions to genetic algorithms and fuzzy logic, and refer the interested reader to material for further study.

2.1. Quantum Circuit Basics

Quantum computing is a system of computation which relies on the principles of quantum mechanics [17]. In particular, it relies on superposition [18], which states that a quantum object can exist in a combination of its possible states simultaneously and entanglement [18], which enables quantum objects to become strongly correlated. A qubit is the fundamental unit of quantum computation and it can exist in a superposition of two basis states $|0\rangle$ and $|1\rangle$, with probability amplitudes that determine measurement outcomes. The state of a single qubit, expressed as a vector $|\psi \rangle$, can be written as a linear combination of the probability amplitudes of its corresponding basis states, $|\psi \rangle =c_0|0\rangle +c_1|1\rangle$. Similarly, an n-qubit state can be written as $|\psi \rangle ={\sum }_{i=0}^{2^n-1}{c}_i|i\rangle$, where ${\sum }_{i=0}^{2^n-1}{\left|c_i\right|}^2=1$, $c_i\in \mathbb{C}$. Operations on qubits are called quantum gates, and can be mathematically represented by unitary operators or matrices [19]. An operator is considered unitary if its matrix U satisfies $U{U}^{†}=I$, where $U^{†}$ is the conjugate transpose. Two quantum operations U and V are considered equivalent, up to a global phase $\theta$, if $U^{†}V=e^{i\theta }I$.

Quantum computations evolve a statevector through unitary operations which can be represented as matrix-vector multiplications, $U|{\psi }_{in}\rangle =|{\psi }_{out}\rangle$. Multiple quantum operations can be combined into a single unitary operation, where gates applied in series can be modeled as matrix multiplications, while parallel gates are described by Kronecker products. Thus, any circuit can be reduced to a single unitary matrix. In some cases, a unitary operation could also be decomposed into a sequence of smaller individual operations. This property is crucial for quantum compilation. The circuit model, or gate model, is a universal framework for quantum computation, representing quantum operations as gates acting on qubits [20], with time flowing from left to right. In this model, qubits are depicted as wires, and gates placed on those wires represent quantum operations acting on those qubits. Gates that can be applied in parallel form a layer. The total number of layers in a circuits is called its depth, and determines the execution time of the circuit; see Figure 1.

2.2. Quantum Circuit Compilation and Synthesis

Quantum circuit compilation, or circuit synthesis, is the process of converting quantum operations into a circuit compatible with the target device. A finite set of gates, called a basis gate set, can be used to construct all possible quantum operations [20]. Quantum devices usually implement such a gate set, referred to as its native basis gate set. In this work, we specifically refer to the process of converting an input unitary matrix to a machine-compatible circuit as ‘quantum circuit synthesis’. Since connectivity of qubits is required for applying certain gates [5], the structure of qubit connectivity, called the qubit topology, is an integral part of quantum compilation. It determines where gates can be applied and if any routing is necessary to move logical qubits to appropriate physical qubits [5,21]. However, routing generally requires application of additional gates (e.g., CNOT or SWAP gates [22]), which can increase the circuit depth and introduce gate errors; see Figure 2. Since NISQ devices have short decoherence times and high noise sensitivity, it is crucial to reduce the circuit depth and number of gates. Therefore, optimizing compilers for these devices must attempt to minimize the circuit depth, as well as the number of gates. In addition, to minimize the routing overhead, compilers will also attempt to optimize the mapping between logical and physical qubits, attempting to place qubits with higher levels of interaction close to each other, such that fewer routing gates are required; see Figure 3.

Compilation can be categorized into two types: exact, which produces a circuit equivalent to the original operation up to a global phase, and approximate, which approximates the original operation with some error. Exact synthesis techniques generally result in very high circuit depths and gate counts, and generating exact circuits of optimal depth can be computationally unfeasible for anything but the smallest qubit counts. Hence, many modern optimizing compilers trade-off approximation error for reduced circuit depth and gate count. The primary compiler provided by the IBM Qiskit framework [23] is an example of an exact compiler, while the BQSkit compiler [11] is an example of an approximate compiler (which can also perform exact compilation).

2.3. Genetic Algorithms

In this section, we take a brief look at GAs, which are search-based, gradient-free, optimization algorithms inspired by the process of natural selection and survival of the fittest [12]. GAs start with a population of potential solutions, called members or individuals. Much like biological life, each individual is characterized by a chromosome, composed of smaller units called genes. The genes encode specific characteristics of the overall solution represented by the chromosome. The encoding scheme is therefore essential for the success of the GA and can determine the size of the search space, time to convergence, and overall quality of solutions. A fitness function is used to evaluate solutions and rank them based on their quality. Fitness functions can be maximizing or minimizing and they can be designed to track single or multiple objectives.

The population undergoes a reproduction step to produce a new generation of individuals from the first. There are two processes that are generally used to achieve this—crossover and mutation. In the process of crossover, individuals, called parents, are combined to produce new individuals, called offspring. Parents are usually chosen with consideration to their relative fitness within the population. For example, individuals with greater fitness can be chosen to try to increase the fitness of the population. However, maintaining population diversity is crucial to prevent premature convergence. To balance these factors, several selection processes exist with various trade-offs. In addition to crossover, a mutation operation is also applied randomly to a subset of the population. This operation causes random modifications to chromosomes and increases the genetic diversity of the population. Here, diversity refers to the chromosomal variation between individuals within a population. This is necessary for the GA to search wide areas within the problem space and escape local minima/maxima [13,24].

Once the reproduction step is complete, the survival step determines which individuals in the population will survive and carry on to the next generation. An ideal survival step aims to preserve the most desirable traits and while maintaining diversity. To guarantee that the population will eventually converge to an optimal solution, it is important to implement elitism—a process where the best individuals survive from generation to generation. Survival strategies differentiate GAs from unstructured random search, the latter not utilizing already discovered solutions to search future ones. This step ensures that each generation is progressively more desirable than the last. The iterations (or generations) of evaluation, crossover, mutation, and survival, halt when a specified end criteria is achieved.

2.4. Non-Dominated Sorting Genetic Algorithms (NSGA)

Multi-objective optimization (MOO) problems involve optimizing different, often competing, objectives simultaneously. These problems typically do not have a single best solution. Instead, they are characterized by a range of non-dominated or Pareto optimal solutions. A non-dominated solution is one which cannot be improved in one objective without causing degradation in another. Algorithms targeting MOO problems attempt to produce a set of non-dominated solutions, called a Pareto front, which characterizes the trade-offs between objectives in the solution space. In a MOO problem instance, the fitness of a solution might be characterized by a vector $\mathbf{x}=[x_0,\dots ,x_{n-1}]$ where each $x_i,0\le i<n$ is an objective value. A solution with vector $\mathbf{a}=[a_0,\dots ,a_{n-1}]$ is said to dominate another solution with vector $\mathbf{b}=[b_0,\dots ,b_{n-1}]$ if and only if (1) and (2) hold true. The number of other solutions which dominate a given solution is sometimes referred to as its domination level or rank in the set of solutions. A Pareto front is, therefore, a set of solutions which have a rank of 0.

$$\forall i,0\le i<n,a_i\mathbf{equal}\mathbf{or}\mathbf{better}\mathbf{than}{b}_i$$

(1)

$$\exists i,0\le i<n,a_i\mathbf{strictly}\mathbf{better}\mathbf{than}{b}_i$$

(2)

Due to their flexibility, many GAs have been proposed which attempt to target MOOs [14,25,26,27,28,29]. One such family of algorithms is called the Non-domintated Sorting Genetic Algorithm (NSGA) [14,25,28]. NSGAs operate by performing a non-dominated sort on the population which ranks solutions with a lower domination level as better. Over time, the GA discards dominated solutions while preserving non-dominated ones, progressing toward the Pareto front of the solution space. In this work, we leverage the NSGA-II [14] variant for our quantum compiler. We chose this over the newer NSGA-III [28] because our proposed work targets three objectives, which is within the threshold of NSGA-II, and thus we can avoid the additional processing overhead of NSGA-III without any loss of efficacy.

2.5. Fuzzy Logic

Fuzzy logic is a mathematical framework that extends classical binary logic to handle degrees of truth [16]. It assigns fractional values between 0 and 1 to variables to indicate its degree of membership to a given state/category. For example, a fuzzy variable, with states “HIGH”, “MEDIUM” and “LOW”, could be 80% “HIGH”, 15% “MEDIUM” and 0.5% “LOW”, simultaneously. The degree of membership in one category can be independent of the degree of membership in another. This approach allows us to model uncertainty and overlap in real-world phenomena, similar to human linguistic reasoning [30]. Fuzzy variables can be combined using the fuzzy equivalents of Boolean operators such as AND and OR (refer to

Table 1. Fuzzy equivalent of Boolean operators.

Boolean Operator	Fuzzy Equivalent
$AND(a,b)$	$min(a,b)$
$OR(a,b)$	$max(a,b)$
$NOT\left(a\right)$	$1-a$

), allowing intuitive, linguistically defined, input–output relationships. Numerical input values (crisp values), are processed into fuzzy variables via membership functions, which map values to states characterized by degrees of membership to different categories. While these functions, often designed based on expert knowledge, can be arbitrary, they are often triangular, sinusoidal, Gaussian, or trapezoidal, and allow variables to belong to multiple categories simultaneously. The outputs can be defuzzified using methods such as the centroid method [31].

3. Related Work

Several exact analytical compilation techniques have been proposed in the current literature [32,33,34,35], each using different compilation techniques and mathematical frameworks [36,37], with different goals and objectives. Many of these have also been incorporated into industry standard compilation frameworks [38]. Additionally, exact compilation techniques often incorporate staged compilation, where an initial compiled circuit is further optimized using dedicated depth reduction techniques [39,40]. However, exact techniques are limited by two prevailing factors. First, exact compilers generate very deep circuits that are unsuitable for NISQ hardware, which have very short decoherence times. Second, attempts to produce optimal depth circuits, while adhering to qubit topologies, quickly become computationally infeasible for all but the smallest of qubit sizes using these methods.

To overcome these limitations, approximate methods trade-off compilation error to produce circuits with reduced depths and/or fewer gates while also trying to be scalable to a higher number of qubits. These compilers use various types of optimization techniques, such as numerical instantiation [11,41,42,43,44,45], SAT-solvers [46] and other methods [47]. We refer the interested reader to a detailed survey of many such compilation methods that have been presented in [48].

GA-based compilation methods are a subcategory of approximate compilation. Several GA-based techniques have been proposed which target circuit compilation, generation, discovery and related tasks. For instance, a simple three-qubit quantum teleportation circuit was evolved using a GA in [49], while [50] introduced an encoding scheme to represent quantum circuits as 1-dimensional array chromosomes. Lukac et al. developed a GA-based circuit synthesis technique that analyzes circuit costs in terms of number of gates used and utilizes predetermined quantum operation primitives to generate low-cost quantum circuits [51]. The Q-PACE framework introduced in [52] leveraged Genetic Programming (GP) [53] to evolve optimized quantum circuits, programs, and algorithms. Ruican et al. proposed a software flow for quantum circuit synthesis with runtime adaptation of GA parameters based on operator performance [54]. Potoček et al. utilized a Non-dominated Sorting Genetic Algorithm (NSGA) for multi-objective circuit synthesis, with objectives of circuit error and cost reduction, incorporating unique genetic operators specifically designed for quantum circuits [54]. Another novel technique utilized evolutionary methods that leverage quantum computers to produce optimized circuits [55]. The work in [56] introduced the use of island GAs [57], which promote diverse evolution trajectories by running separate, mutually exclusive instances of GAs, occasionally allowing crossover between these instances to enhance the search for optimal solutions. The GA4QCO framework [58] proposed a comprehensive set of crossover and mutation methods, along with an encoding scheme that represents circuits as 2-dimensional arrays of gates, allowing for a wide range of genetic operations and allows the user to set ad hoc fitness functions. GAs have also been used in tasks adjacent to quantum compilation, such as discovering unitary matrices [59], optimizing specific algorithms [60], and minimizing routing overhead in circuits [61]. Additionally, GA-based techniques for quantum state preparation have been developed to produce efficient circuits that generate desired quantum states, as demonstrated by Creevey et al. in [62] and the work using the NSGA-II algorithm in [63].

One more area of research where GAs have seen a lot of interest in is variational quantum circuits. Variational quantum circuits provide an effective and resourceful method for utilizing error-prone NISQ devices to perform optimization, simulation, and machine-learning tasks. Various studies have explored the synthesis and tuning of variational circuits using GAs for different purposes. Some research works have focused on discovering effective ansatzes for use in variational algorithms [64,65,66]. Other studies have concentrated on tuning the free parameters of these circuits to optimize their performance [67]. Additionally, some works have aimed to compile noise-limiting circuits using GAs [68].

We now briefly discuss how our work differentiates itself from the existing literature. Our proposed method performs approximate circuit synthesis directly from an arbitrary unitary for a target quantum device, accounting for qubit connectivity. It incorporates and optimizes three compilation objectives simultaneously: approximation error, depth, and gate counts. Our approach leverages the NSGA-II algorithm with modifications, includes qubit mapping strategies and utilizes a nested numerical optimization step to tune parameterized gates. It further enhances the GA through runtime parameter adaptation using a fuzzy logic controller, and is, to our knowledge, the first work to combine fuzzy logic in GA-based circuit synthesis. We also provide parallelization strategies for acceleration of the implementation and perform experimental comparison with industry-standard quantum compilers, making it a comprehensive and unique contribution to the field of GA-based quantum circuit synthesis. Further, by using a GA, our proposed work is also able to avoid many of the limitations of gradient based techniques, such as local minima and unguaranteed convergence. Finally, while our proposed method is able to incorporate several objectives during compilation, and the NSGA technique makes it possible to add more.

4. Materials and Methods

In this section, we discuss the construction of the GA-based circuit synthesizer. We formally describe the problem, followed by an overview of the proposed solution. We then go into details of each component of the GA. Finally, we include some discussions about efforts to accelerate the GA.

4.1. Problem Description

We assume as input a unitary matrix $U_{in}$ which needs to be synthesized for a specific target device. We also provide as input the native basis gate set B and qubit topology T of the target. Our compiler is then required to synthesize a circuit $C_{syn}$, with an equivalent unitary $U_{syn}$, using gates $g\in B$ and adhering to topology T for multi-qubit gate placement. Let $\mathbf{E}(U_{in},C_{syn})$ be the approximation error between $U_{in}$ and $U_{syn}$, $\mathbf{D}\left(C_{syn}\right)$ be the depth of $C_{syn}$, which is used as a metric for execution time, and ${\mathbf{G}}_{\mathbf{n}}\left(C_{syn}\right)$ be the number of n-qubit gates, used as a metric to estimate gate error. In our work $n=2$, since we only consider CNOT gates. The goal of the GA-based compiler is to simultaneously minimize $\mathbf{E}$, $\mathbf{D}$ and ${\mathbf{G}}_{\mathbf{2}}$, possibly with a target threshold $ϵ$ for $\mathbf{E}$.

We can, therefore, formally define our optimization problem as:

$$\begin{array}{cc}\hfill \underset{C_{syn}}{min}& \mathbf{F}\left(C_{syn}\right)=[\mathbf{E}(U_{in},C_{syn}),\mathbf{D}\left(C_{syn}\right),{\mathbf{G}}_{\mathbf{2}}\left(C_{syn}\right)]\hfill \\ \hfill \mathrm{subject}\mathrm{to}& g\in B,\forall g\in C_{syn}\hfill \\ \hfill & g\mathrm{is}\mathrm{valid}\mathrm{in}T,\forall g\in C_{syn}\mathrm{where}g\mathrm{is}\mathrm{multi}\text{-}\mathrm{qubit}\hfill \\ \hfill & \mathbf{E}(U_{in},C_{syn})\le ϵ(\mathrm{optional}\mathrm{constraint})\hfill \end{array}$$

At this point we note that this optimization problem, which includes optimizing both a combinatorial problem (placement of gates in the circuit) and a continuous one (tuning gate parameters), is non-convex by nature [47]. It is characterized by a complex solution landscape with multiple local minima. This problem is also non-linear, since it involves non-linear components such as the optimization of parametric gates.

4.2. GA-Based Compiler Overview

To address the problem described above, in this work, we propose a synthesis technique based on NSGA-II, a GA used for MOO problems. In this section, we describe the high level flow of the proposed technique, shown in Figure 4, and subsequent sections discuss each component of the technique. The compiler begins with an input unitary matrix, $U_{in}$, and starts the compilation process by generating an initial population of randomly generated chromosomes, each of which encode a random quantum circuit. The population size, $N_{pop}$, can be specified by the user, but is ideally adjusted to fully utilize available computational resources. The chromosomes are evaluated, using (6), and the equivalent fitness vector assigned to each chromosome. The population members are then ranked and sorted using the NSGA-II technique and the GA is now ready to begin the main loop.

The first step in the loop is parent selection for producing offspring. In our proposed technique, we keep the population size constant to constrain the design complexity and to reduce the computational burden of having a growing population. Thus, each generation, the compiler produces a fixed number of offspring, also equal to $N_{pop}$. At the start of a generation, pairs of parents are selected to produce two offspring. Limiting the number of offspring per parent pair to two allows more chromosomes to participate in the crossover process since the total number of offspring in a generation is kept constant. Thus, ${\displaystyle \frac{N_{pop}}{2}}$ parent pairs are chosen to produce $N_{pop}$ offspring.

After parent selection, the parents are mutated probabilistically and the mutation rate/probability allows the GA to control the diversity of the population. After mutation, the parents are crossed over, the offspring evaluated for their fitness and merged with the initial population. After the merge, the combined temporary population, of size $2N_{pop}$, is re-ranked and sorted using NSGA-II sorting. If the stopping criteria is met, the best circuit found so far is returned. Otherwise, the bottom half of the population is discarded and the GA moves on to the next generation. However, if runtime parameter adaptation is enabled, the progress statistics and current mutation rates are used to adjust the mutation rate for the next generation using a fuzzy controller.

4.3. Encoding

For a GA-based quantum compiler, encoding involves representing quantum circuits as chromosomes that are compatible with genetic operators. The encoding method used in this work (see Figure 5) was selected after careful investigation of several different schemes with various trade-offs. To encode a circuit as a chromosome, we represent the circuit as a sequence of layers, where each layer consists of gates applied in parallel. Within each layer, a qubit is allowed to be part of only one gate, and gate placements that violate this requirement are incompatible with the scheme. Crossover and mutation are allowed at the level of layers as well as gates, and are discussed further in the following sections. However, one important point to note here is that the process of mutation and crossover can result in layers in offspring with incompatible gates. In the case of crossover, if multiple gates are incompatible, one of them is selected at random and the rest are discarded (and replaced with I gates where appropriate). In the case of mutation, if an incompatible gate is introduced, the new gate is always kept and the old is discarded in order to make the mutation successful.

This scheme also encodes initial qubit mappings and final output qubit mappings. This enables a GA to search across different qubit mapping and routing configurations, in addition to different gate layouts. By nature of being a bottom-up synthesis technique, the GA automatically attempts to discover advantageous mapping and routing scenarios, the latter of which is embedded into the evolved circuit. The input and output mappings also take part in the crossover and mutation process. The encoding scheme is summarized in Figure 5.

4.4. Crossover

In the proposed method, we utilized three different types of crossover operations. In the first crossover operation, complete layers from each chromosome are selected uniformly at random [69] to produce an offspring, as shown in Figure 6a. In the second crossover operation, individual gates from each chromosome are selected uniformly at random, as shown in Figure 6b. We refer to these crossover operations as coarse-grained crossover and fine-grained crossover, respectively. Finally, for the third crossover operation, the input and output qubit mappings are swapped, as shown in Figure 6c. Further, each of these crossover operations act on two parents and yield two offspring. At runtime, a random crossover operation is chosen out of the three and applied between two parents.

During the crossover step, the parents can be selected based on fitness relative to others in the population in order to pass on their genes. If only chromosomes with the best fitness are chosen as parents, then high selection pressure [70] is created. A high selection pressure can speed up convergence by only promoting the best solutions to move forward. However, it can also lead to premature convergence [70,71]. On the other hand, low selection pressure is created when chromosomes with both inferior and superior fitness have similar chances of being chosen as parents. In this case, the genetic exploration is better compared to the high selection pressure scenario since more diverse individuals can participate in reproduction, reducing the risk of premature convergence. However, low selection pressure can slow down convergence. To ensure diversity and steady convergence, we use tournament selection [70,72] for parent selection, as described in Algorithm A1 in Appendix B.1. In this technique, tournament size number of chromosomes are randomly chosen to compete and the chromosome with the best fitness among the selected cohort is selected to be a parent. This process is repeated until the desired number of parents have been obtained. It is worth noting that selection pressure is directly correlated with tournament size. Smaller tournament sizes result in lower selection pressure due to increased randomness in cohort selection, while larger tournament sizes lead to higher selection pressure, as they increase the likelihood of selecting only the highest-fitness individuals in the cohort.

Tournament selection is a proven selection mechanism that provides a broader selection net while allowing control over the influence of fitness (rank) by adjusting the tournament size. In contrast, purely rank-based selection, where parents are chosen exclusively based on fitness, often leads to repeated selection of a limited number of high-ranking chromosomes, resulting in a saturated population with low diversity. Therefore, tournament selection promotes higher diversity compared to purely rank-based methods. In our tests, we use a tournament size of 2.

4.5. Mutation

Genetic algorithms use mutations to ensure diversity of solutions and, thus, avoid local minima. In this work, we utilize three different mutation schemes, coarse-grained mutation, fine-grained mutation, and mapping mutation, similar to the crossover methods described in Section 4.4. The first two schemes perform mutation at different levels of granularity. Coarse-grained mutations, as shown in Figure 7a, are used to introduce mutations at the level of layers and has three variants: layer update, layer addition and layer deletion. The layer update mutation replaces a randomly chosen layer with a randomly generated layer, keeping the depth constant. The layer addition and deletion variants randomly insert or delete a layer, respectively, increasing or decreasing the depth, and can be used to roughly control the average circuit depth of the population. Fine-grained mutations, as shown in Figure 7b, are used to perform individual gate mutations inside a layer and has two variants: gate removal and gate update. In gate removal, a gate is replaced by an identity gate. On the other hand, gate update replaces a gate with a new randomly selected gate from the input basis gate set. To handle the edge case described in Section 4.3, where mutation introduces a gate incompatible with other gates in the layer, the original gate is always removed and replaced with the new gate as a policy. Finally, the initial and final mappings also undergo mutation, as shown in Figure 7c. To perform a mutation on a chromosome, a random mutation out of fine-grained, coarse-grained and mapping mutation schemes is chosen at random. Further, the mutation rate and number of mutations are adjustable parameters to the GA.

4.6. Fitness Evaluation

Fitness functions are key to efficient GAs, as they guide the algorithm toward optimal solutions. While a naive fitness function may be used, which directly models the input problem, fitness functions can be enhanced with additional metrics to enable better search efficiency and faster convergence. Since efficient synthesis of quantum circuits for NISQ devices require simultaneous optimization of multiple objectives, the NSGA-II algorithm proves itself as a suitable candidate. Specifically, it allows the use of different objective metrics without needing to normalize them, assign weights to them or combine them into a single metric. This alleviates many of the issues which appear when trying to combine multiple metrics into a single one (e.g., using Euclidean distance). We discuss some of these issues in Appendix A for the interested reader.

For a given chromosome, with circuit $C_{syn}$ and unitary $U_{syn}$, the approximation error $\mathbf{E}(U_{in},C_{syn})$, shown in (3), is based on the Hilbert–Schmidt distance, and is adapted from [42]. This method is chosen over the more familiar Frobenius distance [73], ${\Delta }_F=\left|\right|U_{in}^{†}{U}_{syn}-I\left|\right|$, since the latter is not tolerant of global phase [42]. The chosen error function generates an error value between 0 and 1, where 0 indicates equivalence of two circuits/unitaries and 1 indicates maximal error. The depth $\mathbf{D}\left(U_{syn}\right)$, and CNOT count ${\mathbf{G}}_{\mathbf{2}}\left(U_{syn}\right)$ are obtained trivially by counting the number of layers and CNOT gates, respectively. The final fitness vector is therefore as shown in (6).

$$\mathbf{E}(U_{in},C_{syn})=1-{\displaystyle \frac{\left|\mathbf{Tr}\right(U_{target}^{†}{U}_{syn}\left)\right|}{N}}\mathrm{where},N=2^n,n=\mathrm{number}\mathrm{of}\mathrm{qubits}$$

(3)

$$\mathbf{D}\left(C_{syn}\right)=\mathrm{Number}\mathrm{of}\mathrm{layers}\mathrm{in}\mathrm{the}\mathrm{circuit}$$

(4)

$${\mathbf{G}}_{\mathbf{2}}\left(C_{syn}\right)=\mathrm{Total}\mathrm{number}\mathrm{of}\mathrm{CNOTs}$$

(5)

$$\mathbf{F}\left(C_{syn}\right)=[\mathbf{E}(U_{in},C_{syn}),\mathbf{D}\left(C_{syn}\right),{\mathbf{G}}_{\mathbf{2}}\left(C_{syn}\right)]$$

(6)

4.7. Gate Elimination and Gate Fusion

In many cases, adjacent gates in a circuit can be canceled out, or combined into a single gate. Two consecutive X gates, for example, could be canceled out or eliminated, see Figure 8a, while two consecutive rotation gates $R_z\left({\theta }_1\right)$ and $R_z\left({\theta }_2\right)$ can be fused into a single gate $R_z\left({\theta }_{comb}\right)$; see Figure 8b. Gate fusions and eliminations often reduce the gate count as well as the number of layers; see Figure 8c, affecting the fitness of a chromosome. Therefore, in our proposed method, we account for possible gate eliminations and fusions before the evaluation of any objective metrics. We accomplish this by comparing each gate with its right-most neighbor, and applying appropriate eliminations and fusions, which can be user-specified. Since the circuit resulting from one round of elimination and fusion could contain potential for more, the process is performed repeatedly until no more possible eliminations and fusions are found.

4.8. Free Parameter Optimizations

Native basis gate sets often include parameterized gates and a compiler needs to be able to assign optimum values for any such free parameters. In our proposed compiler, we utilize a nested numerical optimization step for tuning free parameters for each chromosome, before assigning final fitness values. The numerical optimizer, obtained from the Python SciPy [74,75] library, uses a Broyden–Fletcher–Goldfarb–Shanno (BFGS)-based technique [76,77,78,79] to find the best set of parameters which minimizes the approximation error $\mathbf{E}(U_{in},U_{syn})$. For a free gate parameter vector $\overrightarrow{\theta }$, the optimization is given as:

$$\begin{array}{cc}\hfill & \mathbf{Optimize}(\mathbf{E},C_{syn})={\overrightarrow{\theta }}_{optimized},\hfill \\ \hfill & \mathrm{where},\mathbf{E}(U_{in},C_{syn}\left({\overrightarrow{\theta }}_{optimized}\right))=\underset{\overrightarrow{\theta }}{min}\left(\mathbf{E}(U_{in},C_{syn}\left(\overrightarrow{\theta }\right))\right)\hfill \end{array}$$

(7)

4.9. NSGA-II Configuration

NSGAs permit multi-objective optimizations with an arbitrary number of objectives and do not require special weighting or combination functions. In this work, we utilize the NSGA-II variation [14], adapted for quantum compilation. In the basic NSGA-II, the solutions are not concentered near one objective. However, we deliberately bias our solutions towards lower approximation errors, since shallower circuits with less gates might not compensate for lost approximation accuracy. To achieve this, during the sorting step in NSGA-II, the members are sorted on the basis of their rank, then by their approximation errors (our modification) and finally by their crowding distance. The approximation error sorting condition allows the GA to bias towards lower approximation errors rather than trying to balance all objective metrics.

4.10. Runtime Adaptation and Fuzzy Logic

For complex and rough solution spaces, GA convergence can slow down and avoiding local minima may become more challenging. In order to improve search efficiency, GAs can be enhanced using runtime parameter adaptations. These techniques generally try to analyze the current state of the GA parameters, population statistics and improvement trajectory to dynamically adjust parameters for future generations. In our work, we leverage a fuzzy logic controller [30] to analyze the update history and current mutation rate and adjust the mutation rate parameter for future generations. Update history is defined as the number of new chromosomes discovered and added to the Pareto front in the last five generations, as a proportion of the total population. Updates are measured with respect to the total population since larger populations would intuitively produce more updates, as a bigger chunk of the solution space is searched each generation. The goal is to guide the GA to increase diversity in the population when updates stagnate, or if the GA already has high mutation rates, to slow down and exploit existing solutions. The update history and current mutation rate are converted into fuzzy variables with three membership categories: LOW, MEDIUM, and HIGH. These variables are processed by the fuzzy inference engine, which outputs a new fuzzified mutation rate value. This value is later defuzzified using the mutation rate’s membership function to obtain a new mutation rate. Figure 9 gives a brief overview of the fuzzy controller for mutation rate.

Fuzzification uses the membership functions presented in Figure A2, in Appendix B.2, to convert crisp values into fuzzy values, while defuzzification uses the centroid method [31] and the membership function from Figure A2b specifically to obtain a crisp value from a fuzzy mutation variable. We chose the triangle membership function due to its simplicity of implementation and because it is one of the most widely used functions in literature [80]. The fuzzy rules, detailed in

Table 2. Fuzzy rule-set used by the inference engine to guide the GA.

Updates	Mutation Rate	New Mutation Rate
Low	Low	Medium
Low	Medium	High
Low	High	Low
Medium	Low	Medium
Medium	Medium	High
Medium	High	Medium
High	Low	Low
High	Medium	Medium
High	High	High

, are designed to address observed evolutionary scenarios: when the GA demonstrates low exploration (few updates and low mutation rates), the system increases mutation rates to enhance solution diversity. Conversely, when the GA demonstrates high exploration (high mutation rates with limited updates), the controller reduces mutation rates to promote exploitation of already discovered chromosomes. The controller also attempts to maintain stable rates when the GA is making consistent progress.

This adaptive mechanism ensures that the genetic algorithm can dynamically balance exploration and exploitation, improving overall search performance. While the membership functions were initially based on informed guesses from experimentation, fuzzy logic’s flexibility allows them to be updated without changing the rule set.

4.11. Additional Runtime Adaptations

When synthesizing circuits, there is usually a trade-off between the circuit depth and approximation error. Deeper circuits allow more configurations and fine-tuned adjustments, making it easier to achieve lower errors while shallower circuits give the compiler less flexibility. In some cases, it may be impossible to achieve a given error threshold without incurring a certain minimum circuit depth. Our testing showed that despite the use of the fuzzy controller, the GA would often plateau at high error values, without any improvement for many generations, indicating premature convergence. Upon closer inspection, it was discovered that the average circuit depth of the population would remain stagnant at a low value. This suggested that the GA was not exploring deeper circuit configurations enough, thereby missing out on lower approximation error opportunities. To address this issue, the dynamic adaptation mechanism also observes the update history over a larger window of 20 generations, and, if the best achieved error has not improved in that duration, it increases the probability of the layer addition mutation type. This biasing helps steer the GA to explore deeper circuits, which may offer much better approximation errors.

4.12. Parallelization and Acceleration of GA

Typically, the fitness function evaluation of individual chromosomes is the most computationally expensive step in a GA. However, since population members can generally be evaluated independently, the fitness evaluation step is also embarrassingly parallel. This also means that the workload, i.e., the population size can be scaled proportionally with available computational resources. In our work, we leverage the parallel nature of GAs and utilize the Python multiprocessing library [81] to distribute chromosomes to separate cores/processes for evaluation, and collect them back for further processing. This method scales linearly with the number of available cores and, thus, bigger population sizes can be evaluated efficiently given more computational resources. However, it is worth mentioning that if the subroutines for function evaluation utilize multiple cores/processes themselves, then the one-to-one ratio of cores to chromosomes will not be guaranteed. Moreover, the communication overhead becomes significant in the cases of larger population size and higher number of cores, and must be accounted for.

The fitness evaluation of a chromosome requires running three subroutines: depth calculation, computation of number of CNOTs, and approximation error calculation. Performance profiling reveals that the last subroutine is the most computationally intensive since it involves free parameter tuning using the BFGS-based numerical optimizer. This optimizer repeatedly calls the approximation error function, until the desired accuracy and convergence conditions are achieved. Calculating the approximation error itself involves three main steps: (a) decoding the chromosome into the equivalent quantum circuit, (b) obtaining the equivalent unitary of the circuit and (c) calculating the approximation error using the formula in (3). Upon deeper investigation, it was discovered that the second step, obtaining a unitary from a circuit, was the biggest performance bottleneck.

To optimize the first step, we leverage the symbolic variable feature of the IBM Qiskit circuit objects. Specifically, we use symbolic variables for any free parameters in the parameterized gates and cache the circuit decoded from the chromosome. Thus, instead of regenerating the circuit with parameters applied in each iteration, just the free parameter values are supplied before converting to unitary.

To address the next two steps, we use Qiskit API functions to obtain unitary matrices from the circuits which are used to compute the final error value using (3). To optimize the computation of the error value, we combine the last two steps into one. That is, instead of computing the unitary for a solution circuit, we append the adjoint of our input unitary as a black-box gate to the solution circuit. The final unitary of the resultant circuit is $U_{in}^{†}{U}_{syn}$, which can be obtained using fast Qiskit API functions. From there, we can simply plug this value into (3) and obtain the final error.

Figure A3 in Appendix B.3 shows a visual representation of this optimization, where we highlight parts of the optimized and unoptimized functions called repeatedly by the numerical optimizer. However, note that circuits without any parametrized gates do not incur any numerical optimization time penalty. Lastly, since approximation error calculations require $U_{in}^{†}$, we calculate this matrix ahead of time and cache it.

5. Results

In this section, we present details about our experimental setup and the results obtained from our evaluations. The computational hardware and software libraries are mentioned, followed by a description of the input dataset used for evaluation. We compare our GA-based method with and without fuzzy logic adaptations against Qiskit and BQSkit, and

Table 3. Experiments for comparisons between all compilers.

Input Size	2 Qubit Unitary				3 Qubit Unitary
Error Thresholds	0.1	0.01	0.001	${\mathbf{10}}^{-\mathbf{8}}$	0.1	0.01	0.001	${\mathbf{10}}^{-\mathbf{8}}$
GA	✓	✓	✓	✓	✓	✓	✓	✓
GA-F	✓	✓	✓	✓	✓	✓	✓	✓
Qiskit	✓	✓	✓	✓	✓	✓	✓	✓
BQSkit	✓	✓	✓	✓	✓

and

Table 4. Experiments for analyzing effects of population size.

Input Size	2 Qubit Unitary			3 Qubit Unitary
Population Size	10	20	40	10	20	40
GA	✓	✓	✓	✓	✓	✓
GA-F	✓	✓	✓	✓	✓	✓

summarize the experiments carried out in this work. For clarity, we label GA with fuzzy logic based adaption as GA-F, while GA without fuzzy logic is labeled as just GA.

5.1. Experiment Setup

The KU ITTC HPC cluster was used to run the evaluations, with each compiler provided with 20 CPUs and 8 GB of memory. The compute nodes consisted of AMD Opteron^TM Processor 6274 and 6376 CPUs [82]. The nodes ran the Rocky Linux 9.4 (Blue Onyx) [83] operating system, and a Python environment, using version 3.10.9, was set up using Conda (version 24.9.2). The popular scientific Python library SciPy (version 1.11.4) [74] was utilized for the numerical BFGS-based numerical optimizer, while the SciKit Fuzzy library (version 0.5.0) [84] was used to implement the fuzzy logic controller. Finally, several libraries from Qiskit (version 1.2.4) [85] were used to implement the GA-based compiler. It, and BQSkit (version 1.2.0) [86], were also used for comparison and evaluation of the compiler.

For evaluations, a test suite of random unitary matrices was generated for qubit sizes 2 and 3. These were generated using the random_unitary [87] library function from Qiskit, which ensures even distribution of generated unitaries. Five unitaries were generated per qubit size, and we refer to each as a trial. All experiments were conducted on this test suite, and all compiler comparisons were made based on the outcome of compiling this dataset.

In addition to input matrices, target machines were also provided to the compilers. The target devices used ring-shaped topologies and bidirectional connectivity (i.e., CNOTs available in both direction) were used; see Figure 10. The basis gate set of $\{I,X,R_z\left(\theta \right),\sqrt{X},CNOT\}$ was used for the targets. For the GA,

Table 5. Gate fusion and elimination rules.

Gate 1	Gate 2	Action	New Gate on Left-Most Position
X	X	Elimination	I
$CX(q_x,q_y)$	$CX(q_x,q_y)$	Elimination	I on both qubits $q_x$ and $q_y$
$R_z\left({\theta }_1\right)$	$R_z\left({\theta }_2\right)$	Fusion	$R_z\left({\theta }^{\prime }\right)$
$\sqrt{X}$	$\sqrt{X}$	Fusion	X

lists the gate elimination and gate fusion policies, noting that during both gate fusion and elimination, the right-most gate gets replaced with the I gate. All qubits and connections were assumed to be of the same quality.

5.2. GA-Based Compilers vs. Qiskit and BQSkit

We present the results of our comparison of the GA-based compiler with Qiskit and BQSkit. We configured GA with a crossover rate of 1.0 (always occurs) and a mutation rate of 0.1. For the comparison, GA, GA-F and BQSkit were given error threshold targets of 0.1, 0.01 and 0.001 and the results were compared in terms of depth and CNOT count. It is worth mentioning that the compilation techniques used in BQSkit are designed to perform approximate compilation up to a target error threshold, although it is usually also possible to perform exact compilation by setting the error threshold to zero. Thus, we use BQSkit to compare our GAs against existing approximate compilation techniques. Qiskit, on the other hand, uses exact compilers based on analytical methods and does not compile against an error threshold. It always produces unitary preserving circuits [88], i.e., circuits with effective approximation error of zero. For a fair comparison between Qiskit and the other approximate compilers, we also test GA, GA-F and BQSkit with an extremely low error threshold of ${10}^{-8}$. This is the default error threshold for the BQSkit compiler and is also the default used by the equiv method of the Operator class in Qiskit [89], which is used to check if two operators are equivalent up to a global phase. The Qiskit transpile function was used for synthesis with the highest optimization level of 3 and the BQSkit compile function was used with the highest optimization setting of 4. Each compiler was given a 12 h timeout limit per trial.

The compilation results are displayed in Figure 11, showing the median values across five trials for each metric. These show that the GA and GA-F appear to produce results comparable with BQSkit across all metrics across for thresholds of 0.1, 0.01 and 0.001 for 2 qubit unitaries. Furthermore, it able to achieve comparable results with both BQSkit and Qiskit for 2 qubit unitaries with the much more restrictive error threshold of ${10}^{-8}$.

For 3 qubits, however, GA and GA-F are unable to achieve the target error thresholds, indicating that the 12 h limit was not adequate. This can be explained by the fact that moving from 2 qubits to 3 qubits drastically increases the search space, since the number of possible circuits increases exponentially with the number of qubits. Thus, a reasonable conclusion could be that many more generations of the GA and GA-F are needed to converge to an acceptable solution for larger qubit numbers.

Looking at the runtime characteristics of both GA-based compilers (Figure 12, Figure 13 and Figure 14) provides further evidence of this. In particular, the plots of best error vs. generations for 3 qubits in Figure 14e–h are missing the sharp drop in error towards the target threshold that we see for 2 qubits in Figure 13e–h. It indicates that they are struggling to converge to the provided error threshold within the time limit. We can also observe in those figures that the convergence times for GA and GA-F appear to be less than 1000 generations for all but the lowest error threshold when compiling 2 qubit unitaries, whereas for 3 qubits unitaries, they were unable to achieve median errors less than 0.25 even after 1500 generations. Finally, Figure 13a–d and Figure 14a–d indicate that the proposed methods are able to maintain slightly higher updates on average for 2 qubits than 3 qubits, although the difference is not much. Overall, this analysis provides additional motivation to accelerate GAs, since running more generations can potentially improve the final solution quality.

At this point we note that error threshold levels for 0.01 and lower, for 3 qubits, are not available for BQSkit due to execution timeout and memory over-utilization. We suspect this is a result of using the highest optimization setting, which incurs a higher compilation time.

5.3. Effect of Runtime Parameter Adaptation

Figure 12 compares GA and GA-F specifically, restricting the plots to only these for clarity. For 2 qubits, both GA and GA-F were able to reach the target error thresholds. We observe that GA-F is able to produce similar median depths and CNOTs for error thresholds of 0.1, 0.001 and 0.001. It performs slightly worse on those metrics for error threshold of ${10}^{-8}$. These observations prompt us to take a deeper look using Figure 13a–d, which show the cumulative average number of updates each GA-based compiler is able to sustain throughout its progress. It shows that GA-F generally maintains a higher median value for the average number of updates, indicating it is able to find new solutions, which extend the Pareto-front, faster than the regular GA. The graphs also show the median number of generations required for the proposed techniques to hit the error targets and these are marked with vertical lines. We see that, except for the error threshold of 0.1, GA-F is able to achieve convergence earlier. Figure 13e–h show the progression of the best error achieved over generations. The solid traces plot the median and the shaded areas indicate the region between the maximum and minimum best error values at that generation across trials. We observe that both GA and GA-F progress at similar rates towards convergence in terms of best error for 2 qubits, with GA-F able to achieve slightly faster rates of convergence in some cases.

The results are more mixed and inconclusive for 3 qubits. Neither configuration has a definitive lead in either the average rate of updates or the progress of achieved best error, as can be seen from Figure 14a–h. Furthermore, since the GAs were not able to achieve the error targets within the given timeout limit, these results are possibly not representative. It is plausible that over a longer number of generations, the GAs would settle into a more stable pattern, perhaps the same as observed for 2 qubit unitaries, but further experimentation is required to confirm.

5.4. Effect of Population Size

The population size used in a genetic algorithm can affect its performance and the quality of solutions. To observe the effects of population size, we ran GA and GA-F for three different population sizes, 10, 20 and 40. These sizes were chosen with the execution time constraints in mind. For a fair comparison, we limited the number of generations for each compiler to 800 generations, and we repeated the experiments for five trials, excluding results from any trial which was unable to complete the 800 generations in the given time limit. Figure 15 shows the results for 2 and 3 qubits, respectively, with the median values of metrics plotted.

We can observe that increasing population sizes can sometimes produce slightly better results in terms of approximation error, although there are anomalies and the differences are not significant. There appears to be no noticeable improvements in depth and CNOT across the different population sizes. GA and GA-F perform similarly over the different population sizes. These results, combined with analysis from the previous section, indicate that number of generations has a bigger effect on convergence than the population size, and requires further investigation.

6. Discussion

Our experimental investigations demonstrated that the GA-based compilers are able to produce competitive results for 2 qubits, when compared with industry standard compilers such as BQSkit and Qiskit. However, the investigation was inconclusive for 3 qubits since the compilers were unable to reach error thresholds within the provided time limit. As stated before, going from 2 qubits to 3 qubits dramatically increases the search space. For example, using the five basis gates used in this work, there are $4^2+2=18$ possible circuits of depth 1 for 2 qubits. By contrast, there are $4^3+6=70$ circuits of depth 1 for 3 qubits. As can be observed, the solution space grows exponentially (roughly about $O\left(n_{\mathrm{basis}\mathrm{gates}}^{n_{qubits}}\right)$ in our case). This effect is made more challenging as the depth of the circuit increases. Thus, it becomes harder for the GA to search this increased solution space. In addition, 3-qubit circuits are likely to have more parameterized gates, resulting in the numerical optimizer taking longer to converge. All of these factors contribute to the extended runtimes of the GAs for 3 qubits in its current form.

Although the provided time limit was insufficient, the experimental data shows that the desired metrics do tend downwards over the generations. It therefore prompts the question of whether increasing the time limit, and/or using a higher population would counteract the increase in search space going from 2 to 3 qubits, and requires further investigation. It also stands to reason that with further performance optimizations or more computational resources, the GA-based compilers might achieve the desired error thresholds within shorter time limits and is also worth studying.

Using runtime parameter adaptations appear to provide noticeable benefits for 2 qubit inputs, as seen in the previous section, in terms of number of new solutions discovered in the Pareto front and convergence speed. However, due to the issues discussed above, their effect on 3-qubit circuits is not apparent. Thus, while further experimentation is required for 3 qubits and beyond, the results for 2-qubit circuits show promise.

Setting the compilation performance aside, the GA-based compilers proposed have additional benefits. Firstly, the GA only requires a unitary matrix as an input, and its performance does not depend on individual circuit structures. Moreover, the multi-objective optimization feature of NSGA enables us to add more compilation objectives easily, at the cost of more computation resources. This can be used to address additional compilation goals such as differentiating gates based on their error rates and reducing the number of high error gates, or weigh connections based on the likelihood of error and reduce the number of CNOTs on such error prone connections. Finally, the results show that the GAs appear to continuously make progress towards better fitnesses (i.e., lower values for metrics), even if slowly.

As for future work, given the versatility of GAs, we believe there is a lot of room for improvement in terms of how the genetic operators of crossover, mutation and non-dominated sorting work. For example, the number of offspring produced from crossover was set at 2, and it is worth investigating if allowing more or less offspring from each parent pair would improve the GA convergence. It would also be interesting to study how the GA responds with a tournament size other than 2. For example, we could investigate if a dynamically adjusted tournament size, to control the selection pressure at runtime, would help with GA convergence. The tournament size and number of offspring together could also be used to control the trade-off between diversity of population and exploitation of solutions. For example, a higher tournament size coupled with higher number of offspring per parent pair would promote only high fitness individuals. This may increase the convergence speed, promoting only the best solutions available, at the cost of a higher risk of premature convergence due to loss of diversity. It would also be worthwhile to investigate the effect of dynamic population sizes, allowing it to grow and shrink. In addition to this, the sequence of mutation and crossover, along with their individual mechanisms, could also be varied to observe their effects on GA performance. Further, tuning the fuzzy logic controller could also be helpful. This could include introducing more input variables and applying more complex rules. It is also to be noted that the process of determining good membership functions is usually done using expert knowledge and domain-specific information, coupled with a significant amount of trial and error [80]. Therefore, some future effort could be dedicated to identifying better membership functions and related parameters. Overall, the flexibility of GAs allows many avenues for further study and optimization.

In a broader context, quantum computing could play a key role in advancing HPC capabilities, unlocking new research possibilities. However, to achieve this goal, effective execution of quantum algorithms on physical devices must be enabled. To that effect, research into novel and efficient compilation techniques is crucial. Which is why we believe further work on advanced compilation techniques, such as the one proposed here, is of paramount importance and requires careful consideration.

7. Conclusions

Quantum computing promises to open new frontiers to HPC efforts. However, quantum circuit synthesis in the NISQ era involves significant challenges, stemming from constraints such as restricted qubit connectivity (requiring mapping and routing), rapid decoherence of qubits (requiring short circuits) and vulnerability to gate errors (requiring low gate counts). Exact synthesis techniques for optimized circuits are generally intractable, which necessitates approximate synthesis methods which can balance approximation error with other compilation targets. To address these concerns, we proposed a genetic-algorithm-based approximate quantum synthesis technique which conceptualizes quantum compilation as a multi-objective optimization problem. We leverage the Non-dominated Sorting Genetic Algorithm for direct compilation of unitary matrices to targeted quantum hardware. Our compiler synthesizes circuits which conform to machine specific native basis gate sets and qubit topologies, while attempting to minimize approximation error, circuit depth and 2-qubit CNOT gate counts. Furthermore, to augment the GA, we utilize a fuzzy logic based runtime parameter adaptation scheme. This controller dynamically modulates the algorithm’s exploratory and exploitative search behaviors, enabling the GA to better navigate around local minima. Experimental results show promising results for 2 qubits; however, further investigations are required to understand how the method would perform for higher qubit counts.