Calibration Rules

PortfolioOptimisers.AbstractSignificanceCalibrationAlgorithm — Type
abstract type AbstractSignificanceCalibrationAlgorithm <: AbstractCalibrationAlgorithm

Computes a significance level, the tail probability that an alpha or a beta slot holds.

A rule of this family is a callable subtype of AbstractSignificanceCalibrationAlgorithm. resolve_calibration_slot runs a rule when it calls it, so a plain Function of the same five arguments is also a rule. Num_SigCal is the bound of every significance slot, and it names this family. So a constructor refuses a deformation rule in a significance slot. The slot names the end of the distribution, so one rule serves the lower tail and the upper tail.

Interfaces

To add a significance rule, subtype AbstractSignificanceCalibrationAlgorithm, keep the parameters of the rule in the fields of the struct, and add the method below.

The functor

  • (alg::AbstractSignificanceCalibrationAlgorithm)(key::Symbol, pr::AbstractPriorResult, w, slv, ctx::CalibrationContext) -> Number: Returns the significance level.

Arguments

  • key: Name of the slot that the call resolves.
  • pr: Prior result from which the rule reads its sample size and its moments.
  • w: Effective observation weights, or nothing when neither the measure nor the prior gives any.
  • slv: Effective solver, or nothing when the measure has none.
  • ctx: The facts that the site knows and key does not give, as a CalibrationContext. A rule reads the fields that it needs. A rule that reads no field writes ::CalibrationContext.

Returns

  • alpha::Number: The significance level.

Related

source
PortfolioOptimisers.AbstractDeformationCalibrationAlgorithm — Type
abstract type AbstractDeformationCalibrationAlgorithm <: AbstractCalibrationAlgorithm

Computes a deformation parameter, the Kaniadakis $\kappa$ that a kappa slot holds.

A rule of this family is a callable subtype of AbstractDeformationCalibrationAlgorithm, as a rule of the significance family is. Num_DefCal is the bound of every deformation slot, and it names this family.

Interfaces

To add a deformation rule, subtype AbstractDeformationCalibrationAlgorithm, keep the parameters of the rule in the fields of the struct, and add the method below.

The functor

  • (alg::AbstractDeformationCalibrationAlgorithm)(key::Symbol, pr::AbstractPriorResult, w, slv, ctx::CalibrationContext) -> Number: Returns the deformation parameter.

Arguments

  • key: Name of the slot that the call resolves.
  • pr: Prior result from which the rule reads its sample size and its moments.
  • w: Effective observation weights, or nothing when neither the measure nor the prior gives any.
  • slv: Effective solver, or nothing when the measure has none.
  • ctx: The facts that the site knows and key does not give, as a CalibrationContext. A rule reads the fields that it needs. A rule that reads no field writes ::CalibrationContext.

Returns

  • kappa::Number: The deformation parameter.

The series

A measure of the return distribution and a drawdown measure both have a deformation slot, and both resolve it under the key :kappa. So key does not tell which quantity the owner prices. A rule whose answer depends on that quantity reads ctx.series, which each slot owner sets in the CalibrationContext that it builds. A rule whose answer does not depend on it reads no field of the context. EntropyBudget is such a rule.

Related

source
PortfolioOptimisers.AbstractAmbiguityRadiusCalibrationAlgorithm — Type
abstract type AbstractAmbiguityRadiusCalibrationAlgorithm <: AbstractCalibrationAlgorithm

Computes an ambiguity radius from the data a prior result carries, so that the radius refits whenever the sample moves.

An Ambiguity Radius is the radius of the ball of probability measures that the model prices. It is the coefficient of a norm penalty on the weight vector, with no square. It is not a tail probability and not a deformation parameter. So it has its own family next to AbstractSignificanceCalibrationAlgorithm and AbstractDeformationCalibrationAlgorithm, under the same root.

A rule of this family is a callable subtype of AbstractAmbiguityRadiusCalibrationAlgorithm, as a rule of the two other families is. Num_AmbRadCal is the bound of every radius slot, and it names this family.

Interfaces

To add a radius rule, subtype AbstractAmbiguityRadiusCalibrationAlgorithm, keep the parameters of the rule in the fields of the struct, and add the method below.

The functor

  • (alg::AbstractAmbiguityRadiusCalibrationAlgorithm)(key::Symbol, pr::AbstractPriorResult, w, slv, ctx::CalibrationContext) -> Number: Returns the ambiguity radius.

Arguments

  • key: Name of the slot that the call resolves.
  • pr: Prior result from which the rule reads its sample size and its moments.
  • w: Effective observation weights, or nothing when neither the owner nor the prior gives any.
  • slv: Effective solver, or nothing when the owner has none.
  • ctx: The facts that the site knows and key does not give, as a CalibrationContext. A rule reads the fields that it needs. A rule that reads no field writes ::CalibrationContext.

Returns

  • r::Number: The ambiguity radius.

Related

source
PortfolioOptimisers.AbstractAmbiguityTailWeightCalibrationAlgorithm — Type
abstract type AbstractAmbiguityTailWeightCalibrationAlgorithm <: AbstractCalibrationAlgorithm

Computes an Esfahani-Kuhn tail weight, the weight in the l slot of a distributionally robust measure.

The tail weight multiplies the tail term of the Esfahani-Kuhn loss, and it does not multiply the mean term. It is a different quantity from the radius, so it has its own family. Num_AmbTwtCal makes a constructor refuse a radius rule in a tail-weight slot.

TailTermParity is the rule of the family in the library. A stated tail weight has no units, but it is not independent of the scale of the sample. So one number is a different trade-off at each sampling frequency. The rule reads the units of the sample and leaves the preference in the ratio of the caller. Num_AmbTwtCal also admits a plain function, so a rule of a caller needs no type.

Interfaces

To add a tail-weight rule, subtype AbstractAmbiguityTailWeightCalibrationAlgorithm, keep the parameters of the rule in the fields of the struct, and add the method below.

The functor

  • (alg::AbstractAmbiguityTailWeightCalibrationAlgorithm)(key::Symbol, pr::AbstractPriorResult, w, slv, ctx::CalibrationContext) -> Number: Returns the tail weight.

Arguments

  • key: Name of the slot that the call resolves.
  • pr: Prior result from which the rule reads its sample size and its moments.
  • w: Effective observation weights, or nothing when neither the owner nor the prior gives any.
  • slv: Effective solver, or nothing when the owner has none.
  • ctx: The facts that the site knows and key does not give, as a CalibrationContext. A rule reads the fields that it needs. A rule that reads no field writes ::CalibrationContext.

Returns

  • l::Number: The tail weight.

Related

source
PortfolioOptimisers.AbstractNormCeilingCalibrationAlgorithm — Type
abstract type AbstractNormCeilingCalibrationAlgorithm <: AbstractCalibrationAlgorithm

Computes a norm ceiling from the data a prior result carries, so that the ceiling refits whenever the universe moves.

A Norm Ceiling is an upper bound on a norm of the weight vector. The l2c, lpc and linfc slots of JuMPOptimiser hold it. It is not an Ambiguity Radius. A radius is the coefficient of a norm penalty in the objective, and a ceiling bounds that norm in a constraint. A ceiling on the norm is a floor on the effective number of assets. That is a statement about diversification, and not about the set of probability measures that the model prices. So the quantity has its own family next to the others, under the same root.

A rule of this family is a callable subtype of AbstractNormCeilingCalibrationAlgorithm, as a rule of the other families is. Num_NormCeilCal is the bound of every ceiling slot, and it names this family.

Interfaces

To add a ceiling rule, subtype AbstractNormCeilingCalibrationAlgorithm, keep the parameters of the rule in the fields of the struct, and add the method below.

The functor

  • (alg::AbstractNormCeilingCalibrationAlgorithm)(key::Symbol, pr::AbstractPriorResult, w, slv, ctx::CalibrationContext) -> Number: Returns the norm ceiling.

Arguments

  • key: Name of the slot that the call resolves: :l2c, :lpc or :linfc.
  • pr: Prior result from which the rule reads its asset count and its sample size.
  • w: Effective observation weights, or nothing when neither the owner nor the prior gives any.
  • slv: Effective solver, or nothing when the owner has none.
  • ctx: The facts that the site knows and key does not give, as a CalibrationContext. A rule reads the fields that it needs. A rule that reads no field writes ::CalibrationContext.

Returns

  • val::Number: The norm ceiling.

The norm order

A ceiling applies to one norm order, and that order belongs to the constraint and not to the rule. A rule that needs the order reads ctx.p. Each constraint site sets it in the CalibrationContext that it builds. A rule that needs no order reads no field of the context.

Related

source
PortfolioOptimisers.RelativeDrawdownSeries — Type
struct RelativeDrawdownSeries <: AbstractDrawdownSeries

Names the relative drawdown series of a column, which relative_drawdown_vec builds.

The path is the compounded value of the column, and the series is the fractional distance of that path below its running peak. RelativeRelativisticDrawdownatRisk prices it. RelativeDrawdownatRisk uses the same series.

Related

source
PortfolioOptimisers.CalibrationContext — Type
struct CalibrationContext{__T_alpha, __T_series, __T_p, __T_cs, __T_n} <: AbstractResult

Holds the facts that a calibration site knows and the key of the slot does not give, from resolve_calibration_slot into the rule that it runs.

The site runs a rule as alg(key, pr, w, slv, ctx). key names the slot and not the quantity. For example, RelativisticValueatRisk and RelativisticDrawdownatRisk both use :kappa, and they price different series. So the quantities below are properties of the site and not of the key, and the site states them in this type.

FieldThe site that states itThe rules that read it
alphathe slot owner, off a sibling slot it resolved firstEntropyBudget, HillTailDecay, RadialTailDecay, TailTermParity
seriesthe slot owner, through calibration_seriesHillTailDecay, RadialTailDecay, ConcentrationRadius, DimensionalRateRadius, DualNormRadius, TailTermParity
pthe constraint or the penalty the quantity stands ina CountOf or a FractionOf through resolve_calibration_slot, DualNormRadius
csa CrossSectionalFactorPrior, after the split of its Return ForecastPrecisionBlend, SteinShrinkage, ForecastCalibrationSlope
na site that prices the empirical measure of its own rowsConcentrationRadius, RateRadius, DimensionalRateRadius, DualNormRadius

p also names the family of a CountOf or a FractionOf. The pair is one occupant of two families. In a significance slot it states a part of the scenarios in the tail, and in a norm-ceiling slot it states the effective assets that the ceiling keeps. Every norm-ceiling site states the order p of its ceiling, and no significance site states one. So resolve_calibration_slot reads the family off p, the order that a ceiling reads anyway.

No rule has a field for these quantities. Each one belongs to the site, and a rule cannot know which site it reached. So a site overwrites no value of the rule, and no precedence between the two is necessary. A caller who runs a rule outside a measure builds the context that the site builds. That context is the only place where these quantities are written.

Only the Cross-Sectional Factor Prior states cs. Its Spanned Shrinkage lambda and its Orthogonal Forecast Scale c resolve inside prior, after the prior splits the Return Forecast and before it makes the mean. The prior states cs = (; g, ap, csfm, hist, cre). These are the spanned coefficients g, the unscaled orthogonal part ap, the factor-model block csfm, the Return Forecast history hist and the Cross-Sectional Regression Estimator cre of the prior. The block holds the idiosyncratic variance history vs and the regression weights rw, so a rule reads them from csfm. The block holds a zero b and no Return Forecast, because the scale is not resolved yet.

The site states n because two sites price two different counts. A distributionally robust measure centres its Wasserstein ball on the empirical measure of the rows of pr.X that its programme holds, weighted by its observation weights. The concentration bound of a radius is a statement about that measure, so its count is the count of those rows, which scenario_sample_size gives. A regularisation penalty prices the error of pr.mu, and that error decreases with the observations behind the moments, which effective_sample_size gives. The two counts differ under a Scenario Cap, which fits the moments over every observation and holds fewer rows. key cannot tell the rule which count it prices, so the site states it. A site that states no n prices the moments, and a rule then reads effective_sample_size.

The default is the context of a site that states nothing. It has no sibling significance level, no norm order, no cs and no count. Its series is the ReturnsSeries that calibration_series returns for every owner that names no other series. A rule that needs a field that the default leaves at nothing refuses, and its message names that field.

alpha is available only because the slots of one owner resolve in an order. A deformation rule reads the significance level of a sibling slot. So the resolve_deferred_quantities method of the owner resolves alpha first, and puts the number in the context of the slot that reads it. No derivation can find that order, so each type writes its own resolution.

Fields

  • alpha: Significance level of a sibling slot that the owner resolved first, or nothing when the site gives none. The resolution method of the owner resolves alpha first, and it puts the number in the context of the slot that reads it.
  • p: Norm order against which the rule reads the quantity, or nothing when the site gives none. The order belongs to the constraint or to the penalty and not to the rule, so each site that has an order gives it here.
  • cs: The fit of a CrossSectionalFactorPrior as (; g, ap, csfm, hist, cre), or nothing when the site gives none. g holds the spanned coefficients of the Return Forecast, one per estimated factor. ap holds its unscaled orthogonal part, one per asset. Both are nothing when the prior has no Return Forecast Estimator. csfm is the CrossSectionalFactorModel block, with a zero b and no Return Forecast. It holds the idiosyncratic variance history vs and the regression weights rw. hist is the Return Forecast history from forecast_history, or nothing unless a slot answers true to reads_forecast_history. cre is the Cross-Sectional Regression Estimator of the prior. It splits a row of the history in the same way as the prior splits the latest forecast.
  • n: Count of the scenarios that the site prices, or nothing when the site prices the observations behind the moments. A distributionally robust measure centres its ball on the empirical measure of its rows, so it gives the count of scenario_sample_size here. A radius rule reads effective_sample_size when the field is nothing.

Constructors

CalibrationContext(;    alpha::Option{<:Number} = nothing,    series::AbstractCalibrationSeries = ReturnsSeries(),    p::Option{<:Number} = nothing,    cs::Option{<:NamedTuple} = nothing,    n::Option{<:Number} = nothing) -> CalibrationContext

Keywords correspond to the fields of the struct. The default of each field is the value that a site that states nothing gives.

Related

source
PortfolioOptimisers.RateSignificance — Type
struct RateSignificance{__T_c} <: AbstractSignificanceCalibrationAlgorithm

Computes a significance level that decreases with the square root of the sample length.

The tail probability is c / sqrt(T), so the expected count of the tail is c * sqrt(T). The count increases with the sample, but more slowly than the sample. The error of a sample mean decreases at the same rate. So a longer sample moves the tail further out and also puts more scenarios in it. alpha = CountOf(n) keeps the count fixed, through resolve_calibration_slot.

T is the count of the scenarios that the measure prices, as for a CountOf in the slot. The tail is a set of the rows of pr.X, so the expected count of the tail is c * sqrt(T) only when T counts those rows. That is scenario_sample_size: the row count of pr.X when no observation weights are stated, and the effective sample size of the weights otherwise. Under a Scenario Cap, the rows are fewer than the observations behind the moments, and the rule reads the rows. A read of the count in eoc there gave a tail of sqrt(5) times fewer scenarios than c * sqrt(T), for max_scenarios = 250 over 1250 observations.

The rule does not check the range of its value, for the reason that resolve_calibration_slot states.

Fields

  • c: Rate coefficient. The significance level is this coefficient divided by the square root of the count of the scenarios that the measure prices, so the tail holds this coefficient times that square root.

Constructors

RateSignificance(;    c::Number = 1) -> RateSignificance

Keywords correspond to the fields of the struct. The default c = 1 gives the rate $1/\sqrt{T}$.

Validation

  • c > 0 and finite.

Related

source
PortfolioOptimisers.EntropyBudget — Type
struct EntropyBudget{__T_target} <: AbstractDeformationCalibrationAlgorithm

Computes the Kaniadakis deformation parameter that makes a relativistic measure spend a stated entropy budget.

RRM multiplies its dual variable by kappa_log(inv(alpha * T), kappa), where T is the row count of the sample of the measure. So that coefficient is the price that the model pays for the deformation, and target states it. The rule returns the $\kappa$ that gives it. A stated kappa fixes the shape of the deformation and lets the price change with the sample. This rule fixes the price and lets the shape change. The Kaniadakis logarithm is Equation 63 of [179].

The rule reads its sibling alpha from ctx.alpha. So the resolution method of the owner resolves alpha first and puts the number in the context of the slot that reads it. A caller who runs the rule outside a measure states alpha in the context.

The coefficient is monotone in $\kappa$, and the rule inverts it by bisection over $(0, 1)$. Let $l = \ln(u)$. The coefficient is $l \sinh(\kappa l) / (\kappa l)$, and $\sinh(x)/x$ increases with $|x|$. So the coefficient moves once from $l$ at $\kappa \to 0$ to $\sinh(l)$ at $\kappa = 1$. The function $\sinh(x)/x$ has no elementary inverse, so the rule runs a fixed sequence of 64 halvings.

The band that the coefficient reaches changes with the sample, and the rule refuses a target outside the band when the fold runs. This check does not limit the range of the value that the rule returns. The constructor of the slot owner does that, as it does for the two significance rules. The check states that the equation has a root. With no check, a target outside the band stops the bisection at an end of the interval. That $\kappa$ is inside the range that the slot owner accepts, but it does not give the target.

Fields

  • target: Target value of the Kaniadakis logarithm. It is the coefficient by which RRM multiplies its dual variable. The rule returns the deformation parameter that gives this value.

Constructors

EntropyBudget(;    target::Option{<:Number} = nothing) -> EntropyBudget

Keywords correspond to the fields of the struct. No default of target is useful, because the band of the target changes with the sample. So the default is nothing, which is not a budget, and the constructor refuses EntropyBudget(). The message names the budget and tells why the rule needs it. The keyword admits nothing only for this refusal, and the field never holds it.

Validation

  • target is stated, else an ArgumentError.
  • target is finite. The band of the target changes with the sample, so the rule checks the band when it runs, and not here.

Related

References

  • [179] G. Kaniadakis. Non-linear kinetics underlying generalized statistics. Physica A: Statistical Mechanics and its Applications 296, 405–425 (2001). Equation 63.
source
PortfolioOptimisers.HillTailDecay — Type
struct HillTailDecay{__T_kmin} <: AbstractDeformationCalibrationAlgorithm

Computes the Kaniadakis deformation parameter whose tail decays at the rate of the tail of the sample.

The inverse of kappa_log is the $\kappa$-exponential $\exp_{\kappa}(x) = \left(\kappa x + \sqrt{1 + \kappa^{2} x^{2}}\right)^{1/\kappa}$ of Equation 53 of [179]. It approaches $(2 \kappa x)^{1/\kappa}$ for large $x$, as page 20 of [179] states. So a $\kappa$-deformed exponential tail is a power law of index $1/\kappa$, and $\kappa$ is the reciprocal of a tail index. The rule estimates the tail index $\hat{a}$ of the sample and returns $1/\hat{a}$, so the deformation decays at the rate of the sample. The band of the slot, $(0,\, 1)$, is $\hat{a} > 1$, which is the condition for a finite mean. So the rule refuses an estimate outside the band, as EntropyBudget refuses a target outside its band.

The estimator is that of [180], over the k most extreme order statistics of a pool. The rule centres each column of pr.X and divides it by its sample standard deviation. It gives the standardised values the sign of the end that the slot prices, and it pools all T * N of them. The rule reads only pr.X, and never pr.sigma. The dispersion of a column comes from that column. This is the difference from RadialTailDecay. This rule measures how far one end of one column moves, and its sibling measures how far the whole cross-section moves. So this rule keeps the sign of the end and gives one answer for each end. Its sibling reads a distance and gives one answer for both ends.

The pool has two assumptions:

  • The columns have one tail index after standardisation, so one estimate serves the whole sample.
  • The columns are cross-correlated. So the pool holds far fewer than T * N independent points, and the spread of the estimator is wider than the spread for k independent points.

The median of N estimates, one for each asset, needs neither assumption, but it is less accurate. At alpha = 0.05 and T = 250, a column has 13 tail points, and a Hill estimate on 13 points changes from fold to fold with no cause in the data.

alpha fixes the depth of the estimate as well as the count. A Hill estimate reads the tail at the depth that alpha names. If the tail of a sample approaches its power law slowly, the estimate has a bias that decreases as the depth increases. For example, a Student-t sample at a depth of five per cent gives a $\kappa$ above the reciprocal of its degrees of freedom. The same sample at a depth of one per cent gives a $\kappa$ that is nearer to it. The spread of the estimate increases as the count decreases, and kmin is the floor of that count.

key names the end that the slot prices, so the answer can be different for each key. :kappa and :kappa_a read the loss tail, and :kappa_b reads the gain tail. EntropyBudget is different, because its budget is a price that the model pays, so it gives one number for both ends. A tail index is a property of one tail, and a skewed sample has two different tail indices. On a Range measure, the rule gives the two ends two different numbers.

ctx.series names the quantity in the pool, and the slot owner states it. A measure of the return distribution pools the columns of pr.X. A drawdown measure pools the drawdown series of each column of pr.X, because it prices that quantity. The resolution site names the marker in ctx.series. The standardisation, the count and the estimator do not change. The pool then gives the tail index of the drawdown series and not of the returns, and the two numbers are different. AbstractDrawdownSeries states how the length of the record decides the difference.

The drawdown series of the columns stand for the drawdown of the portfolio, under the assumption of the pool. The rule makes no portfolio, so it pools the drawdown series of the columns, as it pools the columns on a returns series. The columns have one tail index after standardisation, and one map takes a column to its drawdown series. So the pool gives the same estimate as the drawdown series of the portfolio. A portfolio drawdown is smaller than the average asset drawdown, but that is a difference of scale, and a tail index does not read the scale.

A drawdown series has one entry for each observation. So the pool holds T N entries under every marker, and the count k = ceil(alpha * T * N) does not change. The change of series drops no observation.

A drawdown measure resolves the significance level of its own drawdown series. So under a drawdown marker, the rule reads its tail at the level of that series.

The pool of a drawdown series has more dependence than the pool of a returns series. A drawdown series is a running function of the path, so consecutive entries move together, and one deep drawdown fills many of the k order statistics of the estimate. So the T N entries hold far fewer independent tail points than the same count of returns, and the spread of the estimate is wider than the count suggests. kmin counts entries and not independent points, so the same floor gives less accuracy here. Use a larger kmin for a drawdown owner.

The rule does not check the range of the parameter that it returns. The constructor of the slot owner does that, as for every calibration rule. The checks of the rule state that the estimate exists.

Fields

  • kmin: Floor under the number of order statistics that the Hill estimate reads. The count is ceil(alpha * T * N) over the pool. The rule refuses a count below this floor, because a Hill estimate over too few order statistics changes from fold to fold with no cause in the data, and the deformation parameter changes with it.

Constructors

HillTailDecay(;    kmin::Integer = 30) -> HillTailDecay

Keywords correspond to the fields of the struct. The default kmin = 30 is the floor of the count of order statistics that the estimate reads. The significance level and the series of the estimate are not fields of the rule. Both reach the rule in the CalibrationContext of the site.

Validation

  • kmin > 0.

Related

References

  • [179] G. Kaniadakis. Non-linear kinetics underlying generalized statistics. Physica A: Statistical Mechanics and its Applications 296, 405–425 (2001). Equation 53 and page 20.
  • [180] B. M. Hill. A simple general approach to inference about the tail of a distribution. The Annals of Statistics 3, 1163–1174 (1975). Pages 1163–1174. The original source of this formulation was not found. The formulation follows this work and is not checked against the original.
source
PortfolioOptimisers.RadialTailDecay — Type
struct RadialTailDecay{__T_kmin} <: AbstractDeformationCalibrationAlgorithm

Computes the Kaniadakis deformation parameter whose tail decays at the rate of the radial series of the sample.

The inverse of kappa_log is the $\kappa$-exponential $\exp_{\kappa}(x) = \left(\kappa x + \sqrt{1 + \kappa^{2} x^{2}}\right)^{1/\kappa}$ of Equation 53 of [179]. It approaches $(2 \kappa x)^{1/\kappa}$ for large $x$, as page 20 of [179] states. So a $\kappa$-deformed exponential tail is a power law of index $1/\kappa$, and $\kappa$ is the reciprocal of a tail index. The rule estimates a tail index $\hat{a}$ and returns $1/\hat{a}$, so the deformation decays at the rate of the sample. The band of the slot, $(0,\, 1)$, is $\hat{a} > 1$, which is the condition for a finite mean. So the rule refuses an estimate outside the band, as EntropyBudget refuses a target outside its band.

The rule reads a radial series. A covariance matrix is a scale and $\kappa$ is a shape. So a rule that gets a shape from a scale needs a second quantity to fix the units, and the sample is the only such quantity in a prior result. The covariance matrix turns the $T \times N$ sample into one univariate series. whitening_factor gives the factor of $\hat{\mathbf{\Sigma}}$, the rule centres and whitens each row, and the Euclidean norm of the whitened row is the Mahalanobis distance of that observation. Under an elliptical scale mixture, that series has the tail index of the mixture, and each entry reads the whole cross-section. A standardisation per column removes every off-diagonal term. So HillTailDecay cannot give this estimate, and this rule cannot give the estimate per column.

The rule reads no direction. A distance has no sign, so one $\kappa$ serves both ends of a Range measure, and the rule does not read key. HillTailDecay gives one answer for each end. A radial series measures how far the cross-section moves, and a series per column measures how far one end of one column moves. A head slot that defaults to its tail slot holds the same rule and gets the same number, and that is correct for a distance.

The series holds T entries, and the pool of HillTailDecay holds T N. So this rule reads fewer tail points from the same sample. At alpha = 0.05 and T = 250, the series has 13 of them. kmin is the floor of that count, in the same units as the floor of the sibling, so this floor refuses more samples. The rule refuses a count below the floor. The series has one point for each observation and not N, so its points have none of the cross-correlation of the pool.

series names the sample of the rows, and the slot owner states it. A measure of the return distribution whitens the rows of pr.X. A drawdown measure whitens the rows of the drawdown sample. calibration_series_matrix turns each column into its drawdown series, and the rule whitens the rows of that sample and takes their norms in the same way. So the radial series is the same function, and only its sample changes. On a drawdown sample, the distance is the depth of the whole cross-section in drawdown at one date. On a returns series, it is the distance that the whole cross-section moved.

A drawdown sample has its own moments, and the prior states none of them. pr.mu and pr.sigma are the moments of the returns, and no scaling of them gives the moments of a drawdown. So under a drawdown marker, the centre is the vector of column means of the drawdown sample. The factor is the Cholesky factor of the covariance matrix of that sample. radial_series_inputs makes this choice, so the precedence of pr.chol over pr.sigma applies to the returns series alone.

The rule does not use a third estimate of $\kappa$. The excess kurtosis $g$ of a Student-t distribution gives $\nu = 4 + 6/g$, and then $\kappa = 1/\nu$. That estimate reads the whole sample and not the tail. So it changes less than a Hill estimate, but it assumes the shape of the whole distribution and not only of its tail.

The rule does not check the range of the parameter that it returns. The constructor of the slot owner does that, as for every calibration rule. The checks of the rule state that the estimate exists. They do not refuse a covariance matrix that is almost singular. The whitening then reads the direction of the smallest eigenvalue of the sample, the radial series follows it, and that is a property of the covariance matrix.

Fields

  • kmin: Floor under the number of order statistics that the Hill estimate reads. The count is ceil(alpha * T) over the radial series. The rule refuses a count below this floor, because a Hill estimate over too few order statistics changes from fold to fold with no cause in the data, and the deformation parameter changes with it. The radial series holds one entry per observation, so this floor refuses a sample that the same floor over a pool accepts.

Constructors

RadialTailDecay(;    kmin::Integer = 30) -> RadialTailDecay

Keywords correspond to the fields of the struct. The default kmin = 30 is the floor of the count of order statistics that the estimate reads. The significance level and the series of the estimate are not fields of the rule. Both reach the rule in the CalibrationContext of the site.

Validation

  • kmin > 0.

Related

References

  • [179] G. Kaniadakis. Non-linear kinetics underlying generalized statistics. Physica A: Statistical Mechanics and its Applications 296, 405–425 (2001). Equation 53 and page 20.
  • [180] B. M. Hill. A simple general approach to inference about the tail of a distribution. The Annals of Statistics 3, 1163–1174 (1975). Pages 1163–1174. The original source of this formulation was not found. The formulation follows this work and is not checked against the original.
source
PortfolioOptimisers.ConcentrationRadius — Type
struct ConcentrationRadius{__T_confidence, __T_scale} <: AbstractAmbiguityRadiusCalibrationAlgorithm

Computes an ambiguity radius from a chi-squared quantile, so that the ball becomes smaller as the sample becomes longer.

The radius is a scale, in the units of the series that the slot owner prices, times the square root of a chi-squared quantile divided by the sample size. It simplifies Theorem 3 and Equation 22 of [181]. For the estimating equation of the mean, $h(\boldsymbol{x}, \boldsymbol{\theta}) = \boldsymbol{x} - \boldsymbol{\theta}$, under the squared Euclidean cost, $T$ times the robust Wasserstein profile function converges to $\boldsymbol{H}^{\intercal} \boldsymbol{H}$, with $\boldsymbol{H} \sim \mathcal{N}(\boldsymbol{0}, \mathbf{\Sigma})$. The rule replaces $\mathbf{\Sigma}$ with $s^{2} \mathbf{I}$, so the law is $s^{2} \chi^{2}_{N}$. The radius of that work is the quantile of this law divided by $T$, for the squared cost. The rule takes its square root, because its slot multiplies a norm with no square. The isotropic covariance is an assumption of the rule and not of [181].

The chi-squared factor has no units and increases with the number of assets. So at a fixed confidence level, a wider universe gives a wider ball, and a longer sample gives a smaller ball.

scale gives the units. A radius multiplies a norm of the weight vector, so it is in the units of the loss around which the ball is drawn. A caller cannot get that number from the confidence level alone. scale = nothing reads the average per-asset dispersion of the series that the slot owner prices. That scale changes with the sample, as the rest of the rule does.

A drawdown owner gets a drawdown scale. DistributionallyRobustConditionalDrawdownatRisk measures the transport cost of its programme against the per-asset drawdown sample. So its ball is a ball over drawdown scenarios, and the radius has the units of a drawdown. series names that quantity, and calibration_series_dispersion takes the dispersion from the drawdown sample. pr.sigma is not read there, because it is a moment of the returns.

T is the count that the site prices. It is the n that the site states in its CalibrationContext, and effective_sample_size when the site states none. A distributionally robust measure states the count of the rows on which its ball is centred, because the bound is a statement about the empirical measure of those rows. A regularisation slot states no count, because its radius prices the error of pr.mu, and that error decreases with the observations behind the moments. With observation weights, both counts are the effective sample size of the weights, because the error of a weighted estimate decreases with that count and not with the number of rows. The two counts differ only under a Scenario Cap. RateRadius and DimensionalRateRadius read the same count.

The rule does not check the range of its value. It returns the quantity of its slot, so the site that receives the number checks the range. resolve_calibration_slot refuses a radius that is not > 0 and finite. The owner of a slot that rebuilds a term refuses a radius outside its range when the fold runs.

Fields

  • confidence: Confidence level of the chi-squared quantile that sets the radius. A higher level gives a larger ball, so the model prices a wider set of probability measures.
  • scale: Scale of the radius, in the units of the series that the slot owner prices, or nothing to read the average per-asset dispersion of that series off the sample. The chi-squared factor has no units, so this field gives the radius all of its units.

Constructors

ConcentrationRadius(;    confidence::Number = 0.95,    scale::Option{<:Number} = nothing) -> ConcentrationRadius

Keywords correspond to the fields of the struct. The default confidence is 0.95. The default scale is nothing, which reads the average per-asset dispersion from the sample. The series of that dispersion is not a field of the rule. It reaches the rule in the CalibrationContext of the site.

Validation

  • 0 < confidence < 1.
  • If scale is not nothing: scale > 0 and finite.

Related

References

  • [181] J. Blanchet, Y. Kang and K. Murthy. Robust Wasserstein profile inference and applications to machine learning. Journal of Applied Probability 56, 830–857 (2019). Section 3.3, Theorem 3 and Equation 22.
source
PortfolioOptimisers.RateRadius — Type
struct RateRadius{__T_c} <: AbstractAmbiguityRadiusCalibrationAlgorithm

Computes an ambiguity radius that decreases with the square root of the sample length.

The radius is c / sqrt(T). The rate has a theoretical basis, and the coefficient does not. So calibrate c with a cross-validation, and use this rule as the form of the radius over a grid of c.

T is the count that the site prices, as for ConcentrationRadius. The rate $1/\sqrt{T}$ is the rate at which the empirical measure of T draws concentrates around the true law, and it is the basis of the rate of the three other radius rules. So T is the n that the site states in its CalibrationContext, and effective_sample_size when the site states none. A distributionally robust measure states the count of the rows on which its ball is centred. Under a Scenario Cap, a read of the count in eoc there made the ball sqrt(5) times too small for max_scenarios = 250 over 1250 observations. With observation weights, both counts are the effective sample size of the weights, because a weighted empirical measure concentrates at the rate of that count.

c has the units of the returns, because the rate has no units.

The rule does not check the range of its value, for the reason that ConcentrationRadius states.

Fields

  • c: Rate coefficient. The radius is this coefficient divided by the square root of the count that the site prices.

Constructors

RateRadius(;    c::Number = 1) -> RateRadius

Keywords correspond to the fields of the struct. The default c = 1 gives the rate $1/\sqrt{T}$.

Validation

  • c > 0 and finite.

Related

source
PortfolioOptimisers.DimensionalRateRadius — Type
struct DimensionalRateRadius{__T_confidence, __T_scale} <: AbstractAmbiguityRadiusCalibrationAlgorithm

Computes an ambiguity radius that decreases at the dimensional rate of a Wasserstein ball, and not at the square-root rate.

The radius is the radius of Equation 8 of [182] with the constants $c_{1} = c_{2} = 1$, times a scale in the units of the series that the slot owner prices. It is the sample factor log(1 / (1 - confidence)) / T to the power 1 / max(N, 2). Equation 8 inverts the concentration bound of Theorem 3.4 of [182], which is Theorem 2 of [183] for the Wasserstein distance of order one. A ball of probability measures must contain the true measure, and not only the true mean, and the concentration bound needs that exponent for a measure.

The constants $c_{1}$ and $c_{2}$ depend on the dimension and on the light-tail condition of the bound. Section 3 of [182] states that the proof of Theorem 2 of [183] gives them, and that the ball that they give is larger than necessary. Neither work states them as numbers. The rule sets both to one. So the radius has the rate of the bound, but it is not a calibrated confidence bound. Theorem 3.4 of [182] excludes $N = 2$. At that dimension, Theorem 2 of [183] has an additional logarithmic factor, and the rule does not apply it. At N = 1 and N = 2, the rule gives the square-root rate of ConcentrationRadius and RateRadius.

The ball becomes only a little smaller over a wide universe. At N = 20 and T = 250, the factor T^(-1/20) is 0.76, and a record ten times longer gives 0.68. This is the curse of dimensionality of the Wasserstein ball. A square-root rate is a rate for the error of a mean, and this rule states a rate for a measure.

In practice the radius is conservative. Section 3 of [182] recommends that the radius come from a bootstrap or a cross-validation, and not from this bound, and Section 7.2 compares a holdout method with a k-fold cross-validation. A portfolio that a ball this wide prices can hold only cash. RateRadius is the form for such a grid. So calibrate the radius with that rule, and use this rule to know the rate.

Equation 8 of [182] has a second branch for a short record. Its exponent is 1 / a and not 1 / max(N, 2). The branch applies when $T < \ln(c_{1} / \beta) / c_{2}$, with $\beta = 1 - q$. With the constants of the rule, that is fewer than 3 rows at confidence = 0.95. The rule does not use this branch.

HillTailDecay does not give the a of that branch. The a of Equation 8 is the exponent of the light-tail condition $\mathbb{E}\left[\exp\left(\lVert \boldsymbol{\xi} \rVert^{a}\right)\right] < \infty$ of Assumption 3.3 of [182]. HillTailDecay estimates the index of a power-law tail, which does not meet that condition. So the two quantities have the same letter and different meanings.

N is the asset count, size(pr.X, 2), because the ball is over the assets. A factor prior has a smaller effective dimension, but the ball is still over the assets, so a factor prior does not change N.

scale gives the units, as for ConcentrationRadius. scale = nothing reads the average per-asset dispersion of the series that the slot owner prices.

DistributionallyRobustConditionalDrawdownatRisk prices a ball around the drawdown scenarios. The dimension of a scenario is still N, so the rate does not change. The site states the marker of the owner in ctx.series, and calibration_series_dispersion then reads the per-asset dispersion from the drawdown sample and not from pr.sigma. A drawdown column is a running function of its returns, so its dispersion is the larger of the two. So with scale = nothing, that owner gets a wider ball than a returns owner of the same sample. A stated scale has precedence, and it is the way to price a ball whose units are neither of the two.

T is the count that the site prices, as for ConcentrationRadius: the n of its CalibrationContext, and effective_sample_size when the site states none. Theorem 2 of [183] bounds the distance between the true law and the empirical measure of T draws. A distributionally robust measure centres its ball on the empirical measure of its rows, so it states the count of those rows. The rate is a statement of concentration, so it prices the effective sample size of the weights when weights are stated. RateRadius reads the same count, at the square-root rate.

The rule does not check the range of its value, for the reason that ConcentrationRadius states.

Fields

  • confidence: Confidence level of the measure-concentration bound. It enters the radius as log(1 / (1 - confidence)), so a higher level gives a larger ball. The exponent 1 / max(N, 2) applies to this term too, so a change of level moves the radius less as N increases.
  • scale: Scale of the radius, in the units of the series that the slot owner prices, or nothing to read the average per-asset dispersion of that series off the sample. The rate factor has no units, so this field gives the radius all of its units.

Constructors

DimensionalRateRadius(;    confidence::Number = 0.95,    scale::Option{<:Number} = nothing) -> DimensionalRateRadius

Keywords correspond to the fields of the struct. The default confidence is 0.95. The default scale is nothing, which reads the average per-asset dispersion from the sample. The series of that dispersion is not a field of the rule. It reaches the rule in the CalibrationContext of the site.

Validation

  • 0 < confidence < 1.
  • If scale is not nothing: scale > 0 and finite.

Related

References

  • [182] P. Mohajerin Esfahani and D. Kuhn. Data-driven distributionally robust optimization using the Wasserstein metric: performance guarantees and tractable reformulations. Mathematical Programming 171, 115–166 (2018). Section 3, Assumption 3.3, Theorem 3.4 and Equation 8, and Section 7.2.
  • [183] N. Fournier and A. Guillin. On the rate of convergence in Wasserstein distance of the empirical measure. Probability Theory and Related Fields 162, 707–738 (2015). Theorem 2.
source
PortfolioOptimisers.DualNormRadius — Type
struct DualNormRadius{__T_confidence} <: AbstractAmbiguityRadiusCalibrationAlgorithm

Computes an ambiguity radius in the ground metric that its slot names, so that two slots of two different norms get two different numbers.

The eight radius slots of the library do not measure distance in one norm. A radius multiplies a norm of the weight vector, and the ground metric of the ball is the dual of that norm. For a loss that is linear in the sample point, Theorem 6.3 and Proposition 6.5 of [182] give the worst case over the ball as the sample mean of the loss plus the radius times the dual norm of the weights. So the l1 coefficient of JuMPOptimiser is a distance in the ∞-norm, and its linf coefficient is a distance in the 1-norm. This rule reads key, selects the ground metric of that slot, and returns the sampling error of the empirical measure in that metric. ConcentrationRadius and RateRadius return one number for every key. That is correct inside one measure, and not correct across the eight slots.

A linear loss reads the sampling error of the mean vector. The per-asset scale of that error is the dispersion of the series that the slot owner prices, divided by the square root of the count that the site prices. The radius is a norm of that error vector, at the confidence level that confidence states.

The vector has no term for the error of the covariance matrix. A radius multiplies a norm of the weight vector, so it prices the part of the loss that is linear in the weights. The loss of a distributionally robust measure is linear in the sample point. The error of the second moment reaches the objective through the tail term and not through the ball. The tail term has its own coefficient, which TailTermParity sets. A radius with both errors prices one error two times.

confidence is a level per coordinate, and the rule does not correct it for the number of assets. The ∞-norm case is a maximum over N coordinates, so a level per coordinate is too low for it. A caller who wants a level over the whole vector states the corrected level, for example 1 - (1 - c) / N.

The rule leaves the correction to the caller, because the correction is large and it is a choice. A Bonferroni correction from 0.95 to 1 - 0.05 / N increases the quantile by about a third at four assets, and by more at twenty. Other corrections exist. A level over the vector for N correlated coordinates and one for N independent coordinates differ by an amount that only the correlation gives. So the rule uses the level per coordinate, and this docstring names the corrected level. A rule that corrects the level with no notice gives a caller a level that the caller did not ask for and cannot see.

The 1-norm case adds the per-asset errors, so it prices them as if they moved together. That is the worst case over the correlations, so it is the conservative choice for a radius. A form that reads the correlations gives a smaller ball, and this rule does not compute it.

A radius must not be too small, so the rule keeps the worst case. A radius that is too small gives a model that is robust to less than the caller asked for. That failure is silent: the optimisation solves, and the weights are not robust. A radius that is too large is visible, because the portfolio moves towards cash. The two errors are not symmetric, so the rule takes the error that a caller can see.

ctx.p serves the :lpreg_val slot alone. The ground metric of LpRegularisation is the metric of order $q$, with $1/p + 1/q = 1$, and key names the slot and not the norm order. The order belongs to the penalty, so that site states it in the CalibrationContext before it resolves the slot. The rule holds no order, so a caller who runs it outside that site states the order in the context. No other key reads it.

series gives the drawdown owner a drawdown scale. DistributionallyRobustConditionalDrawdownatRisk measures the transport cost of its programme against the per-asset drawdown sample. So its ball is a ball over drawdown scenarios, and the ground metric is a distance between two such vectors. Under a drawdown marker, calibration_series_dispersion reads the error scale from that sample. pr.sigma is not read, because it is a moment of the returns, and no scaling of it gives a moment of a drawdown. The ground metric does not change with the series. Only the vector of the norm changes.

The error scale of a drawdown series is too small, because of the record. A drawdown is a running function of the path, so its entries are strongly dependent down a column. $\hat{s}_{i} / \sqrt{T_{c}}$ prices a record of $T_{c}$ independent draws, and a drawdown sample does not have them. The rule does not correct for this, as it does not correct for the number of assets. A correction needs a model of the dependence, and the sample gives none. So the rule uses the scale of the quantity as if the record were independent.

T_c is the count that the site prices, as for ConcentrationRadius: the n of its CalibrationContext, and effective_sample_size when the site states none. On a distributionally robust measure the error vector is the sampling error of the mean of the rows on which the ball is centred, so the count is the count of those rows. On a regularisation slot it is the sampling error of pr.mu, so the count is the count of the observations behind the moments.

The rule does not check the range of its value, for the reason that ConcentrationRadius states.

A sample with no dispersion gives a radius of zero, and the slot accepts it. Every entry of the dispersion vector is zero or more, so the radius is zero or more, and finite, for every admissible input. A sample whose columns never move gives an error vector of zeros, and a ball of no width is correct for it. The empirical measure is the only measure that such a sample supports, and the robust measure becomes the plain measure at the centre of the ball. In floating point, such a sample gives a very small number and not an exact zero. The > 0 check of the slot owner then passes, and the model prices a ball of almost no width. The two results have the same meaning.

Fields

  • confidence: confidence: Confidence level per coordinate of the normal quantile that multiplies the error scale. The rule does not correct it for the number of assets, so the ∞-norm case reads a level over one coordinate and not over the vector.

Constructors

DualNormRadius(;    confidence::Number = 0.95) -> DualNormRadius

Keywords correspond to the fields of the struct. The default confidence is 0.95. The norm order and the series are not fields of the rule. Both reach the rule in the CalibrationContext of the site.

Validation

  • 0 < confidence < 1.
  • The norm order is not a field, so the constructor cannot check it. dual_norm_radius_scale checks ctx.p when it resolves the :lpreg_val slot. ctx.p must be stated, finite and more than one, as for LpRegularisation.

Related

References

  • [182] P. Mohajerin Esfahani and D. Kuhn. Data-driven distributionally robust optimization using the Wasserstein metric: performance guarantees and tractable reformulations. Mathematical Programming 171, 115–166 (2018). Section 6, Theorem 6.3 and Proposition 6.5.
source
PortfolioOptimisers.TailTermParity — Type
struct TailTermParity{__T_ratio} <: AbstractAmbiguityTailWeightCalibrationAlgorithm

Computes the Esfahani-Kuhn tail weight that prices the tail term of the loss at a stated multiple of its mean term.

At $r \to 0$, the loss of DistributionallyRobustConditionalValueatRisk becomes $-\mathbb{E}[\boldsymbol{w}^{\intercal} \boldsymbol{\xi}] + l \, \mathrm{CVaR}_{\alpha}(\boldsymbol{w}^{\intercal} \boldsymbol{\xi})$, the mean-risk objective of Equation 26 of [182], where the tail weight is $\rho$. So l is the exchange rate between one unit of expected return and one unit of tail loss. Both terms have the units of the returns, so l has no units. But l is not independent of the scale of the sample. For returns that are independent over time, the mean of a return column increases with the horizon, and its CVaR increases about as the square root of the horizon. So the ratio of the CVaR to the mean decreases about as the square root of the horizon. A stated l = 1.0 thus prices the tail term at a much larger multiple of the mean term on a daily sample than on a monthly sample. One stated number is a different trade-off at each sampling frequency, and at each fit that changes the record.

The rule reads the units of the sample and nothing else, so the preference stays with the caller. ratio states how many mean terms one tail term is worth. The rule returns the l that gives this ratio on the sample of the prior result. ratio = 1 is parity, and ratio = 2 prices the tail term at two times the mean term on every sample.

A rule reads no portfolio, so it cannot make $\boldsymbol{w}^{\intercal} \boldsymbol{\xi}$. It reads the cross-section of the per-asset losses of the quantity that the slot owner prices. The mean-term scale $m$ is the mean of that pool, and the tail-term scale $c$ is the mean of the $\mathrm{CVaR}_{\alpha}$ of each column. The mean of the values per column is not the pooled $\mathrm{CVaR}_{\alpha}$, and the difference is intentional. A pooled tail comes from the worst columns, so the most volatile assets control it, and it gives a smaller weight. The measure prices a portfolio and not a single asset, so the rule uses the mean over the columns.

A caller cannot state a reference portfolio. The pooled cross-section gives the rate for equal weights, and a reference portfolio gives a more exact rate. But a reference portfolio makes the rule a second place where a portfolio enters the problem. resolve_calibration_slot gives a rule the Prior and nothing else, so a reference vector needs a separate route. The rule must also check the vector against the universe of each fold, and the caller must state it again when a subset view or a cluster changes that universe. The exchange rate is a property of the sample, and the cross-section with equal weights needs no second input. A caller who wants the rate at a portfolio computes l and states the number.

$m$ is negative for a sample with a positive expected return, and the rule takes $\lvert m \rvert$. No field states the sign. The slot does not accept a negative weight, and a sample with a negative expected return does not reverse the trade-off.

The rule reads its sibling alpha, because $c$ is a $\mathrm{CVaR}$ at the significance level of the measure. So the resolution method of the owner resolves alpha first and puts the number in ctx.alpha, as it does for alpha and kappa. A caller who runs the rule outside a measure states alpha in the context.

Both scales read the observation weights. They are sample statistics and not counts, so the rule reads a weighted sample with its weights. A rule that prices a count, such as RateRadius or RateSignificance, reads w only through the effective sample size of the weights.

ctx.series names the quantity of both terms, and the slot owner states it. DistributionallyRobustConditionalDrawdownatRisk also has the key :l, and its tail term is a $\mathrm{CDaR}$ of the drawdown series of the portfolio. A rule gets no portfolio, but it can make the drawdown series of each column, and the resolution site names the marker in ctx.series. Both terms then change together. The mean term is the mean drawdown of the pool, and the tail term is the mean of the $\mathrm{CDaR}_{\alpha}$ of each column. The rule computes it with ConditionalValueatRisk, because the tail mean of a drawdown column that is not positive is the $\mathrm{CDaR}$ of that column. So the rule and the measure that it calibrates use one definition.

The rule does not use a second meaning of l. l can be read as a coefficient of risk aversion and mapped from a mean-variance coefficient. But a variance penalty is quadratic in the weight vector, and a $\mathrm{CVaR}$ term is positively homogeneous, so the two objectives cannot be compared term by term. The map is correct at one reference portfolio only, and a rule gets no portfolio.

The rule does not check the range of the weight that it returns, for the reason that RateRadius states. The constructor of the slot owner checks it. The two refusals of the rule state that the ratio exists, as the check of EntropyBudget states that its root exists. A sample whose mean loss is near zero gives a very large weight, and that is correct for such a sample. No threshold separates a small mean loss from a smaller one.

Fields

  • ratio: Number of mean terms that one tail term is worth. The rule returns the tail weight that prices the tail term at this multiple of the mean term on the sample of the prior result. So 1 is parity, and 2 prices the tail term at two times the mean term.

Constructors

TailTermParity(;    ratio::Number = 1) -> TailTermParity

Keywords correspond to the fields of the struct. The default ratio = 1 is parity between the two terms. The significance level and the series of both terms are not fields of the rule. Both reach the rule in the CalibrationContext of the site.

Validation

  • ratio > 0 and finite.

Related

References

  • [182] P. Mohajerin Esfahani and D. Kuhn. Data-driven distributionally robust optimization using the Wasserstein metric: performance guarantees and tractable reformulations. Mathematical Programming 171, 115–166 (2018). Section 7.1, Equation 26.
source

References

[179]
G. Kaniadakis. Non-linear kinetics underlying generalized statistics. Physica A: Statistical Mechanics and its Applications 296, 405–425 (2001), arXiv:cond-mat/0103467.
[180]
B. M. Hill. A simple general approach to inference about the tail of a distribution. The Annals of Statistics 3, 1163–1174 (1975).
[181]
J. Blanchet, Y. Kang and K. Murthy. Robust Wasserstein profile inference and applications to machine learning. Journal of Applied Probability 56, 830–857 (2019), arXiv:1610.05627.
[182]
P. Mohajerin Esfahani and D. Kuhn. Data-driven distributionally robust optimization using the Wasserstein metric: performance guarantees and tractable reformulations. Mathematical Programming 171, 115–166 (2018).
[183]
N. Fournier and A. Guillin. On the rate of convergence in Wasserstein distance of the empirical measure. Probability Theory and Related Fields 162, 707–738 (2015), arXiv:1312.2128.