Black-Litterman Prior

PortfolioOptimisers.BlackLittermanPrior Type

struct BlackLittermanPrior{__T_pe, __T_mp, __T_views, __T_sets, __T_views_conf, __T_rf, __T_tau} <: AbstractLowOrderPriorEstimator_AF

Black-Litterman prior estimator for asset returns.

BlackLittermanPrior is a low order prior estimator that computes the mean and covariance of asset returns using the Black-Litterman model. It combines a prior estimator, matrix post-processing, user or algorithmic views, asset sets, view confidences, risk-free rate, and a blending parameter tau. The estimator supports both direct and constraint-based views, and allows for flexible confidence specification and matrix processing.

Fields

• pe: Prior estimator.

• mp: Matrix processing estimator.

• views: Views estimator or result.

• sets: Sets used to map estimator values to features.

• views_conf: Views confidence estimator or result.

• rf: Risk-free rate.

• tau: Blending parameter controlling the weight given to the prior relative to the views.

Constructors

BlackLittermanPrior(;
    pe::AbstractLowOrderPriorEstimator_A_F_AF = EmpiricalPrior(;
        me = EquilibriumExpectedReturns()
    ),
    mp::AbstractMatrixProcessingEstimator = MatrixProcessing(),
    views::Lc_BLV,
    sets::Option{<:AssetSets} = nothing,
    views_conf::Option{<:Num_VecNum} = nothing,
    rf::Number = 0.0,
    tau::Option{<:Number} = nothing
) -> BlackLittermanPrior

Keywords correspond to the struct's fields.

Validation

• If views is a LinearConstraintEstimator, !isnothing(sets).

• If views_conf is not nothing, views_conf is validated with assert_bl_views_conf.

• If tau is not nothing, tau > 0.

Examples

julia> BlackLittermanPrior(; sets = AssetSets(; key = "nx", dict = Dict("nx" => ["A", "B", "C"])),
                           views = LinearConstraintEstimator(;
                                                             val = ["A == 0.03", "B + C == 0.04"]))
BlackLittermanPrior
          pe ┼ EmpiricalPrior
             │        ce ┼ PortfolioOptimisersCovariance
             │           │   ce ┼ Covariance
             │           │      │    me ┼ SimpleExpectedReturns
             │           │      │       │   w ┴ nothing
             │           │      │    ce ┼ GeneralCovariance
             │           │      │       │   ce ┼ StatsBase.SimpleCovariance: StatsBase.SimpleCovariance(true)
             │           │      │       │    w ┴ nothing
             │           │      │   alg ┴ Full()
             │           │   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 ┼ EquilibriumExpectedReturns
             │           │   ce ┼ PortfolioOptimisersCovariance
             │           │      │   ce ┼ Covariance
             │           │      │      │    me ┼ SimpleExpectedReturns
             │           │      │      │       │   w ┴ nothing
             │           │      │      │    ce ┼ GeneralCovariance
             │           │      │      │       │   ce ┼ StatsBase.SimpleCovariance: StatsBase.SimpleCovariance(true)
             │           │      │      │       │    w ┴ nothing
             │           │      │      │   alg ┴ Full()
             │           │      │   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)
             │           │    w ┼ nothing
             │           │    l ┴ Int64: 1
             │   horizon ┴ 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)
       views ┼ LinearConstraintEstimator
             │   val ┼ Vector{String}: ["A == 0.03", "B + C == 0.04"]
             │   key ┴ nothing
        sets ┼ AssetSets
             │    key ┼ String: "nx"
             │   ukey ┼ String: "ux"
             │   dict ┴ Dict{String, Vector{String}}: Dict("nx" => ["A", "B", "C"])
  views_conf ┼ nothing
          rf ┼ Float64: 0.0
         tau ┴ nothing

Related

• AbstractLowOrderPriorEstimator_AF

• EmpiricalPrior

• BlackLittermanViews

• AssetSets

• LowOrderPrior

• prior

source

PortfolioOptimisers.factory Method

factory(
    pe::BlackLittermanPrior,
    w::Union{DynamicAbstractWeights, AbstractWeights}
) -> BlackLittermanPrior{_A, var"#s179", _B, _C, _D, <:Number} where {_A, var"#s179"<:AbstractMatrixProcessingEstimator, _B, _C, _D}

Return a new BlackLittermanPrior estimator with observation weights w applied to the underlying prior estimator.

Related

• BlackLittermanPrior

• factory

source

Base.getproperty Method

getproperty(obj::BlackLittermanPrior, sym::Symbol) -> Any

Access properties of BlackLittermanPrior. Exposes :me and :ce from the embedded prior estimator obj.pe for transparent access.

source

PortfolioOptimisers.prior Function

prior(pe::BlackLittermanPrior, X::MatNum;
      F::Option{<:MatNum} = nothing, dims::Int = 1, strict::Bool = false,
      kwargs...)

Compute the Black-Litterman prior moments for asset returns.

prior estimates the mean and covariance of asset returns using the Black-Litterman model, combining a prior estimator, matrix post-processing, user or algorithmic views, asset sets, view confidences, risk-free rate, and blending parameter tau. The method supports both direct and constraint-based views, flexible confidence specification, and matrix processing.

Mathematical definition

The Black-Litterman posterior distribution combines the prior $(\mathbf{\Pi },\tau \mathbf{\Sigma })$ with investor views $(\mathbf{P},\mathit{q},\mathbf{\Omega })$:

$$\begin{array}{rl}{\hat{\mathit{\mu }}}_{BL}& ={[(\tau \mathbf{\Sigma }{)}^{-1}+{\mathbf{P}}^{⊺}{\mathbf{\Omega }}^{-1}\mathbf{P}]}^{-1}[(\tau \mathbf{\Sigma }{)}^{-1}\mathbf{\Pi }+{\mathbf{P}}^{⊺}{\mathbf{\Omega }}^{-1}\mathit{q}].\end{array}$$$$\begin{array}{rl}{\hat{\mathbf{\Sigma }}}_{BL}& =\mathbf{\Sigma }+{[(\tau \mathbf{\Sigma }{)}^{-1}+{\mathbf{P}}^{⊺}{\mathbf{\Omega }}^{-1}\mathbf{P}]}^{-1}.\end{array}$$

Where:

• $\mathbf{\Pi }$: N × 1 prior (equilibrium) expected returns.

• $\mathbf{\Sigma }$: N × N prior covariance matrix.

• $\tau$: Scaling parameter for the uncertainty in the prior.

• $\mathbf{P}$: K × N views matrix (each row is one view).

• $\mathit{q}$: K × 1 views vector.

• $\mathbf{\Omega }$: K × K views uncertainty matrix.

Arguments

• pe: Black-Litterman prior estimator.

• X: Asset returns matrix (observations × assets).

• F{Nothing, <:MatNum}: Optional factor matrix (default: nothing).

• dims: Dimension along which to perform the computation.

• strict: If true, enforce strict validation of views and sets. Default is false.

• kwargs...: Additional keyword arguments passed to underlying estimators and matrix processing.

Returns

• pr::LowOrderPrior: Result object containing asset returns, posterior mean vector, and posterior covariance matrix.

Validation

• dims in (1, 2).

• length(pe.sets.dict[pe.sets.key]) == size(X, 2).

Details

• If dims == 2, X and F are transposed to ensure assets are in columns.

• The prior model is computed using the embedded prior estimator pe.pe.

• Views are extracted using black_litterman_views, which returns the view matrix P and view returns vector Q.

• tau defaults to 1/T if not specified, where T is the number of observations.

• The view uncertainty matrix omega is computed using calc_omega.

• The posterior mean and covariance are computed using vanilla_posteriors.

• Matrix processing is applied to the posterior covariance and asset returns using the embedded matrix processing estimator pe.mp.

Related

• BlackLittermanPrior

• LowOrderPrior

• prior

• calc_omega

• vanilla_posteriors

source

PortfolioOptimisers.port_opt_view Method

port_opt_view(
    pr::BlackLittermanPrior,
    i,
    args...
) -> BlackLittermanPrior{_A, var"#s179", _B, _C, _D, <:Number} where {_A, var"#s179"<:AbstractMatrixProcessingEstimator, _B, _C, _D}

Return a new BlackLittermanPrior estimator restricted to the assets at index i.

Related

• BlackLittermanPrior

source

PortfolioOptimisers.calc_omega Function

calc_omega(views_conf::Option{<:Num_VecNum}, P::MatNum,
           sigma::MatNum)

Compute the Black-Litterman view uncertainty matrix Ω.

This method constructs the view uncertainty matrix Ω for the Black-Litterman model when no explicit view confidences are provided (views_conf = nothing). The uncertainty for each view is set to the variance of the projected prior covariance, i.e., Ω = LinearAlgebra.diag(P * Σ * P'), where P is the view matrix and Σ is the prior covariance matrix.

Mathematical definition

Let $\mathbf{P}$ be the $K\times N$ view matrix and $\mathbf{\Sigma }$ the $N\times N$ prior covariance. The view uncertainty matrix for each views_conf variant:

$$\begin{array}{rl}\mathbf{\Omega }& =\mathrm{Diag}(\mathbf{P}\mathbf{\Sigma }{\mathbf{P}}^{⊺})(\text{no confidence}).\end{array}$$$$\begin{array}{rl}\mathbf{\Omega }& =(\frac{1}{v}-1)\mathrm{Diag}(\mathbf{P}\mathbf{\Sigma }{\mathbf{P}}^{⊺})(\text{scalar confidence }v).\end{array}$$$$\begin{array}{rl}\mathbf{\Omega }& =\mathrm{Diag}((\frac{1}{\mathit{v}}-\mathbf{1})\odot \mathrm{diag}(\mathbf{P}\mathbf{\Sigma }{\mathbf{P}}^{⊺}))(\text{vector confidence }\mathit{v}).\end{array}$$

Where:

• $\mathbf{\Omega }$: $K\times K$ diagonal view uncertainty matrix.

• $\mathbf{P}$: $K\times N$ views matrix.

• $\mathbf{\Sigma }$: $N\times N$ prior covariance matrix.

• $v$: Scalar view confidence level.

• $\mathit{v}$: $K\times 1$ vector of view confidence levels.

• $\odot$: Element-wise multiplication.

Arguments

• views_conf:

  • ::Nothing: Indicates no view confidence is specified, LinearAlgebra.Diagonal(P * sigma * transpose(P)).

  • ::Number: Scalar confidence level applied uniformly to all views, (1/v - 1) * LinearAlgebra.Diagonal(P * sigma * transpose(P)), where v is the view confidence level.

  • ::VecNum: Vector of confidence levels for each view, (1 ./ v - 1) * Diag(P * Σ * P').

• P: The view matrix (views × assets).

• sigma: The prior covariance matrix (assets × assets).

Returns

• omega::Diagonal: Diagonal matrix of view uncertainties.

Related

• BlackLittermanPrior

• vanilla_posteriors

source

PortfolioOptimisers.vanilla_posteriors Function

vanilla_posteriors(tau::Number, rf::Number, prior_mu::VecNum,
                   prior_sigma::MatNum, omega::MatNum, P::MatNum,
                   Q::VecNum)

Compute the Black-Litterman posterior mean and covariance for asset returns.

vanilla_posteriors implements the standard Black-Litterman update equations, combining the prior mean and covariance with user or algorithmic views. The function returns the posterior mean and covariance matrix, incorporating the blending parameter tau, risk-free rate rf, view uncertainty matrix omega, view matrix P, and view returns vector Q.

Mathematical definition

Let $\mathbf{\Pi }$ be the prior mean, $\mathbf{\Sigma }$ the prior covariance, $\tau$ the scaling parameter, $\mathbf{P}$ the view matrix, $\mathit{q}$ the view vector, and $\mathbf{\Omega }$ the view uncertainty matrix:

$$\begin{array}{rl}{\hat{\mathit{\mu }}}_{BL}& =\mathbf{\Pi }+\tau \mathbf{\Sigma }{\mathbf{P}}^{⊺}{(\mathbf{P}\tau \mathbf{\Sigma }{\mathbf{P}}^{⊺}+\mathbf{\Omega })}^{-1}(\mathit{q}-\mathbf{P}\mathbf{\Pi })+r_f.\end{array}$$$$\begin{array}{rl}{\hat{\mathbf{\Sigma }}}_{BL}& =\mathbf{\Sigma }+\tau \mathbf{\Sigma }-\tau \mathbf{\Sigma }{\mathbf{P}}^{⊺}{(\mathbf{P}\tau \mathbf{\Sigma }{\mathbf{P}}^{⊺}+\mathbf{\Omega })}^{-1}\mathbf{P}\tau \mathbf{\Sigma }.\end{array}$$

Where:

• ${\hat{\mathit{\mu }}}_{BL}$: Black-Litterman posterior mean vector.

• ${\hat{\mathbf{\Sigma }}}_{BL}$: Black-Litterman posterior covariance matrix.

• $\mathbf{\Pi }$: $N\times 1$ prior (equilibrium) expected returns.

• $\mathbf{\Sigma }$: $N\times N$ prior covariance matrix.

• $\tau$: Scaling parameter for the uncertainty in the prior.

• $\mathbf{P}$: $K\times N$ views matrix.

• $\mathit{q}$: $K\times 1$ views vector.

• $\mathbf{\Omega }$: $K\times K$ view uncertainty matrix.

• $r_f$: Risk-free rate.

Arguments

• tau: Scalar blending parameter for prior and views.

• rf: Risk-free rate to add to the posterior mean.

• prior_mu: Prior mean vector of asset returns.

• prior_sigma: Prior covariance matrix of asset returns.

• omega: View uncertainty matrix.

• P: View matrix (views × assets).

• Q: Vector of view returns (views).

Returns

• posterior_mu::VecNum: Posterior mean vector of asset returns.

• posterior_sigma::Matrix{<:Number}: Posterior covariance matrix of asset returns.

Related

• BlackLittermanPrior

• calc_omega

source

PortfolioOptimisers.remove_excl_views Function

remove_excl_views(
    views_conf::Union{Nothing, Number},
    args...
) -> Union{Nothing, Number}

Remove excluded views from views_conf.

Returns views_conf unchanged when excl is nothing or views_conf is scalar. Filters views_conf by removing indices in excl when both are vectors.

Related

• BlackLittermanPrior

source

remove_excl_views(
    views_conf::AbstractVector{<:Union{var"#s20", var"#s19"} where {var"#s20"<:Number, var"#s19"<:AbstractJuMPScalar}},
    _::Nothing
) -> AbstractVector{<:Union{var"#s20", var"#s19"} where {var"#s20"<:Number, var"#s19"<:AbstractJuMPScalar}}

Remove excluded views from views_conf.

Returns views_conf unchanged (no exclusions).

Related

• BlackLittermanPrior

source

remove_excl_views(
    views_conf::AbstractVector{<:Union{var"#s20", var"#s19"} where {var"#s20"<:Number, var"#s19"<:AbstractJuMPScalar}},
    excl::AbstractVector{<:Integer}
) -> Any

Remove excluded views from views_conf.

Returns a view of views_conf with indices in excl removed.

Related

• BlackLittermanPrior

source