Relaxed risk budgeting

PortfolioOptimisers.RelaxedRiskBudgetingResult — Type
struct RelaxedRiskBudgetingResult{__T_jr, __T_rbr, __T_fb} <: NonRiskJuMPOptimisationResult

Holds the solution, the budget and the fallback chain of a relaxed risk budgeting optimisation.

optimise returns it for a RelaxedRiskBudgeting. The model reads the covariance matrix of the prior and resolves no risk measure, so the result has no r, and it is a NonRiskJuMPOptimisationResult. A name that is not a field resolves through rbr first, so res.rkb is the budget of the model. Every other name, and the property w, then resolves through jr, the JuMPOptimisationResult that the result holds.

Fields

  • jr: The JuMPOptimisationResult that holds the resolved bundle of the optimiser, the return code, the solution and the model.
  • fb: The fallback chain that answered this result: the (estimator, result) pair of every attempt optimise made before this one, in the order they ran, or nothing when the estimator it was asked of answered (see FbChain).

Constructors

RelaxedRiskBudgetingResult(;    jr::JuMPOptimisationResult,    rbr::AbstractResolvedRiskBudgeting,    fb::Option{<:OptE_Opt_FbChain}) -> RelaxedRiskBudgetingResult

Keywords correspond to the struct's fields.

Related

source
PortfolioOptimisers.BasicRelaxedRiskBudgeting — Type
struct BasicRelaxedRiskBudgeting <: RelaxedRiskBudgetingAlgorithm

Selects Model (A) of RelaxedRiskBudgeting, where the standard deviation of the portfolio alone bounds $\psi$.

The objective of this model is zero exactly when the contributions meet the budget, so the model gives the risk budgeting portfolio when no other row binds. Model (A) of [244] is the second-order cone model of [245] with a target return.

Related

References

  • [244] V. Gambeta and R. Kwon. Risk return trade-off in relaxed risk parity portfolio optimization. Journal of Risk and Financial Management 13, 237 (2020). Model (0), Equations 5 to 11, and Model (A), Equations 12 to 17. The original source of this formulation was not found. The formulation follows this work and is not checked against the original.
  • [245] H. Mausser and O. Romanko. Computing equal risk contribution portfolios. IBM Journal of Research and Development 58, 5:1–5:12 (2014).
source
PortfolioOptimisers.RegularisedRelaxedRiskBudgeting — Type
struct RegularisedRelaxedRiskBudgeting <: RelaxedRiskBudgetingAlgorithm

Selects Model (B) of RelaxedRiskBudgeting, which adds a regulating term $\rho$ that the standard deviation of the portfolio bounds.

The term raises the price of the standard deviation in the objective, so the model trades the budget for a lower standard deviation. The objective is not zero at the budget, so the solution can leave the budget also when no other row binds.

Related

References

  • [244] V. Gambeta and R. Kwon. Risk return trade-off in relaxed risk parity portfolio optimization. Journal of Risk and Financial Management 13, 237 (2020). Section 3.2, Model (B), Equations 21 to 27.
source
PortfolioOptimisers.RegularisedPenalisedRelaxedRiskBudgeting — Type
struct RegularisedPenalisedRelaxedRiskBudgeting{__T_p} <: RelaxedRiskBudgetingAlgorithm

Selects Model (C) of RelaxedRiskBudgeting, where the variances of the single assets, times the penalty p, bound the regulating term $\rho$.

The term reads the diagonal of the covariance matrix, and not the whole matrix as Model (B) does. So it limits the weight of an asset of high variance. Section 3.3 of [244] uses this to keep the contributions nearer to the budget than Model (B) does. A larger p gives the term more strength. The objective is not zero at the budget, so the solution can leave the budget also when no other row binds.

Fields

  • p: Penalty $\lambda$ of the regulating term. It multiplies $\boldsymbol{w}^\intercal \mathbf{\Theta} \boldsymbol{w}$, the variances of the single assets times the squares of their weights.

Constructors

RegularisedPenalisedRelaxedRiskBudgeting(;    p::Number = 1.0) -> RegularisedPenalisedRelaxedRiskBudgeting

Keywords correspond to the struct's fields.

Validation

  • isfinite(p) and p > 0. Otherwise a DomainError names p.

Related

References

  • [244] V. Gambeta and R. Kwon. Risk return trade-off in relaxed risk parity portfolio optimization. Journal of Risk and Financial Management 13, 237 (2020). Section 3.3, Equations 28 and 30, and Section 3.4, Model (C), Equations 31 to 37.
source
PortfolioOptimisers.RelaxedRiskBudgeting — Type
struct RelaxedRiskBudgeting{__T_opt, __T_rba, __T_wi, __T_alg, __T_fb, __T_mtx_sqrt} <: JuMPOptimisationEstimator

Optimises the portfolio whose assets, or whose factors, take stated shares of the variance, through a model of second-order cones.

rba selects the budget, alg selects the model, and opt gives the prior, the solver and every other constraint. The model reads the covariance matrix alone and resolves no risk measure, so its result carries no r. Model (A) gives the risk budgeting portfolio when no row of opt binds at that portfolio. A row that binds, such as a target return, moves the contributions away from the budget. Models (B) and (C) can leave the budget also when no row binds. RiskBudgeting states the budget as a row of the logarithm, and it reads any risk measure.

Mathematical definition

The risk budgeting condition asks that each asset contribute the share $b_{i}$ of the variance, $w_{i} (\mathbf{\Sigma} \boldsymbol{w})_{i} = b_{i} \boldsymbol{w}^\intercal \mathbf{\Sigma} \boldsymbol{w}$. [245] writes the condition for equal shares as a second-order cone programme, and [244] adds a target return and a regulating term to it. The library writes Models (A), (B) and (C) of [244] with the shares of a general budget:

\[\begin{align} \underset{\boldsymbol{w},\, \psi,\, \gamma,\, \boldsymbol{\zeta}}{\min} \quad & \psi - \gamma \\ \text{s.t.} \quad & \boldsymbol{\zeta} = \mathbf{\Sigma} \boldsymbol{w}\,, \quad \boldsymbol{\zeta} \geq \boldsymbol{0}\,, \\ & w_{i} \zeta_{i} \geq b_{i} \gamma^{2}\,, \quad i = 1, \ldots, n\,, \\ & \boldsymbol{w} \in \mathcal{W}\,. \end{align}\]

The model in alg adds the cones that bound $\psi$. Model (A), BasicRelaxedRiskBudgeting, adds one:

\[\begin{align} \psi &\geq \lVert \mathbf{G} \boldsymbol{w} \rVert_{2}\,. \end{align}\]

Model (B), RegularisedRelaxedRiskBudgeting, and Model (C), RegularisedPenalisedRelaxedRiskBudgeting, add a regulating term $\rho$:

\[\begin{align} \psi^{2} &\geq \lVert \mathbf{G} \boldsymbol{w} \rVert_{2}^{2} + \rho^{2}\,, \\ \rho^{2} &\geq n\, \boldsymbol{w}^\intercal \mathbf{\Sigma} \boldsymbol{w} \quad \text{in Model (B)}\,, \\ \rho^{2} &\geq n \lambda\, \boldsymbol{w}^\intercal \mathbf{\Theta} \boldsymbol{w}\,, \quad \mathbf{\Theta} = \mathrm{diag}(\mathbf{\Sigma})\,, \quad \text{in Model (C)}\,. \end{align}\]

The variables $\psi$, $\gamma$ and $\rho$ are $\sqrt{n}$ times the variables of [244], so the objective is $\sqrt{n}$ times its objective and the weights are the same. With $b_{i} = 1/n$ the rows are its Equations 13 to 15, 22 to 25 and 32 to 35. Its target return, Equations 16, 26 and 36, is the lower bound of the return that opt.ret can state. It is then a row of $\mathcal{W}$.

In Model (A), for a budget whose shares sum to one, the rows give the chain $\gamma^{2} = \gamma^{2} \sum_{i} b_{i} \leq \sum_{i} w_{i} \zeta_{i} = \boldsymbol{w}^\intercal \mathbf{\Sigma} \boldsymbol{w} \leq \psi^{2}$. So the objective is not below zero, and it is zero exactly when $w_{i} \zeta_{i} = b_{i} \boldsymbol{w}^\intercal \mathbf{\Sigma} \boldsymbol{w}$ for every $i$, which is the risk budgeting condition. In Models (B) and (C) the regulating term is at its bound at the optimum, so $\psi$ is larger than the standard deviation, and the objective is not zero at the budget. The optimum then trades the budget for a lower $\psi$.

Where:

  • $\boldsymbol{w}$: Portfolio weights vector $N \times 1$.
  • $\psi$: Upper bound of the standard deviation of the portfolio. In Models (B) and (C) it also bounds the regulating term.
  • $\gamma$: Lower bound of $\sqrt{w_{i} \zeta_{i} / b_{i}}$ over the assets.
  • $\boldsymbol{\zeta}$: Marginal risks, $\mathbf{\Sigma} \boldsymbol{w}$. So $w_{i} \zeta_{i}$ is the contribution of asset $i$ to the variance.
  • $b_{i}$: Share of asset $i$ in the budget rba.rkb, its entry divided by the sum of the entries. So a budget of 1:5 and a budget of (1:5) / 15 give the same portfolio.
  • $n$: Number of entries of the budget, which is the number of assets, or the number of factors of a FactorRiskBudgeting.
  • $\mathcal{W}$: Feasible weight set, the portfolios that the constraints of the optimiser admit. It holds the weight bounds, the budget, the target return and every other row of opt. The budgeted weights are not negative, because $\boldsymbol{\zeta} \geq \boldsymbol{0}$ and the cones give $w_{i} \geq 0$.
  • $\mathbf{G}$: Covariance factor, with $\mathbf{G}^\intercal \mathbf{G} = \mathbf{\Sigma}$. It need not be square, and $\lVert \mathbf{G} \boldsymbol{w} \rVert_{2}^{2} = \boldsymbol{w}^\intercal \mathbf{\Sigma} \boldsymbol{w}$. It is the chol of the prior, or the transpose of the square root of $\mathbf{\Sigma}$ that matrix_square_root takes under mtx_sqrt.
  • $\mathbf{\Sigma}$: Covariance matrix of the prior.
  • $\rho$: Regulating term of Models (B) and (C).
  • $\lambda$: Penalty p of RegularisedPenalisedRelaxedRiskBudgeting.
  • $\mathbf{\Theta}$: Diagonal matrix of the variances of the single assets.

Factor risk budgeting

With a FactorRiskBudgeting the budget is over the factor weights $\boldsymbol{w}_{1}$. So the cones of the budget pair $[\boldsymbol{w}_{1}]_{j}$ with $\zeta_{j}$ and read the share of factor $j$. The marginal risks and the cones on $\psi$ read the whole portfolio:

\[\begin{align} \boldsymbol{w} &= \begin{cases} \mathbf{B}_{1} \boldsymbol{w}_{1} & \text{if } \texttt{flag} = \texttt{false}\,, \\ \mathbf{B}_{1} \boldsymbol{w}_{1} + \mathbf{B}_{2} \boldsymbol{w}_{2} & \text{if } \texttt{flag} = \texttt{true}\,, \end{cases} \\ \boldsymbol{\zeta} &= \mathbf{B}_{1}^\intercal \mathbf{\Sigma} \boldsymbol{w}\,, \qquad \psi \geq \lVert \mathbf{G} \boldsymbol{w} \rVert_{2} \quad \text{in Model (A)}\,. \end{align}\]

So $[\boldsymbol{w}_{1}]_{j} \zeta_{j}$ is the Euler contribution of factor $j$ to $\boldsymbol{w}^\intercal \mathbf{\Sigma} \boldsymbol{w}$, the value that factor_risk_contribution reports. With flag = true the variance splits into the factor contributions and the off-factor contribution $c_{2} = \boldsymbol{w}_{2}^\intercal \mathbf{B}_{2}^\intercal \mathbf{\Sigma} \boldsymbol{w}$, which takes no budget. The chain of Model (A) then gives $\gamma^{2} \leq \boldsymbol{w}^\intercal \mathbf{\Sigma} \boldsymbol{w} - c_{2}$. So the objective can fall below zero by the term $c_{2}$, and in general its optimum is not the optimum of RiskBudgeting. The penalty of Model (C) reads the decision vector, $\boldsymbol{w}_{1}$, or $\boldsymbol{w}_{1}$ followed by $\boldsymbol{w}_{2}$, with the covariance $\mathbf{P}^\intercal \mathbf{\Sigma} \mathbf{P}$ of its basis $\mathbf{P}$.

With hedge = true the model adds the rows $\mathbf{B}_{2}^\intercal \mathbf{\Sigma} \boldsymbol{w} = \boldsymbol{0}$. They are the first-order condition of the variance in $\boldsymbol{w}_{2}$, so $c_{2} = 0$, and the model is the model above on the factor covariance $(\mathbf{B}^\intercal \mathbf{\Sigma}^{-1} \mathbf{B})^{-1}$. Model (A) is then exact: when no other row binds, its optimum is the optimum of RiskBudgeting under Variance. The cost is that the weights lie in a subspace of dimension $N_{f}$, so a weight bound that the free off-factor weights meet can make the model infeasible.

Where:

  • $\boldsymbol{w}_{1}$: Factor weights, one entry for each of the $N_{f}$ factors.
  • $\boldsymbol{w}_2$: Off-factor weights, one entry for each direction of the null space of $\mathbf{B}^\intercal$. There are $N - N_f$ of them when $\mathbf{B}$ has full column rank.
  • $\mathbf{B}$: Loading matrix, of size $N \times N_{f}$. It is rr.L.
  • $\mathbf{B}_{1}$: Factor basis, the pseudoinverse of $\mathbf{B}^\intercal$.
  • $\mathbf{B}_{2}$: Off-factor basis, an orthonormal basis of the null space of $\mathbf{B}^\intercal$.
  • $\mathbf{P}$: Basis of the decision vector, $\mathbf{B}_{1}$, or $[\mathbf{B}_{1} \; \mathbf{B}_{2}]$ when flag = true.
  • $c_{2}$: Off-factor contribution to the variance.

Fields

  • opt: JuMP optimiser configuration.
  • rba: Risk budget algorithm.
  • wi: Initial portfolio weights for warm-starting the solver.
  • fb: Fallback result or estimator.
  • mtx_sqrt: Square-root algorithm of the covariance matrix that the cones read, when the prior carries no chol, or nothing for the plain Cholesky factor, which raises a LinearAlgebra.PosDefException on a matrix that is not positive definite. The default takes the square root of the eigendecomposition of a singular positive semidefinite matrix. matrix_square_root states each algorithm.

Constructors

RelaxedRiskBudgeting(;    opt::JuMPOptimiser,    rba::TD{<:RiskBudgetingAlgorithm} = AssetRiskBudgeting(),    wi::TD_Option{<:VecNum} = nothing,    alg::RelaxedRiskBudgetingAlgorithm = BasicRelaxedRiskBudgeting(),    fb::TDO_Option{<:OptE_Opt} = nothing,    mtx_sqrt::Option{<:AbstractMatrixSquareRootAlgorithm} = EigenFallbackSquareRoot()) -> RelaxedRiskBudgeting

Keywords correspond to the struct's fields. A field of the type TD, TD_Option or TDO_Option can hold a TimeDependent schedule in place of a static value. The budgeting algorithm with its budget, the initial weights and the fallback define the problem, so a cross-validation fold loop resolves them for each fold. An optimise outside a fold loop uses the static default of each field. The default of wi and of fb is nothing. The model alg and the square-root algorithm mtx_sqrt control the formulation, and they cannot hold a schedule.

Validation

  • If wi is provided: !isempty(wi). Otherwise an IsEmptyError.
  • A schedule in fb: bind !== :nearest.
  • A part that states no source and reads the raw returns, beside a part that states x_src = ExcessSource(), logs one warning that names its path, see warn_raw_readers. The constructor then builds the estimator as configured.

Propagated parameters

factory passes its arguments on to these @fprop fields:

  • opt: Recursively updated through factory.
  • fb: Recursively updated through factory.

View parameters

RelaxedRiskBudgeting defines its own port_opt_view method rather than deriving one from field tags.

  • The method reads the returns matrix X as its third argument. When opt.pe holds a prior result, the method uses opt.pe.X in place of X. So the views of the children read the observations of the prior, and not the matrix of the caller.
  • opt recurses through port_opt_view with that matrix. rba recurses with the indices alone.
  • fb recurses through view_child with that matrix.
  • wi is sliced to the selected assets.
  • alg and mtx_sqrt pass unchanged.

Observation weight parameters

obs_weights_view indexes these fields to the selected observations:

Related

References

  • [244] V. Gambeta and R. Kwon. Risk return trade-off in relaxed risk parity portfolio optimization. Journal of Risk and Financial Management 13, 237 (2020). Model (0), Equations 5 to 11, and Model (A), Equations 12 to 17. The original source of this formulation was not found. The formulation follows this work and is not checked against the original.
  • [244] V. Gambeta and R. Kwon. Risk return trade-off in relaxed risk parity portfolio optimization. Journal of Risk and Financial Management 13, 237 (2020). Model (B), Equations 21 to 27, and Model (C), Equations 31 to 37.
  • [245] H. Mausser and O. Romanko. Computing equal risk contribution portfolios. IBM Journal of Research and Development 58, 5:1–5:12 (2014).
  • [12] D. Cajas. Advanced Portfolio Optimization: A Cutting-edge Quantitative Approach (Springer Nature Switzerland, 2025). Section 10.1.2, Equations 10.5 and 10.6, for the rotated cone with a general budget.
  • [223] T. Roncalli and G. Weisang. Risk parity portfolios with risk factors. Available at SSRN 2155159 (2012). Problem 8 and Section 4.1.1, for the budget over the factors.
source
PortfolioOptimisers.factory — Method
factory(a, args...; kwargs...) -> a
factory(a::AbstractArray{<:Union{Nothing, AbstractEstimator, AbstractAlgorithm,
                                 AbstractResult, StatsBase.CovarianceEstimator}},
        args...; kwargs...) -> AbstractArray

Rebuild an estimator, an algorithm or a result with runtime values. These two methods are the leaf and the array step of the traversal.

factory and port_opt_view are the two propagation mechanisms of this library. factory passes runtime values, such as prior moments, observation weights and previous portfolio weights, down a tree of composed structs. port_opt_view passes an index selection, a subset of the assets, down the same tree.

factory is a traversal, so it owns the identity on every leaf, as fmap in Functors.jl and adapt_structure in Adapt.jl do. A value that has no method of its own comes back with no change: a data field, a scalar, nothing, a set of observation weights and a covariance estimator of StatsBase. So a @propagatable struct sends each @fprop field to factory directly, whatever the field holds.

The array method is the one forwarding contract for every propagation field that holds an array of estimators, algorithms, results or covariance estimators. It applies factory to each element, and it forwards args... and kwargs... with no change. A family that accepts an array of them needs no method of its own. A family that needs more than the forward defines its own, more specific method. A concrete element type, through concrete_typed_array_if_abstract, is an example. An array of data, such as a vector of numbers, is a leaf, and it comes back with no change and with no copy.

Algorithm

The leaf method:

  1. Return a with no change, and drop args... and kwargs.... This method is the leaf of the recursion. Because of it, a call of the verb on a type with no tags returns the value and raises no error.

The array method:

  1. For each element ai of a, call factory on ai, and forward args... and kwargs... with no change.
  2. Collect the results into a new array of the shape of a, in the order of a, and return it.

A @propagatable struct always has a generated method that is more specific than the leaf method. If the struct has at least one @fprop or @wprop field, that method builds the struct again with its keyword constructor. It sends each @fprop field through factory and each @wprop field through _wprop. If the struct has no such field, that method returns x.

The leaf method does not fill a nothing field. A weights field that must take the incoming weights when it holds nothing carries @wprop, and it goes to _wprop.

Arguments

  • a: Any value, which the leaf method returns with no change. For the array method, an array of estimators, algorithms, results, covariance estimators or nothing, which it rebuilds one element at a time.
  • args...: Positional arguments. The leaf method ignores them, and the array method forwards them.
  • kwargs...: Keyword arguments. The leaf method ignores them, and the array method forwards them.

Returns

  • a: The input with no change, for the leaf method.
  • v::AbstractArray: The rebuilt elements, in an array of the shape of a, for the array method.

Examples

julia> factory(nothing, 1, 2; x = 3)julia> factory([1.0, 2.0], 1, 2; x = 3)2-element Vector{Float64}: 1.0 2.0julia> factory(MeanValue())MeanValue  w ┴ nothing

Related

source
factory(
    opt::Union{NonFiniteAllocationOptimisationEstimator, NonFiniteAllocationOptimisationResult},
    _
) -> RelaxedRiskBudgeting{JuMPOptimiser{__T_pe, __T_slv, __T_cbe, __T_bgt, __T_fees, __T_ret, __T_sca, __T_sc, __T_so, __T_strict, __T_cache}, _A, _B, <:RelaxedRiskBudgetingAlgorithm} where {__T_pe, __T_slv, __T_cbe, __T_bgt, __T_fees, __T_ret, __T_sca, __T_sc, __T_so, __T_strict, __T_cache, _A, _B}

Returns opt unchanged.

This is the fallback factory of an optimisation estimator or result. An estimator whose parameters change at each step of an optimisation adds its own method. A precomputed result in a field of an estimator, for example in fb, reaches this method when factory gives the estimator the weights of the previous fold. A precomputed result does not change.

Related

source
PortfolioOptimisers.port_opt_view — Method
port_opt_view(
    rrb::RelaxedRiskBudgeting,
    i,
    X::AbstractMatrix{<:Union{Number, AbstractJuMPScalar}},
    args...
) -> RelaxedRiskBudgeting{JuMPOptimiser{__T_pe, __T_slv, __T_cbe, __T_bgt, __T_fees, __T_ret, __T_sca, __T_sc, __T_so, __T_strict, __T_cache}, _A, _B, <:RelaxedRiskBudgetingAlgorithm} where {__T_pe, __T_slv, __T_cbe, __T_bgt, __T_fees, __T_ret, __T_sca, __T_sc, __T_so, __T_strict, __T_cache, _A, _B}

Return the view of a RelaxedRiskBudgeting at the assets i.

The ## View parameters subsection of RelaxedRiskBudgeting states how the method takes the view of each field.

Arguments

  • rrb: The optimiser.
  • i: Indices of the assets that the view keeps.
  • X::MatNum: Returns matrix of the caller. The method uses the matrix of the prior in its place when rrb.opt.pe holds a prior result.
  • args...: Not read.

Returns

  • RelaxedRiskBudgeting: A new optimiser, built through the keyword constructor.

Related

source
PortfolioOptimisers._optimise — Function
_optimise(rrb::RelaxedRiskBudgeting, rd::ReturnsResult = ReturnsResult();
          str_names::Bool = false, save::Bool = true, blocks::Tuple = (),
          kwargs...) -> RelaxedRiskBudgetingResult

Build the model of a RelaxedRiskBudgeting, solve it, and return its result.

optimise reaches this method through shared_series_solve, which drops the observations of a Shared Series gap before the solve.

Algorithm

  1. Replace each schedule of rrb with its static default through reset_time_dependent_estimator.
  2. Resolve rrb.opt against rd with resolve_jump_optimiser, with the blocks of blocks, giving attrs. It holds the prior, the block Results, the fees, the return terms and the Investable Mask.
  3. Take the view of rrb and of rd at the investable assets with investable_view. Both are unchanged when every asset is investable.
  4. Bind the benchmark of each DataBenchmarkTracking term to rd with bind_data_benchmark.
  5. Build a new model. Register the scales with set_model_scales!, the number of observations with set_model_observations!, and the expression k = 1 with set_maximum_ratio_factor_variables!, because MinimumRisk does not scale the weights.
  6. Add the weights, the cones and the weight constraints with set_relaxed_risk_budgeting_constraints!, giving rbr.
  7. Add the constraints of every block and the return terms of rrb.opt with assemble_jump_model!.
  8. Set the objective MinimumRisk, which minimises risk, and solve with optimise_JuMP_model!, giving retcode and sol.
  9. Build the result. It holds attrs, retcode, sol, the model when save is true, and rbr.

Arguments

  • rrb::RelaxedRiskBudgeting: The optimiser.
  • rd: The returns result to use. When rrb.opt.pe is a prior result, the solve does not read rd, except to fit the loadings of FactorRiskBudgeting when no other source holds them. A fallback or a clustering step can still read it.
  • str_names::Bool: true gives each variable and each row of the model its string name.
  • save::Bool: true keeps the model in the result.
  • blocks::Tuple = (): The blocks after the block of the optimiser of the head, the keyword blocks of resolve_jump_optimiser. The head adds the rows of every block to its model with assemble_jump_model!. The fallback chain of optimise passes the keyword to each member, so a fallback solves on the same blocks.
  • kwargs...: Passed on to resolve_jump_optimiser.

Returns

Related

source

References

[12]
D. Cajas. Advanced Portfolio Optimization: A Cutting-edge Quantitative Approach (Springer Nature Switzerland, 2025).
[223]
T. Roncalli and G. Weisang. Risk Parity Portfolios with Risk Factors. Available at SSRN 2155159 (2012).
[244]
V. Gambeta and R. Kwon. Risk Return Trade-Off in Relaxed Risk Parity Portfolio Optimization. Journal of Risk and Financial Management 13, 237 (2020).
[245]
H. Mausser and O. Romanko. Computing Equal Risk Contribution Portfolios. IBM Journal of Research and Development 58, 5:1–5:12 (2014).