Enhancing Knapsack-based Financial Portfolio Optimization Using Quantum Approximate Optimization Algorithm

The feasibility oracle is used as a hypothetical subroutine that instantly determines whether a proposed solution to the knapsack problem violates any constraints [41]. We can explore solutions within a well-defined space of bitstrings by representing our portfolio model as a binary knapsack problem. We defined $K(N)=(0,1)^{N}$ as the set of all possible bitstrings of length $N$ representing potential portfolio choices. Furthermore, each possible choice of any of the $N$ items is represented by a bitstring $x\in K(N)$. ). Thus, the subset feasible solution was denoted as $F$ for the knapsack problem, and the feasibility function was defined as

Considerably, the feasibility oracle to be unitary $U_{f}$ as:

In portfolio optimization, a state $\ket{x}$ symbolizes a specific stock allocation, which is deemed feasible (i.e., $x\in F$) if the total weight $w(x)$ does not exceed the capacity $C$. This oracle toggles a flag qubit $\ket{y}$ based on the feasibility of the state $\ket{x}$, representing a possible portfolio configuration.

Next, we allocated qubits for storage as follows: $S$ to record the formulated knapsack choices, $K_{w}$ to hold the weight of the item choice, and $K_{F}$ as the flag qubit indicating the feasibility of the state $S$. Remarkably, the number of qubits required for $S$, $K_{w}$, and $K_{F}$ are deonted by $Q_{S}$, $Q_{w}$, and $Q_{F}$ respectively. Upon that, the total number of qubits that are required is $Q_{S}+Q_{w}+Q_{F}$.

Furthermore, the total weight $w(x)$ is calculated by adding the weight of each item to register $K_{w}$, controlled by the corresponding bit in register $S$. We also compare the computed weight $w(x)$ to the capacity $C$ using an inequality check facilitated by a multiple-controlled NOT gate.

For suitable $W_{0}\in\mathbb{N}$, the inequality can be verified using the following condition:

This condition ensures that the binary representation of $w(x)+C_{0}$ has zeros in all positions beyond $k$. The feasibility oracle $U_{f}$ employs two primary unitary operations-$U_{1}$ and $U_{2}$. $U_{1}$ augments $K_{w}$ with a predetermined offset $C_{0}$, facilitating the binary representation required for the feasibility check; $U_{2}$ is applied conditionally based on $U_{1}$’s outcome.

We begin by illustrating how $U_{1}$ is prepared. Quantum Fourier Transform (QFT) [40] is employed within the unitary operation $U_{1}$ to facilitate the process of adding weights in the knapsack problem.

This process starts with the initialization of the ancillary weight register $K_{w}$ to $\ket{0}$. Next, QFT is applied to $K_{w}$ to prepare the register for quantum addition, even though the QFT does not change the state for state $\ket{0}$. This step is necessary for nonzero initial states $K_{w}$. Post-state transformation of $K_{w}$ from the computational basis to the Fourier basis, the weight representation was distributed across the amplitude of the quantum state:

where we use the notaion $e(t)=exp(2\pi it)$, and $k\in\mathbb{Z}$ is the binary representation of $k_{n}-1,\cdot\cdot\cdot,k_{0}$. Furthermore, weights were added to $QFT\ket{K_{w}}$ using controlled operations applying phase rotations. These operations are conditioned on the bits of the bitstring $x$ indicating the selection of items. Each bit in $x$ determines whether the corresponding weight $w_{i}$ should be added to $K_{w}$. The addition in the Fourier space was related to phase rotation and implemented by a sequence of controlled phase gates. The magnitude of the rotation was determined by $w_{i}$ and the position of the bit controlling the operation. The implementation of controlled additions can be described as follows: for each selected item (where the corresponding bit in $x$ is $\ket{1}$, a controlled phase rotation is applied to $K_{w}$. The phase added to each computational basis state $\ket{k}$ within $K_{w}$ is proportional to $w_{i}$:

This phase rotation effectively encodes the addition of $w_{i}$ into the quantum state. After completing this process, the step transformed the register back to the computational basis required, where

The inverse QFT decodes the phase information back into a computational state representing the total weight of the selected items. If QFT encodes the weight as a superposition of phases, the inverse QFT converts these phases back into a binary number the sum of the weights. The final state of the register $K_{w}$ after applying $U_{1}$ was the binary representation of the total weight of the items:

Figure 2 shows how $U_{1}$ is implemented using an algorithm based on QFT. Following the implementation of the unitary operation $U_{1}$, $U_{2}$ is described in Figure 3, which comprises a quantum circuit that conditionally modifies the state of an ancillary qubit concerning the sum of weights represented in the register $K_{w}$. Referring to Equation 16, the ancillary qubit $\ket{y}$ underwent a state flip to signal a valid configuration when the total weight $w(x)$, augmented by a constant offset $C_{0}$ is less than the predefined threshold $C+C_{0}+1$. This transformation was executed through several multi-controlled-NOT gates, where each gate was influenced by a qubit distinct from the weight register. The successful transition of the ancillary qubit’s state post $U_{2}$ signified a feasible solution, adhering to the knapsack’s capacity, which effectively segregates the solution space into permissible and impermissible weights.

This process relies on the mixing operator $U_{B}(\beta)$ generated by mixing Hamiltonian $B$ from Equation 8 as follows:

Alternatively, by leveraging the feasible function $f$ in Equation 14 and neighboring states $n_{i}(x)$ for exploring the solution space, $B$ can be described as

where $n_{i}(x)$ is the $i_{th}$ neighbor of $x$ ($x$ with $i_{th}$ bit flipped). Using this alternative representation, it is easy to observe that $\forall x,x^{\prime}\in K(N)$.

where Ham $(x,x^{\prime})$ represents the Hamming distance between two binary strings $x$ and $x^{\prime}$, which is the count of positions where the corresponding bits differ. The exact implementation of the desired mixing operator $U_{B}(\beta)$ presents challenges due to its Hamiltonian, requiring additional resources and non-commuting elements. To address this, we employ an alternative operator $\tilde{B}$, closely resembling $B$. This operator is constructed from $V_{i}$, and the inverse $V_{i}^{\dagger}$ for encoding feasibility information of neighboring states into auxiliary qubits that enable the controlled state manipulation. Additionally, the operator includes single-qubit $X_{i}$ gates for creating neighboring state exploration. Moreover, $U_{f}$ the feasible oracle is included to determine the feasibility of states by ensuring that only valid states are mixed. Finally, $R_{i}^{X}(2\beta)$ aids in adjusting the amplitudes of states based on feasibility and further refining the mixing process, whereas auxiliary qubits are employed to store feasibility information.

As shown in Figure 4, the process starts from:

which implies that the behavior of $V_{i}$ when acting on a state $\ket{x,0,0,0}$ is to transform it into a new state with additional information encoded in the auxiliary qubits, dependent on the feasibility function $f$ and its value at neighboring points. Therefore, the state of $V_{j}$ can be described as

Next, neighboring state mapping is performed using $V_{i}^{\dagger}$ to determine whether the original and neighboring states have the same feasibility. Thus, Equation 24 can be written as

Then, the bit flip of the $i-{th}$ qubit acts as:

Therefore, we can describe the encoded feasibility information after applying $V_{i}$ and based on Equation 25 as follows:

Next,

Thus, for a given $\tilde{B}$ operator, which approximates the original $B$ operator, we have

Moreover, $\tilde{B}$ implements $B$ given three ancillary qubits, or more precisely, it is represented as:

It follows that

where $\tilde{B}$ is used to generate $U_{B}$. Moreover, $\tilde{B}$ is not commute and should use three ancilla qubits. Therefore, the approximate implementation of $e^{-i\beta\tilde{B}}$ needs to use the trotter product formula. Meanwhile, using the identity $R_{i}^{X}(2\beta)$, the state representing the rest of the circuit in Figure 4.

where $R_{i}^{X}(2\beta)=cos(\beta)\mathbb{I}^{\otimes N}-isin(\beta)X_{i}$. Furthermore, we optimized $U_{B}(\beta)\otimes\mathbb{I}^{\otimes 3}$ with the trotter product formula as

Moreover, to maintain $\beta$ the validity of the approximation within the new parameter range, the $\beta$ range needs to be adjusted accordingly to $\beta\in[0,m\pi)$.

As an objective function, we use the value function $v$. Therefore, the corresponding phase separation can be described as follows:

The presented illustration implies that using a feasibility oracle with $n_{f}$ ancilla qubits requires $N+n_{f}+3$ qubits. In contrast, there is an exigency for an additional three qubits, specifically for generating the unitary $U_{B}$ (Equation 32).

Initially, we implemented the proposed method using the Qiskit library [42], a widely used open-source quantum computing framework. We run the algorithms on the QASM simulator, a tool provided by Qiskit for simulating quantum circuits, which helped us gain insights into the behavior and performance of the algorithms before moving on to the real quantum device. Moreover, we used a fake backend noise from 127 qubits of IBM FakeWashington. While using the real device, we used IBM Nazca, a 127-qubit quantum device, for quantum computations, which offers the opportunity to test the algorithms in a real-world quantum computing environment. The experimental phase involves conducting several tests in which we select varying stocks from $yahoofinance$, such as Apple Inc. (AAPL), Amazon.com Inc. (AMZN), Alphabet Inc. (GOOGL), Microsoft Corporation (MSFT), NVIDIA Corporation (NVDA), and Tesla, Inc. (TSLA), Netflix, Inc. (NFLX), and Visa Inc. (N). Notably, the selection of these stocks was based on different scenarios, including all cases from two to eight stocks. Postselection, we proceeded with the experimental setup of the proposed method. During the optimization process, we focused on optimizing QAOA, which was achieved by optimizing the $2p$ angle parameters, i.e., $\beta$ and $\gamma$, using the classical optimizer SHGO [43]. Additionally, we integrated quantum walk to boost optimization by leveraging its benefits for refining the process and achieving superior results.

To evaluate our proposed method’s performance, we defined our algorithm’s problem based on the number of assets to be optimized (Table 2). First, we selected 2–8 subsets of stocks using the capabilities of PyPortfoliopt [44]. The values represent the expected return of stocks counting from January 1, 2018, to January 1, 2023. The knapsack capacity $Cap$ is the maximum weight, where in our case we set it to be half of the total number of assets. This step clarifies the problem and enables us to tailor our algorithm accordingly. We aimed to evaluate the effectiveness of the QAOA optimization technique in portfolio optimization. To achieve this, we specifically evaluated the performance of the algorithm using the best-known solution (BKS), a result of using a classical algorithm [45], where $1$ signifies selection and $0$ denotes exclusion. This technique compared the results obtained from our algorithm with those of the classical solution, providing a benchmark for assessing its performance and effectiveness. By undertaking this evaluation, we can gain valuable insights into the capabilities and limitations of the QAOA optimization technique in portfolio optimization.

By meticulously exploring the variable settings within our QWM-QAOA, we identified that a circuit layer depth of $p=3$ and a Trotter step value of $m=3$ yielded the best results. Figure 5 illustrates the approximation ratios for knapsack-based portfolio optimization with varying numbers of stocks (ranging from 2 to 8 stocks) under three different environmental conditions: noise-free (simulator), noisy (using FakeWashington as a simulated backend), and noisy (real device: IBM Nazca with 127 qubits).

• •

  Noise-free (Simulator): The approximation ratios remain very high across all stock configurations, ranging from 100% (for 2 and 3 stocks) to 96% (8 stocks), indicating that the algorithm performs near-perfectly in an ideal, noise-free environment.

• •

  Noisy (Fake Backend): The introduction of noise through the simulated FakeWashington backend results in a decline in performance. The approximation ratios range from 98% to 70%, with lower values observed for larger portfolios. For example, 2 stocks achieve an approximation ratio of 98%, while 6 and 7 stocks drop to 70%. Interestingly, for 8 stocks, the approximation ratio slightly improves to 78%, indicating a non-linear impact of noise for larger portfolios.

• •

  Noisy (Real Device): The experiment is executed on the real IBM Nazca device with the approximation ratios dropping further, ranging from 96% (for 2 stocks) to 51% (for 6 stocks). Surprisingly, for 7 and 8 stocks, the approximation ratios increased to 52% and 55%, respectively.

This performance reduction is due to real-world factors, such as gate errors and decoherence, which exert a more significant impact as the number of stocks increases. This unexpected result hints at the potential for further improvements, even as the number of stocks increases in a noisy environment [46]. These issues highlight the importance of advanced error mitigation techniques, though such methods are beyond the scope of this study [47, 48].

We conducted a sensitivity analysis of key parameters using our QWM–QAOA algorithms, such as the circuit layer $(p)$ and the number of trotter steps $(m)$. These parameters are crucial for shaping the effectiveness of our proposed algorithm. Through a methodical examination and evaluation, we present details of the relationship between these parameters and how much they influence the overall efficiency and resilience of our QWM–QAOA.

• •

  Circuit Layer: Figure 6 shows that as the circuit layer increases beyond the initial value of $p\geqslant 3$, the approximation ratio of the diverse portfolio optimization result consistently reaches an impressive result ranging from 100% to 95%, categorically based on the setup cases of portfolio optimization. This empirical evidence emphatically establishes that our performance consistently produces an efficient result even at some circuit layers.

  

• •

  Trotter Step in QWM-QAOA: We aimed to find the parameter $m$, representing the trotter step counts in the QWM–QAOA algorithm while maintaining a constant circuit layer of $p=3$ and optimize $\beta$, $\gamma$ for the resulting circuit of 1–5. Table 3 shows that the approximation ratio for various stock selections increasingly exhibits a better result starting from $m=3$, ranging from 100% to 95%. When $m=5$, we obtained efficient optimization results from our proposed method ranging from 100% to 96%. The approximation ratios demonstrate how increasing the trotter steps improves the portfolio optimization results, particularly when $m\geqslant 3$, yielding consistently higher performance across different portfolio problem sizes.

  #Stocks	$m$ = 1	$m$ = 2	$m$ = 3	$m$ = 4	$m$ = 5
  2	1.00	0.96	1.00	1.00	1.00
  3	1.00	0.60	1.00	1.00	1.00
  4	0.77	0.99	0.99	0.99	0.99
  5	0.96	0.96	0.98	0.98	0.98
  6	0.96	0.97	0.98	0.98	0.98
  7	0.96	0.96	0.95	0.96	0.96
  8	0.96	0.96	0.96	0.96	0.96