Teleman quantization

QuiverTools implements Teleman weights and bounds computations. See also Harder–Narasimhan types, as well as Tensor calculus.

QuiverTools.weights_hn_type — Function

weights_hn_type(hntype::HNType, theta::AbstractVector{Int}, denom::Function=sum)

Compute the weights of the 1-PS corresponding to hn_type for the slope function theta/denom.

source

QuiverTools.teleman_bounds — Function

teleman_bounds(Q::Quiver, d::AbstractVector{Int}, theta::AbstractVector{Int}, denom::Function=sum)

Compute the weight on $\det(N_{S/R}|_Z)$ of the 1-PS corresponding to each HN type for the given Q, d, \theta and denom.

Input

Q::Quiver: a quiver
d::AbstractVector{Int}: a dimension vector
theta::AbstractVector{Int}: a stability parameter
denom::Function: a denominator for the slope function. Defaults to sum.

Output

A dictionary with the weights of the 1-PS corresponding to each HN type.

Examples

julia> Q = kronecker_quiver(3);

julia> teleman_bounds(Q, [2, 3], [3, -2])
Dict{HNType{2}, Int64} with 7 entries:
  [[2, 2], [0, 1]]         => 20
  [[2, 1], [0, 2]]         => 100
  [[1, 0], [1, 2], [0, 1]] => 100
  [[1, 0], [1, 3]]         => 120
  [[1, 0], [1, 1], [0, 2]] => 90
  [[1, 1], [1, 2]]         => 15
  [[2, 0], [0, 3]]         => 90

source

teleman_bounds(M::QuiverModuli)

Compute the weight on $\det(N_{S/R}|_Z)$ of the 1-PS corresponding to each HN type for the datum of M.

Input

M::QuiverModuli: a quiver moduli space or stack

Output

A dictionary with the weights of the 1-PS corresponding to each HN type.

Examples

julia> Q = three_vertex_quiver(1, 2, 3); d = [3, 1, 2]; theta = [5, 3, -9];

julia> M = QuiverModuliSpace(Q, d, theta);

julia> teleman_bounds(M)
Dict{HNType{3}, Int64} with 24 entries:
  [[2, 1, 1], [1, 0, 1]]                       => 12
  [[1, 0, 0], [0, 1, 0], [2, 0, 1], [0, 0, 1]] => 306
  [[1, 0, 0], [1, 1, 0], [1, 0, 1], [0, 0, 1]] => 131
  [[2, 0, 0], [1, 0, 1], [0, 1, 1]]            => 64
  [[3, 0, 0], [0, 1, 2]]                       => 150
  [[1, 1, 0], [2, 0, 1], [0, 0, 1]]            => 312
  [[2, 0, 0], [1, 1, 1], [0, 0, 1]]            => 336
  [[2, 0, 0], [1, 1, 0], [0, 0, 2]]            => 242
  [[3, 0, 0], [0, 1, 1], [0, 0, 1]]            => 168
  [[3, 1, 1], [0, 0, 1]]                       => 432
  [[3, 0, 0], [0, 1, 0], [0, 0, 2]]            => 246
  [[0, 1, 0], [3, 0, 2]]                       => 108
  [[0, 1, 0], [2, 0, 1], [1, 0, 1]]            => 76
  [[1, 0, 0], [2, 0, 1], [0, 1, 1]]            => 122
  [[1, 0, 0], [2, 1, 1], [0, 0, 1]]            => 92
  [[2, 0, 0], [0, 1, 0], [1, 0, 2]]            => 312
  [[1, 0, 0], [2, 1, 2]]                       => 18
  [[2, 0, 0], [0, 1, 0], [1, 0, 1], [0, 0, 1]] => 132
  [[1, 0, 0], [1, 1, 1], [1, 0, 1]]            => 68
  ⋮                                            => ⋮

source

QuiverTools.weights_universal_bundle — Function

weights_universal_bundle(Q::Quiver, d::AbstractVector{Int}, i::Int, theta::AbstractVector{Int}, denom::Function=sum; chi::AbstractVector{Int})

Compute the Teleman weights of the universal bundle $U_i(chi)$ for the linearization $chi$ on all the non-dense Harder-Narasimhan strata.

Input

Q::Quiver: a quiver
d::AbstractVector{Int}: a dimension vector
i::Int: the index of the universal bundle
theta::AbstractVector{Int}: a stability parameter
denom::Function: a denominator for the slope function. Defaults to sum.

Keyword arguments:

chi::AbstractVector{Int}: the linearization of the universal bundle. Defaults to extended_gcd(d)[2].

Output

A dictionary with the weights of the universal bundle on each stratum.

source

weights_universal_bundle(M::QuiverModuli, i::Int; chi::Union{AbstractVector{Int},UndefInitializer}=undef)

Compute the Teleman weights of the universal bundle $U_i(chi)$ for the linearization chi on all the non-dense Harder-Narasimhan strata.

Input

M::QuiverModuli: a quiver moduli space or stack.

Keyword arguments:

chi::AbstractVector{Int}: the linearization of the universal bundle. Defaults to M.chow.chi.

Output

A dictionary with the weights of the universal bundle $U_{i}(chi)$ on each stratum.

Example

The weights of the universal bundles on our favourite 6-fold:

julia> Q = kronecker_quiver(3); M = QuiverModuliSpace(Q, [2, 3]);

julia> weights_universal_bundle(M, 1; chi=[2, -1])
Dict{HNType{2}, Vector{Int64}} with 7 entries:
  [[2, 2], [0, 1]]         => [-15, -15]
  [[2, 1], [0, 2]]         => [-20, -20]
  [[1, 0], [1, 2], [0, 1]] => [-15, -25]
  [[1, 0], [1, 3]]         => [-45, -90]
  [[1, 0], [1, 1], [0, 2]] => [-45, -60]
  [[1, 1], [1, 2]]         => [0, -5]
  [[2, 0], [0, 3]]         => [-45, -45]

If not specified, the linearization is taken from the moduli space, and defaults to extended_gcd(M.d)[2] if not defined.

julia> Q = kronecker_quiver(3); M = QuiverModuliSpace(Q, [2, 3]);

julia> weights_universal_bundle(M, 1)
Dict{HNType{2}, Vector{Int64}} with 7 entries:
  [[2, 2], [0, 1]]         => [15, 15]
  [[2, 1], [0, 2]]         => [20, 20]
  [[1, 0], [1, 2], [0, 1]] => [25, 15]
  [[1, 0], [1, 3]]         => [90, 45]
  [[1, 0], [1, 1], [0, 2]] => [60, 45]
  [[1, 1], [1, 2]]         => [5, 0]
  [[2, 0], [0, 3]]         => [45, 45]

julia> QuiverTools.set_linearization!(M, [-4, 3]);

julia> weights_universal_bundle(M, 1)
Dict{HNType{2}, Vector{Int64}} with 7 entries:
  [[2, 2], [0, 1]]         => [45, 45]
  [[2, 1], [0, 2]]         => [60, 60]
  [[1, 0], [1, 2], [0, 1]] => [65, 55]
  [[1, 0], [1, 3]]         => [225, 180]
  [[1, 0], [1, 1], [0, 2]] => [165, 150]
  [[1, 1], [1, 2]]         => [10, 5]
  [[2, 0], [0, 3]]         => [135, 135]

source

QuiverTools.weights_canonical_bundle — Function

weights_canonical_bundle(Q::Quiver, d::AbstractVector{Int}, theta::AbstractVector{Int}, denom::Function=sum)

Compute the Teleman weights of the irreducible component of $\omega_R|_Z$ on all the non-dense Harder-Narasimhan strata.

More explicitly, if $\omega_X = O(rH)$, this returns the weights of the pullback of $\mathcal{O}(H)$ on each stratum.

Input

Q::Quiver: a quiver.
d::AbstractVector{Int}: a dimension vector.
theta::AbstractVector{Int}: a stability parameter.
denom::Function: a denominator for the slope function. Defaults to sum.

Output

A dictionary with the weights of the irreducible component of the canonical bundle on each stratum.

source

weights_canonical_bundle(M::QuiverModuliSpace)

Compute the Teleman weights of $\omega_R|_Z$ on all the non-dense Harder-Narasimhan strata.

Input

M::QuiverModuliSpace: a quiver moduli space.

Output

A dictionary with the weights of $\omega_{R}|_{Z}$ on each stratum $Z$.

Example

The canonical bundle of our favourite 6-fold:

julia> Q = kronecker_quiver(3); M = QuiverModuliSpace(Q, [2, 3]);

julia> weights_canonical_bundle(M)
Dict{HNType{2}, Vector{Int64}} with 7 entries:
  [[2, 2], [0, 1]]         => [90]
  [[2, 1], [0, 2]]         => [120]
  [[1, 0], [1, 2], [0, 1]] => [120]
  [[1, 0], [1, 3]]         => [405]
  [[1, 0], [1, 1], [0, 2]] => [315]
  [[1, 1], [1, 2]]         => [15]
  [[2, 0], [0, 3]]         => [270]

source

QuiverTools.all_weights_endomorphisms_universal_bundle — Function

all_weights_endomorphisms_universal_bundle(Q::Quiver, d::AbstractVector{Int}, theta::AbstractVector{Int}, denom::Function=sum)

Compute all the weights that can occur in $U^{\vee} \otimes U$ on the given Harder-Narasimhan stratum.

source

all_weights_endomorphisms_universal_bundle(M::QuiverModuli)

Compute all the possible weights of the endomorphisms of the universal bundles $U_i \otimes U_j$ on all the non-dense Harder-Narasimhan strata for each 1-PS relative to the HN type.

Example

The weights of the endomorphisms of the universal bundles on our favourite 6-fold:

julia> Q = kronecker_quiver(3); M = QuiverModuliSpace(Q, [2, 3]);

julia> all_weights_endomorphisms_universal_bundle(M)
Dict{HNType{2}, Vector{Int64}} with 7 entries:
  [[2, 2], [0, 1]]         => [0, 15, -15, 0]
  [[2, 1], [0, 2]]         => [0, 10, -10, 0]
  [[1, 0], [1, 2], [0, 1]] => [0, 10, 15, -10, 0, 5, -15, -5, 0]
  [[1, 0], [1, 3]]         => [0, 45, -45, 0]
  [[1, 0], [1, 1], [0, 2]] => [0, 15, 30, -15, 0, 15, -30, -15, 0]
  [[1, 1], [1, 2]]         => [0, 5, -5, 0]
  [[2, 0], [0, 3]]         => [0, 15, -15, 0]

source

QuiverTools.weights_endomorphisms_universal_bundles — Function

weights_endomorphisms_universal_bundles(Q::Quiver, d::AbstractVector{Int}, i::Int, j::Int, theta::AbstractVector{Int}, denom::Function=sum)

source

weights_endomorphisms_universal_bundles(M::QuiverModuli, i::Int, j::Int)

source

QuiverTools.does_rigidity_inequality_hold — Function

does_rigidity_inequality_hold(M::QuiverModuli)

Check if the Teleman quantization criterion of [arXiv:2311.17003] holds.

In case the quiver is acyclic, this ensures that the moduli space is infinitesimally rigid.

Input

M::QuiverModuli: a quiver moduli space or stack.

Output

true if the Teleman inequality holds, false otherwise.

Examples

Our favourite 6-fold is rigid:

julia> Q = kronecker_quiver(3); M = QuiverModuliSpace(Q, [2, 3]);

julia> does_rigidity_inequality_hold(M)
true

Some quiver moduli are rigid, but it can't be proved by this criterion: the following moduli space can be shown to be $\mathbb{P}^6$, whose rigidity follows from the Euler sequence (see [Example 4.8, arXiv:2311.17003]). However, the Teleman inequality does not hold:

julia> Q = three_vertex_quiver(1, 6, 1); M = QuiverModuliSpace(Q, [1, 6, 6], [42, 5, -12]);

julia> does_rigidity_inequality_hold(M)
false

source

QuiverTools.set_teleman_weights! — Function

set_teleman_weights!(F::Bundle, weights::Dict{<:HNType,Vector{Int}})

Set the Teleman weights of the bundle F to the given dictionary.

This is used to construct Bundle objects and assign them Teleman weights.

source