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 ┴ FullMoment()
             │           │   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 ┴ FullMoment()
             │           │      │   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.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.calc_omega Function

calc_omega(views_conf::Option{<:Num_VecNum}, P::MatNum,
           sigma::MatNum) -> LinearAlgebra.Diagonal

Compute the Black-Litterman view uncertainty matrix Ω.

Mathematical definition

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

$$\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: No confidence specified; Ω = Diag(P * sigma * P').

  • ::Number: Scalar confidence v; Ω = (1/v - 1) * Diag(P * sigma * P').

  • ::VecNum: Per-view confidences v; Ω = Diag((1 ./ v .- 1) .* diag(P * sigma * P')).

• P: Views loading matrix views × assets.

• sigma: Covariance matrix features × features.

Returns

• omega::LinearAlgebra.Diagonal: Diagonal view uncertainty matrix views × views.

Related

• BlackLittermanPrior

• bl_preroll

• vanilla_posteriors

source

PortfolioOptimisers.bl_preroll Function

bl_preroll(
    views,
    sets,
    views_conf,
    prior_sigma,
    pe_tau,
    T,
    datatype,
    strict
) -> NamedTuple{(:P, :Q, :tau, :omega), <:NTuple{4, Any}}

Pre-compute shared Black-Litterman inputs from views, prior covariance, and blending parameters.

Extracts the view matrix P, view returns vector Q, and excluded indices from views and sets via black_litterman_views, resolves tau, filters excluded rows from views_conf via remove_excl_views, and computes the scaled uncertainty matrix omega = tau * Ω via calc_omega.

Arguments

• views: Views estimator or result.

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

• views_conf: Views confidence estimator or result.

• prior_sigma::MatNum: Prior covariance matrix of asset returns assets × assets.

• pe_tau::Option{<:Number}: Optional user-specified blending parameter. If nothing, defaults to 1/T.

• T::Integer: Number of observations used to compute the default tau = 1/T.

• datatype: Data type to use for the result in case val is nothing.

• strict: Whether to throw an error if sets does not contain the desired value in sets.dict[key].

Returns

• (; P, Q, tau, omega): Named tuple where:

  • P::MatNum: View matrix views × assets.

  • Q::VecNum: View returns vector views × 1.

  • tau::Number: Resolved blending parameter.

  • omega::LinearAlgebra.Diagonal: Scaled view uncertainty matrix tau * Ω.

Related

• BlackLittermanPrior

• black_litterman_views

• calc_omega

• remove_excl_views

• 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"#s29", var"#s28"} where {var"#s29"<:Number, var"#s28"<:AbstractJuMPScalar}},
    _::Nothing
) -> AbstractVector{<:Union{var"#s29", var"#s28"} where {var"#s29"<:Number, var"#s28"<:AbstractJuMPScalar}}

Remove excluded views from views_conf.

Returns views_conf unchanged (no exclusions).

Related

• BlackLittermanPrior

source

remove_excl_views(
    views_conf::AbstractVector{<:Union{var"#s29", var"#s28"} where {var"#s29"<:Number, var"#s28"<: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