A Beam Search Framework for Quantum Circuit Mapping

TL;DR

This paper introduces a beam search framework to optimize quantum circuit mapping, reducing the number of SWAP gates needed for execution on quantum devices.

Contribution

The novel contribution is a beam search framework that effectively reduces SWAP gates in quantum circuit mapping for NISQ devices.

Findings

The proposed beam search framework reduces SWAP gates by an average of 44% compared to baseline methods.

The method is effective for medium to large quantum circuits and works across various sizes and complexities.

Abstract

In the era of noisy intermediate-scale quantum (NISQ) computing, the limited connectivity between qubits is one of the common physical limitations faced by current quantum computing devices. Quantum circuit mapping methods transform quantum circuits into equivalent circuits that satisfy physical connectivity constraints by remapping logical qubits, making them executable. The optimization problem of quantum circuit mapping has NP-hard computational complexity, and existing heuristic mapping algorithms still have significant potential for optimization in terms of the number of quantum gates generated. To reduce the number of SWAP gates inserted during mapping, the solution space of the mapping problem is represented as a tree structure, and the mapping process is equivalent to traversing this tree structure. To effectively and efficiently complete the search process, a beam search framework (BSF) is proposed for solving quantum circuit mapping. By iteratively selecting, expanding, and making decisions, high-quality target circuits are generated. Experimental results show that this method can significantly reduce the number of inserted SWAP gates on medium to large circuits, achieving an average reduction of 44% compared to baseline methods, and is applicable to circuits of various sizes and complexities.

Figures

Full text

1. Introduction

With IBM’s recent launch of the Condor superconducting quantum computer featuring over 1000 qubits [1], Noisy Intermediate-Scale Quantum (NISQ) computing devices [2] have attracted widespread attention in both academia and industry. However, these quantum computing devices still have numerous shortcomings. Their core quantum processing unit (QPU) supports only a limited set of quantum operations and is affected by constraints on connectivity between qubits, as well as the relatively short coherence times of physical qubits, which typically results in a high error rate during the execution of quantum circuits. Current QPUs often cannot directly execute quantum circuits due to limited connectivity between qubits, necessitating the design of quantum circuit mapping methods [3,4] to remap qubits, thereby transforming them into equivalent quantum circuits that fit the architecture of the physical device.

Quantum circuit mapping consists of two parts: the initial mapping of qubits and the remapping. Since the initial mapping $[eqn]$ can interfere with the remapping, the latter becomes the primary focus. Existing qubit remapping methods can be classified into two categories. The first category redefines the quantum circuit mapping problem as an optimization problem and uses existing algorithms to solve it [5,6,7,8,9,10,11]. However, the quantum circuit mapping problem on NISQ devices has an NP-complete computational complexity. While these methods can achieve better results for circuits of limited scale, they often lack scalability and practicality when dealing with large-scale circuits. The second category employs heuristic search, progressively transforming the initial circuit into a version suitable for the physical device [2,12,13,14,15,16,17]. Experimental results indicate that heuristic search has advantages over the first category for large circuits and exhibits strong applicability across circuits of various scales but still has shortcomings. Current heuristic search methods struggle to balance search width and depth when addressing the tree-like solution space of the quantum circuit mapping problem, leading to difficulties in maintaining good mapping quality and efficiency for circuits of varying sizes and complexities.

Inspired by the recent significant success of beam search algorithms in natural language text generation [18], this paper proposes a quantum circuit mapping method based on a beam search framework (BSF), aiming to minimize the number of inserted SWAP gates. The main contributions include: (1) the design of a multi-layer window approximation of a real effect value function to calculate the effect value of each inserted SWAP gate node in the search tree, providing a basis for the search decision-making process and (2) the construction of a quantum circuit mapping method based on the aforementioned approximate real effect value function within the beam search framework, subdividing the search process into selection, expansion, and decision phases. This method leverages the characteristics of beam search to adjust the search width and depth, allowing the algorithm to adapt to quantum circuits of different scales.

2. Preliminaries

2.1. Qubit

Classical computer bits have two states, usually represented as 0 and 1, serving as the fundamental units of information. In contrast, a qubit also has two basic states, typically represented as $[eqn]$ and $[eqn]$ . Unlike classical bits, qubits can exist in a linear combination of the two basic states, which can be expressed as $[eqn]$ , where $[eqn]$ , and the state vector is $[eqn]$ . Additionally, two or more qubits can become entangled, forming a composite system. The state of a two-qubit system can be represented as $[eqn]$ , with its state vector being $[eqn]$ .

2.2. Quantum Operation

Quantum circuits consist of qubits and a sequence of quantum gates applied to the qubits, collectively representing a quantum program. As shown in Figure 1, each horizontal line in the quantum circuit represents a qubit, while the quantum gates applied to the qubits are represented by different blocks along the lines.

From left to right in Figure 1 are the Hadamard gate, controlled NOT (CNOT) gate, and SWAP gate. The squares represent single-qubit gates, while the vertical lines connecting two qubits represent two-qubit gates. Barenco has demonstrated that any quantum circuit can be represented using only single-qubit gates and CNOT gates [19]. Based on this, the test quantum circuits in the test set contain only single-qubit gates and CNOT gates, and through combinations of these gates, all the quantum gates supported by the IBM cloud computing platform can be constructed.

2.3. NISQ Computing Architecture

Figure 2 shows the classical IBM Q Tokyo chip architecture [16], where the effective time of the qubits averages around 50 μs, and the average error probabilities for single-qubit gates, measurement gates, and CNOT gates are denoted as $[eqn]$ , $[eqn]$ , and $[eqn]$ , respectively. As illustrated in Figure 2, two coupled physical qubits are connected by bidirectional arrows. These qubits are arranged in a planar geometric structure, and due to hardware connectivity constraints, a single qubit can only couple with its neighboring qubits. For example, $[eqn]$ is connected to $[eqn]$ and $[eqn]$ , meaning that a CNOT gate can be applied to the qubit pair $[eqn]$ and $[eqn]$ . However, $[eqn]$ is not directly connected to $[eqn]$ , so a CNOT gate cannot be directly applied to these two qubits.

2.4. Quantum Circuit Mapping

Due to the connectivity constraints between qubits in the quantum physical architecture, quantum programs must undergo quantum circuit mapping before execution to convert logical quantum programs into hardware-compatible quantum circuits. The connectivity constraints primarily affect the execution of two-qubit gates, while they have no impact on the execution of single-qubit gates. Therefore, this study focuses solely on addressing the connectivity constraint issues of two-qubit gates through quantum circuit mapping.

The basic quantum circuit mapping process is as follows: Assuming the quantum physical architecture is as shown in Figure 3, given an original quantum circuit diagram to be processed, as indicated in part b of the figure, only the second CNOT gate can be executed directly. The first CNOT gate cannot be executed immediately because its corresponding logical qubits, $[eqn]$ and $[eqn]$ , do not correspond to directly adjacent physical qubits, $[eqn]$ and $[eqn]$ , when mapped to the physical architecture. Therefore, a quantum circuit mapping transformation is required.

Current mainstream mapping transformation methods involve inserting SWAP operations into the quantum circuit to exchange the states of the corresponding logical qubits in the physical qubits. This approach allows for adjustments in the mapping state, enabling the execution of two-qubit gates that are originally constrained by connectivity limitations. As shown in Figure 3, after inserting a SWAP gate between the logical qubits $[eqn]$ and $[eqn]$ of the second CNOT gate, all two-qubit gates in the updated front layer satisfy the connectivity constraints. After inserting the SWAP gate, the mapping $[eqn]$ updates to $[eqn]$ , allowing all quantum gates in the front layer to be executable.

3. A Beam Search Framework for Quantum Circuit Mapping

3.1. Basic Idea

The state of the quantum circuit is represented as nodes in a bundle search tree. A single search in the beam search framework consists of three main processes: selection, expansion, and decision. In the selection process, a certain number of nodes are chosen from the current layer based on the effect values of each node, with the quantity determined by the width of the bundle search. The expansion process applies all candidate SWAP operations to the selected nodes, generating an equal number of expansion nodes, and calculates the effect values of each SWAP operation using an approximate real effect value function. The selection and expansion processes are repeated until the set search depth is reached. The decision process compares the long-term effect values of the newly expanded leaf nodes, then backtracks to the set of nodes generated during the first expansion. Ultimately, a new node is selected as the root node for the next search, which is an ancestor of the chosen leaf nodes.

The following explanation combines with Figure 4 to provide a detailed illustration. The state of the quantum circuit $[eqn]$ represented as the root node of the search tree after removing the executable gates under the initial mapping, is treated as the current layer (the blue box in Figure 4). Since the current layer contains only one node, the root node is selected for expansion. The specific steps involve inserting all candidate SWAP gates into the circuit of the root node and removing the quantum gates that become executable due to the insertion of the SWAP gates. Assuming there are currently three candidate SWAP gates, three nodes—let us call them $[eqn]$ , $[eqn]$ , and $[eqn]$ —are expanded, and the long-term effect values for each corresponding node are calculated. At this point, the layer containing these nodes is the current layer (the green box in Figure 4). If the search width is set to 2, the two nodes with the highest values (the gray nodes $[eqn]$ and $[eqn]$ in Figure 4) are selected for further expansion. This process is repeated until the set search depth is reached, which we assume to be 4 in this case. During this phase, the long-term effect values of the leaf nodes in the last layer (the red box in Figure 4) are compared, and node $[eqn]$ is chosen for backtracking. From the set of ancestor nodes generated during the first expansion (the green box in Figure 4), node $[eqn]$ is decided upon as the root node for the next search, as shown in the (b) in Figure 4. This search process will continue to repeat until all quantum gates in the circuit have been executed.

3.2. Preprocessing

The preprocessing of the quantum circuit mapping algorithm based on the beam search framework primarily includes the following operations:

Calculate the physical distance of double quantum gates: Given a quantum architecture diagram $[eqn]$ , let D represent the distance matrix recording the shortest path lengths between various physical qubits, where the distance between each pair of adjacent qubits is 1. For a two-qubit gate, suppose we have $[eqn]$ , $[eqn]$ , the two-qubit gate $[eqn]$ , and the corresponding logical qubits are $[eqn]$ and $[eqn]$ , where $[eqn]$ . In this case, the physical distance of the two-qubit gate is the distance between the physical qubits $[eqn]$ and $[eqn]$ minus one, denoted as $[eqn]$ , which can be expressed as follows:

$$[eqn]$$

where $[eqn]$ represents the physical qubit corresponding to the logical qubit under the mapping $[eqn]$ .

Quantum gate dependency graph (directed acyclic graph, DAG): Any quantum circuit can be represented as a sequence of combinations of single quantum gates and CNOT gates. Therefore, in this context, the term ’double quantum gate’ specifically refers to the CNOT gate. Figure 5 illustrates a specific quantum gate dependency graph. To clearly demonstrate the dependency relationships of CNOT gates on physical qubits within the quantum circuit, a directed acyclic graph (DAG) is used to represent the dependency order of these CNOT gates. Since single quantum gates operate only on single qubits and do not create dependencies on other qubits, the circuit mapping algorithm does not consider the influence of single quantum gates in its design. A CNOT gate can only be executed when both corresponding physical qubits $[eqn]$ and $[eqn]$ have completed all preceding CNOT gates.

Quantum circuit layering: The layering of quantum circuits is achieved through the quantum gate dependency graph, and based on this layered structure, the definition of the front layer is proposed. The front layer is defined as a set of CNOT gates that have no predecessor dependencies; there are no unexecuted predecessor CNOT gates in the DAG, allowing these gates to be executed immediately on the hardware. Specifically, for a CNOT gate $[eqn]$ , it can be included in the front layer when its corresponding two qubits $[eqn]$ and $[eqn]$ and all previously executed quantum gates on them have completed execution. As shown in the front layer of Figure 5, the CNOT gates $[eqn]$ and $[eqn]$ in the front layer have no pending predecessor quantum gates in DAG; thus, they can be safely placed in the front layer.

Initial mapping of qubits: Due to the use of different initial mapping schemes, varying results may be generated for different quantum circuits, and the optimal initial mapping scheme applicable to all quantum circuits remains unclear. Therefore, to avoid interference from the initial mapping of qubits on the quantum circuit mapping experiment, this study adopts only the most basic initial mapping strategy. In this scheme, the specific conditions of the CNOT gates in the front layer F are not considered; logical qubit $[eqn]$ is mapped to physical qubit $[eqn]$ ( $[eqn]$ and $[eqn]$ ), n is the number of qubits. This initial mapping does not take into account the details of the actual quantum circuit and its physical architecture, thereby eliminating any potential impact on subsequent quantum circuit mapping algorithms.

3.3. Approximate Real Effect Value Function

The cost function is the core of heuristic search algorithms [3,14], providing a basis for action decisions by estimating the favorability of candidate operations for problem-solving. Currently, existing heuristic quantum circuit mapping algorithms [3,14] generally use a lookahead cost function, which approximates the potential improvement from applying a SWAP gate by calculating the sum of the physical distances of all quantum gates within the lookahead window, ultimately selecting the SWAP gate with the minimum cost function value as the next action. However, the lookahead cost function only considers the direct impact of the SWAP gate on the physical distances of subsequent quantum gates, without further assessing the potential negative effects that this SWAP gate might introduce. For example, if the currently inserted SWAP gate increases the physical distance of a certain quantum gate within the lookahead window, the execution of that quantum gate may be adversely affected. To address this issue, additional SWAP gates need to be introduced in the subsequent mapping process to offset the negative effects of the aforementioned SWAP gate. To improve the shortcomings of the existing lookahead cost function in current mapping methods, this approach constructs a cost function that comprehensively considers both the physical distances of quantum gates and the SWAP gates needed thereafter. To distinguish it from the existing lookahead cost function, it is referred to as the ‘approximate real effect value function’.

The calculation idea of the approximate real effect value function is as follows: when evaluating the overall effect of a SWAP gate, the first step is to calculate the reduction in the sum of the physical distances of all quantum gates within the lookahead window after applying the SWAP gate, which serves as the numerator of the effect value function. Secondly, the number of subsequent SWAP gates that may be introduced within the lookahead window after applying this SWAP gate is estimated, which serves as the denominator of the effect value function. Next, the implementation details of this effect value function will be explained in detail.

According to the previous definition of the physical distance for double quantum gates, when $[eqn]$ , it implies that at least a number of SWAP gates equal to $[eqn]$ must be inserted to satisfy the connectivity constraints between two qubits in the physical quantum architecture. Based on this, the effect value $[eqn]$ of a double quantum gate g under the action of candidate SWAP gates can be defined as follows:

$$[eqn]$$

where $[eqn]$ is the temporary mapping generated after applying the SWAP operation to $[eqn]$ . For all double quantum gates in the front layer F, the effect value of the front layer F under the action of candidate SWAP gates can be obtained by summation, as follows:

$$[eqn]$$

Since the range of change in physical distance for double quantum gates due to the SWAP operation does not exceed 1, the range of $[eqn]$ is $[eqn]$ . When $[eqn]$ is positive, it indicates that this SWAP operation helps to reduce the physical distance of the current double quantum gate, making its execution more favorable. For $[eqn]$ , if its value is positive, it is considered that the SWAP operation can effectively reduce the overall physical distance of the front layer F, thereby facilitating the advancement of the front layer in the DAG. For the quantum circuit state $[eqn]$ , there may be multiple candidate SWAP gates that can be inserted, so each candidate SWAP operation needs to be evaluated. For those SWAP operations with a negative $[eqn]$ , to avoid situations where the algorithm does not converge, such operations are not considered.

For candidate SWAP gates, if their effect value $[eqn]$ is positive, subsequent operations can continue. In this case, using the multi-layer window approach to calculate the approximate real effect value function, if a negative situation arises as the front layer advances, it indicates that the initial candidate SWAP gate has a negative effect on the subsequent layer, resulting in an increased physical distance for that layer. To eliminate this negative effect, it is necessary to insert auxiliary SWAP gates identical to the original SWAP gate before that subsequent layer. However, such an operation will also negate the positive effect of the original candidate SWAP gate on the subsequent layer. Therefore, for subsequent layers that are not affected by the negative effects of the original candidate SWAP gate, it is necessary to insert auxiliary SWAP gates identical to the original candidate SWAP gate before them to retain the positive effect of the original candidate SWAP gate.

The following is a detailed explanation in conjunction with Figure 6. In Figure 6, the original candidate SWAP gate is represented in red, and the multi-layer window size is set to 5, indicating that the front layer F needs to be advanced five times. First, Layer 1 is considered the front layer of the DAG. Since $[eqn]$ has been calculated and is positive, there is no need to insert auxiliary SWAP gates before it; the front layer F can be advanced directly to the next layer in the DAG, which is Layer 2. Next, the effect value $[eqn]$ for this layer is calculated. Assuming it is negative, an auxiliary SWAP gate identical to the original candidate SWAP gate must be inserted before this layer, reverting the new mapping $[eqn]$ back to the original mapping $[eqn]$ , and recalculating $[eqn]$ for this layer, resulting in 0. Subsequently, the front layer F is advanced again, updating to Layer 3, and the effect value $[eqn]$ for this layer is calculated, assuming it is 0. Since an auxiliary SWAP gate was previously added to restore the mapping to $[eqn]$ , eliminating the positive effect of the original candidate SWAP gate on this layer, it is necessary to add another auxiliary SWAP gate identical to the original SWAP gate before this layer to restore its positive value. These operations will continue to be repeated until the window advancement is complete.

After calculating the effect values for each layer of the window $[eqn]$ , the effect value of node s is obtained, expressed as follows:

$$[eqn]$$

Here, $[eqn]$ represents the number of additional auxiliary SWAP gates added during the multi-layer window calculation process. For each layer in the window, a weight parameter is introduced to reduce the influence of subsequent layers, which will help the algorithm select candidate SWAP gates with parallel execution capabilities, thereby introducing a decay effect into the effect value function. The $[eqn]$ in Equation (4) refers to the decay parameter, which has been repeatedly verified through multiple experiments, with an adjustment to 0.7 yielding optimal results for the algorithm. Additionally, $[eqn]$ is used to quantify the effect value of the new node s after applying the SWAP operation. Clearly, as $[eqn]$ increases, the number of SWAP gates needed to reach the target state will correspondingly decrease, thereby enhancing the superiority of node s.

3.4. Beam Search Framework

The beam search method, as a combinatorial optimization algorithm, is an improvement over the greedy strategy. In the search process at each layer, this method retains multiple candidate results instead of just the current optimal output. It does not search the entire solution space but improves the algorithm’s computational speed by branching, selecting, and eliminating within the solution space. It is known that the quantum circuit mapping optimization problem is NP-hard, with a vast search space, making it extremely difficult to find the optimal solution. Moreover, as a critical part of the quantum computing compilation process, the execution time of the algorithm must be strictly controlled. Therefore, finding an approximately optimal solution has become a feasible approach.

Using the beam search method, with the goal of minimizing the number of inserted SWAP gates, we start from the initial state $[eqn]$ to construct the beam search decision tree. Here, $[eqn]$ represents the initial mapping, $[eqn]$ is the physical quantum circuit applicable to the actual architecture, and $[eqn]$ is the logical quantum circuit to be processed. The state $[eqn]$ serves as a node in the tree, where $[eqn]$ represents the physical circuit of the current node, and $[eqn]$ represents the logical circuit of the current node. The effect value $[eqn]$ for each node is calculated using the approximate real effect value function. Through this process, the minimum number of SWAP gates required to reach the target node $[eqn]$ (where $[eqn]$ is empty, indicating the target node) is computed.

Each node s in the beam search tree has three effect values for decision assessment: the reward value $[eqn]$ , the effect value $[eqn]$ , and the long-term effect value $[eqn]$ . The reward value $[eqn]$ indicates the extent to which the number of quantum gates to be executed in the circuit decreases from the parent node s to the child node $[eqn]$ after inserting a SWAP gate. The effect value $[eqn]$ describes the pros and cons of inserting a single SWAP gate in subsequent mapping tasks. The long-term effect value $[eqn]$ reflects the overall quality of the current circuit state at each node (which includes all previously inserted SWAP gates) in the mapping task, serving as a basis for evaluation and decision-making during selection and backtracking. By applying a SWAP operation to node s, a new node is obtained, denoted as $[eqn]$ , with s as its parent node. Thus, the reward value $[eqn]$ from node s to $[eqn]$ can be defined, and its calculation function is as follows:

$$[eqn]$$

Here, $[eqn]$ represents the number of double quantum gates in the logical circuit of node s, so $[eqn]$ can also refer to the number of newly added executable gates in the node $[eqn]$ compared to the node s, with its value always being non-negative. Based on the above definition of the nodes in the beam search tree, the beam search problem for quantum circuits can be divided into three processes: selection, expansion, and decision, as shown in Figure 7.

Selection: The selection process aims to find the optimal set of nodes in the beam search tree for further expansion. Part a of Figure 5 details the specific process of selection. For each layer of expanded nodes, a fixed number of nodes is selected as candidates for further expansion. First, the root node is added to the set of nodes to be selected, $[eqn]$ . Before reaching the search depth set by the beam search, a certain number of optimal nodes are selected from $[eqn]$ based on the long-term effect values of each node. The specific quantity k is determined by the search width $[eqn]$ and the number of elements n in the set, specifically $[eqn]$ . Through repeated experiments, it has been found that setting the search width of the beam search tree to 8 yields optimal results for the algorithm.

During the selection process, nodes are compared and ranked based on their long-term effect values, with the specific calculation function detailed in the expansion process. In each round of selection, the nodes with the highest long-term effect values are chosen to be added to the set of nodes for expansion, $[eqn]$ .

Expansion: The expansion process involves applying SWAP operations to all nodes in the set of nodes for expansion, thereby generating the corresponding set of child nodes and calculating the long-term effect value for each node corresponding to the SWAP operation. The set of candidate SWAP operations for node s is denoted as $[eqn]$ . For any SWAP gate $[eqn]$ in this set, the logical qubit $[eqn]$ corresponds to the physical qubit $[eqn]$ , and $[eqn]$ corresponds to $[eqn]$ , both of which should be part of the front layer F involved in node s. For a given node s, expansion can only be performed using the SWAP gates from its corresponding $[eqn]$ set, a strategy that has been widely used in quantum circuit mapping.

By applying the candidate SWAP operations to $[eqn]$ , a new node $[eqn]$ is obtained, where $[eqn]$ is derived from $[eqn]$ after the SWAP operation. Specifically, this involves remapping the two logical qubits of $[eqn]$ as $[eqn]$ and $[eqn]$ . The set $[eqn]$ is obtained by removing all executable gates in $[eqn]$ under the new mapping $[eqn]$ , while $[eqn]$ is formed by adding $[eqn]$ to $[eqn]$ and subsequently removing the executable gates from $[eqn]$ . Next, the long-term effect value of the new node $[eqn]$ is calculated, with the calculation function as follows:

$$[eqn]$$

Here, s represents the parent node of $[eqn]$ . $[eqn]$ is the long-term effect value of the parent node s; for the root node, which does not have a parent node, its long-term effect value is 0. Using the aforementioned approximate real effect value function, the one-step effect value $[eqn]$ for node $[eqn]$ can be calculated, while $[eqn]$ represents the reward value obtained by applying the SWAP operation on the parent node s to derive the child node $[eqn]$ . All newly expanded nodes are then added to the set of nodes for selection.

Decision: After repeatedly performing the selection and expansion processes for $[eqn]$ rounds, a decision is made, where $[eqn]$ is the search depth of the beam search tree. Through repeated experiments, it has been found that setting the search depth of the beam search tree to 13 yields optimal results for the algorithm. Based on the long-term effect values of each node in the current selection set, the leaf node with the highest long-term effect value is chosen, and the search backtracks to the initial set of nodes expanded from the root node to find the corresponding ancestor node. The SWAP operation corresponding to this ancestor node is selected as the final choice in the decision-making process, representing the long-term optimal SWAP operation for the root node state. This ancestor node is then set as the new root node, initiating the next search. When the $[eqn]$ corresponding to the new root node $[eqn]$ is empty, it indicates that the quantum circuit mapping has been completed, and its $[eqn]$ is the desired quantum circuit that satisfies the physical quantum architecture $[eqn]$ .

3.5. Complexity Analysis of Proposed Algorithm

The time complexity of the approximate real effect value function is as follows: when the value of the current layer $[eqn]$ is 0, if $[eqn]$ is not 0, it indicates that the previously inserted auxiliary SWAP gates have restored the mapping to the state before the original alternative SWAP gates were inserted, ensuring that the subsequent layer’s value $[eqn]$ is not negative. When encountering another layer with $[eqn]$ equal to 0, it can be inferred that it was originally positive but has become 0 due to the influence of the auxiliary SWAP gates. In this case, the same auxiliary SWAP gates need to be reinserted to restore it to a positive value. In terms of algorithm complexity, since the values of each layer can be fully computed after inserting the first SWAP gate, the time complexity of this effect value function is $[eqn]$ , where k is the window size.

In the worst-case scenario, the algorithm’s time complexity is given by $[eqn]$ , where $[eqn]$ is the number of two-qubit gates in the quantum circuit, which indicates that in the worst case, inserting a SWAP gate can only execute one two-qubit gate. $[eqn]$ represents the number of qubits in the quantum physical architecture. In the worst case, all SWAP gates applied to the qubits in the architecture diagram can serve as alternative SWAP gates, d denotes the depth of the clustered search tree, w is the width of the clustered search tree, and k represents the window size of the approximated real effect value function. Although the algorithm may be unsolvable in terms of time in the worst case, a balance can be achieved between algorithm performance and efficiency by adjusting d, w, and k. The optimal case is $[eqn]$ , meaning the circuit already meets the constraints of the physical architecture and does not require mapping.

3.6. Practical Example

The following provides a practical example, where a simple quantum circuit is selected, as shown in the Figure 8a, which contains five CNOT gates and six single-qubit gates. It is assumed that this circuit will run on the physical architecture in Figure 3, with a search depth set to 15 and a search width set to 8. The initial mapping $[eqn]$ is defined as $[eqn]$ . First, as shown in Figure 8b, a clustered search tree is constructed. The root node $[eqn]$ contains the complete physical circuit $[eqn]$ , an empty logical circuit $[eqn]$ , and its corresponding mapping $[eqn]$ . For the root node $[eqn]$ , its front layer includes a $[eqn]$ . Since this CNOT gate cannot be executed directly under the corresponding mapping at this node, an auxiliary SWAP is required to change its mapping, allowing the circuit to proceed. For this node, the available SWAP gate set is $[eqn]$ . Next, using the approximate real effect value function from Section 3.2, the effect value of the $[eqn]$ gate is calculated with a window size set to 7. It can be observed that after inserting $[eqn]$ , the physical distances of the first $[eqn]$ and the fourth $[eqn]$ both decrease by 1, while the physical distance of the final $[eqn]$ increases by 1, with no change in the physical distances of the other CNOT gates. Therefore, an additional SWAP gate needs to be added before the final $[eqn]$ . Given a decay parameter set to 0.7, the effect value for $[eqn]$ is calculated as $[eqn]$ . These SWAP gates are applied to the circuit at the root node, resulting in the expansion of two new nodes. Each new node’s mapping is obtained by applying the corresponding SWAP gates to the mapping of the root node. The circuit is then advanced under the new mapping until no further execution is possible. At this point, combining the previously calculated effect values of the SWAP gates with the number of CNOT gates executed during the circuit advancement, the effect values of the expanded nodes are calculated to be 1.74 and 3.49, respectively. Since the number of expanded nodes is less than the search width, all expanded nodes are chosen as candidate nodes. As the search depth has not yet been reached, further expansion of the candidate nodes is performed, resulting in the expansion of four new nodes. Since node $[eqn]$ is obtained by adding another $[eqn]$ to $[eqn]$ ( $[eqn]$ ), as shown in the Figure 8b, it has already executed all the gates in the circuit, thus completing the algorithm.

4. Results

4.1. Experimental Setup

The quantum circuit mapping algorithm based on the beam search framework aims to minimize the total number of inserted SWAP gates. Therefore, in the experiments, the number of CNOT gates inserted during the quantum circuit mapping process is used as an evaluation metric, which is three times the number of SWAP gates. The IBM Q Tokyo architecture is chosen as the quantum physical architecture for the experiments. This quantum computing platform is a commonly used testing platform in recent similar studies and contains 20 qubits, as detailed in Figure 2. The experiments utilize quantum circuits that are widely used as benchmarks in similar research; these benchmark circuits consist of the quantum instruction set supported by IBM Q series quantum computers, where double quantum gates only include CNOT gates, and the rest are single quantum gates. The algorithm is implemented in Python 3.10, and the experiments are conducted on a Lenovo Y9000P laptop equipped with an Intel Core i9-13900HX CPU (manufactured by Intel Corporation, Santa Clara, CA, USA) and 16GB of memory (Samsung Electronics, Suwon, Republic of Korea), running Windows 11 operating system.

To evaluate the performance of the algorithm, the SABRE algorithm proposed in reference [3] and the IBM basic mapping algorithm were chosen as comparison benchmarks. The SABRE algorithm is a commonly used comparative algorithm in quantum circuit mapping research, while the IBM basic mapping algorithm is the most widely used and fundamental mapping algorithm in current quantum computing platforms. After multiple tests, the quantum circuit mapping algorithm based on the beam search framework finalized a set of optimal parameters, specifically as follows: the search width of the beam search framework is set to 8, the search depth to 15, the decay parameter in the approximate real effect value function is set to 0.7, and the window size for multi-layer calculations of the effect value function is set to 7.

4.2. Comparison of Experimental Results

The quantum circuit mapping method based on beam search does not consider the optimization of results based on the initial mapping. Therefore, it initially uses the same identity mapping, mapping the ith logical qubit to the ith physical qubit. The experimental results of the algorithm on multiple benchmark circuits are shown in Table 1. The first two columns represent the names of the quantum circuits and the number of CNOT gates included, while the next three columns display the number of CNOT gates inserted by the SABRE algorithm, the IBM basic mapping algorithm, and our BSF algorithm, respectively. To intuitively show the difference between this algorithm and the existing algorithms, the following two columns present the reduction in the number of CNOT gates inserted by this algorithm compared to the other two methods. This value is calculated by subtracting the number of CNOT gates inserted by this algorithm from that of the other algorithms, and then dividing by the number of gates inserted by the other algorithms. The last column of Table 1 provides the runtime of this algorithm.

As shown in Table 1, the quantum circuit mapping algorithm based on the bundle search framework significantly reduces the number of additional CNOT gates inserted in medium-sized (original CNOT gate count over 1000) and large circuits (original CNOT gate count over 10,000) compared to the SABRE algorithm in reference [3], with an average reduction exceeding 44%. However, it is somewhat lacking in small circuits. In contrast to IBM’s basic mapping algorithm, this algorithm can significantly reduce the number of additional CNOT gates inserted in small, medium, and large circuits, achieving an average reduction of over 60%.

The disadvantage of this algorithm on small circuits may stem from the impact of the initial mapping on the results. To explore the enhancement effect of the initial mapping on algorithm performance, we adopted the initial mapping method from reference [3] and presented the experimental results of the three algorithms on multiple benchmark circuits, as shown in Table 2. The first column lists the names of the quantum circuits, while the next three columns show the number of CNOT gates inserted by the SABRE algorithm with the initial mapping, the algorithm without initial mapping (BSF), and the algorithm with initial mapping (BSF’), respectively. The following two columns display the reductions in the number of inserted CNOT gates of the algorithm compared to the other two methods after applying the initial mapping. The last column of Table 2 provides the average runtime of the algorithm.

As shown in Table 2, after applying the initial mapping, this algorithm can reduce the number of inserted CNOT gates by an additional 10% compared to the SABRE algorithm for medium-sized and large circuits, based on the no-initial-mapping scenario. Although the algorithm still struggles with some small circuits where it cannot effectively reduce the number of inserted CNOT gates, significant improvements have been observed in certain cases. By comparing the results of the algorithm before and after applying the initial mapping, it can be confirmed that the initial mapping positively impacts the algorithm’s performance, resulting in an average reduction of 16.86% in the number of inserted gates.

By applying the initial mapping, the discrepancies in results caused by the initial mapping between different algorithms are eliminated. Compared to this algorithm, the SABRE algorithm only considers the foresight in the initial mapping and cost function, lacking the global perspective that this algorithm employs during the search process. Therefore, in large test cases, as the logical circuit deepens, the influence of the initial mapping gradually diminishes, allowing this algorithm to insert fewer CNOT gates to generate the final circuit. To address the issue of excessive execution time for this algorithm on certain large circuits, adjustments can be made to the width and depth of the bundle search to achieve a balance between execution time and algorithm performance.

5. Conclusions

The quantum circuit mapping algorithm based on the bundle search framework proposed in this study achieves efficient mapping of logical quantum circuits, allowing them to overcome connectivity constraints of quantum physical architectures and successfully deploy on specific quantum computing devices. This method significantly reduces the number of basic gates required for quantum circuit mapping by introducing a multi-layer window approximation of the true effect value function within the bundle search framework. Experimental results show that for large circuits with over 10,000 CNOT gates, this method can quickly generate mapping schemes with fewer inserted SWAP gates, demonstrating generally superior performance compared to existing methods. However, it shows some shortcomings on certain small circuits due to the lack of consideration for the impact of initial mapping. Looking ahead, as the number of qubits in NISQ devices increases dramatically, the scale of quantum circuits will also become increasingly large. Therefore, this algorithm is of significant importance for enhancing the usability and computational efficiency of NISQ computing devices. Future work will focus on designing suitable initial mappings for this algorithm and improving the effect value function to address the algorithm’s shortcomings encountered during experimental processes.