Parameter Determination of Quantum Approximate Optimization Algorithm Using Layerwise Grid Search Method ^†

Abstract

The quantum approximate optimization algorithm (QAOA) is an efficient method for solving combinatorial optimization problems in quantum computing. These problems involve finding the best solution from a finite set of possibilities. At its core, the QAOA uses an Ansatz circuit composed of alternating unitary operators, the mixing and problem Hamiltonians, that are controlled by a set of parameters. Its goal is to find the optimal parameters so that the final quantum state of the circuit encodes the problem’s solution. While this parameter optimization is often handled by classical optimizers, including constrained optimization by linear approximations (COBYLA) and Nelder–Mead, these methods frequently present local extrema. Therefore, we developed a layerwise grid search (LGS) method as an alternative. Since a full grid search is too time-consuming, the LGS method significantly reduces the search time while still finding a good solution. To demonstrate its effectiveness, we present experimental results for the max-cut problem, comparing the performance of our LGS method against conventional classical optimizers.

1. Introduction

Quantum computation is a revolutionary field that uses the principles of quantum mechanics to process information, offering a paradigm shift from classical computing [1,2,3,4]. While classical computers rely on binary bits (0 s and 1 s), quantum computers use qubits, which can exist in a superposition of both states simultaneously. This, along with entanglement, which is a phenomenon where qubits are linked and their states are interdependent, enables quantum computers to perform certain calculations exponentially faster than classical machines. This has led to the development of powerful quantum algorithms, such as Shor’s algorithm for integer factorization and Grover’s algorithm for database searches, which provide exponential and quadratic speedups, respectively, over their classical counterparts.

These breakthroughs have significant implications, particularly in cybersecurity. For example, Shor’s algorithm poses a direct threat to current public-key encryption, driving the urgent development of new, quantum-resistant cryptographic methods. Beyond security, an emerging subfield of quantum machine learning seeks to leverage quantum computers to accelerate the training of complex models and to analyze vast datasets, which could lead to significant discoveries in fields like materials science and drug development. The ongoing challenge is to develop robust quantum hardware and refine these algorithms, with the ultimate promise of transforming computation, data analysis, and problem-solving across countless engineering disciplines.

In the research of quantum computation, the quantum approximate optimization algorithm (QAOA) is a hybrid quantum–classical algorithm designed to find approximate solutions to combinatorial optimization problems, which involves finding the best solution from a finite, but often exponentially large, set of possibilities [5,6,7]. The QAOA is well-suited for the noisy intermediate-scale quantum era because it uses relatively shallow quantum circuits [8]. The algorithm operates by encoding the optimization problem into a quantum circuit with adjustable parameters. It begins by preparing a quantum state in a uniform superposition of all possible solutions. This state is then evolved by a sequence of two types of unitary operators: a problem Hamiltonian, which imprints the cost function of the optimization problem onto the quantum state, and a mixing Hamiltonian, which helps explore the solution space by creating new superpositions. The duration of each application of these Hamiltonians is controlled by classical parameters. A classical computer then measures the final quantum state, evaluates its quality, and uses a classical optimizer to adjust the parameters, creating a feedback loop to find better solutions. This iterative process allows the QAOA to iteratively shape the quantum state to concentrate its probability amplitude on the best possible solutions, offering a promising approach to tackle complex problems in logistics, finance, and materials science that are currently intractable for classical computers.

On the other hand, grid search methods are widely used to determine optimal hyperparameters in machine learning [9,10], but they are often computationally expensive. Instead of using a full grid search, we apply the layerwise grid search (LGS) method to find the optimal parameters for the quantum approximate optimization algorithm in this paper. The idea behind it is to break down the parameter tuning problem for an Ansatz circuit into a series of smaller, more manageable sub-problems. Instead of finding the optimal parameters for the entire Ansatz circuit at once (which is an astronomically large and computationally expensive search space), we sequentially tune the layers. That is, we perform a grid search to find the optimal parameters for the first layer of the Ansatz circuit. Once we have the best parameters for the first layer, we perform another grid search to find the best parameters for the second layer, while keeping the first layer’s parameters fixed. This process is repeated for each subsequent layer, with the new layer’s parameters being tuned on top of the already-tuned layers. Moreover, to show the effectiveness of the LGS method, we present experimental results for the max-cut problem and compare the performance against conventional classical optimizers.

This article is structured as follows. Section 2 provides a brief review of relevant background concepts, including quantum computation and the QAOA. Section 3 details our proposed layerwise grid search method. Section 4 discusses the experimental results of applying the QAOA with our LGS method to the max-cut problem. Performance comparisons of our LGS method with conventional classical optimizers are also made. Finally, discussions and conclusions are drawn.

2. Preliminaries

2.1. Basics of Quantum Computation

In quantum computation, a quantum bit, or qubit, is a two-state system. Using Dirac ket notation, we represent the two basis states as $\left|0\right.⟩$ and $\left|1\right.⟩$. The state of a single qubit can be a superposition of these two basis states, described by a linear combination.

$$\left|\varphi \right.⟩={\alpha }_0\left|0\right.⟩+{\alpha }_1\left|1\right.⟩.$$

(1)

In the above, ${\alpha }_0$ and ${\alpha }_1$ are complex numbers called probability amplitudes, and they must satisfy condition

$${\left|{\alpha }_0\right|}^2+{\left|{\alpha }_1\right|}^2=1,$$

(2)

where $|{\alpha }_0{|}^2$ is the probability of measuring the state as $\left|0\right.⟩$ and $|{\alpha }_1{|}^2$ is the probability of measuring the state as $\left|1\right.⟩$. When $n$ qubits are joined to get a quantum register, the state of register can be represented as follows:

$$\left|\varphi \right.⟩={\sum }_{k=0}^{2^n-1}{\alpha }_k\left|k\right.⟩,$$

(3)

where $\left|k\right.⟩$ are basis states and $|{\alpha }_k{|}^2$ is the probability of measuring the state as $\left|k\right.⟩$. The following normalization condition must be satisfied:

$${\sum }_{k=0}^{2^n-1}{\left|{\alpha }_k\right|}^2=1,$$

(4)

As classical computers use logic gates (AND, OR, NOT, and NAND) to manipulate bits, quantum computers use quantum gates to operate qubits. These gates are represented by unitary matrices $U$ to preserve the normalization of the state vector. A simple example is the Pauli X gate, which flips the state of qubit by the unitary matrix.

$$\mathit{U}=\left[\begin{array}{cc}0& 1\\ 1& 0\end{array}\right].$$

(5)

Applying this gate to a qubit in the state $\left|0\right.⟩$ results in the following:

$$\mathit{U}\left|0\right.⟩=\left[\begin{array}{cc}0& 1\\ 1& 0\end{array}\right]\left[\begin{array}{c}1\\ 0\end{array}\right]=\left[\begin{array}{c}0\\ 1\end{array}\right]=\left|1\right.⟩.$$

(6)

Figure 1 shows frequently used quantum gates, circuit symbols, and unitary transform matrices $\mathit{U}$. A quantum circuit is a sequence of these gates applied to one or more qubits, forming a computation.

A typical structure used in quantum computation is shown in Figure 2. First, an initial superposition state is prepared; that is, the classical data is loaded into the quantum register. Second, the quantum circuit constructed using elementary quantum gates with prescribed parameters performs the unitary transformation on the state of register such that the initial state is mapped to the desired state, which encodes the solution. Third, full or partial qubits are measured as the results of the computation performed using measurement gates. These results are saved in the classical register, and post-processing tasks are conducted to obtain the final solution. The structure in Figure 2 is used to construct the quantum computation part of the QAOA.

2.2. Background Knowledge of QAOA

The QAOA is a hybrid quantum–classical (HQC) algorithm designed to find approximate solutions to combinatorial problems. Figure 3a shows a typical block diagram in which the HQC algorithm is performed on a classical computer and a quantum computer. Both computers communicate with each other by using the data saved in memory. Figure 3b shows another HQC block diagram of an iterative method. In the iterative loop, the quantum computer provides the measured result to the classical computer. The parameters in the classical computer are sent to the quantum computer.

The core idea of the QAOA is to encode the relevant optimization problem into the cost of the Hamiltonian $H_C$. The ground state of the Hamiltonian $H_C$ corresponds to the optimal solution of the problem. Figure 4 illustrates the overview of the p-layer QAOA, whose quantum part is obtained from the structure in Figure 2; that is, the unitary transformation is replaced by an alternating operator Ansatz circuit with two parameter vectors, $\gamma =[{\gamma }_1,{\gamma }_2,\cdots ,{\gamma }_p{]}^T$ and $\beta =[{\beta }_1,{\beta }_2,\cdots ,{\beta }_p{]}^T$. Moreover, the details of the Ansatz circuit are depicted in Figure 5, where $U(H_C,{\gamma }_k)$ are cost unitary operators and $U(H_B,{\gamma }_k)$ are mixing unitary operators for $k=1, 2,\cdots ,p$.

The QAOA is a variational algorithm, so it relies on a classical computer to iteratively optimize the parameters $\gamma$ and $\beta$ of a shallow quantum Ansatz circuit. If $n$ qubits are used, the details of the QAOA method are described below. The initial state preparation is obtained by applying the Hadamard gate to each of the n qubits, starting from the ${\left|0\right.⟩}^{\otimes n}$ state as follows:

$$\left|{\varphi }_{initial}\right.⟩=H^{\otimes n}{\left|0\right.⟩}^{\otimes n}={\left|+\right.⟩}^{\otimes n},$$

(7)

where $\left|+\right.⟩={\displaystyle \frac{1}{\sqrt{2}}}\left|0\right.⟩+{\displaystyle \frac{1}{\sqrt{2}}}\left|1\right.⟩$. That is, the initial state is a uniform superposition of all $2^n$ computational basis states. Moreover, the QAOA state generated by the alternating operator Ansatz circuit with p layers is given as follows:

$$\left|\varphi (\gamma ,\beta )\right.⟩=U(H_B,{\beta }_p)U(H_C,{\gamma }_p)\cdots U(H_B,{\beta }_1)U(H_C,{\gamma }_1){\left|+\right.⟩}^{\otimes n},$$

(8)

where $\gamma =[{\gamma }_1,{\gamma }_2,\cdots ,{\gamma }_p{]}^T$ and $\beta =[{\beta }_1,{\beta }_2,\cdots ,{\beta }_p{]}^T$ are the variational parameters that are optimized classically. The above unitary operators, $U(H_C,{\gamma }_k)$ and $U(H_B,{\beta }_k)$ $(k=1, 2,\cdots ,p)$, are described below.

The cost unitary operator $U(H_C,{\gamma }_k)$ is used to encode the optimization problem cost function. It is defined as follows:

$$U(H_C,{\gamma }_k)=e^{-i{\gamma }_k{H}_C}\hspace{1em}\hspace{1em}k=\mathrm{1,2},\cdots ,p.$$

(9)

This operator applies a phase to each computation basis state proportional to its cost. If the cost Hamiltonian $H_C$ is the sum of local terms as follows:

$$H_C={\sum }_m{H}_{C,m},$$

(10)

then the cost unitary matrix $U(H_C,{\gamma }_k)$ can be implemented as a product of exponentials by using the Trotter–Suzuki decomposition.

$$U(H_C,{\gamma }_k)=e^{-i{\gamma }_k{H}_C}=e^{-i{\gamma }_k{\sum }_m{H}_{C,m}}\approx {\prod }_m{e}^{-i{\gamma }_k{H}_{C,m}}.$$

(11)

If the individual terms $H_{C,m}$ commute, the decomposition in Equation (11) becomes exact. Otherwise, it is an approximation. In [5], the parameters ${\gamma }_k$ $(k=\mathrm{1,2},\cdots ,p)$ are all restricted to lie between 0 and $2\pi$; that is, ${\gamma }_k\in [0,2\pi ]$.

The mixing unitary operator $U(H_B,{\beta }_k)$ is used to explore the solution space by introducing fluctuations. The mixer Hamiltonian $H_B$ is often chosen as the sum of Pauli-X operators ${\sigma }^x$ on each qubit as follows:

$$H_B={\sum }_{j=1}^n{\sigma }_j^x.$$

(12)

Therefore, the mixing unitary matrix $U(H_B,{\beta }_k)$ is given as follows:

$$U(H_B,{\beta }_k)=e^{-i{\beta }_k{H}_B}=e^{-i{\beta }_k{\sum }_{j=1}^n{\sigma }_j^x}={\prod }_{j=1}^n{e}^{-i{\beta }_k{\sigma }_j^x}.$$

(13)

In reference [5], the parameters ${\beta }_k$ $(k=\mathrm{1,2},\cdots ,p)$ are all restricted to lie between 0 to $\pi$; that is, ${\beta }_k\in [0,\pi ]$.

Based on the above descriptions, the procedure of the QAOA is summarized as follows:

• Step 1: Initialize the parameters $\gamma$ and $\beta$ randomly.
• Step 2: Prepare the quantum initial state $\left|{\varphi }_{initial}\right.⟩$ using Equation (7).
• Step 3: Execute the alternating operator Ansatz quantum circuit with given parameters $\gamma$ and $\beta$ to get the state $\left|\varphi (\gamma ,\beta )\right.⟩$ in Equation (8).
• Step 4: Measure the state $\left|\varphi (\gamma ,\beta )\right.⟩$ multiple times to estimate the expectation value:

  $$J(\gamma ,\beta )=\left.⟨\varphi (\gamma ,\beta )\right|H_C\left|\varphi (\gamma ,\beta )\right.⟩.$$

  (14)
• Step 5: Use a classical computer with Nelder–Mead, constrained optimization by linear approximations (COBYLA), or gradient descent methods to find new better parameters $\gamma$ and $\beta$ that are expected to result in a lower $J(\gamma ,\beta )$.
• Step 6: Check whether the termination condition is fulfilled or not. If the condition is satisfied, stop the iterative procedure. Otherwise, go back to step 2 and repeat the process.

Once the above iterative loop is completed, the final parameters $\gamma$ and $\beta$ are used to run the quantum computer to obtain state $\left|\varphi (\gamma ,\beta )\right.⟩$. This final state is measured, and the resulting bit string is the final solution produced by the QAOA method. In step 5, the Nelder–Mead or COBYLA method needs to be employed to find the parameters $\gamma$ and $\beta$. Because these optimization tools are complicated, a simple layerwise grid search method is used in this study.

3. Layerwise Grid Search Method

In this section, the LGS method is used to find the parameters $\gamma$ and $\beta$ of the Ansatz circuit that yield good performance. A conventional full grid search is first described. Then, the LGS method is described.

3.1. Full Grid Search Method

For a grid search method, we define a discrete, finite set of parameters ${\gamma }_k$ and ${\beta }_k$ $(k=\mathrm{1,2},\cdots ,p)$. To achieve this purpose, the parameter space $({\gamma }_k,{\beta }_k)$ at the k-th layer of the Ansatz circuit is discretized below. Because ${\gamma }_k$ is restricted to lie in the interval $[0,2\pi ]$ and ${\beta }_k$ is restricted to lie in the interval $[0,\pi ]$, the uniform dense grid points of $({\gamma }_k,{\beta }_k)$ are defined as follows:

$${\gamma }_k^{\left(m_k\right)}={\displaystyle \frac{m_k\pi }{N}} (m_k=\mathrm{0,1},2,\cdots ,2N),$$

(15)

$${\beta }_k^{\left(j_k\right)}={\displaystyle \frac{j_k\pi }{N}} (j_k=\mathrm{0,1},2,\cdots ,N).$$

(16)

Figure 6 shows the graphical representation of this discretization of parameter space. All of these grid points of $({\gamma }_k,{\beta }_k)$ can be combined into the following point set:

$$S_k=\left\{\right({\gamma }_k^{\left(m_k\right)},{\beta }_k^{\left(j_k\right)}\left)\right|m_k=\mathrm{0,1},\cdots ,2N, j_k=\mathrm{0,1},\cdots ,N\}.$$

(17)

The grid of all possible parameter combinations of the QAOA is the Cartesian product of all sets at each layer.

$$\begin{array}{c}Grid=S_1\times S_2\times \cdots \times S_p\\ =\left\{\right({\gamma }_1^{\left(m_1\right)},{\beta }_1^{\left(j_1\right)})\in S_1,\cdots ,({\gamma }_p^{\left(m_p\right)},{\beta }_p^{\left(j_p\right)})\in S_p\}\end{array}.$$

(18)

The full grid search algorithm exhaustively evaluates every single possible combination from the Grid in Equation (18), and the one with the best performance is selected as the solution. That is, the optimal parameter is given as follows:

$$({\gamma }^{\ast },{\beta }^{\ast })=\underset{(\gamma ,\beta )\in Grid}{argmin}J(\gamma ,\beta ),$$

(19)

where $J(\gamma ,\beta )$ is defined in (14). Although the above grid search method is simple and effective for finding the optimal parameters ${\gamma }^{\ast }$ and ${\beta }^{\ast }$, it is computationally extensive and time-consuming. The total number of grid points in (18) is equal to $\left(\right(2N+1\left)\right(N+1){)}^p$, so the computational complexity of the full grid search method is $O\left(N^{2p}\right)$. That is, the number of evaluations of the cost function $J(\gamma ,\beta )$ grows exponentially. To reduce the computational load, a layerwise grid search method is used.

3.2. LGS Method

Instead of finding the optimal parameters $\gamma$ and $\beta$ for the entire Ansatz circuit at once, the optimization problem is broken down into a series of smaller, more manageable sub-problems. And each sub-problem is sequentially solved layer by layer. The Ansatz circuit is chosen as a single-layer circuit with $p=1$; then, the first step of the LGS method is to find the best parameters ${\gamma }_1^{\ast }$ and ${\beta }_1^{\ast }$. That is, the best parameters ${\gamma }_1^{\ast }$ and ${\beta }_1^{\ast }$ are determined by using the following equation:

$$({\gamma }_1^{\ast },{\beta }_1^{\ast })=\underset{({\gamma }_1,{\beta }_1)\in S_1}{argmin}{J}_1({\gamma }_1,{\beta }_1).$$

(20)

The above cost function $J_1({\gamma }_1,{\beta }_1)$ is defined as follows:

$$J_1({\gamma }_1,{\beta }_1)=\left.⟨\varphi ({\gamma }_1,{\beta }_1)\right|H_C\left|\varphi ({\gamma }_1,{\beta }_1)\right.⟩,$$

(21)

where state is given as Equation (22):

$$\left|\varphi ({\gamma }_1,{\beta }_1)\right.⟩=U(H_B,{\beta }_1)U(H_C,{\gamma }_1){\left|+\right.⟩}^{\otimes n}.$$

(22)

Because the number of grid points in this sub-problem is equal to $(2N+1)(N+1)$, the computational complexity is only $O\left(N^2\right)$. After we have the best parameters for the first layer, we perform another grid search to find the best parameters ${\gamma }_2^{\ast }$ and ${\beta }_2^{\ast }$ for the second layer, while keeping the first layer’s parameters $({\gamma }_1,{\beta }_1)$ fixed at $({\gamma }_1^{\ast },{\beta }_1^{\ast })$. That is, let the Ansatz circuit be chosen as a double-layer circuit with $p=2$; the best parameters ${\gamma }_2^{\ast }$ and ${\beta }_2^{\ast }$ are determined by the following equation:

$$({\gamma }_2^{\ast },{\beta }_2^{\ast })=\underset{({\gamma }_2,{\beta }_2)\in S_2}{argmin}{J}_2({\gamma }_2,{\beta }_2).$$

(23)

The above cost function $J_2({\gamma }_2,{\beta }_2)$ is defined as follows:

$$J_2({\gamma }_2,{\beta }_2)=\left.⟨\varphi ({\gamma }_2,{\beta }_2)\right|H_C\left|\varphi ({\gamma }_2,{\beta }_2)\right.⟩,$$

(24)

where state is given by

$$\left|\varphi ({\gamma }_2,{\beta }_2)\right.⟩=U(H_B,{\beta }_2)U(H_C,{\gamma }_2)U(H_B,{\beta }_1^{\ast })U(H_C,{\gamma }_1^{\ast }){\left|+\right.⟩}^{\otimes n}.$$

(25)

After we have the best parameters for the first and second layers, we perform the other grid search to find the best parameters ${\gamma }_3^{\ast }$ and ${\beta }_3^{\ast }$ for the third layer, while keeping the first and second layer’s parameters fixed at $({\gamma }_1^{\ast },{\beta }_1^{\ast })$ and $({\gamma }_2^{\ast },{\beta }_2^{\ast })$. That is, the Ansatz circuit is used as a triple-layer circuit with $p=3$; the best parameters ${\gamma }_3^{\ast }$ and ${\beta }_3^{\ast }$ are found by the following equation:

$$({\gamma }_3^{\ast },{\beta }_3^{\ast })=\underset{({\gamma }_3,{\beta }_3)\in S_3}{argmin}{J}_3({\gamma }_3,{\beta }_3).$$

(26)

The above cost function $J_3({\gamma }_3,{\beta }_3)$ is defined as follows:

$$J_3({\gamma }_3,{\beta }_3)=\left.⟨\varphi ({\gamma }_3,{\beta }_3)\right|H_C\left|\varphi ({\gamma }_3,{\beta }_3)\right.⟩,$$

(27)

where state is given as follows:

$$\left|\varphi ({\gamma }_3,{\beta }_3)\right.⟩=U(H_B,{\beta }_3)U(H_C,{\gamma }_3)U(H_B,{\beta }_2^{\ast })U(H_C,{\gamma }_2^{\ast })U(H_B,{\beta }_1^{\ast })U(H_C,{\gamma }_1^{\ast }){\left|+\right.⟩}^{\otimes n}.$$

(28)

The process is repeated for each subsequent layer, with the new layer’s parameters being determined on top of the already-determined layers. Because there are p layers in the Ansatz circuit in Figure 5, we need to solve p sub-problems with computational complexity $O\left(N^2\right)$ at each layer. Therefore, the total computational complexity of the above layerwise grid search method is $O\left(p{N}^2\right)$, which is much smaller than the complexity $O\left(N^{2p}\right)$ of the conventional full grid search method. In Section 4, the max-cut problem is solved by the QAOA with the LGS method to show the effectiveness of the proposed method.

4. Results and Discussions

A typical application example for the QAOA is the max-cut problem. Given a graph $G=\{V,E\}$ where $V$ is the vertex set and $E$ is the edge set, the goal of max-cut is to partition the vertex set $V$ into two disjoint subsets, $V_1$ and $V_2$, such that the number of edges with one endpoint in $V_1$ and the other in $V_2$ is maximized. The cost Hamiltonian $H_C$ of this max-cut problem is given by

$$H_C={\displaystyle \frac{1}{2}}{\sum }_{(\mathcal{l},m)\in E}(1-{\sigma }_{\mathcal{l}}^z{\sigma }_m^z),$$

(29)

where ${\sigma }^z$ is the Pauli Z operator. This maximization problem is transformed into a minimization problem by multiplying the cost function by a factor of –1 such that the QAOA can be performed. The max-cut of a star graph is used to conduct the experiment. Figure 7a shows a star graph with five vertices and four edges, and Figure 7b depicts the maximum cut of this star graph.

When the QAOA is applied to solve this problem, the details of the alternating operator of the Ansatz circuit with p = 1 are shown in Figure 8. In this circuit, each qubit corresponds to each vertex, and each ZZ gate corresponds to each edge.

Figure 9 shows the results of the first step of the LGS method. The integer $N$ in Equations (15) and (16) is chosen as 30. The cost function $J_1({\gamma }_1,{\beta }_1)$ defined in Equation (21) is shown in Figure 9a. The best parameters ${\gamma }_1^{\ast }$ and ${\beta }_1^{\ast }$ to minimize $J_1({\gamma }_1,{\beta }_1)$ are then given by 5.64421731 and 1.94995406. Figure 9b depicts the count of measured histogram of the QAOA method with p = 1 when the quantum circuit is performed 1024 times. The expectation value of the cut of the star graph is 3.04199219 for this result with p = 1.

Moreover, when the QAOA is applied to solve this problem, the details of the alternating operator Ansatz circuit with p = 2 are shown in Figure 10. The experimental results of the second step of the LGS method are shown in Figure 11. The cost function $J_2({\gamma }_2,{\beta }_2)$ defined in Equation (24) is shown in Figure 11a. The best parameters ${\gamma }_2^{\ast }$ and ${\beta }_2^{\ast }$ to minimize $J_2({\gamma }_2,{\beta }_2)$ are then given as 4.68576531 and 1.19163859. Figure 11b depicts the count of measured histogram of the QAOA method with p = 2 when the quantum circuit is performed 1024 times. The expectation value of the cut of the star graph is 3.90917969 for this result with p = 2.

Next, when the QAOA is applied to solve this problem, the details of the alternating operator Ansatz circuit with p = 3 are shown in Figure 12. The experimental results of the third step of the LGS method are shown in Figure 13. The cost function $J_3({\gamma }_3,{\beta }_3)$ defined in Equation (27) is shown in Figure 13a. The best parameters ${\gamma }_3^{\ast }$ and ${\beta }_3^{\ast }$ to minimize $J_3({\gamma }_3,{\beta }_3)$ are then given as 5.64421731 and 3.03326187. Figure 13b depicts the count of measured histogram of the QAOA method with p = 3 when the quantum circuit is performed 1024 times. The expectation value of the cut of the star graph is 3.984375 for this result with p = 3. Furthermore, the bit strings 00100 and 11011 are observed to have the highest counts, which correlate with the maximum-cut scenario depicted in Figure 7b. As the maximum cut for the star graph in Figure 7 is 4, an expectation value of the cut that more closely approaches this value of 4 is indicative of superior performance by the QAOA method.

Finally, let us compare the proposed LGS method with conventional methods. When QAOA methods using COBYLA and Nelder–Mead are used to solve the max-cut problem of the star graph, Figure 14a,b show the counts of measured histograms of conventional QAOA methods with p = 3 when the quantum circuit is performed 1024 times. The expectation value of the cut of the star graph is 3.837890625 for the COBYLA method. The expectation value of the cut of the star graph is 3.5537109375 for the Nelder–Mead method. Both cut values are smaller than the cut value 3.984375 of the proposed method. Therefore, the proposed LGS method is effective for solving the max-cut problem of the graph.

5. Conclusions

We propose the LGS method to determine the optimal parameters for the QAOA, specifically targeting combinatorial optimization problems in quantum computing. The LGS method significantly reduces search time compared to a full grid search while still identifying a high-quality solution. To demonstrate its effectiveness, we provide experimental results on the max-cut problem for a star graph, comparing the performance of the LGS against conventional classical optimizers, such as COBYLA and Nelder–Mead. Since this study was limited to the graph max-cut problem, an interesting direction for future work is to apply the QAOA with the LGS method to a wider variety of combinatorial optimization problems.