Internal Methods

__chow_ring__monomial_grading(M::QuiverModuliSpace, f)

Compute the "pseudodegree" of the monomial f in the Chow ring of the moduli space M passed.

This method is unsafe, as it does not consider the actual degree of the MPolyRingElem objects passed. Instead, it assumes that the Chow ring passed has variables $x_{i, j}$ as in the Chow ring paper.

symmetric_polynomial(degree::Int)

Return the symmetric polynomial of degree degree in the variables vars as a Julia function.

Input

• vars: a list of variables.
• degree: the degree of the wanted symmetric polynomial.

Output

• The symmetric polynomial of degree degree in the variables vars.

Examples

julia> using Singular;

julia> R, vars = polynomial_ring(Singular.QQ, ["x", "y", "z"]);

julia> f = QuiverTools.symmetric_polynomial(2); f(vars)
x*y + x*z + y*z

_chern_characters_symmetric(F::Bundle, k)

Compute the symmetric powers of F up to degree k. For internal use only.

Cardinality of product of general linear groups $\mathrm{GL}_{d}(\mathbb{F}_q)$.

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

Compute the Teleman weight of $\omega_R|_Z$ on the Harder-Narasimhan stratum hn_type.

weight_irreducible_component_canonical_on_stratum(M::QuiverModuli, hn_type::HNType)

Compute the Teleman weight of the irreducible component of $\omega_R|_Z$ on the Harder-Narasimhan stratum hn_type.

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

poincare_polynomial(M::QuiverModuliSpace)

Compute the Poincaré polynomial of the moduli space M.

Input

• M::QuiverModuliSpace: a moduli space of representations of a quiver.

Output

• the Poincaré polynomial of the moduli space.

Examples

A Kronecker quiver setup where M is the projective line:

julia> Q = kronecker_quiver(2);

julia> M = QuiverModuliSpace(Q, [1, 1]);

julia> poincare_polynomial(M)
L + 1

The Poincaré polynomial of our favourite 6-fold:

julia> Q = kronecker_quiver(3);

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

julia> poincare_polynomial(M)
L^6 + L^5 + 3*L^4 + 3*L^3 + 3*L^2 + L + 1

all_destabilizing_subdimension_vectors(d::AbstractVector{Int}, theta::AbstractVector{Int}, denom::Function=sum)

Return the subdimension vectors of d with a strictly larger slope than d.

Input

• d::AbstractVector{Int} a dimension vector.
• theta::AbstractVector{Int} a stability parameter.
• denom::Function a function to compute the denominator. Default is sum.

Output

• an array of subdimension vectors of d with a strictly larger slope than d.

Examples

julia> QuiverTools.all_destabilizing_subdimension_vectors([2, 3], [3, -2])
5-element Vector{Vector{Int64}}:
 [1, 0]
 [2, 0]
 [1, 1]
 [2, 1]
 [2, 2]

julia> QuiverTools.all_destabilizing_subdimension_vectors([2, 3], [0, 0])
Vector{Int64}[]

julia> QuiverTools.all_destabilizing_subdimension_vectors([0, 0], [1, -1])
Vector{Int64}[]

variety(F::Bundle)

weights_endomorphisms_universal_bundles_on_stratum(i::Int, j::Int, hn_type::HNType, theta::AbstractVector{Int}, denom::Function=sum)

Compute the weights of $U_i^{\vee} \otimes U_j$ on hn_type for the slope theta/denom, with the correct multiplicities.

weights_endomorphism_universal_bundle_on_stratum(hn_type::HNType, theta::AbstractVector{Int}, denom::Function=sum)

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

weights_endomorphism_universal_bundle_on_stratum(M::QuiverModuli, hn_type::HNType)

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

__chow_degrees(d)

Compute the vector of degrees for the variables of a Chow ring.

For internal use only.

__helper_accelerate(P::Polyhedron)

Internal method.

Convert the polyhedron P to be spanned by its rays. Only works for strongly convex polyhedra.

product_lists(L)

For internal use only.

Cardinality of general linear group $\mathrm{GL}_n(\mathbb{F}_v)$.

weight_line_bundle_on_stratum(hn_type::HNType, eta::AbstractVector{Int}, theta::AbstractVector{Int}, denom::Function=sum)

Compute the weight on hn_type of the line bundle with linearization eta.

Cardinality of representation space $\mathrm{R}(Q,d), over \mathbb{F}_q$.

extended_gcd(x)

Compute the gcd and the Bezout coefficients of a list of integers.

Input

• x: a list of integers.

Output

A tuple containing:

• the gcd of the integers,
• a choice of Bezout coefficients.

Examples

julia> QuiverTools.extended_gcd([2, 3, 4])
2-element Vector{Any}:
 1
  [-1, 1, 0]

julia> QuiverTools.extended_gcd([2, 3])
2-element Vector{Any}:
 1
  [-1, 1]

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

Compute the Teleman weights on the line bundle given by the linearization eta.

Entry of the transfer matrix, as per Corollary 6.9 of [MR1974891].

diagonal(m::AbstractMatrix{Int})

Return the diagonal matrix with the diagonal of m as its diagonal.

diagonal(v::AbstractVector)

Return a square matrix with diagonal v.

adams(F::Bundle, k)

Compute the Adams operation $\Phi^k$ on the Chern character of F. For internal use only.

identity_matrix(n::Int)

Return the identity matrix of size n.

teleman_bound_on_stratum(Q::Quiver, hn_type::HNType, theta::AbstractVector{Int}, denom::Function=sum)

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

Input

• Q: a quiver.
• hn_type: a Harder–Narasimhan type.
• theta: a stability parameter.
• denom: a denominator for the slope function. Defaults to sum.

Output

The weight of the 1-PS corresponding to the given HN type.

_chern_characters_wedge(F::Bundle, k)

Compute the exterior powers of F up to degree k. For internal use only.

weights_universal_bundle_on_stratum(hn_type::HNType, i::Int, theta::AbstractVector{Int}, denom::Function=sum; chi::AbstractVector{Int})

Returns the weights of a universal bundle $U_i(a)$ for the linearization $a$ for the 1-PS corresponding to the given HN type.

local_quiver_setting(M::QuiverModuli, tau)

Returns the local quiver and dimension vector for the given Luna type.

Input

• M::QuiverModuli: a moduli space or stack of representations of a quiver.
• tau::Dict{AbstractVector{Int}, Vector{Int}}: a Luna type for M.

Output

• a dictionary with the local quiver Q and dimension vector d for the given Luna type.

thin_dimension_vector(Q::Quiver)

Create the thin dimension vector for a given quiver Q.

Examples:

julia> Q = kronecker_quiver(3);

julia> QuiverTools.thin_dimension_vector(Q) == [1, 1]
true

solve(A, b)

Solve $A\cdot x = b$ for $A$ upper triangular via back substitution.

This is an internal method only used in the implementation of the Hodge polynomial and to compute motives.

Input

• A::AbstractMatrix: an upper triangular matrix.
• b::AbstractVector: a vector.

Output

• the solution x to the equation.

Examples

julia> A = [1 2 3; 0 4 5; 0 0 6];

julia> b = [1, 2, 3];

julia> QuiverTools.solve(A, b)
3-element Vector{Any}:
 -0.25
 -0.125
  0.5

We call the series $Q(t) = t/(1-e^{-t})$ the Todd generating series. The function computes the terms of this series up to degree n. We use this instead of the more conventional notation Q to avoid a clash with the notation for the quiver.

is_root(Q::Quiver, d)

Check whether d is a root, i.e., if $<d, d> \leq 1$.

total_chern_class_universal(M::QuiverModuliSpace, i)

Compute the total Chern class of the universal bundle U_i.

Input

• M::QuiverModuliSpace: a moduli space of representations of a quiver.
• i: the universal bundle we want the Chern class of.

Output

• the total Chern class of the universal bundle $U_i(\chi)$.

Examples

The universal Chern classes on both vertices of our favourite 3-Kronecker quiver:

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

julia> total_chern_class_universal(M, 1)
x11 + x12 + 1

julia> total_chern_class_universal(M, 2)
x21 + x22 + x23 + 1

all_subdimension_vectors(d::AbstractVector{Int}; nonzero::Bool=false, strict::Bool=false)

Compute all subdimension vectors of a given dimension vector d.

Input

• d::AbstractVector{Int}: The input dimension vector.
• nonzero::Bool=false: whether to exclude the zero vector.
• strict::Bool=false: whether to exclude the input vector d.

Output

• An array of all subdimension vectors of d, with or without the zero vector and d.

Examples

julia> QuiverTools.all_subdimension_vectors([2, 3])
12-element Vector{Vector{Int64}}:
 [0, 0]
 [1, 0]
 [2, 0]
 [0, 1]
 [1, 1]
 [2, 1]
 [0, 2]
 [1, 2]
 [2, 2]
 [0, 3]
 [1, 3]
 [2, 3]

julia> QuiverTools.all_subdimension_vectors([2, 3]; nonzero=true)
11-element Vector{Vector{Int64}}:
 [1, 0]
 [2, 0]
 [0, 1]
 [1, 1]
 [2, 1]
 [0, 2]
 [1, 2]
 [2, 2]
 [0, 3]
 [1, 3]
 [2, 3]

julia> QuiverTools.all_subdimension_vectors([2, 3]; nonzero=true, strict=true)
10-element Vector{Vector{Int64}}:
 [1, 0]
 [2, 0]
 [0, 1]
 [1, 1]
 [2, 1]
 [0, 2]
 [1, 2]
 [2, 2]
 [0, 3]
 [1, 3]

julia> QuiverTools.all_subdimension_vectors([0, 0, 0]; nonzero=true, strict=true)
Vector{Int64}[]

unit_vector(n::Int, i::Int)

Return a vector of length n with a 1 at index i and 0 elsewhere.

Arguments

• n::Int: The length of the unit vector.
• i::Int: The index at which to place the 1 in the unit vector.

Examples

julia> QuiverTools.unit_vector(3, 2) == [0, 1, 0]
true

unit_vector(Q::Quiver, i::Int)

Return a dimension vector for the quiver Q with a 1 at index i and 0 elsewhere.

Arguments

• Q::Quiver: The input quiver.
• i::Int: The index at which to place the 1 in the unit vector.

Examples

julia> Q = kronecker_quiver(3);

julia> QuiverTools.unit_vector(Q, 2) == [0, 1]
true

is_subdimension_vector(e::AbstractVector{Int}, d::AbstractVector{Int})

Check whether vector e is a subdimension of vector d.

Examples

julia> QuiverTools.is_subdimension_vector([1, 1], [2, 3])
true

julia> QuiverTools.is_subdimension_vector([1, 1], [1, 1])
true

julia> QuiverTools.is_subdimension_vector([1, 2], [1, 1])
false

zero_vector(n::Int)

Create a zero vector of length n.

Examples

julia> QuiverTools.zero_vector(3) == [0, 0, 0]
true

zero_vector(Q::Quiver)

Create the zero dimension vector for the quiver Q.

Examples

julia> QuiverTools.zero_vector(kronecker_quiver(3)) == [0, 0]
true

__add_and_return_new(luna_type, e)

Returns a new Luna type obtained by adding a subdimension vector e with multiplicity 1 to the given Luna type.

Internal use only.

__add_and_return(luna_type, e, i)

Returns a new Luna type obtained by increasing the multiplicity of the i-th copy the subdimension vector e by 1, in the given Luna type.

Internal use only.

__add_and_return(luna_type, e)

Returns a new Luna type obtained by adding a new copy of the subdimension vector e in the given Luna type.

Internal use only.

Takes a quotient ring R/I and returns the projection map from R to R/I. For internal use only.