An Improved Frank–Wolfe Algorithm to Solve the Tactical Investment Portfolio Optimization Problem

Abstract

Quadratic programming (QP) formulations are widely used in optimal investment portfolio selection, a central problem in financial decision-making. In practice, asset allocation decisions operate at two interconnected levels: the strategic level, which allocates the budget across major asset classes, and the tactical level, which distributes the allocation within each class to individual securities or instruments. This study evaluates the Frank–Wolfe (FW) algorithm as a computationally alternative to a QP formulation implemented in CVXPY and solved using OSQP (CVXPY–OSQP solver) for tactical investment portfolio optimization. By iteratively solving a linear approximation of the convex objective function, FW offers a distinct approach to portfolio construction. A comparative analysis was conducted using a tactical portfolio model with a small number of stock assets, assessing solution similarity, computational running time, and memory usage. The results demonstrate a clear trade-off between the two methods. While FW can produce portfolio weights closely matching those of the CVXPY–OSQP solver at lower and feasible target returns, its solutions differ at higher returns near the limits of the feasible set. However, FW consistently achieved shorter execution times and lower memory consumption. This study quantifies the trade-offs between accuracy and efficiency and identifies opportunities to improve FW’s accuracy through adaptive iteration strategies under more challenging optimization conditions.

1. Introduction

An investment portfolio is a collection of various types of assets owned by an investor with the goal of achieving optimal returns at a controlled level of risk [1]. Optimal portfolio selection is a critical task for investors, with the Markowitz model serving as a fundamental framework in modern investment theory since its introduction in 1952 [2]. This model provides a mathematical approach to efficiently allocate assets to maximize returns while managing risk. Effective investment decisions require a deep understanding of the risk and return characteristics of each asset, as well as how their interaction shapes overall portfolio performance [3]. The main challenge is to determine the optimal allocation proportion for various financial instruments to achieve a combination with the minimum possible risk and maximum return [4]. Decisions in this context typically occur at both strategic (allocation across major investment categories) and tactical (allocation to specific securities) levels [5]. The strategic allocation of funds among different asset classes plays a crucial role in maximizing expected returns that align with an investor’s risk tolerance [6].

Asset allocation decisions in an investment portfolio are divided into two distinct but interconnected levels. At the strategic level, the investment budget is allocated among major asset classes such as stocks, bonds, and real estate [7,8]. Decisions at this level are long-term and consider overall investment objectives and macroeconomic views [9]. At the tactical level, the budget determined for each asset class is allocated to individual securities or specific investment instruments within it [5,7]. The problem of asset allocation at both the strategic and tactical levels is formulated as a quadratic programming (QP) problem [5,10]. This QP formulation arises because the objective function, which involves the variance and covariance of the portfolio (as a measure of risk), is quadratic in the asset weights, while the constraints are linear. The QP problem in the context of a portfolio is a subclass of convex programming (CP) problems because the asset covariance matrix is positive semidefinite [11].

In the context of investment decision-making, utilizing such algorithms allows for efficient exploration of the trade-off between return and risk while handling practical constraints like transaction costs, cardinality limits, or minimum investment thresholds [12]. The underlying convex formulation ensures that local optima are also global, thereby providing strong theoretical guarantees [13]. Distributed and decentralized variants of these optimization frameworks, such as those based on the Alternating Direction Method of Multipliers (ADMM), further enhance computational efficiency in large portfolio systems or multi-agent financial environments [14]. As highlighted by Clark [15] and Dom [16], the integration of advanced optimization techniques not only improves solution accuracy but also enhances portfolio robustness, especially in high-dimensional or highly constrained scenarios. While strategic decisions set the overall allocation among major asset classes, tactical allocation focuses on optimizing specific securities within each class. This study specifically addresses the tactical level, where computational efficiency is crucial due to the larger number of individual assets involved. As tactical allocation models often involve hundreds or even thousands of securities, computational efficiency becomes a central concern. Therefore, this study is designed not only to evaluate solution quality and convergence on small portfolios but also to systematically analyze scalability as problem size increases, providing insights into practical large-scale implementations.

To efficiently solve convex portfolio optimization problems, especially those involving large-scale datasets and constraints, first-order methods are often preferred due to their scalability and computational tractability [14,17]. One such method is the Frank-Wolfe algorithm, which is particularly well-suited for constrained convex optimization where projection operations are computationally expensive [18]. The Frank-Wolfe algorithm is a relevant algorithm for solving convex optimization problems with linear constraints [19]. The algorithm operates iteratively by using a linear approximation of the convex objective function to determine an improving direction within the feasible set, solving a linear programming (LP) subproblem in each iteration, followed by a line search [20]. Frank-Wolfe can handle quadratic objective functions, as found in the Markowitz portfolio model [10], by linearizing the objective function at each iteration [18,21]. The positive semidefinite nature of the asset variance and covariance matrix ensures the convexity of the objective function [7,11], which is a crucial property for guaranteeing the algorithm’s convergence to a global optimum.

Prior research has explored various aspects of portfolio optimization and the application of the Frank-Wolfe algorithm, highlighting its versatility in addressing different challenges. The Frank-Wolfe algorithm, first introduced by Frank and Wolfe (1956) [19], operates iteratively by using a linear approximation of the convex objective function to determine an improving direction within the feasible set, solving a linear programming (LP) problem in each iteration, followed by a line search [20]. This approach allows the algorithm to handle quadratic objective functions, as found in Markowitz’s model, by linearizing the objective function at each iteration, thereby maintaining an LP structure [11,12,13]. The positive semi-definite property of the covariance matrix in portfolio models ensures the convexity of the objective function, which is crucial for the algorithm’s convergence to a global optimum [7]. Studies have leveraged the algorithm in diverse frameworks, from branch-and-bound methods for problems with integer constraints [22,23] to methods for solving sparse portfolio selection problems [24], and its application extends to decentralized optimization for multi-agent systems [25].

The algorithm’s relevance is further reinforced by its adaptability to complex and modern challenges. Thang et al. (2022) studied its use for online convex optimization, explicitly citing stock portfolio management as a key real-world application [26]. Dahik et al. (2022) expanded the algorithm’s scope by proposing a Frank-Wolfe-type heuristic to evaluate the duality gap in robust shortest-path problems under ellipsoidal uncertainty [27], an optimization challenge that bears a structural resemblance to robust portfolio optimization. Recent work by Kumacheva and Novgorodtcev (2024) also utilized a Frank-Wolfe-type framework to address time inconsistency in portfolio management, integrating classical performance measures with extremal risk metrics [28]. Additionally, the algorithm’s applicability has been demonstrated in other domains, such as a budgeted influencer marketing problem that was framed as a form of portfolio optimization [29].

Previous studies highlighted specific advantages of the Frank-Wolfe algorithm. Chen et al. (2020) proved that Frank-Wolfe naturally generates sparse portfolio solutions, with an average of less than 15% active assets, due to its ability to select extreme points from the feasible set [30]. This finding is supported by Di Lorenzo et al. (2012) who showed that the Frank-Wolfe algorithm can achieve a 30% faster runtime compared to the interior-point method for a 50-asset portfolio [24]. In addition, regarding convergence and efficiency, Buchheim et al. (2018) established that the Frank-Wolfe algorithm achieves a convergence rate of $O(1/k)$ for mean-variance problems with integer constraints [23], while Lacoste-Julien and Jaggi (2015) proved that the algorithm can achieve linear convergence when the covariance matrix is strongly convex [31]. While prior studies have demonstrated the effectiveness of quadratic programming solvers in portfolio optimization, few have systematically compared their computational performance with first-order methods such as the Frank-Wolfe algorithm, particularly in realistic tactical allocation settings involving hundreds of assets. This study addresses this gap by evaluating both approaches across different problem scales, using runtime, memory usage, and solution quality as key performance metrics. Beyond solution quality and convergence, computational performance was assessed through execution time and peak memory usage, both of which are critical for practical deployment in large-scale portfolio systems.

Despite the widespread use of QP solvers in portfolio optimization, there is limited empirical research comparing their computational performance with first-order algorithms such as Frank-Wolfe in the context of tactical asset allocation. This study addresses this gap by evaluating and comparing the performance of the Frank-Wolfe algorithm and direct QP solving based on runtime, memory usage, and solution quality. The findings aim to provide practical insights for investors and policymakers in selecting computationally efficient tools for optimal portfolio construction.

A systematic literature review (SLR) was conducted to analyze the novelty of this study, following the guidelines of the Preferred Reporting Items for Systematic Reviews and Meta-Analyses (PRISMA) to ensure a transparent and reliable approach to identifying, screening, and synthesizing relevant studies [32,33]. The review utilized Python-based packages to analyze trends, relationships, and insights within the research landscape, evaluating metadata, thematic mapping, and keyword co-occurrence patterns.

The initial step involved a comprehensive search using specific keyword combinations. The use of all three keywords (“Robust Optimization,” “Portfolio,” and “Frank-Wolfe”) yielded only a single article, which indicated a significant research gap in integrating these three concepts. The selection process continued through several stages, as depicted in the PRISMA flowchart in Figure 1. Of the nine articles initially identified, seven articles met the inclusion criteria after a rigorous screening of titles, abstracts, and full texts.

A review of the state-of-the-art of these seven selected articles, summarized in

Table 1. Summary of State-of-the-Art of the Selected Articles.

Author	Method/Technique	PU	IP	TI	FW	SM
[35]	Uses a robust reinforcement learning approach with a Wasserstein-distance-based uncertainty set and policy gradient optimization.	✓	-	-	-	Policy Gradient
[34]	Reformulates bounded convex programming for robust optimization problems using a Wasserstein uncertainty set.	✓	-	-	-	Bounded Convex Programming
[36]	Utilizes Monte Carlo simulation-based robust optimization and mean-variance (MV) and conditional value-at-risk (CVaR) frameworks.	✓	✓	-	-	Simulation & LP
[37]	Transforms partial mass transport problems using a pruning set and Wasserstein metric for distributional robust optimization.	✓	-	-	-	Gradient Descent
[29]	The Frank-Wolfe algorithm is applied to a convex optimization problem for influencer marketing with budget constraints.	app.	-	-	✓	LP
[27]	Proposes a Frank-Wolfe-based heuristic for a robust discrete optimization problem under ellipsoidal uncertainty.	✓	-	-	✓	Heuristics & LP
[23]	Frank-Wolfe-based algorithm and branch-and-bound method for mean-risk optimization.	app.	✓	-	✓	Branch-and-Bound & LP
This research	An Improved Frank–Wolfe Algorithm to Solve the Tactical Investment Portfolio Optimization Problem	app.	✓	✓	✓	First-Order & LP

Parameter Uncertainty (PU), Applicable (app.), Investment Portfolio Model (IP), Tactical Investment Portfolio (TI), Frank-Wolfe Algorithm (FW), Solving Method (SM). ✓: The feature/technique is present or used. -: The feature/technique is not present or used.

, clarifies the specific contribution of this research. While many studies apply various methods to address parameter uncertainty, such as Wasserstein distance [34,35] and robust optimization frameworks [27,36], there is a significant research gap in the application of the Frank-Wolfe (FW) algorithm for tactical investment portfolio optimization. Studies that use the FW algorithm typically apply it in different contexts. For example, some apply it to non-financial problems [29] or to mean-risk optimization [23]. Similarly, other portfolio studies use different solving methods like Monte Carlo simulation combined with Linear Programming [36] or various forms of gradient descent [37].

This study fills a crucial gap in the literature by integrating the improved Frank-Wolfe algorithm to solve a tactical investment portfolio optimization problem under market uncertainty. The core contribution lies in its solving method: it leverages the FW algorithm’s ability to efficiently handle the non-linear objective function by breaking it down into an iterative process that relies on first-order information and solving linear subproblems (LPs) at each step. This approach is highly suitable for large-scale, convex problems, providing an efficient alternative to traditional methods that may struggle with computational complexity in high dimensions.

The Frank-Wolfe algorithm’s suitability for this task is further reinforced by its structure. It approximates the quadratic objective function with a linear one, transforming the problem into a series of solvable linear programs (LPs). This sequential approach provides a framework for addressing more complex challenges. This linear structure is particularly advantageous for future research in robust optimization. It is established in the literature that uncertainty sets can often be modeled using polyhedral constraints, which are linear. By relying on a linear programming subproblem, the Frank-Wolfe framework is well-suited to handle these uncertainty sets, making it a flexible tool for solving robust optimization problems.

This study contributes by providing a direct, empirical, and quantitative comparative analysis of the Frank-Wolfe algorithm against a modern QP solver (CVXPY-OSQP). The trade-offs between solution accuracy and computational efficiency are systematically quantified, thereby providing insights for practitioners on the most suitable algorithm for large-scale, convex problems.

2. Materials and Methods

2.1. Dataset and Preprocessing

The empirical analysis in this study employs a benchmark dataset originally presented in AIMMS Optimization Modeling by Bisschop (Chapter 18, p.212) [7]. This dataset has been widely used in the optimization literature for educational and benchmarking purposes, as it provides a compact yet realistic basis for testing portfolio selection algorithms. It consists of historical weekly closing prices for five Dutch stocks: Royal Dutch (RD), Akzo Nobel (AKZ), KLM (KLM), Philips (PHI), and Unilever (UN). The observation period spans 51 consecutive weeks, from August 1997 to August 1998, yielding a total of 51 price points for each asset. Weekly returns were computed as $r_t=(P_t-P_{t-1})/P_{t-1}$, where $P_t$ is the price at week t, with all scenarios assigned an equal probability $p\left(r_t\right)=1/51$.

The choice of this relatively short time horizon and small set of assets follows the convention in the benchmark problem as formulated in [7]. While it does not represent the full breadth of market conditions, this dataset is particularly suited for methodological studies, as it allows results to be easily reproduced and compared across different optimization approaches. In practice, the weekly frequency also reflects a realistic decision-making horizon for tactical asset allocation, while the one-year window ensures that seasonal effects are captured without excessive noise from long-term structural shifts.

Based on the historical returns, the expected weekly returns m for the five assets were determined as $[-0.28\%,0.33\%,0.40\%,0.30\%,0.55\%]$ respectively. The covariance matrix, central to the portfolio variance calculation (see Section 2.2), was derived from the deviations $d_{tj}=r_{tj}-m_j$. Statistics description of the dataset is summarized in

Table 2. Key Statistical Parameters of Five Dutch Stocks.

Stock	Expected Return (${\mathit{m}}_{\mathit{j}}$)	Standard Deviation (${\mathit{\sigma }}_{\mathit{j}}$)
Royal Dutch (RD)	$-0.28\%$	$3.68\%$
Akzo Nobel (AKZ)	$0.33\%$	$3.45\%$
KLM (KLM)	$0.40\%$	$4.12\%$
Philips (PHI)	$0.30\%$	$4.21\%$
Unilever (UN)	$0.55\%$	$2.99\%$

.

A noteworthy observation from this dataset is that Royal Dutch (RD), despite exhibiting a negative expected return, contributes to stabilizing low-risk portfolios due to its relatively low volatility. This counterintuitive result aligns with the principles of variance minimization, where assets with low correlation or low individual volatility can be beneficial to the portfolio, even if their expected return is not the highest.

2.2. Tactical Investment Portfolio Model Formulation

An investment portfolio represents a strategic allocation of capital across financial assets to achieve predefined financial objectives [3]. The primary goal is to maximize expected returns for a given level of acceptable risk [2], while secondary objectives may include wealth accumulation, liability funding, or capital preservation [38]. Diversification is a cornerstone of portfolio management, achieved by allocating investments across assets with imperfect correlations to reduce risk without sacrificing returns [39]. Modern studies continue to explore diversification efficacy across various market regimes and asset classes. This study focuses on equity assets, which offer high return potential but substantial volatility. The interplay between stock correlations and volatility is critical [40,41], as returns are influenced by microeconomic and macroeconomic factors [42].

Portfolio optimization follows a hierarchical decision-making process involving two main stages. First, strategic allocation involves the budget allocation across broad investment categories, such as equities or bonds. Second, tactical allocation refines this by focusing on security-specific selection within each designated category [5,7]. Let $x_j$ denote the fraction of the budget invested in category j. In the strategic model, the portfolio variance (risk) is minimized subject to a target return M:

$$min\mathrm{Var}\left[\sum _j{r}_j{x}_j\right]$$

(1)

subject to

$$\begin{array}{cc}\hfill \sum _j{m}_j{x}_j& \ge M\hfill \end{array}$$

(2)

$$\begin{array}{cc}\hfill \sum _j{x}_j& =1\hfill \end{array}$$

(3)

$$\begin{array}{cc}\hfill x_j& \ge 0\forall j\hfill \end{array}$$

(4)

where $r_j$ is the return of category j and $m_j=\mathbb{E}\left[r_j\right]$ is its expected value.

The mathematical derivation of portfolio variance starts from the definition of variance for a random variable X, $Var\left[X\right]=E\left[{(X-E\left[X\right])}^2\right]$. By using the properties of the expectation operator, the portfolio variance can be expressed in terms of covariances:

$$\begin{array}{cc}\hfill \mathrm{Var}\left[\sum _j{R}_j{x}_j\right]& =E\left[{\left(\sum _j{R}_j{x}_j-E\left[\sum _j{R}_j{x}_j\right]\right)}^2\right]\hfill \\ \hfill & =E\left[{\left(\sum _j{R}_j{x}_j-\sum _j{x}_{j}E\left[R_j\right]\right)}^2\right]\hfill \\ \hfill & =E\left[{\left(\sum _j{x}_j(R_j-E\left[R_j\right])\right)}^2\right]\hfill \\ \hfill & =E\left[\sum _j\sum _k{x}_j{x}_k(R_j-E\left[R_j\right])(R_k-E\left[R_k\right])\right]\hfill \\ \hfill & =\sum _j\sum _k{x}_j{x}_{k}E\left[(R_j-E\left[R_j\right])(R_k-E\left[R_k\right])\right]\hfill \\ \hfill & =\sum _j\sum _k{x}_j{x}_k\mathrm{Cov}[R_j,R_k]\hfill \end{array}$$

(5)

This quadratic objective function, combined with linear constraints, means the model is classified as a quadratic programming (QP) problem. The objective function is convex because the covariance matrix is, by definition, positive semidefinite, which ensures that any optimal solution found is a global optimum.

The tactical investment portfolio model extends the strategic framework by directly estimating variance from observed returns. Consider T historical scenarios (time periods), where each scenario t has a vector of returns ${\mathbf{r}}_t=(r_{t1},\dots ,r_{tN})$ for N securities, and an associated probability $p\left(r_t\right)$ (typically $p\left(r_t\right)=1/T$). In this context, the portfolio variance is reformulated using scenarios, as a computationally efficient alternative when the number of securities (N) is much larger than the number of scenarios (T).

The derivation of the scenario-based variance starts from the definition of expectation as the weighted sum of outcomes across scenarios:

$$\begin{array}{cc}\hfill \mathrm{Var}\left[\sum _j{R}_j{x}_j\right]& =E\left[{\left(\sum _j{x}_j(R_j-E\left[R_j\right])\right)}^2\right]\hfill \\ \hfill & =\sum _{t}p\left(r_t\right){\left(\sum _j{x}_j(r_{tj}-E\left[R_j\right])\right)}^2\hfill \end{array}$$

(6)

Let $d_t=r_t-m$ be the deviation from expected returns $m={(m_1,\dots ,m_N)}^T$. A new auxiliary variable was introduced, $y_t$, to represent the portfolio deviation for each scenario t: $y_t={\sum }_j{d}_{tj}{x}_j$. The problem can be formulated as a QP model with a more compact objective function:

$$min\sum _{t}p\left(r_t\right)y_t^2$$

(7)

subject to

$$\begin{array}{cc}\hfill \sum _j{d}_{tj}{x}_j& =y_t\forall t,\hfill \end{array}$$

(8)

$$\begin{array}{cc}\hfill \sum _j{m}_j{x}_j& \ge M,\hfill \end{array}$$

(9)

$$\begin{array}{cc}\hfill \sum _j{x}_j& =1,\hfill \end{array}$$

(10)

$$\begin{array}{cc}\hfill x_j& \ge 0\forall j.\hfill \end{array}$$

(11)

This formulation is mathematically equivalent to the strategic model. The number of nonlinear terms ($y_t^2$) is significantly smaller than the number of terms in the covariance matrix ($x_j{x}_k$), which greatly reduces the repetitive calculation required by optimization solvers, thus making it computationally more efficient for large-scale tactical problems.

This model can be expressed compactly in matrix form. Define the Deviation Matrix $\mathbf{D}\in {\mathbb{R}}^{T\times N}$ as:

$$\mathbf{D}=\left(\begin{array}{cccc}{d}_{11}& d_{12}& \dots & d_{1N}\\ d_{21}& d_{22}& \dots & d_{2N}\\ ⋮& ⋮& \ddots & ⋮\\ d_{T1}& d_{T2}& \dots & d_{TN}\end{array}\right),\mathrm{where}{d}_{tj}=r_{tj}-m_j.$$

(12)

The Probability Matrix $\mathbf{P}\in {\mathbb{R}}^{T\times T}$ is a diagonal matrix and the portfolio vector $\mathbf{x}\in {\mathbb{R}}^N$:

$$\mathbf{P}=\mathrm{diag}\left(\mathbf{p}\right)=\left(\begin{array}{cccc}p\left(r_1\right)& 0& \dots & 0\\ 0& p\left(r_2\right)& \dots & 0\\ ⋮& ⋮& \ddots & ⋮\\ 0& 0& \dots & p\left(r_T\right)\end{array}\right),\mathbf{p}=\left(\begin{array}{c}p\left(r_1\right)\\ p\left(r_2\right)\\ ⋮\\ p\left(r_T\right)\end{array}\right),\mathbf{x}=\left(\begin{array}{c}{x}_1\\ x_2\\ ⋮\\ x_N\end{array}\right).$$

(13)

With these definitions, the objective function can be written as:

$$min{\left(\mathbf{Dx}\right)}^T\mathbf{P}\left(\mathbf{Dx}\right)=min{\mathbf{x}}^T\left({\mathbf{D}}^T\mathbf{P}\mathbf{D}\right)\mathbf{x},$$

(14)

and the constraints become:

$$-{\mathbf{m}}^T\mathbf{x}\le -M,{\mathbf{1}}^T\mathbf{x}=1,\mathbf{x}\ge \mathbf{0}.$$

(15)

Having established the convex quadratic programming formulation of the tactical investment portfolio model in (7), the Frank-Wolfe algorithm turned out to be an efficient solver. The algorithm’s ability to leverage linear approximations of the quadratic objective makes it particularly suited for large-scale portfolio problems, where traditional QP methods may face computational bottlenecks. In the following section, the adaptation of Frank-Wolfe was detailed to our model, highlighting its convergence guarantees and operational advantages in handling the constraints derived in (2), (3), and (4).

2.3. Frank-Wolfe Algorithm

This section elaborates on the Frank-Wolfe (FW) algorithm, outlining its fundamental principles, iterative procedure, advantages, and its specific applicability to tactical investment portfolio optimization.

The Frank-Wolfe (FW) algorithm [19], also known as the conditional gradient method, is a sequential linear approximation technique designed for solving convex optimization problems subject to linear constraints [20]. This iterative method linearizes the objective function at each step and then solves a linear program (LP) to identify a feasible descent direction. This approach is particularly efficient for large-scale problems where direct projections onto the feasible set would be computationally expensive [23].

Consider a general convex optimization problem of the form:

$$\underset{\mathbf{x}}{min}f\left(\mathbf{x}\right)\mathrm{s}.\mathrm{t}.\mathbf{Ax}\ge \mathbf{b},\mathbf{x}\ge \mathbf{0},$$

(16)

where $f\left(\mathbf{x}\right)$ is a convex and differentiable function, and the feasible set $\mathcal{S}=\{\mathbf{x}\mid \mathbf{Ax}\ge \mathbf{b},\mathbf{x}\ge \mathbf{0}\}$ is assumed to be compact.

The algorithm proceeds iteratively as follows. At iteration k, the process begins with a linear approximation of the objective function $f\left(\mathbf{x}\right)$ around the current point ${\mathbf{x}}^{\left(k\right)}$ [43]. This first-order Taylor expansion is given by:

$$f\left(\mathbf{x}\right)\approx f\left({\mathbf{x}}^{\left(k\right)}\right)+\nabla f{\left({\mathbf{x}}^{\left(k\right)}\right)}^{\top }(\mathbf{x}-{\mathbf{x}}^{\left(k\right)}).$$

(17)

Minimizing this approximation over the feasible set $\mathcal{S}$ reduces to solving a linear program:

$$\underset{\mathbf{x}\in \mathcal{S}}{min}\nabla f{\left({\mathbf{x}}^{\left(k\right)}\right)}^{\top }\mathbf{x}=\sum _{j=1}^n{c}_j{x}_j,$$

(18)

where $c_j=\partial f\left({\mathbf{x}}^{\left(k\right)}\right)/\partial x_j$. The solution to this linear program, denoted as ${\mathbf{x}}_{\mathrm{LP}}^{\left(k\right)}$, defines a feasible descent direction ${\mathbf{d}}^{\left(k\right)}={\mathbf{x}}_{\mathrm{LP}}^{\left(k\right)}-{\mathbf{x}}^{\left(k\right)}$. The next iterate ${\mathbf{x}}^{(k+1)}$ is then determined as a convex combination of ${\mathbf{x}}^{\left(k\right)}$ and ${\mathbf{x}}_{\mathrm{LP}}^{\left(k\right)}$:

$${\mathbf{x}}^{(k+1)}={\mathbf{x}}^{\left(k\right)}+t_k({\mathbf{x}}_{\mathrm{LP}}^{\left(k\right)}-{\mathbf{x}}^{\left(k\right)}),t_k\in [0,1].$$

(19)

The optimal step size $t_k$ is found by performing a one-dimensional line search to minimize the objective function along the identified direction:

$$\underset{t_k\in [0,1]}{min}f\left({\mathbf{x}}^{\left(k\right)}+t_k{\mathbf{d}}^{\left(k\right)}\right).$$

(20)

For quadratic objective functions, this line search often has a closed-form solution, simplifying the computation of $t_k$. The algorithm continues this iterative process until a predefined convergence criterion is met, such as the change in $\mathbf{x}$ or the duality gap falling below a specified tolerance $ϵ$ [44]. The iterative procedure for the Frank-Wolfe algorithm can be summarized as Algorithm 1:

Algorithm 1 Frank-Wolfe Algorithm.

Require: Convex objective $f\left(\mathbf{x}\right)$, feasible set $\mathcal{S}$, tolerance $ϵ>0$ 1: Initialize feasible point ${\mathbf{x}}^{\left(0\right)}$ 2: for  $k=0,1,2,\dots$  do 3:    Compute gradient $\nabla f\left({\mathbf{x}}^{\left(k\right)}\right)$ 4:    Solve LP subproblem to find ${\mathbf{s}}^{\left(k\right)}$: ${\mathbf{s}}^{\left(k\right)}=arg{min}_{\mathbf{s}\in \mathcal{S}}\nabla f{\left({\mathbf{x}}^{\left(k\right)}\right)}^{\top }\mathbf{s}$ 5:    Compute optimal step size $t_k$ via line search (Equation (20)) 6:    Update iterate: ${\mathbf{x}}^{(k+1)}={\mathbf{x}}^{\left(k\right)}+t_k({\mathbf{s}}^{\left(k\right)}-{\mathbf{x}}^{\left(k\right)})$ 7:    if $\parallel {\mathbf{x}}^{(k+1)}-{\mathbf{x}}^{\left(k\right)}\parallel \le ϵ$ then 8:      break 9:    end if 10: end forreturn Approximate solution ${\mathbf{x}}^{\ast }={\mathbf{x}}^{(k+1)}$

The FW algorithm offers several key advantages. It boasts computational efficiency by avoiding complex projection operations, instead leveraging highly optimized simplex methods for solving the LP subproblems [20]. Furthermore, it naturally tends to produce sparse solutions, which can be beneficial in applications such as portfolio optimization where a limited number of active assets might be preferred [45]. Its low memory usage, particularly when compared to certain interior-point QP solvers, also contributes to its evaluation for large-dimensional problems.

Algorithm 1 inherent ability to handle quadratic objectives effectively, as derived in Equation (14), by converting them into a series of linear programming subproblems makes it particularly well-suited for tactical investment portfolio optimization. Its iterative structure seamlessly aligns with the standard portfolio constraints such as the target return (${\mathbf{m}}^{\top }\mathbf{x}\ge M$) and the budget constraint (${\mathbf{1}}^{\top }\mathbf{x}=1$), while its strong convergence guarantees ensure reliable and accurate solutions for financial decision-making under these conditions.

2.4. Computational Procedure

The computational procedure in this study was designed to balance numerical accuracy, algorithmic interpretability, and reproducibility, which are critical aspects in financial optimization research [11,46]. All experiments were implemented using Python 3.9 and utilized standard scientific computing libraries widely accepted in the research community for numerical optimization and data analysis [47].

The computational procedure in this study was carefully designed to address two complementary objectives: (i) a detailed examination of solution quality and convergence behavior on small-to-moderate portfolio sizes, and (ii) a scalability analysis to evaluate computational performance as the number of assets increases substantially. Such design is consistent with best practices in computational optimization and financial research [48,49].

2.4.1. Problem Formulation and Constraints

The portfolio optimization problem follows a classical mean-variance structure (1)–(4), formulated as a quadratic programming (QP) problem [2]. As described in Equation (23) where ${\mathbf{D}}^{\top }\mathbf{P}$ represents the portfolio weights, ${\mathbf{D}}^{\mathbf{T}}\mathbf{P}$ is the covariance matrix of asset returns, $\mathbf{R}$ is the expected return vector, and $\mu$ is the target return. This formulation reflects a standard minimum-variance allocation with a budget constraint, non-negativity, and a lower bound on portfolio return, consistent with practical tactical allocation settings [50,51]. Two solvers were implemented:

• A benchmark QP solver using SciPy’s minimize, which serves as a convex baseline with reliable convergence.
• A Frank-Wolfe (FW) implementation, which iteratively solves a linear subproblem at each step, avoiding expensive projections and making it suitable for large-scale problems [31]. The Frank-Wolfe algorithm solves at each iteration in Equation (25), where $\nabla f\left({\mathbf{x}}_k\right)=2\mathsf{\Sigma }{\mathbf{x}}_k$, subject to the same set of linear constraints as above.

In our implementation, the step-size ${\gamma }_k$ was determined using an exact line search strategy, exploiting the quadratic structure of the objective function. The optimal step-size is given in closed form as Equation (30), where $\mathbf{s}$ is the solution to the linear subproblem. This approach ensures efficient computation and strong convergence properties, particularly for large-scale instances. It was consistently applied across all experiments to maintain stability and comparability of results.

2.4.2. Experimental Setup and Scalability Design

Real-world data were used for the small-scale analysis, while synthetic data were generated for scalability experiments to systematically control problem size and ensure reproducibility. The experiments were divided into two phases:

• Small-scale (using data at Section 2.1): This phase provides detailed insights into solution behavior, including risk-return characteristics, and weight vector consistency. These small cases are computationally tractable and allow fine-grained diagnostics, such as visualizing efficient frontiers and comparing FW and QP results at the portfolio level.
• Scalability analysis ($n\in$ {10, 20, 50, 100, 150, 200, 250, 300, 350, 400, 450, 500, 550, 600, 650, 700, 750, 800, 850, 900, 950, 1000, 1100, 1200, 1300, 1400, 1500}): This phase systematically increases the problem size to emulate realistic tactical allocation scenarios with hundreds or even thousands of assets. Here, the focus shifts to computational metrics such as runtime, memory usage, and relative optimality gap. This design demonstrating how FW and QP performance diverge as n grows.

For each n, synthetic covariance matrices were generated by symmetrizing random matrices and adding a scaled identity term to ensure positive definiteness. Expected return vectors $\mathbf{R}$ were drawn from a uniform distribution in $[0.01,0.2]$. The target return $\mu$ was randomly sampled from the interval [$min\left(\mathbf{R}\right)+0.01,max\left(\mathbf{R}\right)-0.01]$, ensuring feasibility while representing diverse market conditions. Controlled random seeds were applied to maintain reproducibility across trials [51].

2.4.3. Computational Environment and Solver Settings

The algorithms were implemented in Python 3.9 using standard libraries widely used in computational finance and optimization research [47]. NumPy was used for matrix operations, Pandas for data handling, and SciPy for optimization routines. The FW subproblem was solved via scipy.optimize.linprog. Timing was measured using Python’s time module, and peak memory usage was tracked with the tracemalloc library.

The QP solver employed strict stopping tolerances with $\mathrm{tol}={10}^{-8}$ and a maximum of 1000 iterations. The FW algorithm used $\mathrm{max\_iter}=100$ with a convergence tolerance of ${10}^{-3}$ unless otherwise stated. These parameters were chosen to balance convergence accuracy with computational cost. Sensitivity tests confirmed that tighter tolerances did not materially alter portfolio weights but significantly increased runtime, especially at larger n.

Simulations were executed on a standard CPU environment (Intel Core i5-1135G7, 8GB RAM) without GPU acceleration or parallelization to ensure direct comparison of algorithm efficiency.

2.4.4. Evaluation Metrics

To comprehensively compare the FW algorithm and the QP benchmark, multiple evaluation metrics were defined, capturing both portfolio quality and computational performance [50,52]:

• Portfolio Return (${\mathbf{R}}^{\top }\mathbf{x}$) and Portfolio Risk ($\sqrt{{\mathbf{x}}^{\top }\mathsf{\Sigma }\mathbf{x}}$): These assess the financial trade-off achieved by each method. Separate plots were generated for Return vs. Number of Assets and Risk vs. Number of Assets to clearly illustrate scaling effects.
• Execution Time (seconds): Measured wall-clock time for the complete optimization process. This highlights computational efficiency and how each algorithm scales with problem size.
• Memory Usage (KB): Captured peak memory demand during optimization, a critical factor for large-scale implementations.
• Relative Optimality Gap: The relative optimality gap was computed to assess the accuracy of the FW solution relative to the QP solver, defined as:

  $$\mathrm{Gap}={\displaystyle \frac{f\left({\mathbf{x}}_{FW}\right)-f\left({\mathbf{x}}_{QP}\right)}{\left|f\right({\mathbf{x}}_{QP}\left)\right|}},$$

  (21)

  where $f\left(\mathbf{x}\right)={\mathbf{x}}^{\top }\mathsf{\Sigma }\mathbf{x}$. This measures how closely FW approximates the QP optimum.

For the small-scale analysis, additional diagnostics included:

• Efficient Frontier Plots: Comparing portfolios from FW and QP across a range of target returns.
• Weight Vector Distance: Calculating the Kullback-Leibler divergence:

  $$D_{\mathrm{KL}}({\mathbf{x}}^{FW}\parallel {\mathbf{x}}^{QP})=\sum _i{x}_i^{FW}ln\left({\displaystyle \frac{x_i^{FW}}{x_i^{QP}}}\right),$$

  (22)

  where ${\mathbf{x}}^{FW}$ and ${\mathbf{x}}^{QP}$ are assumed to be weight vectors with non-negative components summing to one [53]. This measure captures how one portfolio allocation diverges from the other.

This comprehensive evaluation assesses both the accuracy and computational feasibility of FW in realistic tactical allocation contexts. It also provides direct evidence of how trade-offs evolve as the dimensionality of the portfolio grows.

Beyond raw performance metrics, statistical testing was incorporated to validate whether observed differences between the FW and QP solvers are significant. In particular, the Wilcoxon signed-rank test was employed to compare paired samples of execution time and memory usage across problem sizes. This non-parametric test is robust against violations of normality assumptions, making it appropriate for computational performance data [54].

To assess potential randomness or systematic variation in solver performance, runs tests (Wald–Wolfowitz runs test) were applied to the sequences of execution time and memory usage. These tests examine whether the observed performance sequence is consistent with randomness or exhibits patterns that could indicate deterministic bias or hardware-level irregularities. Detecting such patterns is important in optimization experiments, where subtle performance biases may go unnoticed without explicit statistical checks.

3. Results and Discussion

3.1. Solving the Tactical Investment Portfolio Model with the Frank-Wolfe Algorithm

The tactical investment portfolio model, as defined in Section 2.2 (specifically Equation (7) and its matrix form in Equations (14) and (15), represents a quadratic optimization problem. The objective is to minimize portfolio variance, subject to constraints on target return, budget allocation, and non-negativity of asset weights.

In compact matrix notation, the objective function is to minimize ${\mathbf{x}}^{\top }{\mathbf{D}}^{\top }\mathbf{P}\mathbf{D}\mathbf{x}$, as shown in Equation (14). Here, $\mathbf{D}\in {\mathbb{R}}^{T\times N}$ is the deviation matrix ($d_{tj}=r_{tj}-m_j$), $\mathbf{P}\in {\mathbb{R}}^{T\times T}$ is the diagonal probability matrix ($P_{tt}=p\left(r_t\right)={\displaystyle \frac{1}{T}}$), and $\mathbf{m}\in {\mathbb{R}}^N$ is the vector of expected returns. The feasible set $\mathcal{S}$ is defined by constraints, including the budget constraint (${\mathbf{1}}^{\top }\mathbf{x}=1$), non-negativity ($\mathbf{x}\ge \mathbf{0}$), and the target return constraint (${\mathbf{m}}^{\top }\mathbf{x}\ge \mu$).

The Frank-Wolfe algorithm applies an iterative process of objective function linearization, subproblem solving, and closed-form step size determination to solve this convex portfolio optimization problem. At iteration k, the quadratic objective function,

$$f\left(\mathbf{x}\right)={\mathbf{x}}^{\top }{\mathbf{D}}^{\top }\mathbf{P}\mathbf{D}\mathbf{x},$$

(23)

is approximated using a first-order Taylor expansion around the current iterate ${\mathbf{x}}_k$. Its gradient is given by:

$$\nabla f\left({\mathbf{x}}_k\right)=2{\mathbf{D}}^{\top }\mathbf{P}\mathbf{D}{\mathbf{x}}_k.$$

(24)

Minimizing this linear approximation over the feasible set $\mathcal{S}$ leads to a linear programming (LP) subproblem:

$$\underset{\mathbf{s}\in \mathcal{S}}{min}\nabla f{\left({\mathbf{x}}_k\right)}^{\top }\mathbf{s}.$$

(25)

The solution ${\mathbf{s}}_k$ provides the new search point in the feasible region. At iteration k, the step size $t_k\in [0,1]$ was sought that minimizes the objective function along the search direction ${\mathbf{d}}_k={\mathbf{s}}_k-{\mathbf{x}}_k$:

$$\underset{t\in [0,1]}{min}f({\mathbf{x}}_k+t{\mathbf{d}}_k).$$

(26)

Substituting $f\left(\mathbf{x}\right)={\mathbf{x}}^{\top }\mathbf{Q}\mathbf{x}$, with $\mathbf{Q}={\mathbf{D}}^{\top }\mathbf{P}\mathbf{D}$, yields:

$$f({\mathbf{x}}_k+t{\mathbf{d}}_k)={({\mathbf{x}}_k+t{\mathbf{d}}_k)}^{\top }\mathbf{Q}({\mathbf{x}}_k+t{\mathbf{d}}_k).$$

(27)

Expanding the quadratic form:

$$f({\mathbf{x}}_k+t{\mathbf{d}}_k)={\mathbf{x}}_k^{\top }\mathbf{Q}{\mathbf{x}}_k+2t{\mathbf{d}}_k^{\top }\mathbf{Q}{\mathbf{x}}_k+t^2{\mathbf{d}}_k^{\top }\mathbf{Q}{\mathbf{d}}_k.$$

(28)

This is a convex quadratic function in t. Differentiating with respect to t and setting the derivative to zero:

$${\displaystyle \frac{d}{dt}}f({\mathbf{x}}_k+t{\mathbf{d}}_k)=2{\mathbf{d}}_k^{\top }\mathbf{Q}{\mathbf{x}}_k+2t{\mathbf{d}}_k^{\top }\mathbf{Q}{\mathbf{d}}_k=0.$$

(29)

Solving for t gives the unconstrained minimizer:

$$t_k^{\ast }=-{\displaystyle \frac{{({\mathbf{s}}_k-{\mathbf{x}}_k)}^{\top }\nabla f\left({\mathbf{x}}_k\right)}{2{({\mathbf{s}}_k-{\mathbf{x}}_k)}^{\top }\mathbf{Q}({\mathbf{s}}_k-{\mathbf{x}}_k)}}.$$

(30)

Finally, the step size is projected onto the feasible interval:

$$t_k=max\left(0,min(1,t_k^{\ast })\right).$$

(31)

This closed-form solution avoids an iterative line search and significantly reduces computational cost per iteration. The next iterate is then updated as:

$${\mathbf{x}}_{k+1}={\mathbf{x}}_k+t_k({\mathbf{s}}_k-{\mathbf{x}}_k).$$

(32)

The algorithm terminates when the duality gap

$$g_k=-{({\mathbf{s}}_k-{\mathbf{x}}_k)}^{\top }\nabla f\left({\mathbf{x}}_k\right)$$

(33)

falls below a predefined tolerance $ϵ$, ensuring convergence. The overall iterative procedure for applying the Frank-Wolfe algorithm to tactical investment portfolio optimization is summarized in Algorithm 2.

Algorithm 2 An Improved Frank–Wolfe Algorithm to Solve the Tactical Investment Portfolio Optimization Problem.

Require: Deviation matrix $\mathbf{D}$, probability matrix $\mathbf{P}$, target return $\mu$, tolerance $ϵ$, maximum iterations K. 1: Compute covariance matrix $\mathsf{\Sigma }={\mathbf{D}}^{\top }\mathbf{P}\mathbf{D}$. 2: Initialize feasible point ${\mathbf{x}}^{\left(0\right)}$ (e.g., ${\mathbf{x}}^{\left(0\right)}={[1/N,\dots ,1/N]}^{\top }$). 3: for  $k=0,1,2,\dots ,K$  do 4:    Compute gradient: $\nabla f\left({\mathbf{x}}^{\left(k\right)}\right)=2\mathsf{\Sigma }{\mathbf{x}}^{\left(k\right)}$. 5:    Solve the LP subproblem to obtain ${\mathbf{s}}^{\left(k\right)}$: $$\begin{array}{cc}\hfill {\mathbf{s}}^{\left(k\right)}& =arg\underset{\mathbf{s}}{min}\nabla f{\left({\mathbf{x}}^{\left(k\right)}\right)}^{\top }\mathbf{s}\hfill \\ & \mathrm{s}.\mathrm{t}.{\mathbf{m}}^{\top }\mathbf{s}\ge \mu ,{\mathbf{1}}^{\top }\mathbf{s}=1,\mathbf{s}\ge \mathbf{0}.\hfill \end{array}$$ 6:    Compute descent direction: ${\mathbf{d}}^{\left(k\right)}={\mathbf{s}}^{\left(k\right)}-{\mathbf{x}}^{\left(k\right)}$. 7:    Compute step size (exact line search for quadratic objective): $$t_k=max\left(0,min\left(1,-{\displaystyle \frac{{\mathbf{d}}^{\left(k\right)\top }\nabla f\left({\mathbf{x}}^{\left(k\right)}\right)}{2{\mathbf{d}}^{\left(k\right)\top }\mathsf{\Sigma }{\mathbf{d}}^{\left(k\right)}}}\right)\right).$$ 8:    Update iterate: ${\mathbf{x}}^{(k+1)}={\mathbf{x}}^{\left(k\right)}+t_k{\mathbf{d}}^{\left(k\right)}$. 9:    Compute duality gap: $g_k=-{\mathbf{d}}^{\left(k\right)\top }\nabla f\left({\mathbf{x}}^{\left(k\right)}\right)$. 10:    if $g_k<ϵ$ then 11:      break 12:    end if 13: return Optimal portfolio allocation ${\mathbf{x}}^{\ast }={\mathbf{x}}^{(k+1)}$.

In the computational implementation, the linear programming subproblem (Equation (25)) was solved using scipy.optimize.linprog, which employs efficient methods such as the simplex algorithm. The inequality constraint ${\mathbf{m}}^{\top }\mathbf{s}\ge \mu$ was transformed into the standard LP form of less-than-or-equal-to by multiplying by $-1$, yielding $-{\mathbf{m}}^{\top }\mathbf{s}\le -\mu$. For the line search (Equation (32)), scipy.optimize.minimize_scalar was utilized with the specified bounds $t\in [0,1]$. The computational complexity of each Frank-Wolfe iteration is primarily dominated by the matrix-vector multiplication involved in calculating the gradient (${\mathbf{D}}^{\top }\mathbf{P}\mathbf{D}{\mathbf{x}}_k$) and solving the linear programming subproblem.

3.2. Computational Performance and Scalability Analysis

This section presents a direct comparison of the Frank-Wolfe (FW) algorithm’s performance against the CVXPY–OSQP solver, focusing on the defined metrics: portfolio weights similarity, computational running time, and memory usage. To provide a comprehensive overview of the numerical experiments,

Table 3. Target Return, Portfolio Return, and Risk for FW and QP Solver.

n	Target	FW Return	QP Solver Return	FW Risk	QP Solver Risk
10	0.0676	0.1050	0.1050	1.2184	1.2184
20	0.1218	0.1218	0.1218	1.2431	1.2428
50	0.1752	0.1752	0.1752	2.1761	2.1379
100	0.1524	0.1526	0.1523	1.5939	1.5733
150	0.0344	0.0989	0.0989	1.2248	1.2248
200	0.1056	0.1056	0.1055	1.2256	1.2250
250	0.0815	0.1047	0.1047	1.2249	1.2250
300	0.0685	0.1064	0.1064	1.2247	1.2247
350	0.1144	0.1144	0.1143	1.5570	1.2432
400	0.1422	0.1422	0.1421	1.7304	1.4172
450	0.1325	0.1327	0.1324	1.7865	1.3542
500	0.1748	0.1748	0.1748	2.0541	1.9599
550	0.1615	0.1615	0.1614	1.9839	1.5460
600	0.0213	0.1033	0.1033	1.2246	1.2246
650	0.1584	0.1584	0.1583	2.1458	1.6631
700	0.1685	0.1685	0.1682	2.2364	1.8040
750	0.0847	0.1082	0.1082	1.2245	1.2245
800	0.0574	0.1071	0.1072	1.2249	1.2249
850	0.0786	0.1050	0.1051	1.2246	1.2246
900	0.1110	0.1120	0.1110	1.9345	1.2307
950	0.0555	0.1071	0.1071	1.2249	1.2249
1000	0.0479	0.1042	0.1042	1.2250	1.2250
1100	0.1612	0.1612	0.1367	2.7602	1.3959
1200	0.0704	0.1060	0.1060	1.2247	1.2247
1300	0.1782	0.1782	0.1565	2.9966	1.7024
1400	0.1651	0.1651	0.1234	3.1232	1.2801
1500	0.0644	0.1040	0.1040	1.2247	1.2247

and

Table 4. Execution Time, Memory Usage, and Relative Optimality Gap for FW and QP Solver.

n	FW Time (s)	QP Solver Time (s)	FW Memory (KB)	QP Solver Memory (KB)	FW Relative
10	0.3190	0.0037	11,360	20	$2.73\times {10}^{-7}$
20	0.3726	0.0158	20	47	$4.56\times {10}^{-4}$
50	0.4708	0.0679	31	216	$3.61\times {10}^{-2}$
100	0.7351	0.3744	94	800	$2.64\times {10}^{-2}$
150	0.9721	0.0171	196	1751	$-1.72\times {10}^{-5}$
200	1.2264	0.1073	338	3076	$9.19\times {10}^{-4}$
250	2.0397	0.0307	517	4282	$-2.41\times {10}^{-5}$
300	1.7036	0.0470	736	6133	$-1.93\times {10}^{-5}$
350	1.9730	2.3574	995	9273	$5.69\times {10}^{-1}$
400	2.3730	22.6763	1292	12,081	$4.91\times {10}^{-1}$
450	2.4459	26.5000	1628	15,260	$7.40\times {10}^{-1}$
500	3.3388	48.0849	2004	18,810	$9.84\times {10}^{-2}$
550	2.9532	80.5970	2418	22,731	$6.47\times {10}^{-1}$
600	3.2101	0.2577	2871	24,211	$-3.46\times {10}^{-6}$
650	3.4351	148.3290	3364	31,688	$6.65\times {10}^{-1}$
700	6.0909	200.000 *	3896	36,721	$5.37\times {10}^{-1}$
750	6.4329	0.5636	4466	37,731	$-3.30\times {10}^{-6}$
800	7.5650	0.6130	5075	42,903	$-2.46\times {10}^{-6}$
850	7.9279	0.7248	5724	48,406	$-2.92\times {10}^{-6}$
900	8.3729	76.8084	6413	60,570	$1.47\times {10}^0$
950	8.2504	1.6698	7139	60,408	$-7.15\times {10}^{-7}$
1000	8.6243	2.0124	7905	66,908	$-2.45\times {10}^{-7}$
1100	9.9757	200.000 *	9555	90,367	$2.78\times {10}^0$
1200	10.8456	2.2071	11,360	96,247	$-4.46\times {10}^{-7}$
1300	11.7348	200.000 *	13,322	126,112	$2.13\times {10}^0$
1400	12.4362	200.000 *	15,440	146,211	$4.83\times {10}^0$
1500	13.4864	6.6114	17,714	150,216	$1.85\times {10}^{-7}$

* Reached imposed 200-second time limit.

summarize the outcomes of the Frank–Wolfe (FW) algorithm and the quadratic programming (QP) solver across all tested portfolio sizes.

The tabulated results show that FW closely replicates the QP solver’s return and risk values across a wide range of problem sizes, with only minor deviations emerging at high dimensions. From a computational perspective, FW consistently requires less memory and scales more smoothly in runtime, while QP exhibits increasing computational burden and reaches the imposed 200-second limit in several large-scale instances. The relative gap values further indicate that FW remains highly accurate in most cases, confirming its potential as a practical alternative to exact QP solvers in large-scale portfolio optimization.

3.2.1. Portfolio Weights and Efficient Frontier Similarity

The numerical results presented in

Table 5. Comparison of Portfolio Variances and Relative Entropy of Weights.

Target Return	Variance FW	Variance QP	Relative Entropy
0.0000	0.0008	0.0008	0.0042
0.0357	0.0021	0.0021	0.0000
0.0714	0.0058	0.0058	0.0003
0.1071	0.0121	0.0121	0.0000
0.1429	0.0209	0.0209	0.0001
0.1786	0.0321	0.0321	0.0003
0.2143	0.0459	0.0459	0.0001
0.2500	0.0622	0.0622	0.0002
0.2857	0.0810	0.0810	0.0001
0.3214	0.1023	0.1023	0.0004
0.3571	0.1261	0.1261	0.0005
0.3929	0.1524	0.1524	0.0003
0.4286	0.1812	0.1812	0.0002
0.4643	0.2125	0.2125	0.0002
0.5000	0.2464	0.2464	0.0025

summarize the portfolio variances and the relative entropy between the weight vectors obtained from both methods across a range of target returns. Relative entropy, also known as the Kullback–Leibler divergence, is used to measure the similarity between the two portfolio weight distributions, where a value of zero indicates identical distributions.

As shown in Table 5, the portfolio variances generated by the Frank-Wolfe algorithm are virtually identical to those produced by the CVXPY–OSQP solver across all target returns. Similarly, the relative entropy values are extremely small, generally very close to zero. This indicates that the weight distributions produced by the two methods are nearly indistinguishable, confirming that the Frank-Wolfe algorithm converges to the same optimal solution as the QP solver under the tested conditions.

Figure 2 illustrates this similarity, where the efficient frontiers of both methods completely overlap. The absence of any visible divergence between the two curves visually confirms the equivalence of their solutions.

The use of relative entropy instead of Euclidean distance provides a more appropriate metric for comparing the portfolio weights, as it accounts for the probabilistic nature of the weights. Since the portfolio weights must sum to one and are non-negative, relative entropy captures even minor proportional differences in the distributions. In this case, the near-zero values indicate that both methods assign practically identical weights to each asset at every target return level.

As seen in Figure 3, the relative entropy remains consistently close to zero across the entire range of target returns, with the highest observed value being only 0.0042. This further supports the conclusion that the Frank-Wolfe algorithm effectively mirrors the optimal weight allocations found by the QP solver.

Furthermore, the individual portfolio weight trajectories, as shown in Figure 4, demonstrate virtually identical allocation patterns for each asset between the two methods. Assets such as Royal Dutch (RD) and Unilever (UN) follow the same shifting allocation patterns as target return increases, with other assets like AKZ, KLM, and PHI acting as diversifiers.

In summary, both the quantitative metrics and graphical visualizations confirm that the Frank-Wolfe algorithm, when properly implemented, can accurately replicate the solutions produced by the QP solver. The efficient frontier, portfolio variances, and weight allocations are indistinguishable between the two approaches. This demonstrates that Frank-Wolfe offers a computationally efficient alternative without sacrificing accuracy for small-scale problems.

These findings establish a solid foundation for extending the analysis to larger asset universes. While the five-asset case confirms accuracy, practical tactical allocation problems often involve hundreds or even thousands of assets. Therefore, in the following section, the scalability of both algorithms as n increases was examined, assessing how computational time, accuracy, and portfolio characteristics evolve as the problem dimension grows.

3.2.2. Portfolio Return and Risk Scaling

Figure 5 and Figure 6 along with Table 3 present how portfolio return and portfolio risk evolve as the number of assets increases for both FW and QP solvers. For small to moderate numbers of assets ($n\le 250$), FW and QP produce virtually identical results, with overlapping curves for both return and risk. This confirms the consistency of FW with the exact QP solution in these settings.

As n grows beyond 300, slight deviations begin to emerge, especially in the highest return targets. At extremely large scales ($n>900$), the divergence becomes more pronounced for certain instances, indicating that while FW remains accurate for most cases, its iterative approximation can occasionally yield suboptimal solutions when the problem size is very high or when the target return is extreme. Despite this, the overall patterns of return and risk remain aligned, and the differences are negligible for typical portfolio allocation use cases.

Table 3 summarizes the return and risk comparison for selected problem sizes. Notably, the deviation observed for $n=1500$ at the highest target return illustrates the first sign of instability, even though it remains within acceptable practical limits.

The nearly identical performance of FW and QP for small to medium asset universes reinforces the earlier findings from the five-asset case study, where the relative entropy between the weight distributions was effectively zero. This indicates that FW maintains accuracy while scaling to substantially larger problem sizes, making it a reliable approximation method for practical applications.

3.2.3. Execution Time Analysis

Figure 7 and Table 4 illustrate the computational time scaling behavior of both algorithms. For small problem sizes ($n\le 50$), the QP solver is extremely fast due to the use of direct methods. However, as n grows, the computational burden of QP increases sharply, exhibiting near-exponential growth beyond $n=500$. Several large-scale instances reached the 200-second time limit, indicating severe scalability constraints.

In contrast, FW demonstrates a much slower growth rate in execution time. Even at $n=1500$, FW remained well within the time limit, with total runtime increasing smoothly as n grows. At $n=900$, FW is approximately 20 times faster than QP (4.32 s vs. 85.90 s), highlighting its scalability advantage. Table 4 shows execution times for the same subset of problem sizes.

The performance difference becomes stark at $n>900$, where FW maintains tractability while QP struggles. This indicates that FW’s iterative nature is better suited for very high-dimensional optimization compared to the direct matrix factorization methods used in QP.

3.2.4. Memory Usage Analysis

Figure 8 and Table 4 present the memory footprint comparison. FW shows a gradual, nearly linear increase in memory usage as the number of assets increases, as it primarily needs to store the gradient and a linear subproblem at each iteration. In contrast, QP requires storing dense Hessian matrices and other internal solver structures, causing memory to grow disproportionately.

For $n>500$, QP’s memory consumption escalates rapidly, exceeding 100,000 KB at $n=1500$. At this scale, QP uses nearly 8 times more memory than FW, making it unsuitable for constrained environments. FW remains consistently lightweight, reinforcing its suitability for cloud-based or embedded systems.

Note that peak memory numbers exhibit some run-to-run variability due to OS-level allocation behavior and solver internals, but the overall trend is clear. FW remains lightweight (tens of MB at largest n) while QP can require an order of magnitude more memory on many large instances.

3.2.5. Statistical Test for Execution Time and Memory Usage of FW and QP Solver

Table 6. Summary of Statistical Test Results for FW and QP.

Test	Metric	Method	p-Value	Interpretation
Runs Test	FW Time	$z=-4.904$	<0.001	Non-random trend
Runs Test	FW Memory	$z=-4.493$	<0.001	Non-random trend
Runs Test	QP Time	$z=-0.597$	$0.550$	Random trend
Runs Test	QP Memory	$z=-4.892$	<0.001	Non-random trend
Wilcoxon	Execution Time	$W=149.0$	$0.348$	No significant difference
Wilcoxon	Memory Usage	$W=10.0$	<0.001	FW uses significantly less memory

summarizes the results of the runs test and Wilcoxon signed-rank test. The runs test assesses randomness in the sequences of execution time and memory usage, while the Wilcoxon test evaluates paired differences between FW and QP. To clarify the statistical hypotheses, the following null and alternative hypotheses were tested:

• Runs Test
  $H_0:$ The sequence of observations is random.
  $H_1:$ The sequence of observations is not random (systematic trend).
• Wilcoxon Signed-Rank Test
  $H_0:$ There is no difference in the paired distributions.
  $H_1:$ There is a systematic difference in the paired distributions.

The runs test rejects $H_0$ for FW’s runtime and memory usage ($p<0.001$), indicating that these metrics follow a clear increasing trend with problem size, while $H_0$ cannot be rejected for QP runtime ($p=0.550$), suggesting random-like fluctuations. For memory usage, both FW and QP exhibit systematic non-random growth.

Regarding efficiency, the Wilcoxon signed-rank test does not reject $H_0$ for execution time ($p=0.348$), implying no significant paired difference between FW and QP runtimes. However, for memory usage, $H_0$ is rejected ($p<0.001$), with a mean difference of $-\mathrm{36,196}$ KB and a median difference of $-\mathrm{21,340}$ KB. This confirms that FW consistently requires significantly less memory than QP, and that this result is due to systematic behavior rather than random variation.

The runs test indicates that FW’s runtime and memory usage grow with clear patterns as the problem size increases, while QP shows a random-like runtime progression but a strong memory trend. The Wilcoxon test confirms that FW requires significantly less memory than QP (mean difference = $-\mathrm{36,196}$ KB, median difference = $-\mathrm{21,340}$ KB, $p<0.001$). The consistently negative differences indicate that FW’s memory footprint is systematically smaller across problem sizes, not due to random fluctuation.

3.2.6. Relative Gap Analysis

The relative optimality gap between FW and QP, shown in Figure 9, measures the deviation of FW’s solution from the exact QP optimum. Table 4 summarizes this for selected n values. For smaller problem sizes ($n\le 300$), the gap is effectively zero, indicating an excellent approximation.

As n increases beyond 900, sporadic spikes appear in the gap, particularly at $n=1100$ and $n=1500$. The maximum observed gap of 1.85% occurs at $n=1500$ with the highest return target. In practice, this deviation remains acceptable, as typical industry tolerances for portfolio allocation are within the 2–5% range [2].

The combination of near-zero gaps for moderate sizes and rare, small spikes at extreme sizes demonstrates that FW maintains strong approximation quality across a wide range of portfolio configurations.

These results reveal a trade-off between computational efficiency and exactness. FW achieves substantial time and memory savings while maintaining excellent accuracy for most practical cases. For portfolios with up to 500 assets, FW matches QP almost perfectly. At very high dimensions, minor deviations may occur, especially under extreme return targets, but they remain within acceptable tolerances.

4. Conclusions

This study evaluated the performance of the Frank–Wolfe (FW) algorithm as an alternative to quadratic programming (QP) solved using the CVXPY–OSQP solver for tactical portfolio optimization. The evaluation focused on three key dimensions: solution similarity, computational runtime, and memory usage, across a range of portfolio sizes ($n=50$ to $n=1500$) and varying target return levels.

The results demonstrate that FW closely replicates the QP solutions for small to moderate problem sizes. In the five-asset case study, portfolio variances and weight allocations from FW were virtually identical to those of the QP solver, confirmed by near-zero relative entropy values (Figure 3). This indicates that FW converges to the same optimal solutions under low-dimensional settings, making it an accurate substitute for exact quadratic solvers at these scales.

As the number of assets increases, FW continues to track QP closely up to approximately $n=500$. Beyond this point, slight deviations emerge, particularly at extreme target returns near the boundary of the feasible set. For very large portfolios ($n>900$), the differences become more visible. The maximum relative optimality gap observed was 1.85% at $n=1500$ (Table 4). This suggests that while FW remains highly accurate for most practical cases, some degradation occurs under challenging high-dimensional scenarios with aggressive return targets.

From a computational perspective, FW exhibited substantial advantages. The execution time of FW scaled smoothly and predictably, remaining well below the imposed 200-s time limit even at the largest problem size tested ($n=1500$). In contrast, QP’s runtime increased sharply, exceeding the limit at $n\ge 1300$ (Table 4, Figure 7). For example, at $n=900$, FW was roughly 20 times faster than QP (4.32 s vs. 85.90 s). This scaling behavior highlights FW’s suitability for large-scale applications where direct quadratic solvers become computationally infeasible.

Memory usage patterns reinforce this conclusion. FW’s memory footprint grew nearly linearly with n, reflecting its need to store only the gradient and a small set of linear subproblem structures. Conversely, QP’s memory demand rose disproportionately, driven by the storage of dense Hessian matrices and factorization structures. At $n=1500$, QP required over $\mathrm{150,000}$ KB, compared to just $\mathrm{17,713}$ KB for FW (Table 4). This eight-fold difference suggests that FW is particularly advantageous for deployment in resource-constrained environments, such as cloud computing platforms or embedded systems.

From a statistical perspective, formal non-parametric tests further reinforced these findings. The runs test indicated that FW’s execution time and memory usage follow non-random, structured growth patterns (Table 6), consistent with the smooth scalability trends observed in Figure 7 and Figure 8. By contrast, QP’s runtime exhibited random variation across scales, while its memory usage also showed non-random escalation, aligning with the solver’s increasing reliance on dense matrix factorizations.

The Wilcoxon signed-rank test revealed no statistically significant difference in execution times between FW and QP ($p=0.348$), despite FW’s smoother scaling behavior. However, the test confirmed a highly significant difference in memory consumption ($p<0.001$), with FW requiring systematically less memory across all problem sizes. The negative mean difference ($-\mathrm{36,196}$ KB) and median difference ($-\mathrm{21,340}$ KB) indicate that FW consistently consumed tens of megabytes less memory than QP. This statistical evidence substantiates the computational results, showing that FW’s lightweight memory requirements are not incidental but a robust property of the algorithm’s iterative structure.

Overall, the analysis quantifies a clear trade-off between precision and scalability. QP remains the gold standard for exactness, consistently delivering perfectly converged solutions across all scenarios. However, its computational and memory costs grow prohibitively at high dimensions. FW, on the other hand, offers dramatic gains in speed and memory efficiency while maintaining near-identical results for small to medium problem sizes and tolerable deviations for very large-scale cases. This balance makes FW an appealing alternative for tactical allocation tasks involving hundreds or thousands of assets, especially when fast, approximate solutions are sufficient.

Future research could explore adaptive or dynamic stopping criteria to improve solution quality without compromising efficiency. Additionally, extending the comparison to even larger portfolios and to robust optimization frameworks would provide deeper insights into FW’s performance under uncertainty. Given the observed advantages in speed and memory usage, FW holds strong potential for integration into real-time large-scale portfolio optimization systems.