Encoding-independent optimization problem formulation for quantum computing

Abstract

We review encoding and hardware-independent formulations of optimization problems for quantum computing. Using this generalized approach, an extensive library of optimization problems from the literature and their various derived spin encodings are discussed. Common building blocks that serve as a construction kit for formulating these spin Hamiltonians are provided. This previously introduced approach paves the way toward a fully automatic construction of Hamiltonians for arbitrary discrete optimization problems and this freedom in the problem formulation is a key step for tailoring optimal spin Hamiltonians for different hardware platforms.

1 Introduction

Discrete optimization problems are ubiquitous in almost any enterprise and many of these are known to be NP-hard (Lenstra and Rinnooy Kan, 1979). The objective of such problems is to find the minimum of a real-valued function f(v₀, …, v_N−1) (the cost function) over a set of discrete variables v_k. The search space is restricted by hard constraints, which are commonly presented as equalities such as g(v₀, …, v_N−1) = 0 or inequalities as h(v₀, …, v_N−1) > 0. Besides using classical heuristics (Dorigo and Di Caro, 1999; Melnikov, 2005) and machine learning methods (Mazyavkina et al., 2021) to solve these problems, there is a growing interest in applying quantum computation (Au-Yeung et al., 2023). A common approach for realizing this consists of first encoding the cost function f in a Hamiltonian H such that a subset of eigenvectors of H represents elements in the domain of f and the eigenvalues are the respective values of f:In such an encoding, the ground state of H is the solution to the optimization problem. Having obtained a Hamiltonian formulation, one can use a variety of quantum algorithms to find the ground state including adiabatic quantum computing (Farhi et al., 2000) and variational approaches, for instance, the quantum/classical hybrid quantum approximate optimization algorithm (QAOA) (Farhi et al., 2014) or generalizations thereof such as the quantum alternating operator ansatz (Hadfield et al., 2019). On the hardware side, these algorithms can run on gate-based quantum computers, quantum annealers, or specialized Ising machines (Mohseni et al., 2022).

In the current literature, almost all Hamiltonians for optimization are formulated as Quadratic Unconstrained Binary Optimization (QUBO) problems (Kochenberger et al., 2014). The success of QUBO reflects the strong hardware limitations of current devices, where multiqubit interactions are not available and must be decomposed into two-qubit interactions using ancilla qubits. Moreover, quantum algorithms with the dynamical implementation of hard constraints (Hen and Sarandy, 2016; Hen and Spedalieri, 2016) require driver terms that can be difficult to design and implement on quantum computers. Hence, hard constraints are usually included as energy penalizations of QUBO Hamiltonians. The prevalence of QUBO has also increased the popularity of one-hot encoding, a particular way of mapping (discrete) variables to eigenvalues of spin operators (Lucas, 2014), since this encoding allows for Hamiltonians with low-order interactions which is especially appropriate for QUBO problems.

However, compelling alternatives to QUBO and one-hot encoding have been proposed in recent years. A growing number of platforms are exploring high-order interactions (Chancellor et al., 2017; Lu et al., 2019; Schöndorf and Wilhelm, 2019; Wilkinson and Hartmann, 2020; Menke et al., 2021; 2022; Dlaska et al., 2022; Pelegrí et al., 2022; Glaser et al., 2023), while the Parity architecture (Lechner, 2020; Fellner et al., 2022; Ender et al., 2023) (a generalization of the LHZ architecture (Lechner et al., 2015)) allows the mapping of arbitrary-order interactions to qubits that require only local connectivity. The dynamical implementation of constraints has also been investigated (Hadfield et al., 2019; 2017; Fuchs et al., 2022; Zhu et al., 2023), including the design of approximate drivers (Wang et al., 2020; Sawaya et al., 2022) and compilation of constrained problems within the Parity architecture (Drieb-Schön et al., 2023). Moreover, simulated and experimental results have shown that alternative encodings outperform the traditional one-hot approach (Chancellor, 2019; Sawaya et al., 2020; Chen et al., 2021; Plewa et al., 2021; Tamura et al., 2021; Glos et al., 2022; Stein et al., 2023). Clearly, alternative formulations for Hamiltonians need to be explored but when the Hamiltonian has been expressed in QUBO using one-hot encoding, it is not trivial to switch to other formulations. Automatic tools to explore different formulations would therefore be highly beneficial.

In practice, many optimization problems are not purely discrete but involve real-valued parameters and variables. Thus, the encoding of real-valued problems to discrete optimization problems (discretization) as an intermediate step is discussed in Section 7.4.

The focus of this review is on optimization problems which can be formulated as diagonal Hamiltonians written as sums and products of Pauli-z-matrices. This subset of Hamiltonians is usually not applicable to quantum systems or quantum simulations. For an introduction to these more general Hamiltonians, we refer to the reviews of Georgescu et al. (2014) for physics problems and McArdle et al. (2020); Cao et al. (2019) for quantum chemistry simulations.

After introducing the notation used throughout the text in Section 2, we present a list of encodings in Section 3. Section 4 reviews the Parity architecture and Section 5 discusses encoding constraints. Section 6 functions as a manual on how to bring optimization problems into a form that can be solved with a quantum computer. Section 7 contains a library of optimization problems which are classified into several categories and Section 8 lists the building blocks used in the formulation of these (and many other) problems. Section 9 offers conclusions.

2 Definitions and notation

A discrete set of real numbers is a countable subset without an accumulation point. Discrete sets are denoted by uppercase Latin letters, except the letter G, which we reserve for graphs. A discrete variable is a variable ranging over a discrete set R and will be represented by lowercase Latin letters, mostly v or w. Elements of R are denoted by lowercase Greek letters.

If a discrete variable has range we call it binary or boolean. Binary variables will be denoted by the letter x. Similarly, a variable with range will be called a spin variable and the letter s will be reserved for these. There is an invertible mapping from a binary variable x to a spin variable s:For a variable v with range R we follow Chancellor (2019) and Sawaya et al. (2022) and define the value indicator function to bewhere α ∈ R.

We also consider optimization problems for continuous variables. A variable v will be called continuous, if its range is given by for some .

The goal for an optimization problem O = (V, f, C) is to find an extreme value y_ex of f, such that all of the constraints are satisfied at y_ex.

Discrete optimization problems can often be stated in terms of graphs or hypergraphs (Berge, 1987). A graph is a pair (V, E), where V is a finite set of vertices or nodes and is the set of edges. An element is called an edge between vertex v_i and vertex v_j. Note that a graph defined like this can neither have loops, i.e., edges beginning and ending at the same vertex, nor can there be multiple edges between the same pair of vertices. Given a graph G = (V, E), its adjacency matrix is the symmetric binary |V|×|V| matrix A with entries

A hypergraph is a generalization of a graph in which we allow edges to be adjacent to more than two vertices. That is, a hypergraph is a pair H = (V, E), where V is a finite set of vertices andis the set of hyperedges.

We reserve the word qubit for physical qubits. To go from an encoding-independent Hamiltonian to a quantum program, binary or spin variables become Pauli-z-matrices which act on the corresponding qubits.

3 Encodings library

For many problems, the cost function and the problem constraints can be represented in terms of two fundamental building blocks: the value of the integer variable v and the value indicator defined in Eq. 3. When expressed in terms of these building blocks, Hamiltonians are more compact, and recurring terms can be identified across many different problems. Moreover, quantum operators are not present at this stage: an encoding-independent Hamiltonian is just a cost function in terms of discrete variables, which eases access to quantum optimization to a wider audience. Encoding variables and the choice of quantum algorithms can come later.

Representation of the building blocks in terms of Ising operators depends on the chosen encoding. An encoding is a function that associates eigenvectors of the σ_z operator with specific values of a discrete variable v:where the spin variables s_i are the eigenvalues of operators. The encodings are also usually defined in terms of binary variables x_i which are related to Ising variables according to Eq. 2.

A summary of the encodings is presented in Figure 1. Some encodings are dense, in the sense that every quantum state |s₀, …, s_N−1⟩ encodes some value of the variable v. Other encodings are sparse because only a subset of the possible quantum states are valid states. The valid subset is generated by adding a core term¹, i.e., a penalty term for constraints that need to be enforced in order to decode the variable uniquely in the Hamiltonian for every sparsely encoded variable. In general, dense encodings require fewer qubits, but sparse encodings have simpler expressions for the value indicator , and are therefore favorable for avoiding higher-order interactions. This is because needs to check a smaller number of qubit states to know whether the variable v has value α or not, whereas dense encodings require the state of every qubit in the register (Sawaya et al., 2020; 2022).

FIGURE 1

3.1 Binary encoding

Binary encoding uses the binary representation for encoding integer variables. Given an integer variable , we can use D binary variables x_i ∈ {0, 1} to represent v:

The value indicator can be written using the generic expressionwhich is valid for every encoding. The expression for in terms of boolean variables x_i can be written using that the value of α is codified in the bitstring (x_α,0…, x_α,D−1). The value indicator checks if the D binary variables x_i are equal to x_α,i to know if the variable v has the value α or not. We note thatand so we writewhereare the corresponding Ising variables. Thus, the maximum order of the interaction terms in scales linearly with D and there are terms of order k. The total number of terms is and the number of interaction terms needed for a value indicator in binary encoding scales linearly with the maximum value of the variable N = 2^D.

If v ∈ {1, …, K} with , then we require D + 1 binary variables to represent v and we will have 2^D+1 − K invalid quantum states that do not represent any value of the variable v. The set of invalid states isfor rejecting quantum states in R, we can force v ≤ K, which can be accomplished by adding a core term H_core in the Hamiltonianor imposing the sum constraint

The core term penalizes any state that represents an invalid value for variable v. Because core terms impose an additional energy scale, the performance can reduce when . In some cases, such as the Knapsack problem, penalties for invalid states can be included in the cost function, so there is no need to add a core term or constraints (Tamura et al., 2021) (Section 8.2.3).

When encoding variables that can also take on negative values, e.g., v ∈ {− K, − K + 1, …, K′ − 1, K′}, in classical computing one often uses an extra bit that encodes the sign of the value. However, this might not be the best option because one spin flip could then change the value substantially and we do not assume full fault tolerance. For binary encoding there is a more suitable treatment of negative values: we can simply shift the valueswhere 2^D−1 < K + K′ ≤ 2^D. The expression for the value indicator functions stays the same, only the encoding of the value α has to be adjusted. An additional advantage over using the sign bit is that ranges that are not symmetrical around zero (K ≠ K′) can be encoded more efficiently. The same approach of shifting the variable by −K can also be used for the other encodings.

3.2 Gray encoding

In binary representation, a single spin flip can lead to a sharp change in the value of v, for example, |1000⟩ codifies v = 9 while |0000⟩ codifies v = 1. To avoid this, Gray encoding reorders the binary representation in a way that two consecutive values of v always differ in a single spin flip. If we line up the potential values v ∈ [1, 2^D] of an integer variable in a vertical sequence, this encoding in D boolean variables can be described as follows: on the ith boolean variable (which is the ith column from the right) the sequence starts with 2ⁱ⁻¹ zeros and continues with an alternating sequence of 2ⁱ 1s and 2ⁱ 0s. As an example, considerwhere D = 4. On the left-hand side of each row of boolean variables, we have the value v. If we, for example, track the right-most boolean variable, we indeed find that it starts with 2^1–1 = 1 zero for the first value, 2¹ ones for the second and third values, 2¹ zeros for the third and fourth values, and so on.

The value indicator function and the core term remain unchanged except that the representation of, for example, α in the analog of Eq. 12 also has to be in Gray encoding.

An advantage of this encoding with regard to quantum algorithms is that single spin flips do not cause large changes in the cost function and thus smaller coefficients may be chosen (see discussion in Section 8). The advantage of using Gray over one-hot encoding was recently demonstrated for quantum simulations of a deuteron (Di Matteo et al., 2021).

3.3 One-hot encoding

One-hot encoding is a sparse encoding that uses N binary variables x_α to encode an N-valued variable v. The encoding is defined by its variable indicator:which means that v = α if x_α = 1. The value of v is given by

The physically meaningful quantum states are those with a single qubit in state 1 and so the dynamics must be restricted to the subspace defined by

One option to impose this sum constraint is to encode it as an energy penalization with a core term in the Hamiltonian:which has minimum energy if only one x_α is different from zero.

3.4 Domain-wall encoding

This encoding uses the position of a domain wall in an Ising chain to codify values of a variable v (Chancellor, 2019; Berwald et al., 2023). If the endpoints of an N + 1 spin chain are fixed in opposite states, there must be at least one domain wall in the chain. Since the energy of a ferromagnetic Ising chain depends only on the number of domain walls it has and not on where they are located, an N + 1 spin chain with fixed opposite endpoints has N possible ground states, depending on the position of the single domain wall.

The codification of a variable v = 1, …, N using domain wall encoding requires the core Hamiltonian Chancellor (2019):Since the fixed endpoints of the chain do not need a spin representation (s₀ = −1 and s_N = 1), N − 1 Ising variables are sufficient for encoding a variable of N values. The minimum energy of H_core is 2 − N, so the core term can be alternatively encoded as a sum constraint:

The variable indicator corroborates if there is a domain wall in the position α:where s₀ ≡ − 1 and s_N ≡ 1, and the variable v can be written as

Quantum annealing experiments using domain wall encoding have shown significant improvements in performance compared to one-hot encoding (Chen et al., 2021). This is partly because the required search space is smaller but also because domain-wall encoding generates a smoother energy landscape: in one-hot encoding, the minimum Hamming distance between two valid states is two, whereas in domain-wall, this distance is one. This implies that every valid quantum state in one-hot is a local minimum, surrounded by energy barriers generated by the core energy of Eq. 21. As a consequence, the dynamics in domain-wall encoded problems freeze later in the annealing process because only one spin-flip is required to pass from one state to the other (Berwald et al., 2023).

3.5 Unary encoding

In unary encodings, a numerical value is represented by the number of repetitions of a symbol. In the context of quantum optimization, we can use the number of qubits in excited states to represent a discrete variable (Rosenberg et al., 2015; Tamura et al., 2021)². In terms of binary variables x_i, we get:so N − 1 binary variables x_i are needed for encoding an N-value variable. Unary encoding does not require a core term because every quantum state is a valid state. However, this encoding is not unique in the sense that each value of v has multiple representations.

A drawback of unary encoding (and every dense encoding) is that it requires information from all binary variables to determine the value of v. The value indicator iswhich involves 2^N interaction terms. This exponential scaling in the number of terms is unfavorable, so unary encoding may be only convenient for variables that do not require value indicators in the problem formulation, but only the variable value v. An example of this type of variable can be found in the clustering problem, as explained in Section 6.

A performance comparison for the Knapsack problem using digital annealers showed that unary encoding can outperform binary and one-hot encoding and requires smaller energy scales (Tamura et al., 2021). The reasons for the high performance of unary encoding are still under investigation, but redundancy is believed to play an important role because it facilitates the annealer to find the ground state. As for domain-wall encoding (Berwald et al., 2023), the minimum Hamming distance between two valid states (i.e., the number of spin flips needed to pass from one valid state to another) could also explain the better performance of the unary encoding. Redundancy has also been pointed out as a potential problem with unary encodings since not all possible values have the same degeneracy and therefore results may be biased towards the most degenerate values (Rosenberg et al., 2015).

3.6 Block encodings

It is also possible to combine different approaches to obtain a balance between sparse and dense encodings (Sawaya et al., 2020). Block encodings are based on B blocks, each consisting of g binary variables. Similar to one-hot encoding, the valid states for block encodings are those states where only a single block contains non-zero binary variables. The binary variables in block b, define a block value w_b, using a dense encoding such as binary, Gray, or unary. For example, if w_b is encoded using binary, we haveThe discrete variable v is defined by the active block b and its corresponding block value w_b,where is the discrete value associated with the quantum state with active block b and block value α, and is a value indicator that only needs to check the value of binary variables in block b. For each block, there are 2^g−1 possible values (assuming Gray or binary encoding for the block), because the all-zero state is not allowed (otherwise block b is not active). If the block value w_b is encoded using unary, then g values are possible. The expression of depends on the encoding and is presented in the respective encoding section.

The value indicator for the variable v is the corresponding block value indicator. Suppose the discrete value v₀ is encoded in the block b with a block variable w_b = α:then the value indicator is

A core term is necessary so that only qubits in a single block can be in the excited state. Defining t_b = ∑_ix_i,b, the core terms results inor, as a sum constraint,

The minimum value of H_core is zero. If the two blocks, b and b′, have binary variables with values one, then t_bt_b′ ≠ 0 and the corresponding eigenstate of H_core is no longer the ground state.

4 Parity architecture

The strong hardware limitations of noisy intermediate-scale quantum (NISQ) (Preskill, 2018) devices have made sparse encodings (especially one-hot) the standard approach to problem formulation. This is mainly because the basic building blocks (value and value indicator) are of linear or quadratic order in the spin variables in these encodings. The low connectivity of qubit platforms requires Hamiltonians in the QUBO formulation and high-order interactions are expensive when translated to QUBO Kochenberger et al. (2014). However, different choices of encodings can significantly improve the performance of quantum algorithms (Chancellor, 2019; Sawaya et al., 2020; Chen et al., 2021; Di Matteo et al., 2021; Tamura et al., 2021), by reducing the search space or generating a smoother energy landscape.

One way this difference between encodings manifests itself is in the number of spin flips of physical qubits needed to change a variable into another valid value (Berwald et al., 2023). If this number is larger than one, there are local minima separated by invalid states penalized with a high cost which can impede the performance of the optimization. On the other hand, such an energy-landscape might offer some protection against errors (Pastawski and Preskill, 2016; Fellner et al., 2022). Furthermore, other fundamental aspects of the algorithms, such as circuit depth and energy scales can be greatly improved outside QUBO (Ender et al., 2022; Drieb-Schön et al., 2023; Fellner et al., 2023; Messinger et al., 2023), prompting us to look for alternative formulations. The Parity Architecture is a paradigm for solving quantum optimization problems (Lechner et al., 2015; Ender et al., 2023) that does not rely on the QUBO formulation, allowing a wide number of options for formulating Hamiltonians. The architecture is based on the Parity transformation, which remaps Hamiltonians onto a 2D grid requiring only local connectivity of the qubits. The absence of long-range interactions enables high parallelizability of quantum algorithms and eliminates the need for costly and time-consuming SWAP gates, which helps to overcome two of the main obstacles of quantum computing: limited coherence time and the poor connectivity of qubits within a quantum register.

The Parity transformation creates a single Parity qubit for each interaction term in the (original) logical Hamiltonian:where the interaction strength J_i,j,… is now the local field of the Parity qubit . This facilitates addressing high-order interactions and frees the problem formulation from the QUBO approach. The equivalence between the original logical problem and the Parity-transformed problem is ensured by adding three- and four-body constraints and placing them on a 2D grid such that only neighboring qubits are involved in the constraints. The mapping of a logical problem into the regular grid of a Parity chip can be realized by the Parity compiler (Ender et al., 2023). Although the Parity compilation of the problem may require a larger number of physical qubits, the locality of interactions on the grid allows for higher parallelizability of quantum algorithms. This allows constant depth algorithms (Lechner, 2020; Unger et al., 2022) to be implemented with a smaller number of gates (Fellner et al., 2023).

The following toy example, summarized in Figure 2, shows how a Parity-transformed Hamiltonian can be solved using a smaller number of qubits when the original Hamiltonian has high-order interactions. Given the logical Hamiltonianthe corresponding QUBO formulation requires seven qubits, including two ancillas for decomposing the three-body interactions, and the total number of two-body interactions is 14. The embedding of the QUBO problem on quantum hardware may require additional qubits and interactions depending on the chosen architecture. Instead, the Parity-transformed Hamiltonian only consists of six Parity qubits with local fields and two four-body interactions between close neighbors.

FIGURE 2

It is not yet clear what the best Hamiltonian representation is for an optimization problem. The answer will probably depend strongly on the particular use case and will take into account not only the number of qubits needed but also the smoothness of the energy landscape, which has a direct impact on the performance of quantum algorithms (King et al., 2019).

5 Encoding constraints

In this section, we review how to implement the hard constraints associated with the problem, assuming that the encodings of the variables have already been chosen. Hard constraints c(v₁, …, v_N) = K often appear in optimization problems, limiting the search space and making problems even more difficult to solve. We consider polynomial constraints of the formwhich remain polynomial after replacing the discrete variables v_i with any encoding. The coefficients g_i, g_i,j, … depend on the problem and its constraints. Even if the original problem is unconstrained, the use of sparse encodings such as one-hot or domain wall imposes hard constraints on the quantum variables.

In general, constraints can be implemented dynamically (Hen and Sarandy, 2016; Hen and Spedalieri, 2016) (exploring only quantum states that satisfy the constraints) or as extra terms H_c in the Hamiltonian, such that eigenvectors of H are also eigenvectors of H_c and the ground states of H_c correspond to elements in the domain of f that satisfy the constraint. These can be incorporated as a penalty term H_c into the Hamiltonian that penalizes any state outside the desired subspace:orin the special case that c(x₁, …, x_N) ≥ K is satisfied. The constant A must be large enough to ensure that the ground state of the total Hamiltonian satisfies the constraint, but the implementation of large energy scales lowers the efficiency of quantum algorithms (Lanthaler and Lechner, 2021) and additionally imposes a technical challenge. Moreover, extra terms in the Hamiltonian imply additional overhead of computational resources, especially for squared terms such as in Eq. 37. The determination of the optimal energy scale is an important open problem. For some of the problems in the library, we provide an estimation of the energy scales (cf. also Section 8.4.2).

Quantum algorithms for finding the ground state of Hamiltonians, such as QAOA or quantum annealing, require driver terms U_drive = exp(−itH_drive) that spread the initial quantum state to the entire Hilbert space. Dynamical implementation of constraints employs a driver term that only explores the subspace of the Hilbert space that satisfies the constraints. Given an encoded constraint in terms of Ising operators :a driver Hamiltonian H_drive that commutes with will be restricted to the valid subspace provided the initial quantum state satisfies the constraint:

In general, the construction of constraint-preserving drivers depends on the problem (Hen and Sarandy, 2016; Hen and Spedalieri, 2016; Hadfield et al., 2017; Chancellor, 2019; Bärtschi and Eidenbenz, 2020; Wang et al., 2020; Fuchs et al., 2021; Bakó et al., 2022). Approximate driver terms have been proposed that admit some degree of leakage and may be easier to construct (Sawaya et al., 2022). Within the Parity Architecture, each term of a polynomial constraint is a single Parity qubit (Lechner et al., 2015; Ender et al., 2023). This implies that for the Parity Architecture the polynomial constraints are simply the conservation of magnetization between the qubits involved:where the Parity qubit represents the logical qubits product and we can sum over all these products that appear in the constraint c. A driver Hamiltonian based on exchange (or flip-flop) terms ., summed over all pairs of products u, w ∈ c, preserves the total magnetization and explores the complete subspace where the constraint is satisfied (Drieb-Schön et al., 2023). The decision tree for encoding constraints is presented in Figure 3.

FIGURE 3

6 Use case example

In this section, we present an example of the complete procedure to go from the encoding-independent formulation to the spin Hamiltonian that has to be implemented in the quantum computer, using an instance of the Clustering problem (Section 7.1.1).

Every problem in this library includes a Problem description, indicating the required inputs for defining a problem instance. In the case of the clustering problem, a problem instance is defined from the number of clusters K we want to create, N objects with weights w_i, and distances d_i,j between the objects. Two different types of discrete variables are required, variables v_i = 1, …, K (i = 1, …, N) indicate to which of the K possible clusters the node i is assigned, and variables y_j = 1, …, W_max track the weight in cluster j.

The cost function of the problem only depends on , the value indicators of variables v_i. In this case, indicates whether the node associated with the discrete variable v_i belongs to the cluster k or not. If two nodes i, j belong to the same cluster k, then the cost function increases by d_i,j, giving the total cost function:We can choose any encoding for the variables v_i. For example, if we decide to use binary or Gray encoding, a variable v_i requires D = log₂(K) qubits (we assume K = 2^D for simplicity, but the resource estimate will not change significantly if this is not the case). From Eq. 12 we see that is a polynomial of order D in variables with terms of order j and 2^D = K terms in total, so the product in the cost function will have 2^D × 2^D = 2^2D = K² terms, with orders between zero and 2D. This product is summed over all the pairs i, j, so we can say that terms are required for the cost function. High-order interactions may be prohibitive for some hardware platforms, but if multiqubit gates are available, binary encoding offers an important reduction in the number of qubits.

Alternatively, we can choose a sparse encoding for the variables v_i. Using one-hot encoding, we need K qubits per node, so NK qubits are required for the cost function. The product is just a two-qubit interaction , so the cost function requires terms. The K qubits associated with a variable v_i must satisfy the core constraint:if this constraint is implemented as an energy penalization , then terms are added to the spin Hamiltonian for each variable, so terms in total are associated with the constraint. The advantage of sparse encodings is that low-order interactions are needed for the value indicator functions (in this case, the maximum order is two).

Besides the core constraints associated with the encodings, the clustering problem includes K additional constraints (one per each cluster). The total weight of nodes in any cluster cannot exceed a problem instance specific maximal value W_max:For the kth cluster, this constraint can be expressed in terms of auxiliary variables y_k:Variables y_k are discrete variables in the range 0, …, W_max. Because the value indicators of y_k are not necessary for the constraints, we can use a dense encoding such as binary without dealing with the high-order interactions associated with value indicators of dense encodings. The variables y_k require K log₂(W_max) qubits if we use binary encoding, or KW_max if we use one-hot. These constraints can also be implemented as energy penalizations in the Hamiltonian or can be encoded in the driver term.

The complete procedure for obtaining the spin Hamiltonian is outlined in Figure 4. We emphasize that the optimal encodings and constraint implementations depend on the details of the hardware, such as native gates, connectivity, and the number of qubits. Moreover, the efficiency of quantum algorithms is also related to the smoothness of the energy landscape, and some encodings can provide better results even though they require more qubits (see, for example, Tamura et al., 2021).

FIGURE 4

7 Problem library

The problems included in the library are classified into four categories: subsets, partitions, permutations, and continuous variables. These categories are defined by the role of the discrete variable and are intended to organize the library and make it easier to find problems but also to serve as a basis for the formulation of similar use cases. An additional category in Section 7.5 contains problems that do not fit into the previous categories but may also be important use cases for quantum algorithms. In Section 8 we include a summary of recurrent encoding-independent building blocks that are used throughout the library and could be useful in formulating new problems.

7.1 Partitioning problems

The goal of partitioning problems is to look for partitions of a set U, minimizing a cost function f. A partition P of U is a set of subsets U_k ⊂ U, such that and U_k ∩ U_k′ = 0 if k ≠ k′. Partitioning problems require a discrete variable v_i for each element u_i ∈ U. The value of v_i indicates to which subset the element belongs, so v_i can take K different values. Values assigned to the subsets are arbitrary, therefore the value of v_i is usually not important in these cases, but only the value indicator is needed, so sparse encodings may be convenient for these variables.

7.1.1 Clustering problem

7.1.2 Number partitioning

7.1.3 Graph coloring

Alternatively we can look for the coloring that uses the minimum number of colors. To check if a color α is used, we can use the following term (see building block Section 8.2.2):which is one if and only if color α is not used in the coloring, and 0 if at least one node is painted with color α. The number of colors used in the coloring is the cost function of the problem:

7.1.4 Graph partitioning

7.1.5 Clique cover

7.2 Constrained subset problems

Given a set U, we look for a non-empty subset U₀ ⊆ U that minimizes a cost function f while satisfying a set of constraints c_i. In general, these problems require a binary variable x_i per element in U which indicates if the element i is included or not in the subset U₀. Although binary variables are trivially encoded in single qubits, non-binary auxiliary variables may be necessary to formulate constraints, so the encoding-independent formulation of these problems is still useful.

7.2.1 Cliques

7.2.2 Maximal independent set

7.2.3 Set packing

7.2.4 Vertex cover

7.2.5 Minimal maximal matching

7.2.6 Set cover

7.2.7 Knapsack

7.3 Permutation problems

In permutation problems, we need to find a permutation of N elements that minimizes a cost function while satisfying a given set of constraints. In general, we will use a discrete variable v_i ∈ [1, N] that indicates the position of the element i in the permutation.

7.3.1 Hamiltonian cycles

7.3.2 Traveling salesperson problem (TSP)

7.3.3 Machine scheduling

Suppose job k can only be started if another job, j, has been done previously. This constraint can be implemented aswhich precludes any solution in which job j is done after job k. Alternatively, it can be codified as

These constraints can be used to encode problems that consider jobs with different operations O₁, …O_q that must be performed in sequential order. Note that constraints allow the use of different machines for different operations. If we want job k to be done immediately after work j, we can substitute t′ by t + 1 in .

7.3.4 Nurse scheduling problem

7.4 Real variables problems

Depending on the problem it might also be useful to have different resolutions for different axes or a non-uniform discretization, e.g., logarithmic scaling of the interval length.

For the fixed set of chosen coordinates D_n, the Dirichlet processes are run m times to get m hyperrectangles . For k = 1, …, m, we define binary projection maps asthen Random subspace coding is defined as a map

Depending on the set of hyperrectangles , random subspace coding can be a sparse encoding. Let and K ⊂ M. We define setsFor , let . The binary vector z is in the image of the random subspace encoding if and only ifholds. From here one can simply use the discrete encodings discussed in Section 3 to map the components z_i(x) of z(x) to spin variables. Due to the potential sparse encoding, a core term has to be added to the cost function. Let , then the core term reads

Despite this drawback, random subspace coding might be preferable due to its simplicity and high resolution with relatively few hyperrectangles compared to the hypercubes of the standard discretization.

7.4.1 Financial crash problem

7.4.2 Continuous black box optimization

7.5 Other problems

In this final category, we include problems that do not fit into the previous classifications but constitute important use cases for quantum optimization.

7.5.1 Syndrome decoding problem

7.5.2 k-SAT

8 Summary of building blocks

Here we summarize the parts of the cost functions and techniques that are used as reoccurring building blocks for the problems in this library. Similar building blocks are also discussed by Sawaya et al. (2022).

8.1 Auxiliary functions

The simplest class of building blocks are auxiliary scalar functions of multiple variables that can be used directly in cost functions or constraints via penalties.

8.1.1 Element counting

One of the most common building blocks is the function t_a that simply counts the number of variables v_i with a given value a. In terms of the value indicator functions, we haveIt might be useful to introduce t_a as additional variables. In that case, one has to bind it to its desired value with the constraints

8.1.2 Step function

Step functions Θ(v − w) can be constructed aswith K being the maximum value that the v, w can take on. Step functions can be used to penalize configurations where v ≥ w.

8.1.3 Minimizing the maximum element of a set

Step functions are particularly useful for minimizing the maximum value of a set {v_i}. Given an auxiliary variable l, we can guarantee that l ≥ v_i, for all i with the penalizationwhich increases the energy if l is smaller than any v_i. The maximum value of {v_i} can be minimized by adding to the cost function of the problem the value of l. In that case, we also have to multiply the term from Eq. 145 by the maximum value that l can take in order to avoid trading off the penalty.

8.1.4 Compare variables

Given two variables v, w ∈ [1, K], the following term indicates if v and w are equal:If we want to check if v > w, then we can use the step function Eq. 144.

8.2 Constraints

Here we present the special case of functions of variables where the groundstate fulfills useful constraints. These naturally serve as building blocks for enforcing constraints via penalties.

8.2.1 All (connected) variables are different

If we have a set of variables and two variables v_i, v_j are connected when the entry A_ij of the adjacency matrix A is 1, the following term has a minimum when v_i ≠ v_j for all connected i ≠ j:

The minimum value of c is zero, and it is only possible if and only if there is no connected pair i, j such that v_i = v_j. For all-to-all connectivity, one can use this building block to enforce that all variables are different. If K = N, the condition v_i ≠ v_j for all i ≠ j is then equivalent to asking that each of the K possible values is reached by a variable.

8.2.2 Value α is used

Given a set of N variables v_i, we want to know if at least one variable is taking the value α. This is done by the term

8.2.3 Inequalities

If the auxiliary variable y is expressed in binary or Gray encoding, then Eq. 152 must be modified when 2ⁿ < K < 2ⁿ⁺¹ for some ,which ensures c(v₁, …, v_N) < K if y = 0, …, 2ⁿ⁺¹ − 1.

8.2.4 Constraint preserving driver

As explained in Section 5, the driver Hamiltonian must commute with the operator generating the constraints so that it reaches the entire valid search space. Arbitrary polynomial constraints c can for example, be handled by using the Parity mapping. It brings constraints to the form . Starting in a constraint-fulfilling state and employing constraint depended flip-flop terms constructed from σ₊, σ₋ operators as driver terms on the mapped spins (Drieb-Schön et al., 2023) automatically enforces the constraints.

8.3 Problem specific representations

For selected problems that are widely applicable, we demonstrate useful techniques for mapping them to cost functions.

8.3.1 Modulo 2 linear programming

For the set of linear equationswhere are given, we want to solve for . The cost functionminimizes the Hamming distance between xA and y and thus the ground state represents a solution. If we consider the second factor for fixed i, we notice that it counts the number of 1s in x (mod 2) where A_ji does not vanish at the corresponding index. When acting withon |x⟩ we find the same result and thus the cost functionwith spin variables s_j has the solution to Eq. 154 as its ground state.

8.3.2 Representation of boolean functions

Given a boolean function f: {0,1}ⁿ → {0, 1} we want to express it as a cost function in terms of the n boolean variables. This is hard in general (Hadfield, 2021), but for (combinations of) local boolean functions there are simple expressions. In particular, we have, e.g.,

It is always possible to convert a k-SAT instance to 3-SAT and, more generally, any boolean formula to a 3-SAT in conjunctive normal form with the Tseytin transformation (Tseitin, 1983) with only a linear overhead in the size of the formula.

Note that for the purpose of encoding optimization problems, one might use different expressions that only need to coincide (up to a constant shift) with those shown here for the ground state/solution to the problem at hand. For example, if we are interested in a satisfying assignment for x₁ ∧…∧x_n we might formulate the cost function in two different ways that both have x₁ = … = x_n = 1 as their unique ground state; namely, and . The two corresponding spin Hamiltonians will have vastly different properties, as the first one will have, when expressed in spin variables, 2ⁿ terms with up to nth order interactions, whereas the second one has n linear terms. Additionally, configurations that are closer to a fulfilling assignment, i.e., that have more of the x_i equal to one, have a lower cost in the second option which is not the case for the first option. Note that for x₁ ∨…∨x_n there is no similar trick as we want to penalize exactly one configuration.

8.4 Meta optimization

There are several options for choices that arise in the construction of cost functions. These include meta parameters such as coefficients of building blocks but also reoccurring methods and techniques in dealing with optimization problems.

8.4.1 Auxiliary variables

It is often useful to combine information about a set of variables v_i into one auxiliary variable y that is then used in other parts of the cost function. Examples include the element counting building block or the maximal value of a set of variables where we showed a way to bind the value of an auxiliary variable to this function of the set of variables. If the function f can be expressed algebraically in terms of the variable values/indicator functions (as a finite polynomial), the natural way to do this is via adding the constraint termwith an appropriate coefficient c. To avoid the downsides of introducing constraints, there is an alternative route that might be preferred in certain cases. This alternative consists of simply using the variable indicator and expressing the variable indicator function in terms of spin/binary variables according to a chosen encoding (one does not even have to use the same encoding for y and the v_i). As an example, let us consider the auxiliary variable τ_m,t in the machine scheduling problem 7.3.3 for which we need to express . For simplicity, we can choose the one-hot encoding for v_m,t and τ_m,t, leading towhere the are the binary variables of the one-hot encoding of v_m,t.

8.4.2 Prioritization of cost function terms

If a cost function is constructed out of multiple terms,one often wants to prioritize one term over another, e.g., if the first term encodes a hard constraint. One strategy to ensure that f₁ is not “traded off” against f₂ is to evaluate the minimal cost Δ₁ in f₁ and the maximal gain Δ₂ in f₂ from flipping one spin. It can be more efficient to do this independently for both terms and assume a state close to an optimum. The coefficients can then be set according to c₁Δ₁ ≳ c₂Δ₂. In general, this will depend on the encoding for two reasons. First, for some encodings, one has to add core terms to the cost function which have to be taken into account for the prioritization (they usually have the highest priority). Furthermore, in some encodings, a single spin flip can cause the value of a variable to change by more than one³. Nonetheless, it can be an efficient heuristic to compare the “costs” and “gains” introduced above for pairs of cost function terms already in the encoding independent formulation by evaluating them for single variable changes by one and thereby fixing their relative coefficients. Then one only has to fix the coefficient for the core term after the encoding is chosen.

8.4.3 Problem conversion

Many decision problems associated with discrete optimization problems are NP-complete: one can always map them to any other NP-complete problem with only the polynomial overhead of classical runtime in the system size. Therefore, a new problem without a cost function formulation could be classically mapped to another problem where such a formulation is at hand. However, since quantum algorithms are hoped to deliver at most a polynomial advantage in the run time for general NP-hard problems, it is advisable to carefully analyze the overhead. This hope is based mainly on heuristic arguments related to the usefulness of quantum tunneling (Mandra et al., 2016) or empiric scaling studies (Guerreschi and Matsuura, 2019; Boulebnane and Montanaro, 2022). It is possible that there are trade-offs (as for k-SAT in Section 7.5.2), where in the original formulation the order of terms in the cost function is k while in the MIS formulation, we naturally have a QUBO problem where the number of terms scales worse in the number of clauses.

9 Conclusion and outlook

In this review, we have collected and elaborated on a wide variety of optimization problems that are formulated in terms of discrete variables. By selecting an appropriate qubit encoding for these variables, we can obtain a spin Hamiltonian suitable for quantum algorithms such as quantum annealing or QAOA. The choice of the qubits encoding leads to distinct Hamiltonians, influencing important factors such as the required number of qubits, the order of interactions, and the smoothness of the energy landscape. Consequently, the encoding decisions directly impact the performance of quantum algorithms.

The encoding-independent formulation (Sawaya et al., 2022) employed in this review offers a significant advantage by enabling the utilization of automated tools to explore diverse encodings, ultimately optimizing the problem formulation. This approach allows for a comprehensive examination and comparison of various encoding strategies, facilitating the identification of the most efficient configuration for a given optimization problem. In addition, the identification of recurring blocks facilitates the formulation of new optimization problems, also constituting a valuable automation tool. By leveraging these automatic tools, we can enhance the efficiency of quantum algorithms in solving optimization problems.

Finding the optimal spin Hamiltonian for a given quantum computer hardware platform is an important problem in itself. As pointed out by Sawaya et al. (2022), optimal spin Hamiltonians are likely to vary across different hardware platforms, underscoring the need for a procedure capable of tailoring a problem to a specific platform. The hardware-agnostic approach made use of in this review represents a further step in that direction.

References

• 1

  AmaroD.RosenkranzM.FitzpatrickN.HiranoK.FiorentiniM. (2022). A case study of variational quantum algorithms for a job shop scheduling problem. EPJ Quantum Technol.9, 5. 10.1140/epjqt/s40507-022-00123-4

  • CrossRef
  • Google Scholar

• 2

  Au-YeungR.ChancellorN.HalffmannP. (2023). NP-Hard but no longer hard to solve? Using quantum computing to tackle optimization problems. Front. Quantum Sci. Technol.2, 1128576. 10.3389/frqst.2023.1128576

  • CrossRef
  • Google Scholar

• 3

  BakóB.GlosO.SalehiA.ZimborásZ. (2022). Near-optimal circuit design for variational quantum optimization. arXiv:2209.03386. 10.48550/arXiv.2209.03386

  • CrossRef
  • Google Scholar

• 4

  BärtschiA.EidenbenzS. (2020). “Grover mixers for QAOA: shifting complexity from mixer design to state preparation,” in 2020 IEEE international conference on quantum computing and engineering (QCE), 72–82. 10.1109/QCE49297.2020.00020

  • CrossRef
  • Google Scholar

• 5

  BergeC. (1987). Hypergraphs. Amersterdam: Elsevier.

  • Google Scholar

• 6

  BerwaldJ.ChancellorN.DridiR. (2023). Understanding domain-wall encoding theoretically and experimentally. Phil. Trans. R. Soc. A381, 20210410. 10.1098/rsta.2021.0410

  • CrossRef
  • Google Scholar

• 7

  BoulebnaneS.MontanaroA. (2022). Solving boolean satisfiability problems with the quantum approximate optimization algorithm. arXiv preprint arXiv:2208.06909. 10.48550/arXiv.2208.06909

  • CrossRef
  • Google Scholar

• 8

  CaoY.RomeroJ.OlsonJ. P.DegrooteM.JohnsonP. D.KieferováM.et al (2019). Quantum chemistry in the age of quantum computing. Chem. Rev.119, 10856–10915. 10.1021/acs.chemrev.8b00803

  • CrossRef
  • Google Scholar

• 9

  CarugnoC.Ferrari DacremaM.CremonesiP. (2022). Evaluating the job shop scheduling problem on a D-wave quantum annealer. Sci. Rep.12, 6539. 10.1038/s41598-022-10169-0

  • CrossRef
  • Google Scholar

• 10

  ChancellorN. (2019). Domain wall encoding of discrete variables for quantum annealing and QAOA. Quantum Sci. Technol.4, 045004. 10.1088/2058-9565/ab33c2

  • CrossRef
  • Google Scholar

• 11

  ChancellorN.ZohrenS.WarburtonP. A. (2017). Circuit design for multi-body interactions in superconducting quantum annealing systems with applications to a scalable architecture. npj Quantum Inf.3, 21. 10.1038/s41534-017-0022-6

  • CrossRef
  • Google Scholar

• 12

  ChenJ.StollenwerkT.ChancellorN. (2021). Performance of domain-wall encoding for quantum annealing. IEEE Trans. Quantum Eng.2, 1–14. 10.1109/TQE.2021.3094280

  • CrossRef
  • Google Scholar

• 13

  ChoiV. (2010). Adiabatic quantum algorithms for the NP-complete maximum-weight independent set, exact cover and 3SAT problems. arXiv:1004.2226. 10.48550/ARXIV.1004.2226

  • CrossRef
  • Google Scholar

• 14

  DevroyeL.EpsteinP.SackJ.-R. (1993). On generating random intervals and hyperrectangles. J. Comput. Graph. Stat.2, 291–307. 10.2307/1390647

  • CrossRef
  • Google Scholar

• 15

  Di MatteoO.McCoyA.GysbersP.MiyagiT.WoloshynR. M.NavrátilP. (2021). Improving Hamiltonian encodings with the Gray code. Phys. Rev. A103, 042405. 10.1103/PhysRevA.103.042405

  • CrossRef
  • Google Scholar

• 16

  DlaskaC.EnderK.MbengG. B.KruckenhauserA.LechnerW.van BijnenR. (2022). Quantum optimization via four-body rydberg gates. Phys. Rev. Lett.128, 120503. 10.1103/PhysRevLett.128.120503

  • CrossRef
  • Google Scholar

• 17

  DorigoM.Di CaroG. (1999). “Ant colony optimization: a new meta-heuristic,” in Proceedings of the 1999 congress on evolutionary computation-CEC99 (Cat. No. 99TH8406) (IEEE), 2, 1470–1477. 10.1109/CEC.1999.782657

  • CrossRef
  • Google Scholar

• 18

  Drieb-SchönM.JavanmardY.EnderK.LechnerW. (2023). Parity quantum optimization: encoding constraints. Quantum7, 951. 10.22331/q-2023-03-17-951

  • CrossRef
  • Google Scholar

• 19

  ElliottM.GolubB.JacksonM. O. (2014). Financial networks and contagion. Am. Econ. Rev.104, 3115–3153. 10.1257/aer.104.10.3115

  • CrossRef
  • Google Scholar

• 20

  EnderK.MessingerA.FellnerM.DlaskaC.LechnerW. (2022). Modular parity quantum approximate optimization. PRX Quantum3, 030304. 10.1103/prxquantum.3.030304

  • CrossRef
  • Google Scholar

• 21

  EnderK.ter HoevenR.NiehoffB. E.Drieb-SchönM.LechnerW. (2023). Parity quantum optimization: compiler. Quantum7, 950. 10.22331/q-2023-03-17-950

  • CrossRef
  • Google Scholar

• 22

  FarhiE.GoldstoneJ.GutmannS. (2014). A quantum approximate optimization algorithm, 4028. arXiv:1411. 10.48550/ARXIV.1411.4028

  • CrossRef
  • Google Scholar

• 23

  FarhiE.GoldstoneJ.GutmannS.SipserM. (2000). Quantum computation by adiabatic evolution. arXiv:quant-ph/0001106. 10.48550/ARXIV.QUANT-PH/0001106

  • CrossRef
  • Google Scholar

• 24

  FeldS.RochC.GaborT.SeidelC.NeukartF.GalterI.et al (2019). A hybrid solution method for the capacitated Vehicle routing problem using a quantum annealer. Front. ICT6. 10.3389/fict.2019.00013

  • CrossRef
  • Google Scholar

• 25

  FellnerM.EnderK.ter HoevenR.LechnerW. (2023). Parity quantum optimization: benchmarks. Quantum7, 952. 10.22331/q-2023-03-17-952

  • CrossRef
  • Google Scholar

• 26

  FellnerM.MessingerA.EnderK.LechnerW. (2022). Universal parity quantum computing. Phys. Rev. Lett.129, 180503. 10.1103/PhysRevLett.129.180503

  • CrossRef
  • Google Scholar

• 27

  FuchsF. G.KoldenH. O.AaseN. H.SartorG. (2021). Efficient encoding of the weighted MAX k-CUT on a quantum computer using QAOA. SN Comput. Sci.2, 89. 10.1007/s42979-020-00437-z

  • CrossRef
  • Google Scholar

• 28

  FuchsF. G.LyeK. O.NilsenH. M.StasikA. J.SartorG. (2022). Constraint preserving mixers for the quantum approximate optimization algorithm. Algorithms15, 202. 10.3390/a15060202

  • CrossRef
  • Google Scholar

• 29

  GeorgescuI. M.AshhabS.NoriF. (2014). Quantum simulation. Rev. Mod. Phys.86, 153–185. 10.1103/RevModPhys.86.153

  • CrossRef
  • Google Scholar

• 30

  GlaserN. J.RoyF.FilippS. (2023). Controlled-controlled-phase gates for superconducting qubits mediated by a shared tunable coupler. Phys. Rev. Appl.19, 044001. 10.1103/PhysRevApplied.19.044001

  • CrossRef
  • Google Scholar

• 31

  GlosA.KrawiecA.ZimborásZ. (2022). Space-efficient binary optimization for variational quantum computing. npj Quantum Inf.8, 39. 10.1038/s41534-022-00546-y

  • CrossRef
  • Google Scholar

• 32

  GuerreschiG. G.MatsuuraA. Y. (2019). Qaoa for max-cut requires hundreds of qubits for quantum speed-up. Sci. Rep.9, 6903. 10.1038/s41598-019-43176-9

  • CrossRef
  • Google Scholar

• 33

  HadfieldS. (2021). On the representation of Boolean and real functions as Hamiltonians for quantum computing. ACM Trans. Quant. Comput.2, 1–21. 10.1145/3478519

  • CrossRef
  • Google Scholar

• 34

  HadfieldS.WangZ.O’GormanB.RieffelE. G.VenturelliD.BiswasR. (2019). From the quantum approximate optimization algorithm to a quantum alternating operator ansatz. Algorithms12, 34. 10.3390/a12020034

  • CrossRef
  • Google Scholar

• 35

  HadfieldS.WangZ.RieffelE. G.O’GormanB.VenturelliD.BiswasR. (2017). Quantum approximate optimization with hard and soft constraints. PMES’17. New York, NY, USA: Association for Computing Machinery. 10.1145/3149526.3149530

  • CrossRef
  • Google Scholar

• 36

  HenI.SarandyM. S. (2016). Driver Hamiltonians for constrained optimization in quantum annealing. Phys. Rev. A93, 062312. 10.1103/PhysRevA.93.062312

  • CrossRef
  • Google Scholar

• 37

  HenI.SpedalieriF. M. (2016). Quantum annealing for constrained optimization. Phys. Rev. Appl.5, 034007. 10.1103/PhysRevApplied.5.034007

  • CrossRef
  • Google Scholar

• 38

  IkedaK.NakamuraY.HumbleT. S. (2019). Application of quantum annealing to nurse scheduling problem. Sci. Rep.9, 12837. 10.1038/s41598-019-49172-3

  • CrossRef
  • Google Scholar

• 39

  IzawaS.KitaiK.TanakaS.TamuraR.TsudaK. (2022). Continuous black-box optimization with an ising machine and random subspace coding. Phys. Rev. Res.4, 023062. 10.1103/PhysRevResearch.4.023062

  • CrossRef
  • Google Scholar

• 40

  KingJ.YarkoniS.RaymondJ.OzfidanI.KingA. D.NevisiM. M.et al (2019). Quantum annealing amid local ruggedness and global frustration. J. Phys. Soc. Jpn.88, 061007. 10.7566/JPSJ.88.061007

  • CrossRef
  • Google Scholar

• 41

  KochenbergerG.HaoJ.-K.GloverF.LewisM.LüZ.WangH.et al (2014). The unconstrained binary quadratic programming problem: a survey. J. Comb. Optim.28, 58–81. 10.1007/s10878-014-9734-0

  • CrossRef
  • Google Scholar

• 42

  KurowskiK.WeglarzJ.SuboczM.RóżyckiR.WaligóraG. (2020). “Hybrid quantum annealing heuristic method for solving job shop scheduling problem,” in Computational science – ICCS 2020. Editors KrzhizhanovskayaV. V.ZávodszkyG.LeesM. H.DongarraJ. J.SlootP. M. A.BrissosS.et al (Springer International Publishing), 502–515.

  • Google Scholar

• 43

  LaiC.-Y.KuoK.-Y.LiaoB.-J. (2022). Syndrome decoding by quantum approximate optimization. arXiv:2207.05942. 10.48550/ARXIV.2207.05942

  • CrossRef
  • Google Scholar

• 44

  LanthalerM.LechnerW. (2021). Minimal constraints in the parity formulation of optimization problems. New J. Phys.23, 083039. 10.1088/1367-2630/ac1897

  • CrossRef
  • Google Scholar

• 45

  LechnerW.HaukeP.ZollerP. (2015). A quantum annealing architecture with all-to-all connectivity from local interactions. Sci. Adv.1, e1500838. 10.1126/sciadv.1500838

  • CrossRef
  • Google Scholar

• 46

  LechnerW. (2020). Quantum approximate optimization with parallelizable gates. IEEE Trans. Quantum Eng.1, 1–6. 10.1109/TQE.2020.3034798

  • CrossRef
  • Google Scholar

• 47

  LenstraJ. K.Rinnooy KanA. H. G. (1979). Computational complexity of discrete optimization problems. AODM4, 121–140. 10.1016/S0167-5060(08)70821-5

  • CrossRef
  • Google Scholar

• 48

  LuY.ZhangS.ZhangK.ChenW.ShenY.ZhangJ.et al (2019). Global entangling gates on arbitrary ion qubits. Nature572, 363–367. 10.1038/s41586-019-1428-4

  • CrossRef
  • Google Scholar

• 49

  LucasA. (2014). Ising formulations of many NP problems. Front. Phys.2, 5. 10.3389/fphy.2014.00005

  • CrossRef
  • Google Scholar

• 50

  MandraS.ZhuZ.WangW.Perdomo-OrtizA.KatzgraberH. G. (2016). Strengths and weaknesses of weak-strong cluster problems: a detailed overview of state-of-the-art classical heuristics versus quantum approaches. Phys. Rev. A94, 022337. 10.1103/physreva.94.022337

  • CrossRef
  • Google Scholar

• 51

  MazyavkinaN.SviridovS.IvanovS.BurnaevE. (2021). Reinforcement learning for combinatorial optimization: a survey. Comput. Oper. Res.134, 105400. 10.1016/j.cor.2021.105400

  • CrossRef
  • Google Scholar

• 52

  McArdleS.EndoS.Aspuru-GuzikA.BenjaminS. C.YuanX. (2020). Quantum computational chemistry. Rev. Mod. Phys.92, 015003. 10.1103/RevModPhys.92.015003

  • CrossRef
  • Google Scholar

• 53

  MelnikovB. (2005). “Discrete optimization problems-some new heuristic approaches,” in Eighth international conference on high-performance computing in asia-pacific region (HPCASIA’05) (IEEE), 73–82. 10.1109/HPCASIA.2005.34

  • CrossRef
  • Google Scholar

• 54

  MenkeT.BannerW. P.BergamaschiT. R.Di PaoloA.VepsäläinenA.WeberS. J.et al (2022). Demonstration of tunable three-body interactions between superconducting qubits. Phys. Rev. Lett.129, 220501. 10.1103/PhysRevLett.129.220501

  • CrossRef
  • Google Scholar

• 55

  MenkeT.HäseF.GustavssonS.KermanA. J.OliverW. D.Aspuru-GuzikA. (2021). Automated design of superconducting circuits and its application to 4-local couplers. npj Quantum Inf.7, 49. 10.1038/s41534-021-00382-6

  • CrossRef
  • Google Scholar

• 56

  MessingerA.FellnerM.LechnerW. (2023). Constant depth code deformations in the parity architecture. arXiv:2303.08602. 10.48550/arXiv.2303.08602

  • CrossRef
  • Google Scholar

• 57

  MohseniN.McMahonP. L.ByrnesT. (2022). Ising machines as hardware solvers of combinatorial optimization problems. Nat. Rev. Phys.4, 363–379. 10.1038/s42254-022-00440-8

  • CrossRef
  • Google Scholar

• 58

  Montanez-BarreraA.Maldonado-RomoA.WillschD.MichielsenK. (2022). Unbalanced penalization: a new approach to encode inequality constraints of combinatorial problems for quantum optimization algorithms. arXiv:2211.13914. 10.48550/arXiv.2211.13914

  • CrossRef
  • Google Scholar

• 59

  OrúsR.MugelS.LizasoE. (2019). Forecasting financial crashes with quantum computing. Phys. Rev. A99, 060301. 10.1103/PhysRevA.99.060301

  • CrossRef
  • Google Scholar

• 60

  PastawskiF.PreskillJ. (2016). Error correction for encoded quantum annealing. Phys. Rev. A93, 052325. 10.1103/PhysRevA.93.052325

  • CrossRef
  • Google Scholar

• 61

  PelegríG.DaleyA. J.PritchardJ. D. (2022). High-fidelity multiqubit Rydberg gates via two-photon adiabatic rapid passage. Quantum Sci. Technol.7, 045020. 10.1088/2058-9565/ac823a

  • CrossRef
  • Google Scholar

• 62

  PlewaJ.SieńkoJ.RycerzK. (2021). Variational algorithms for workflow scheduling problem in gate-based quantum devices. Comput. Inf.40, 897–929. 10.31577/cai_2021_4_897

  • CrossRef
  • Google Scholar

• 63

  PreskillJ. (2018). Quantum computing in the NISQ era and beyond. Quantum2, 79. 10.22331/q-2018-08-06-79

  • CrossRef
  • Google Scholar

• 64

  RachkovskiiD. A.SlipchenkoS. V.KussulE. M.BaidykT. N. (2005). Properties of numeric codes for the scheme of random subspaces rsc. Cybern. Syst. Anal.41, 509–520. 10.1007/s10559-005-0086-8

  • CrossRef
  • Google Scholar

• 65

  Ramos-CaldererS.Pérez-SalinasA.García-MartínD.Bravo-PrietoC.CortadaJ.PlanagumàJ.et al (2021). Quantum unary approach to option pricing. Phys. Rev. A103, 032414. 10.1103/PhysRevA.103.032414

  • CrossRef
  • Google Scholar

• 66

  RosenbergG.HaghnegahdarP.GoddardP.CarrP.WuK.de PradoM. L. (2015). “Solving the optimal trading trajectory problem using a quantum annealer,” in Proceedings of the 8th workshop on high performance computational finance (New York, NY, USA: Association for Computing Machinery). 10.1145/2830556.2830563

  • CrossRef
  • Google Scholar

• 67

  SawayaN. P. D.MenkeT.KyawT. H.JohriS.Aspuru-GuzikA.GuerreschiG. G. (2020). Resource-efficient digital quantum simulation of d-level systems for photonic, vibrational, and spin-s Hamiltonians. npj Quantum Inf.6, 49. 10.1038/s41534-020-0278-0

  • CrossRef
  • Google Scholar

• 68

  SawayaN. P. D.SchmitzA. T.HadfieldS. (2022). Encoding trade-offs and design toolkits in quantum algorithms for discrete optimization: coloring, routing, scheduling, and other problems, 14432. arXiv:2203. 10.48550/arXiv.2203.14432

  • CrossRef
  • Google Scholar

• 69

  SchöndorfM.WilhelmF. K. (2019). Nonpairwise interactions induced by virtual transitions in four coupled artificial atoms. Phys. Rev. Appl.12, 064026. 10.1103/PhysRevApplied.12.064026

  • CrossRef
  • Google Scholar

• 70

  SteinJ.ChamanianF.ZornM.NüßleinJ.ZielinskiS.KölleM.et al (2023). Evidence that PUBO outperforms QUBO when solving continuous optimization problems with the QAOA. arXiv:2305.03390. 10.48550/arXiv.2305.03390

  • CrossRef
  • Google Scholar

• 71

  TamuraK.ShiraiT.KatsuraH.TanakaS.TogawaN. (2021). Performance comparison of typical binary-integer encodings in an ising machine. IEEE Access9, 81032–81039. 10.1109/ACCESS.2021.3081685

  • CrossRef
  • Google Scholar

• 72

  TseitinG. S. (1983). “On the complexity of derivation in propositional calculus,” in Automation of reasoning (Springer), 466–483. 10.1007/978-3-642-81955-1_28

  • CrossRef
  • Google Scholar

• 73

  UngerJ.MessingerA.NiehoffB. E.FellnerM.LechnerW. (2022). Low-depth circuit implementation of parity constraints for quantum optimization, 11287. arXiv:2211. 10.48550/ARXIV.2211.11287

  • CrossRef
  • Google Scholar

• 74

  VenturelliD.MarchandD. J. J.RojoG. (2015). Quantum annealing implementation of job-shop scheduling. arXiv:1506.08479. 10.48550/ARXIV.1506.08479

  • CrossRef
  • Google Scholar

• 75

  WangZ.RubinN. C.DominyJ. M.RieffelE. G. (2020). XY mixers: analytical and numerical results for the quantum alternating operator ansatz. Phys. Rev. A101, 012320. 10.1103/PhysRevA.101.012320

  • CrossRef
  • Google Scholar

• 76

  WilkinsonS. A.HartmannM. J. (2020). Superconducting quantum many-body circuits for quantum simulation and computing. Appl. Phys. Lett.116, 230501. 10.1063/5.0008202

  • CrossRef
  • Google Scholar

• 77

  ZhuY.ZhangZ.SundarB.GreenA. M.AldereteC. H.NguyenN. H.et al (2023). Multi-round QAOA and advanced mixers on a trapped-ion quantum computer. Quantum Sci. Technol.8, 015007. 10.1088/2058-9565/ac91ef

  • CrossRef
  • Google Scholar