Bootstrap Uncertainty Sets

abstract type BootstrapUncertaintySetEstimator <: AbstractUncertaintySetEstimator

Fits an uncertainty set by resampling the return series, so the set assumes no law for the returns.

All concrete subtypes should subtype BootstrapUncertaintySetEstimator. It is the branch of AbstractUncertaintySetEstimator whose bounds come from a resample rather than from a closed form.

Interfaces

A subtype implements the three methods of AbstractUncertaintySetEstimator, and carries a ARCHBootstrapSet that says how the resample is drawn.

Related

• ARCHUncertaintySet
• AbstractUncertaintySetEstimator
• ARCHBootstrapSet

abstract type ARCHBootstrapSet <: AbstractAlgorithm

Selects how a block bootstrap draws its blocks, which is what keeps the serial dependence of a return series in the resample.

All concrete subtypes should subtype ARCHBootstrapSet. The three that ship differ on three axes at once, and a caller chooses between them on those three axes alone.

The wrapping column is the one that decides whether every observation is drawn equally often. The two schemes that wrap draw each of the T observations equally often; the one that does not draw the first and the last observations of the series less often than the middle, in the ramp MovingBootstrap states.

Interfaces

In order to implement a new concrete type that works seamlessly with the library, subtype ARCHBootstrapSet and implement the following method:

bootstrap_indices

• bootstrap_indices(alg::ARCHBootstrapSet, rng::Random.AbstractRNG, T::Integer, block_size::Integer) -> Vector{Int}: Returns the row indices of one resample.

Arguments

• alg: The concrete subtype instance.
• rng: Random number generator.
• T: Number of observations in the sample being resampled.
• block_size: Block length, or the mean block length when the length is random.

Returns

• idx::Vector{Int}: T indices in 1:T, which select the rows of one resample.

Related

• StationaryBootstrap
• CircularBootstrap
• MovingBootstrap
• bootstrap_indices

struct StationaryBootstrap <: ARCHBootstrapSet

Draws blocks of geometrically distributed random length, so the resample is itself a stationary series.

A block starts anywhere in 1:T, continues to the next index by mod1 so that it wraps past the end of the series, and restarts with probability 1 / block_size at each index. The block length is therefore geometric with mean block_size: over 101170 blocks at block_size = 10 the measured mean length is 9.884, and the measured length frequencies [0.101, 0.0921, 0.082, 0.0733, 0.0671, 0.0584] for lengths 1:6 match the geometric masses [0.1, 0.09, 0.081, 0.0729, 0.0656, 0.059]. The mean falls a little below block_size because the last block of an index vector is cut short at T.

Because a block wraps, every observation is drawn equally often. block_size is a mean and not a bound, so it may exceed T without a raise: the restart probability is then below 1 / T and the scheme approaches a single wrapped block. The spread does not collapse, but it narrows — over 250 resamples of a 252-by-5 sample the standard deviation of the bootstrap means at block_size = T + 1 is 0.377 of the value at block_size = 3.

Related

• ARCHBootstrapSet
• CircularBootstrap
• MovingBootstrap

References

• [90] D. N. Politis and J. P. Romano. The stationary bootstrap. Journal of the American Statistical Association 89, 1303–1313 (1994).

struct CircularBootstrap <: ARCHBootstrapSet

Draws blocks of fixed length block_size that wrap past the end of the series, so every observation is drawn equally often.

A block starts anywhere in 1:T and runs block_size indices forward, each taken by mod1, so the series is read as a circle. The wrap is what buys the equal coverage: over 20000 index vectors at T = 100 and block_size = 5 every observation is drawn between 0.985 and 1.015 of the average, against a ramp down to 0.192 under MovingBootstrap.

A block_size of T or more collapses the set to a point. The first block already fills the whole index vector, so every resample is a cyclic shift of the series, and a cyclic shift is a permutation. The mean and the covariance do not change under a permutation of the rows, so every resample returns the same statistics, and the box width and the ellipsoidal shape matrix are both zero to rounding. Nothing raises: a zero-width set is an empty set rather than an error.

Related

• ARCHBootstrapSet
• StationaryBootstrap
• MovingBootstrap

References

• [91] D. N. Politis and J. P. Romano. A circular block-resampling procedure for stationary data. In: Exploring the Limits of Bootstrap (John Wiley & Sons, 1992); pp. 263–270.

struct MovingBootstrap <: ARCHBootstrapSet

Draws blocks of fixed length block_size that never wrap, so a resample holds no join between the end of the series and its start.

A block starts in 1:(T - block_size + 1) and runs block_size indices forward, so the last index of a block never passes T. This is the one scheme of the three that guards block_size, and it is the one that needs a guard: the start range is empty as soon as block_size exceeds T, and the raise turns an ArgumentError about an empty range into a DomainError that names block_size and T. The two schemes that wrap take every index through mod1, which cannot leave 1:T, so neither can build an out-of-range index and neither needs a guard.

The price of the missing wrap is uneven coverage. Observation j of the first block_size observations lies inside only j of the start positions, so it is drawn about j / block_size as often as an observation of the middle, and the last block_size observations mirror the ramp. So the first and the last observations carry about 1 / block_size of the weight of a middle one. Prefer CircularBootstrap when that asymmetry is not wanted.

Related

• ARCHBootstrapSet
• StationaryBootstrap
• CircularBootstrap

References

• [92] H. R. Künsch. The jackknife and the bootstrap for general stationary observations. The Annals of Statistics 17, 1217–1241 (1989).

struct ARCHUncertaintySet{__T_pe, __T_ce, __T_me, __T_alg, __T_n_sim, __T_block_size, __T_q, __T_rng, __T_seed, __T_bootstrap, __T_kwargs} <: BootstrapUncertaintySetEstimator

Fits a box or an ellipsoidal uncertainty set from the spread of the statistics over a block bootstrap of the return series.

It is the bootstrapping method of Equation 11.18 of the source, and it assumes no law for the returns. The bootstrap field picks one of the three block bootstraps, each of which the library implements itself in bootstrap_indices and cites its own paper for.

The name carries no volatility model. It is inherited from the block-bootstrap routines of a volatility-modelling package, and this type fits no such model: it refits me and ce on each resample and reads the spread of the refits, so no docstring in this file states a conditional variance recursion.

The centre and the spread come from different estimators, and nothing reconciles them. The centre val is the point estimate pe fits, while the bounds come from refitting me and ce on the resamples. So a box need not contain its own centre when the two disagree. With pe = EmpiricalPrior() and me = MedianExpectedReturns() over 250 resamples of a 252-by-5 sample at block_size = 3 and seed = 987654321, one asset's val of -0.000934 sits above its ub of -0.001007. A consumer of the mean axis reads only val and the half-width (ub - lb) / 2, so the asymmetry is discarded and the set is centred on the prior's estimate with the bootstrap's width; a consumer of the covariance axis reads both bounds and never val.

ce enters the ellipsoidal covariance axis twice. It fits the covariance of every resample, and it then fits the shape matrix over the deviations of those covariances. Turning off its bias correction moves the resampled covariances by 0.397% over 252 observations and the covariance-axis shape matrix by 1.784% over 100 resamples. The mean axis reads ce once, over the deviations alone, and moves by exactly 1.0%.

Fields

• pe: Prior estimator the set fits on the returns it is handed, or nothing. With nothing the set holds no prior of its own and is calibrated on the prior result it is handed — inside an optimiser, the prior the optimiser is solving on, so its centre is the objective's own — through the prior-result arm of the ucs triple; the returns-data form then refuses by name. The default, EmpiricalPrior(), fits an empirical prior on the returns.

• ce: Covariance estimator.

• me: Expected returns estimator.

• alg: Uncertainty set algorithm.

• n_sim: Number of simulation samples.

• block_size: Block size for bootstrap sampling.

• q: Confidence level that sizes the uncertainty set (0 < q < 1). A smaller q is more demanding and yields a larger, more conservative set (wider box intervals / larger ellipsoid radius); a larger q gives a tighter set closer to the point estimate.

• rng: Random number generator.

• seed: Seed for the random number generator.

• bootstrap: Bootstrap algorithm.

• kwargs: Additional keyword arguments.

Constructors

ARCHUncertaintySet(;    pe::Option{<:AbstractLowOrderPriorEstimator} = EmpiricalPrior(),    ce::StatsBase.CovarianceEstimator = PortfolioOptimisersCovariance(),    me::AbstractExpectedReturnsEstimator = SimpleExpectedReturns(),    alg::AbstractUncertaintySetAlgorithm = BoxUncertaintySetAlgorithm(),    n_sim::Integer = 3_000,    block_size::Integer = 3,    q::Number = 0.05,    rng::Random.AbstractRNG = Random.default_rng(),    seed::Option{<:Integer} = nothing,    bootstrap::ARCHBootstrapSet = StationaryBootstrap(),    kwargs::NamedTuple = (;),) -> ARCHUncertaintySet

Keywords correspond to the struct's fields.

Validation

• n_sim > 0.
• block_size > 0.
• 0 < q < 1.

Examples

julia> ARCHUncertaintySet()ARCHUncertaintySet          pe ┼ EmpiricalPrior             │           ce ┼ PortfolioOptimisersCovariance             │              │   ce ┼ Covariance             │              │      │    me ┼ SimpleExpectedReturns             │              │      │       │   w ┴ nothing             │              │      │    ce ┼ GeneralCovariance             │              │      │       │   ce ┼ StatsBase.SimpleCovariance: StatsBase.SimpleCovariance(true)             │              │      │       │    w ┴ nothing             │              │      │   alg ┼ FullMoment()             │              │      │     w ┴ nothing             │              │   mp ┼ MatrixProcessing             │              │      │     pdm ┼ Posdef             │              │      │         │      alg ┼ UnionAll: NearestCorrelationMatrix.Newton             │              │      │         │   kwargs ┴ @NamedTuple{}: NamedTuple()             │              │      │      dn ┼ nothing             │              │      │      dt ┼ nothing             │              │      │     alg ┼ nothing             │              │      │   order ┴ NTuple{4, Symbol}: (:pdm, :dn, :dt, :alg)             │           me ┼ SimpleExpectedReturns             │              │   w ┴ nothing             │      horizon ┼ nothing             │   fill_limit ┴ nothing          ce ┼ PortfolioOptimisersCovariance             │   ce ┼ Covariance             │      │    me ┼ SimpleExpectedReturns             │      │       │   w ┴ nothing             │      │    ce ┼ GeneralCovariance             │      │       │   ce ┼ StatsBase.SimpleCovariance: StatsBase.SimpleCovariance(true)             │      │       │    w ┴ nothing             │      │   alg ┼ FullMoment()             │      │     w ┴ nothing             │   mp ┼ MatrixProcessing             │      │     pdm ┼ Posdef             │      │         │      alg ┼ UnionAll: NearestCorrelationMatrix.Newton             │      │         │   kwargs ┴ @NamedTuple{}: NamedTuple()             │      │      dn ┼ nothing             │      │      dt ┼ nothing             │      │     alg ┼ nothing             │      │   order ┴ NTuple{4, Symbol}: (:pdm, :dn, :dt, :alg)          me ┼ SimpleExpectedReturns             │   w ┴ nothing         alg ┼ BoxUncertaintySetAlgorithm()       n_sim ┼ Int64: 3000  block_size ┼ Int64: 3           q ┼ Float64: 0.05         rng ┼ Random.TaskLocalRNG: Random.TaskLocalRNG()        seed ┼ nothing   bootstrap ┼ StationaryBootstrap()      kwargs ┴ @NamedTuple{}: NamedTuple()

Related

• BootstrapUncertaintySetEstimator
• ARCHBootstrapSet
• StationaryBootstrap
• CircularBootstrap
• MovingBootstrap
• BoxUncertaintySet
• EllipsoidalUncertaintySet

References

• [5] D. Cajas. Advanced Portfolio Optimization: A Cutting-edge Quantitative Approach (Springer Nature Switzerland, 2025). Equation 11.18.

bootstrap_indices(alg::ARCHBootstrapSet, rng::Random.AbstractRNG, T::Integer,
                  block_size::Integer)

Generate a vector of T observation indices for one block bootstrap resample.

The three methods lay blocks of consecutive indices end to end until T indices are filled, and they differ only in how long a block is, in whether it wraps past the end of the series, and in where it may start. ARCHBootstrapSet tabulates the three axes.

Algorithm

The method Julia selects on the type of alg is the algorithm, so the three procedures below are the three methods.

StationaryBootstrap

1. Set the restart probability p to inv(block_size).
2. Draw idx[1] uniformly from 1:T, which starts the first block.
3. For each later t, draw one uniform variate. Below p, draw idx[t] uniformly from 1:T, which starts a new block. Otherwise set idx[t] to mod1(idx[t - 1] + 1, T), which continues the block and wraps it past the end of the series.
4. Return idx. Step 3 makes the block length geometric with mean block_size, and mod1 keeps every index inside 1:T whatever block_size is.

CircularBootstrap

1. Set the fill position t to zero.
2. While t is below T, draw a start s uniformly from 1:T.
3. Fill the next min(block_size, T - t) entries with mod1(s + k, T) for k from zero, which lays one block and wraps it past the end of the series. The last block of the vector is cut short when fewer than block_size entries are left.
4. Advance t by block_size, and go back to step 2 while t is below T.
5. Return idx. mod1 keeps every index inside 1:T, so this method needs no guard on block_size.

MovingBootstrap

1. Check that block_size does not exceed T, and raise a DomainError otherwise. Step 3 would draw from an empty range.
2. Set the fill position t to zero.
3. While t is below T, draw a start s uniformly from 1:(T - block_size + 1), which is the last start whose block still ends at or before T.
4. Fill the next min(block_size, T - t) entries with s + k for k from zero, which lays one block without a wrap. The last block of the vector is cut short when fewer than block_size entries are left.
5. Advance t by block_size, and go back to step 3 while t is below T.
6. Return idx. Step 3 bounds s + k by T, so no index leaves the range.

Arguments

• alg: Bootstrap algorithm type.
• rng: Random number generator.
• T: Number of observations in the sample being resampled.
• block_size: Size of blocks for resampling. Mean block length for StationaryBootstrap, fixed block length otherwise.

Validation

• MovingBootstrap requires block_size <= T, raising a DomainError. The other two methods take a block_size above T without a raise, and each states on its own type what it degenerates to.

Returns

• idx::Vector{Int}: Indices in 1:T selecting the rows of one bootstrap resample.

Related

• StationaryBootstrap
• CircularBootstrap
• MovingBootstrap
• ARCHBootstrapSet

References

• [90] D. N. Politis and J. P. Romano. The stationary bootstrap. Journal of the American Statistical Association 89, 1303–1313 (1994).
• [91] D. N. Politis and J. P. Romano. A circular block-resampling procedure for stationary data. In: Exploring the Limits of Bootstrap (John Wiley & Sons, 1992); pp. 263–270.
• [92] H. R. Künsch. The jackknife and the bootstrap for general stationary observations. The Annals of Statistics 17, 1217–1241 (1989).

ucs(ue::ARCHUncertaintySet, X::MatNum,
    F::Option{<:MatNum} = nothing; dims::Int = 1, kwargs...)
mu_ucs(ue::ARCHUncertaintySet, X::MatNum,
       F::Option{<:MatNum} = nothing; dims::Int = 1, kwargs...)
sigma_ucs(ue::ARCHUncertaintySet, X::MatNum,
          F::Option{<:MatNum} = nothing; dims::Int = 1, kwargs...)

Fits an ARCHUncertaintySet from returns data, by fitting the set's own prior and calibrating the set on the result.

These are the returns-data arms of the three verbs, and they are one method each whatever shape the set builds, because the shape is decided one call later. Each fits ue.pe once through ucs_prior, which refuses a pe of nothing by name, and hands the result to the prior-result arm of the same verb on the same set with its pe set to nothing, which is where the box, the ellipsoid and the norm ball are dispatched. The resample is drawn from the X that prior result carries, as it always was, so a set with a prior of its own is calibrated on that prior fitted on the returns it is handed, and on nothing else. The keyword arguments travel to both the prior fit and the resample estimators, as before.

Algorithm

1. Fit the prior with ucs_prior on ue.pe, X and F, giving pr.
2. Forward to the prior-result arm of the verb on the set with pe = nothing, which builds the set of the shape ue.alg names from pr.

Arguments

• ue: ARCH uncertainty set estimator.
• X: Data matrix.
• F: Optional factor matrix. Used by the prior estimator.
• dims: Dimension along which to perform the computation.
• kwargs...: Additional keyword arguments passed to the prior estimator, ue.me and ue.ce.

Validation

• ue.pe is not nothing. An ArgumentError naming the prior-result form is thrown otherwise.

Returns

• mu_ucs::AbstractUncertaintySetResult: Expected returns uncertainty set, from mu_ucs.
• sigma_ucs::AbstractUncertaintySetResult: Covariance uncertainty set, from sigma_ucs.
• (mu_ucs, sigma_ucs): Both, from ucs.

Related

• ARCHUncertaintySet
• ucs_prior
• reads_prior_result
• BoxUncertaintySetAlgorithm
• EllipsoidalUncertaintySetAlgorithm
• NormBallUncertaintySetAlgorithm

ucs(ue::ARCHUncertaintySet{Nothing, <:Any, <:Any, <:BoxUncertaintySetAlgorithm, <:Any, <:Any,
                           <:Any, <:Any, <:Any}, pr::AbstractPriorResult; rd = nothing, kwargs...)

Constructs box uncertainty sets for expected returns and covariance statistics using bootstrap resampling for time series data.

This is the prior-result arm of the verb, defined for a set whose pe is nothing. Inside an optimiser pr is the prior the optimiser is solving on, so the centre is the objective's own and the resample is drawn from the rows that prior carries; standalone it takes prior(pe, X) spelled out. The returns-data arm of the same verb fits the set's own prior through ucs_prior and forwards here, so the two routes share this one body.

Both sets come from one pass over one index stream, so the mean and the covariance of a given simulation are read from the same resample. With ue.seed set, this method and the pair mu_ucs and sigma_ucs return the same bounds bit for bit, because resolve_rng restarts each call at the same place and all three walk one index stream. With ue.seed unset they do not: over 200 resamples of a 252-by-5 sample the mean lower bound moved by 5.31e-4 against a set width of 9.53e-3. So a caller who splits one ucs call into two calls to save work keeps the answer only while a seed is set.

Generate $M$ bootstrap samples, compute $\hat{\boldsymbol{\mu}}^{(m)}$ and $\hat{\mathbf{\Sigma}}^{(m)}$, then take element-wise quantile bounds:

\[\begin{align} \mu_{lb,i} &= Q_{q/2}\!\left(\hat{\mu}^{(m)}_i\right)\,, \\ \mu_{ub,i} &= Q_{1-q/2}\!\left(\hat{\mu}^{(m)}_i\right)\,. \end{align}\]

\[\begin{align} (\mathbf{\Sigma}_{lb})_{ij} &= Q_{q/2}\!\left(\hat{\Sigma}^{(m)}_{ij}\right)\,, \\ (\mathbf{\Sigma}_{ub})_{ij} &= Q_{1-q/2}\!\left(\hat{\Sigma}^{(m)}_{ij}\right)\,. \end{align}\]

Where:

• $\mu_{lb,i}$, $\mu_{ub,i}$: Lower/upper bounds for expected return of asset $i$.
• $(\mathbf{\Sigma}_{lb})_{ij}$, $(\mathbf{\Sigma}_{ub})_{ij}$: Lower/upper covariance bounds.
• $Q_{q/2}$, $Q_{1-q/2}$: Quantile functions at level $q/2$.
• $\hat{\mu}^{(m)}_i$: Bootstrap mean for asset $i$ in sample $m$.
• $\hat{\Sigma}^{(m)}_{ij}$: Bootstrap covariance element $(i,j)$ in sample $m$.
• $q$: Significance level.

Algorithm

1. Reduce the prior result to the Investable Mask with investable_ucs_reduction. Inside an optimiser the result arrives already reduced and the step is a passthrough; standalone, on a prior fitted on a point-in-time Asset Panel, it takes the view the optimiser would have taken.
2. Take the prior result pr the set is calibrated on. Its pr.mu and pr.sigma become the centre val of the two sets, and pr.X is the matrix resampled, so under a Scenario Cap the carried rows are resampled.
3. Draw the resampled statistics with bootstrap_generator, giving mus and sigmas from one index stream.
4. Halve ue.q, giving the tail mass q that each side of a bound takes.
5. Read the element-wise quantiles of mus with vec_quantile_bounds, giving mu_l and mu_u.
6. Read the element-wise quantiles of sigmas with box_quantile_bounds, giving sigma_l and sigma_u.
7. Return the two BoxUncertaintySet values. The bounds come from step 2 and the centres from step 1, so neither set is guaranteed to contain its own centre.
8. Before the two sets leave, write both back onto the full universe with expand_investable_ucs, so a set fitted standalone is over the same assets the prior is, and a view of it at the mask recovers the reduced fit.

Arguments

• ue: ARCH uncertainty set estimator. ue.pe fits the centre val of both sets, and ue.me and ue.ce fit the bounds on the resamples, so the two need not agree.
• pr: Fitted prior result the set is calibrated on. pr.X is resampled.
• rd: Returns result the three-argument form passes beside the prior. Not read.
• kwargs...: Additional keyword arguments passed to ue.me and ue.ce.

Returns

• mu_ucs::BoxUncertaintySet: Expected returns uncertainty set.
• sigma_ucs::BoxUncertaintySet: Covariance uncertainty set.

Related

• ARCHUncertaintySet
• BoxUncertaintySet
• bootstrap_generator
• mu_bootstrap_generator
• sigma_bootstrap_generator

ucs(ue::ARCHUncertaintySet{Nothing, <:Any, <:Any, <:EllipsoidalUncertaintySetAlgorithm, <:Any, <:Any,
                           <:Any, <:Any, <:Any}, pr::AbstractPriorResult; rd = nothing, kwargs...)

Constructs ellipsoidal uncertainty sets for expected returns and covariance statistics using bootstrap resampling for time series data.

This is the prior-result arm of the verb, defined for a set whose pe is nothing. Inside an optimiser pr is the prior the optimiser is solving on, so the centre is the objective's own and the resample is drawn from the rows that prior carries; standalone it takes prior(pe, X) spelled out. The returns-data arm of the same verb fits the set's own prior through ucs_prior and forwards here, so the two routes share this one body.

Both sets come from one pass over one index stream. The shape matrices are the empirical covariances of the bootstrap deviations, fitted with ue.ce, so ue.ce fits the covariance axis twice: once inside every resample and once over the deviations of those resampled covariances. The mean axis reads it once, over the mean deviations alone. With ue.seed set, this method and the pair mu_ucs and sigma_ucs agree; with ue.seed unset they do not.

Mathematical definition

Compute bootstrap deviations $\boldsymbol{\delta}_{\mu}^{(m)} = \hat{\boldsymbol{\mu}}^{(m)} - \hat{\boldsymbol{\mu}}$ and $\boldsymbol{\delta}_{\Sigma}^{(m)} = \operatorname{vec}(\hat{\mathbf{\Sigma}}^{(m)} - \hat{\mathbf{\Sigma}})$. Fit empirical covariances:

\[\begin{align} \mathbf{\Sigma}_{\mu} &= \operatorname{Cov}\!\left(\boldsymbol{\delta}_{\mu}^{(m)}\right)\,, \\ \mathbf{\Sigma}_{\Sigma} &= \operatorname{Cov}\!\left(\boldsymbol{\delta}_{\Sigma}^{(m)}\right)\,. \end{align}\]

Then form ellipsoidal sets:

\[\begin{align} \mathcal{E}_{\mu} &= \left\{\boldsymbol{\mu} : (\boldsymbol{\mu} - \hat{\boldsymbol{\mu}})^{\intercal} \mathbf{\Sigma}_{\mu}^{-1} (\boldsymbol{\mu} - \hat{\boldsymbol{\mu}}) \leq k_{\mu}^2\right\}\,. \end{align}\]

\[\begin{align} \mathcal{E}_{\Sigma} &= \left\{\mathbf{\Sigma} : \left\lVert \mathbf{\Sigma}_{\Sigma}^{-1/2} \operatorname{vec}(\mathbf{\Sigma} - \hat{\mathbf{\Sigma}}) \right\rVert_2 \leq k_{\Sigma}\right\}\,. \end{align}\]

Where:

• $\mathbf{\Sigma}_{\mu}$: Empirical covariance of bootstrap mean deviations.
• $\mathbf{\Sigma}_{\Sigma}$: Empirical covariance of bootstrap covariance deviations (vectorised).
• $\hat{\boldsymbol{\mu}}$, $\hat{\mathbf{\Sigma}}$: Estimated mean and covariance.
• $\boldsymbol{\delta}_{\mu}^{(m)}$, $\boldsymbol{\delta}_{\Sigma}^{(m)}$: Bootstrap deviations for mean and covariance.
• $\mathcal{E}_{\mu}$: Ellipsoidal uncertainty set for expected returns.
• $\mathcal{E}_{\Sigma}$: Ellipsoidal uncertainty set for covariance.
• $k_{\mu}$, $k_{\Sigma}$: Empirically fitted scaling parameters.

Algorithm

1. Reduce the prior result to the Investable Mask with investable_ucs_reduction. Inside an optimiser the result arrives already reduced and the step is a passthrough; standalone, on a prior fitted on a point-in-time Asset Panel, it takes the view the optimiser would have taken.
2. Take the prior result pr the set is calibrated on. Its pr.mu and pr.sigma become the centres of the two sets, and pr.X is the matrix resampled, so under a Scenario Cap the carried rows are resampled.
3. Draw the resampled statistics with bootstrap_generator, giving mus and sigmas from one index stream.
4. Subtract pr.mu from each column of mus, and the vectorised pr.sigma from each slice of sigmas, giving the deviation matrices X_mu and X_sigma. Transpose both, so a row is one simulation.
5. Fit ue.ce on X_mu, giving the shape matrix sigma_mu. This is the second reading of ue.ce on the covariance axis and the only one on the mean axis, so the shape matrices are empirical and no asymptotic formula enters.
6. Fit ue.ce on X_sigma, giving the shape matrix sigma_sigma.
7. Build both sets with ellipsoidal_set under ue.alg.diagonal and ue.alg.method, which fits each radius k at the level ue.q.
8. Before the two sets leave, write both back onto the full universe with expand_investable_ucs, so a set fitted standalone is over the same assets the prior is, and a view of it at the mask recovers the reduced fit.

Arguments

• ue: ARCH uncertainty set estimator. ue.ce fits both the covariance of every resample and the shape matrix over the deviations, so it enters the covariance axis twice and the mean axis once. ue.pe fits the centres, and ue.me and ue.ce fit the spread, so the two need not agree.
• pr: Fitted prior result the set is calibrated on. pr.X is resampled.
• rd: Returns result the three-argument form passes beside the prior. Not read.
• kwargs...: Additional keyword arguments passed to ue.me and ue.ce.

Returns

• mu_ucs::EllipsoidalUncertaintySet: Ellipsoidal uncertainty set for expected returns.
• sigma_ucs::EllipsoidalUncertaintySet: Ellipsoidal uncertainty set for covariance.

Related

• ARCHUncertaintySet
• EllipsoidalUncertaintySet
• bootstrap_generator
• mu_bootstrap_generator
• sigma_bootstrap_generator

mu_ucs(ue::ARCHUncertaintySet{Nothing, <:Any, <:Any, <:BoxUncertaintySetAlgorithm, <:Any, <:Any,
                              <:Any, <:Any, <:Any}, pr::AbstractPriorResult; rd = nothing, kwargs...)

Constructs a box uncertainty set for expected returns using bootstrap resampling for time series data.

This is the prior-result arm of the verb, defined for a set whose pe is nothing. Inside an optimiser pr is the prior the optimiser is solving on, so the centre is the objective's own and the resample is drawn from the rows that prior carries; standalone it takes prior(pe, X) spelled out. The returns-data arm of the same verb fits the set's own prior through ucs_prior and forwards here, so the two routes share this one body.

The method walks its own index stream. With ue.seed set it returns the same bounds as the mean half of ucs, bit for bit, because resolve_rng restarts each call at the same place. With ue.seed unset it does not: over 200 resamples of a 252-by-5 sample the lower bound moved by 5.31e-4 against a set width of 9.53e-3.

Mathematical definition

\[\begin{align} \mu_{lb,i} &= Q_{q/2}\!\left(\hat{\mu}^{(m)}_i\right)\,, \\ \mu_{ub,i} &= Q_{1-q/2}\!\left(\hat{\mu}^{(m)}_i\right)\,. \end{align}\]

Where:

• $\mu_{lb,i}$, $\mu_{ub,i}$: Lower/upper bounds for expected return of asset $i$.
• $Q_{q/2}$, $Q_{1-q/2}$: Quantile functions at level $q/2$.
• $\hat{\mu}^{(m)}_i$: Bootstrap mean for asset $i$ in sample $m$.
• $q$: Significance level.

Algorithm

1. Reduce the prior result to the Investable Mask with investable_ucs_reduction. Inside an optimiser the result arrives already reduced and the step is a passthrough; standalone, on a prior fitted on a point-in-time Asset Panel, it takes the view the optimiser would have taken.
2. Take the prior result pr the set is calibrated on. Its pr.mu becomes the centre val, and pr.X is the matrix resampled, so under a Scenario Cap the carried rows are resampled.
3. Draw the resampled means with mu_bootstrap_generator, giving mus. No covariance is fitted here, so ue.ce is not read.
4. Halve ue.q, giving the tail mass q that each side of a bound takes.
5. Read the element-wise quantiles of mus with vec_quantile_bounds, giving mu_l and mu_u.
6. Return the BoxUncertaintySet. The bounds come from step 2 and the centre from step 1, so the set is not guaranteed to contain its own centre.
7. Before the set leaves, write it back onto the full universe with expand_investable_ucs, so a set fitted standalone is over the same assets the prior is, and a view of it at the mask recovers the reduced fit.

Arguments

• ue: ARCH uncertainty set estimator. ue.pe fits the centre val, and ue.me fits the bounds on the resamples, so the two need not agree.
• pr: Fitted prior result the set is calibrated on. pr.X is resampled.
• rd: Returns result the three-argument form passes beside the prior. Not read.
• kwargs...: Additional keyword arguments passed to ue.me.

Returns

• mu_ucs::BoxUncertaintySet: Expected returns uncertainty set.

Related

• ARCHUncertaintySet
• BoxUncertaintySet
• bootstrap_generator
• mu_bootstrap_generator
• sigma_bootstrap_generator

mu_ucs(ue::ARCHUncertaintySet{Nothing, <:Any, <:Any, <:EllipsoidalUncertaintySetAlgorithm, <:Any, <:Any,
                              <:Any, <:Any, <:Any}, pr::AbstractPriorResult; rd = nothing, kwargs...)

Constructs an ellipsoidal uncertainty set for expected returns using bootstrap resampling for time series data.

This is the prior-result arm of the verb, defined for a set whose pe is nothing. Inside an optimiser pr is the prior the optimiser is solving on, so the centre is the objective's own and the resample is drawn from the rows that prior carries; standalone it takes prior(pe, X) spelled out. The returns-data arm of the same verb fits the set's own prior through ucs_prior and forwards here, so the two routes share this one body.

The shape matrix is the empirical covariance of the bootstrap mean deviations, fitted with ue.ce, so ue.ce enters this axis once even though no covariance is fitted inside a resample. With ue.seed set the method returns the same set as the mean half of ucs; with ue.seed unset it does not.

Mathematical definition

\[\begin{align} \mathbf{\Sigma}_{\mu} &= \operatorname{Cov}\!\left(\hat{\boldsymbol{\mu}}^{(m)} - \hat{\boldsymbol{\mu}}\right)\,, \\ \mathcal{E}_{\mu} &= \left\{\boldsymbol{\mu} : (\boldsymbol{\mu} - \hat{\boldsymbol{\mu}})^{\intercal} \mathbf{\Sigma}_{\mu}^{-1} (\boldsymbol{\mu} - \hat{\boldsymbol{\mu}}) \leq k_{\mu}^2\right\}\,. \end{align}\]

Where:

• $\mathbf{\Sigma}_{\mu}$: Empirical covariance of bootstrap mean deviations.
• $\hat{\boldsymbol{\mu}}$: Estimated mean vector.
• $\mathcal{E}_{\mu}$: Ellipsoidal uncertainty set for expected returns.
• $k_{\mu}$: Empirically fitted scaling parameter.

Algorithm

1. Reduce the prior result to the Investable Mask with investable_ucs_reduction. Inside an optimiser the result arrives already reduced and the step is a passthrough; standalone, on a prior fitted on a point-in-time Asset Panel, it takes the view the optimiser would have taken.
2. Take the prior result pr the set is calibrated on. Its pr.mu becomes the centre, and pr.X is the matrix resampled, so under a Scenario Cap the carried rows are resampled.
3. Draw the resampled means with mu_bootstrap_generator, giving mus.
4. Subtract pr.mu from each column of mus, giving the deviation matrix X_mu. Transpose it, so a row is one simulation.
5. Fit ue.ce on X_mu, giving the shape matrix sigma_mu. The shape is empirical and no asymptotic formula enters.
6. Build the set with ellipsoidal_set under ue.alg.diagonal and ue.alg.method, which fits the radius k at the level ue.q.
7. Before the set leaves, write it back onto the full universe with expand_investable_ucs, so a set fitted standalone is over the same assets the prior is, and a view of it at the mask recovers the reduced fit.

Arguments

• ue: ARCH uncertainty set estimator. ue.me fits the mean of every resample, and ue.ce fits the shape matrix over the deviations.
• pr: Fitted prior result the set is calibrated on. pr.X is resampled.
• rd: Returns result the three-argument form passes beside the prior. Not read.
• kwargs...: Additional keyword arguments passed to ue.me.

Returns

• mu_ucs::EllipsoidalUncertaintySet: Ellipsoidal uncertainty set for expected returns.

Related

• ARCHUncertaintySet
• EllipsoidalUncertaintySet
• bootstrap_generator
• mu_bootstrap_generator
• sigma_bootstrap_generator

sigma_ucs(ue::ARCHUncertaintySet{Nothing, <:Any, <:Any, <:BoxUncertaintySetAlgorithm, <:Any, <:Any,
                                 <:Any, <:Any, <:Any}, pr::AbstractPriorResult; rd = nothing, kwargs...)

Constructs a box uncertainty set for covariance using bootstrap resampling for time series data.

This is the prior-result arm of the verb, defined for a set whose pe is nothing. Inside an optimiser pr is the prior the optimiser is solving on, so the centre is the objective's own and the resample is drawn from the rows that prior carries; standalone it takes prior(pe, X) spelled out. The returns-data arm of the same verb fits the set's own prior through ucs_prior and forwards here, so the two routes share this one body.

The method walks its own index stream. With ue.seed set it returns the same bounds as the covariance half of ucs, bit for bit, because resolve_rng restarts each call at the same place. With ue.seed unset it does not: over 200 resamples of a 252-by-5 sample the lower bound moved by 2.12e-5.

Mathematical definition

\[\begin{align} (\mathbf{\Sigma}_{lb})_{ij} &= Q_{q/2}\!\left(\hat{\Sigma}^{(m)}_{ij}\right)\,, \\ (\mathbf{\Sigma}_{ub})_{ij} &= Q_{1-q/2}\!\left(\hat{\Sigma}^{(m)}_{ij}\right)\,. \end{align}\]

Where:

• $(\mathbf{\Sigma}_{lb})_{ij}$, $(\mathbf{\Sigma}_{ub})_{ij}$: Lower/upper covariance bounds.
• $Q_{q/2}$, $Q_{1-q/2}$: Quantile functions at level $q/2$.
• $\hat{\Sigma}^{(m)}_{ij}$: Bootstrap covariance element $(i,j)$ in sample $m$.
• $q$: Significance level.

Algorithm

1. Reduce the prior result to the Investable Mask with investable_ucs_reduction. Inside an optimiser the result arrives already reduced and the step is a passthrough; standalone, on a prior fitted on a point-in-time Asset Panel, it takes the view the optimiser would have taken.
2. Take the prior result pr the set is calibrated on. Its pr.sigma becomes the centre val, and pr.X is the matrix resampled, so under a Scenario Cap the carried rows are resampled.
3. Draw the resampled covariances with sigma_bootstrap_generator, giving sigmas. No mean is fitted here, so ue.me is not read.
4. Halve ue.q, giving the tail mass q that each side of a bound takes.
5. Read the element-wise quantiles of sigmas with box_quantile_bounds, giving sigma_l and sigma_u.
6. Return the BoxUncertaintySet. The bounds come from step 2 and the centre from step 1, so the set is not guaranteed to contain its own centre.
7. Before the set leaves, write it back onto the full universe with expand_investable_ucs, so a set fitted standalone is over the same assets the prior is, and a view of it at the mask recovers the reduced fit.

Arguments

• ue: ARCH uncertainty set estimator. ue.pe fits the centre val, and ue.ce fits the bounds on the resamples, so the two need not agree.
• pr: Fitted prior result the set is calibrated on. pr.X is resampled.
• rd: Returns result the three-argument form passes beside the prior. Not read.
• kwargs...: Additional keyword arguments passed to ue.ce.

Returns

• sigma_ucs::BoxUncertaintySet: Covariance uncertainty set.

Related

• ARCHUncertaintySet
• BoxUncertaintySet
• bootstrap_generator
• mu_bootstrap_generator
• sigma_bootstrap_generator

sigma_ucs(ue::ARCHUncertaintySet{Nothing, <:Any, <:Any, <:EllipsoidalUncertaintySetAlgorithm, <:Any, <:Any,
                                 <:Any, <:Any, <:Any}, pr::AbstractPriorResult; rd = nothing, kwargs...)

Constructs an ellipsoidal uncertainty set for covariance using bootstrap resampling for time series data.

This is the prior-result arm of the verb, defined for a set whose pe is nothing. Inside an optimiser pr is the prior the optimiser is solving on, so the centre is the objective's own and the resample is drawn from the rows that prior carries; standalone it takes prior(pe, X) spelled out. The returns-data arm of the same verb fits the set's own prior through ucs_prior and forwards here, so the two routes share this one body.

The shape matrix is the empirical covariance of the bootstrap covariance deviations, fitted with ue.ce, so ue.ce enters this axis twice: once inside every resample and once over the deviations. Turning off its bias correction moves the resampled covariances by 0.397% over 252 observations and the shape matrix by 1.784% over 100 resamples. With ue.seed set the method returns the same set as the covariance half of ucs; with ue.seed unset it does not.

Mathematical definition

\[\begin{align} \mathbf{\Sigma}_{\Sigma} &= \operatorname{Cov}\!\left(\operatorname{vec}(\hat{\mathbf{\Sigma}}^{(m)} - \hat{\mathbf{\Sigma}})\right)\,, \\ \mathcal{E}_{\Sigma} &= \left\{\mathbf{\Sigma} : \left\lVert \mathbf{\Sigma}_{\Sigma}^{-1/2} \operatorname{vec}(\mathbf{\Sigma} - \hat{\mathbf{\Sigma}}) \right\rVert_2 \leq k_{\Sigma}\right\}\,. \end{align}\]

Where:

• $\mathbf{\Sigma}_{\Sigma}$: Empirical covariance of bootstrap covariance deviations (vectorised).
• $\hat{\mathbf{\Sigma}}$: Estimated covariance matrix.
• $\mathcal{E}_{\Sigma}$: Ellipsoidal uncertainty set for covariance.
• $k_{\Sigma}$: Empirically fitted scaling parameter.

Algorithm

1. Reduce the prior result to the Investable Mask with investable_ucs_reduction. Inside an optimiser the result arrives already reduced and the step is a passthrough; standalone, on a prior fitted on a point-in-time Asset Panel, it takes the view the optimiser would have taken.
2. Take the prior result pr the set is calibrated on. Its pr.sigma becomes the centre, and pr.X is the matrix resampled, so under a Scenario Cap the carried rows are resampled.
3. Draw the resampled covariances with sigma_bootstrap_generator, giving sigmas. This is the first reading of ue.ce.
4. Subtract the vectorised pr.sigma from each slice of sigmas, giving the deviation matrix X_sigma. Transpose it, so a row is one simulation.
5. Fit ue.ce on X_sigma, giving the shape matrix sigma_sigma. This is the second reading of ue.ce, and the shape is empirical rather than asymptotic.
6. Build the set with ellipsoidal_set under ue.alg.diagonal and ue.alg.method, which fits the radius k at the level ue.q.
7. Before the set leaves, write it back onto the full universe with expand_investable_ucs, so a set fitted standalone is over the same assets the prior is, and a view of it at the mask recovers the reduced fit.

Arguments

• ue: ARCH uncertainty set estimator. ue.ce fits both the covariance of every resample and the shape matrix over the deviations, so it enters this axis twice.
• pr: Fitted prior result the set is calibrated on. pr.X is resampled.
• rd: Returns result the three-argument form passes beside the prior. Not read.
• kwargs...: Additional keyword arguments passed to ue.ce.

Returns

• sigma_ucs::EllipsoidalUncertaintySet: Ellipsoidal uncertainty set for covariance.

Related

• ARCHUncertaintySet
• EllipsoidalUncertaintySet
• bootstrap_generator
• mu_bootstrap_generator
• sigma_bootstrap_generator

ucs(ue::ARCHUncertaintySet{Nothing, <:Any, <:Any, <:NormBallUncertaintySetAlgorithm, <:Any,
                           <:Any, <:Any, <:Any, <:Any}, pr::AbstractPriorResult; rd = nothing, kwargs...)

Constructs norm-ball uncertainty sets for expected returns and covariance statistics using bootstrap resampling for time series data.

This is the prior-result arm of the verb, defined for a set whose pe is nothing. Inside an optimiser pr is the prior the optimiser is solving on, so the centre is the objective's own and the resample is drawn from the rows that prior carries; standalone it takes prior(pe, X) spelled out. The returns-data arm of the same verb fits the set's own prior through ucs_prior and forwards here, so the two routes share this one body.

The bootstrap deviations are the geometry map, so this route builds no shape matrix. The ellipsoidal sibling fits ue.ce on the deviations, which on the covariance axis is an $N^{2} \times N^{2}$ matrix of rank at most $\min(M - 1, N(N+1)/2)$, so it is rank deficient at every sample size and the default matrix processing repairs it. The map norm_ball_deviation_factor builds carries the same second moment exactly, at the rank the sample has, and ue.ce takes no part in it. ue.ce still fits the covariance of every resample, so it enters this axis once rather than twice. On the mean axis the map is of full rank once ue.n_sim exceeds $N$, so the two shapes agree and the two sets reach the same weights.

Mathematical definition

\[\mathbf{L} = \dfrac{\left(\mathbf{X} - \boldsymbol{1}\bar{\mathbf{x}}^{\intercal}\right)^{\intercal}}{\sqrt{M - 1}}\,, \qquad \mathbf{L}\mathbf{L}^{\intercal} = \operatorname{Cov}(\mathbf{X})\,, \qquad U = \left\{ \hat{\mathbf{z}} + \mathbf{L}\mathbf{u} \, \vert \, \lVert \mathbf{u} \rVert_{p} \leq \kappa \right\}\,.\]

Where:

• $\mathbf{L}$: Geometry map.
• $\mathbf{X}$: Bootstrap deviations, one row per resample.
• $\bar{\mathbf{x}}$: Column means of $\mathbf{X}$.
• $M$: Number of resamples, ue.n_sim.
• $\hat{\mathbf{z}}$: Point estimate the deviations are taken from.
• $\kappa$, $p$: Radius and norm order of the ball.

Algorithm

1. Reduce the prior result to the Investable Mask with investable_ucs_reduction. Inside an optimiser the result arrives already reduced and the step is a passthrough; standalone, on a prior fitted on a point-in-time Asset Panel, it takes the view the optimiser would have taken.
2. Take the prior result pr the set is calibrated on, and read X = pr.X, the matrix resampled, and N = size(X, 2).
3. Refit both statistics on every resample with bootstrap_generator, giving mus and sigmas from one index stream.
4. Subtract pr.mu from every resampled mean and pr.sigma from every resampled covariance, giving X_mu and X_sigma, one deviation per column.
5. Assemble the two sets with norm_ball_deviation_set on the transposed deviations, and return them as a tuple, mean first.
6. Before the two sets leave, write both back onto the full universe with expand_investable_ucs, so a set fitted standalone is over the same assets the prior is, and a view of it at the mask recovers the reduced fit.

Arguments

• ue: ARCH uncertainty set estimator.
• pr: Fitted prior result the set is calibrated on. pr.X is resampled.
• rd: Returns result the three-argument form passes beside the prior. Not read.
• kwargs...: Additional keyword arguments passed to ue.me and ue.ce.

Returns

• mu_ucs::NormBallUncertaintySet: Expected returns uncertainty set.
• sigma_ucs::NormBallUncertaintySet: Covariance uncertainty set.

Related

• ARCHUncertaintySet
• NormBallUncertaintySetAlgorithm
• NormBallUncertaintySet
• norm_ball_deviation_set
• bootstrap_generator
• mu_ucs
• sigma_ucs

References

• [88] A. Ben-Tal and A. Nemirovski. Robust Convex Optimization. Mathematics of Operations Research 23, 769–805 (1998). Section 3, Equation 14.
• [89] D. Goldfarb and G. Iyengar. Robust Portfolio Selection Problems. Mathematics of Operations Research 28, 1–38 (2003). Section 5.

mu_ucs(ue::ARCHUncertaintySet{Nothing, <:Any, <:Any, <:NormBallUncertaintySetAlgorithm, <:Any,
                              <:Any, <:Any, <:Any, <:Any}, pr::AbstractPriorResult; rd = nothing, kwargs...)

Constructs a norm-ball uncertainty set for expected returns using bootstrap resampling for time series data.

This is the prior-result arm of the verb, defined for a set whose pe is nothing. Inside an optimiser pr is the prior the optimiser is solving on, so the centre is the objective's own and the resample is drawn from the rows that prior carries; standalone it takes prior(pe, X) spelled out. The returns-data arm of the same verb fits the set's own prior through ucs_prior and forwards here, so the two routes share this one body.

The bootstrap deviations are the geometry map, so this route builds no shape matrix, and ue.ce takes no part on this axis at all: the ellipsoidal sibling fits it on the mean deviations, and the map carries the same second moment without it. With ue.seed set the method sees the same resamples as the mean half of ucs; with ue.seed unset it does not.

Algorithm

1. Reduce the prior result to the Investable Mask with investable_ucs_reduction. Inside an optimiser the result arrives already reduced and the step is a passthrough; standalone, on a prior fitted on a point-in-time Asset Panel, it takes the view the optimiser would have taken.
2. Take the prior result pr the set is calibrated on, and read X = pr.X, the matrix resampled, and N = size(X, 2).
3. Refit the mean on every resample with mu_bootstrap_generator, giving mus.
4. Subtract pr.mu from every resampled mean, giving X_mu, one deviation per column.
5. Assemble and return the set with norm_ball_deviation_set on the transposed deviations, with pr.mu as the centre.
6. Before the set leaves, write it back onto the full universe with expand_investable_ucs, so a set fitted standalone is over the same assets the prior is, and a view of it at the mask recovers the reduced fit.

Arguments

• ue: ARCH uncertainty set estimator.
• pr: Fitted prior result the set is calibrated on. pr.X is resampled.
• rd: Returns result the three-argument form passes beside the prior. Not read.
• kwargs...: Additional keyword arguments passed to ue.me.

Returns

• mu_ucs::NormBallUncertaintySet: Expected returns uncertainty set.

Related

• ARCHUncertaintySet
• NormBallUncertaintySetAlgorithm
• NormBallUncertaintySet
• norm_ball_deviation_set
• mu_bootstrap_generator
• sigma_ucs

References

• [88] A. Ben-Tal and A. Nemirovski. Robust Convex Optimization. Mathematics of Operations Research 23, 769–805 (1998). Section 3, Equation 14.
• [89] D. Goldfarb and G. Iyengar. Robust Portfolio Selection Problems. Mathematics of Operations Research 28, 1–38 (2003). Section 5.

sigma_ucs(ue::ARCHUncertaintySet{Nothing, <:Any, <:Any, <:NormBallUncertaintySetAlgorithm,
                                 <:Any, <:Any, <:Any, <:Any, <:Any}, pr::AbstractPriorResult; rd = nothing, kwargs...)

Constructs a norm-ball uncertainty set for covariance using bootstrap resampling for time series data.

This is the prior-result arm of the verb, defined for a set whose pe is nothing. Inside an optimiser pr is the prior the optimiser is solving on, so the centre is the objective's own and the resample is drawn from the rows that prior carries; standalone it takes prior(pe, X) spelled out. The returns-data arm of the same verb fits the set's own prior through ucs_prior and forwards here, so the two routes share this one body.

This is the one route of the library that bounds a covariance without a matrix of side $N^{2}$. The ellipsoidal sibling fits ue.ce on the $M \times N^{2}$ deviations, and its shape is rank deficient at every sample size, because a vectorised symmetric matrix spans only $N(N+1)/2$ coordinates; the default matrix processing then repairs it into a matrix the sample never named, and the chi-squared radius reads $N^{2}$ degrees of freedom where the errors have $N(N+1)/2$. The map norm_ball_deviation_factor builds is the deviations themselves, scaled, so it carries the sample second moment exactly at rank $\min(M - 1, N(N+1)/2)$, and k_norm_ball reads that rank rather than the side of a shape.

Algorithm

1. Reduce the prior result to the Investable Mask with investable_ucs_reduction. Inside an optimiser the result arrives already reduced and the step is a passthrough; standalone, on a prior fitted on a point-in-time Asset Panel, it takes the view the optimiser would have taken.
2. Take the prior result pr the set is calibrated on, and read X = pr.X, the matrix resampled, and N = size(X, 2).
3. Refit the covariance on every resample with sigma_bootstrap_generator, giving sigmas.
4. Subtract pr.sigma from every resampled covariance and vectorise, giving X_sigma, one deviation per column.
5. Assemble and return the set with norm_ball_deviation_set on the transposed deviations, with pr.sigma as the centre.
6. Before the set leaves, write it back onto the full universe with expand_investable_ucs, so a set fitted standalone is over the same assets the prior is, and a view of it at the mask recovers the reduced fit.

Arguments

• ue: ARCH uncertainty set estimator.
• pr: Fitted prior result the set is calibrated on. pr.X is resampled.
• rd: Returns result the three-argument form passes beside the prior. Not read.
• kwargs...: Additional keyword arguments passed to ue.ce.

Returns

• sigma_ucs::NormBallUncertaintySet: Covariance uncertainty set.

Related

• ARCHUncertaintySet
• NormBallUncertaintySetAlgorithm
• NormBallUncertaintySet
• norm_ball_deviation_set
• sigma_bootstrap_generator
• mu_ucs

References

• [88] A. Ben-Tal and A. Nemirovski. Robust Convex Optimization. Mathematics of Operations Research 23, 769–805 (1998). Section 3, Equation 14.
• [89] D. Goldfarb and G. Iyengar. Robust Portfolio Selection Problems. Mathematics of Operations Research 28, 1–38 (2003). Section 5.