Quiver moduli

Summary

abstract type QuiverModuli

Abstract type for a moduli space or stack of quiver representations.

Supertype Hierarchy

QuiverModuliSpace <: QuiverModuli <: Any
QuiverModuliStack <: QuiverModuli <: Any

Summary

struct QuiverModuliSpace

The moduli space of representations of a quiver Q of dimension vector d depends on a choice of stability parameter theta and on whether we consider stable or semistable representations.

Fields

Q :: Quiver
d :: AbstractVector{Int64}
theta :: AbstractVector{Int64}
condition :: String
denom :: Function

Supertype Hierarchy

QuiverModuliSpace <: QuiverModuli <: Any

Summary

struct QuiverModuliStack

The moduli stack of representations of a quiver Q of dimension vector d depends on a choice of stability parameter theta and on whether we consider stable or semistable representations.

Fields

Q :: Quiver
d :: AbstractVector{Int64}
theta :: AbstractVector{Int64}
condition :: String
denom :: Function

Supertype Hierarchy

QuiverModuliStack <: QuiverModuli <: Any

kronecker_moduli(m::Int, d::Int, e::Int)

Construct the Kronecker moduli space with m vertices and dimension vector (d, e).

Examples

julia> kronecker_moduli(3, 2, 3)
Quiver moduli space defined as follows:
 - quiver: 3-Kronecker quiver
 - dimension vector: [2, 3]
 - stability parameter: [9, -6]
 - condition: semistable

subspace_quiver_moduli(m::Int, d::Int)

Construct the subspace quiver moduli space for m points on ℙᵈ⁻¹ julia> subspacequivermoduli(3, 2, 3) Quiver moduli space defined as follows:

• quiver: 5-subspace quiver
• dimension vector: [1, 1, 1, 1, 1, 2]
• stability parameter: [2, 2, 2, 2, 2, -5]
• condition: semistable

```

is_nonempty(M::QuiverModuli)

Checks if the quiver moduli is nonempty.

Input

• M::QuiverModuli: a moduli space or stack of representations of a quiver.

Output

• whether the moduli space is nonempty.

Examples

julia> Q = kronecker_quiver(3);

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

julia> is_nonempty(M)
true

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

julia> is_nonempty(M)
false

dimension(M::QuiverModuliStack)

Returns the dimension of the moduli stack. This differs from the dimension of the moduli space by 1, as we do not quotient out the stabilizer $\mathbb{G}$.

Input

• M::QuiverModuliStack: a moduli stack of representations of a quiver.

Output

• the dimension of the moduli stack.

Examples

The dimension of the moduli stack of the 3-Kronecker quiver

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

julia> dimension(M)
5

dimension(M::QuiverModuliSpace)

Returns the dimension of the moduli space.

Input

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

Output

• the dimension of the moduli space.

Examples

The dimension of the moduli space of the 3-Kronecker quiver:

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

julia> dimension(M)
6

is_smooth(M::QuiverModuliSpace)

Checks if the moduli space is smooth.

Input

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

Output

• whether the moduli space is smooth.

Examples

Setups with d theta-coprime are smooth:

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

julia> is_smooth(M)
true

is_smooth(M::QuiverModuliStack)

Checks if the moduli stack is smooth.

This is always trus, as the quotient stack of a smooth variety is smooth.

Input

• M::QuiverModuliStack: a moduli stack of representations of a quiver.

Output

• true

Examples

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

julia> is_smooth(M)
true

is_projective(M::QuiverModuli)

Checks if the moduli space is projective.

Input

• M::QuiverModuli: a moduli space or stack of representations of a quiver.

Output

• whether the moduli space is projective.

Examples

The moduli space of the 3-Kronecker quiver is projective:

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

julia> is_projective(M)
true

index(M::QuiverModuliSpace)

Compute the index of the moduli space M.

The index of a variety $X$ is the largest integer which divides the canonical divisor $K_X$ in $Pic(X)$.

This implementation currently only works for the canonical stability.

Input

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

Output

• the index of the moduli space.

Examples

The 3-Kronecker quiver has index 3:

julia> Q = kronecker_quiver(3);

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

julia> index(M)
3

The subspace quiver moduli have index 1:

julia> Q = subspace_quiver(5);

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

julia> index(M)
1

motive(Q::Quiver, d, theta, denom=sum)

Compute the motive of the moduli stack of theta-semistable representations.

Input

• Q::Quiver: a quiver.
• d::AbstractVector{Int}: a dimension vector.
• theta::AbstractVector{Int}: a stability parameter. Default is the canonical stability.
• denom::Function: a function. Default is the sum.

Output

• The motive as an element in the function field \mathbb{Q}(L).

Examples

julia> Q = kronecker_quiver(3);

julia> motive(Q, [2, 3])
(-L^6 - L^5 - 3*L^4 - 3*L^3 - 3*L^2 - L - 1)//(L - 1)

picard_rank(M::QuiverModuliSpace)

Compute the Picard rank of the moduli space M.

Input

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

Output

• the Picard rank of the moduli space.

Examples

Kronecker quiver with dimension vector [2, 3]:

julia> Q = kronecker_quiver(3);

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

julia> picard_rank(M)
1

semistable_equals_stable(M::QuiverModuli)

Checks if stability and semistability are equivalent on the given moduli space. In other words, checks if there are no properly semistable points in the representation space.

Input

• M::QuiverModuli: a moduli space or stack of representations of a quiver.

Output

• whether every semistable representation is stable.

Examples

If the dimension vector is coprime with the stability parameter, then semistability and stability are equivalent:

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

julia> semistable_equals_stable(M)
true

However, this is not necessarily the case:

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

julia> semistable_equals_stable(M)
false

codimension_unstable_locus(M::QuiverModuli)

Computes the codimension of the unstable locus in the parameter space.

Input

• M::QuiverModuli: a moduli space or stack of representations of a quiver.

Output

• the codimension of the unstable locus in the parameter space.

Examples

Codimensions for the 3-Kronecker quiver with dimension vector [2, 3]:

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

julia> codimension_unstable_locus(M)
3

If the unstable locus is empty, the codimension is Inf:

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

julia> all_hn_types(M; unstable=true)
HNType[]

julia> codimension_unstable_locus(M)
Inf

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

Check if Q admits a theta-semistable representation of dimension vector d.

A representation $V$ is said to be $\mu$-semistable if for all of its subrepresentations $W$ with $dim(W) < dim(V)$, we have

\[\mu(\dim(W)) \leq \mu\dim((V)).\]

Input

• Q::Quiver a quiver.
• d::AbstractVector{Int} a dimension vector.
• theta::AbstractVector{Int} a stability parameter. Default is canonical_stability(Q, d).
• denom::Function a function to compute the denominator. Default is sum.

Output

• true if there is a theta-semistable representation of dimension vector d, false otherwise.

Examples

julia> A2 = kronecker_quiver(1); theta = [1,-1];

julia> has_semistables(A2, [1,1], theta)
true

julia> has_semistables(A2, [2,2], theta)
true

julia> has_semistables(A2, [1,2], theta)
false

julia> has_semistables(A2, [0,0], theta)
true

The 3-Kronecker quiver:

julia> K3 = kronecker_quiver(3); theta = [3,-2];

julia> has_semistables(K3, [2,3], theta)
true

julia> has_semistables(K3, [1,4], theta)
false

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

Check if Q admits a theta-stable representation of dimension vector d.

A representation $V$ is said to be $mu$-stable if for all of its subrepresentations $W$ with $dim(W) < dim(V)$, we have

\[\mu(\dim(W)) < \mu\dim((V)).\]

Input

• Q::Quiver a quiver.
• d::AbstractVector{Int} a dimension vector.
• theta::AbstractVector{Int} a stability parameter. Default is canonical_stability(Q, d).
• denom::Function a function to compute the denominator. Default is sum.

Output

• true if there is a theta-stable representation of dimension vector d, false otherwise.

Examples

julia> Q = kronecker_quiver(3); d = [2, 3]; theta = [3, -2];

julia> has_stables(Q, d, theta)
true

julia> Q = kronecker_quiver(2); d = [2,2]; theta = [1,-1];

julia> has_stables(Q, d, theta)
false

julia> has_semistables(Q, d, theta)
true

The zero dimension vector has no stables:

julia> Q = kronecker_quiver(3); d = [0,0];

julia> has_stables(Q, d)
false

canonical_stability(Q::Quiver, d::AbstractVector{Int})

Compute the canonical stability parameter for Q and d.

This is defined to be $<d,-> - <-,d>$

Input

• Q::Quiver a quiver.
• d::AbstractVector{Int} a dimension vector.

Output

• the canonical stability parameter for Q and d.

Examples

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

julia> canonical_stability(Q, d) == [9, -6]
true

is_coprime(d::AbstractVector{Int}, theta::AbstractVector{Int})

Check if d is theta-coprime.

A dimension vector $d$ is said to be $\theta$-coprime for the stability parameter $\theta$ if all subdimension vectors $0 \neq e < d$ satisfy $\theta * e \neq 0$.

Input

• d::AbstractVector{Int} a dimension vector.
• theta::AbstractVector{Int} a stability parameter.

Output

• true if d is theta-coprime, false otherwise.

Examples

julia> d = [2, 3]; theta = [3, -2];

julia> is_coprime(d, theta)
true

julia> is_coprime([3, 3], theta)
false

is_coprime(d::AbstractVector{Int})

Check if the gcd of all the entries of d is $1$.

Input

• d::AbstractVector{Int} a vector.

Output

• true if the gcd of all the entries of d is $1$, false otherwise.

Examples

julia> is_coprime([2, 3])
true

julia> is_coprime([3, 3])
false

is_coprime(M::QuiverModuli)

Checks if the stability parameter is coprime with the dimension vector, i.e., if for all subdimension vectors $e$ of $d$, $\theta\cdot e \neq 0$.

Input

• M::QuiverModuli: a moduli space or stack of representations of a quiver.

Output

• whether the dimension vector M.d is theta-coprime for M.theta.

Examples

julia> Q = kronecker_quiver(3);

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

julia> is_coprime(M)
true

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

Return the slope of d with respect to the stability parameter theta and a choice of a denominator function denom.

The slope function for $\theta$ and $\alpha$ is defined as

\[\mu = \frac{\theta}{\alpha} := x \mapsto \frac{\theta \cdot x}{\alpha(x)}.\]

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

• the slope of d with respect to theta and denom.

Examples

julia> slope([2,3], [3,-2])
0//1

Summary

struct HNType{T}

A struct for a Harder-Narasimhan type.

Fields

hn :: Vector{SVector{T,Int}}

all_hn_types(Q::Quiver, d::AbstractVector{Int}, theta::AbstractVector{Int}, denom::Function=sum; unstable::Bool=false, ordered::Bool=true)

Return a list of all the Harder–Narasimhan types of representations of Q with dimension vector d, with respect to the slope function theta/denom.

Input

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

Keyword inputs:

• unstable: if true exclude the trivial Harder–Narasimhan type (d),

which corresponds to stable representations. Default is false.

• ordered: if true return the list of all Harder–Narasimhan types in ascending order.

Default is true.

Output

• a list of all the Harder–Narasimhan types

of representations of Q with dimension vector d.

Examples

julia> Q = kronecker_quiver(3); d = [2,3]; theta = [3,-2];

julia> all_hn_types(Q, d, theta; ordered=true)
8-element Vector{HNType}:
 [[2, 3]]
 [[1, 1], [1, 2]]
 [[2, 2], [0, 1]]
 [[2, 1], [0, 2]]
 [[1, 0], [1, 3]]
 [[1, 0], [1, 2], [0, 1]]
 [[1, 0], [1, 1], [0, 2]]
 [[2, 0], [0, 3]]

julia> all_hn_types(Q, [3,0], [0,0]) == [[[3, 0]]]
true

julia> Q = three_vertex_quiver(1, 4, 1); d = [4, 1, 4];

julia> theta = canonical_stability(Q, d);

julia> all_hn_types(Q, d, theta; ordered=true)
106-element Vector{HNType}:
 [[4, 1, 4]]
 [[4, 1, 3], [0, 0, 1]]
 [[4, 0, 3], [0, 1, 1]]
 [[4, 0, 3], [0, 1, 0], [0, 0, 1]]
 [[3, 1, 2], [1, 0, 2]]
 [[3, 1, 2], [1, 0, 1], [0, 0, 1]]
 [[3, 0, 2], [1, 1, 2]]
 [[3, 0, 2], [0, 1, 0], [1, 0, 2]]
 [[3, 0, 2], [1, 0, 1], [0, 1, 1]]
 [[3, 0, 2], [1, 1, 1], [0, 0, 1]]
 ⋮
 [[3, 0, 0], [1, 1, 2], [0, 0, 2]]
 [[3, 0, 0], [0, 1, 0], [1, 0, 4]]
 [[3, 0, 0], [0, 1, 0], [1, 0, 3], [0, 0, 1]]
 [[3, 0, 0], [0, 1, 0], [1, 0, 2], [0, 0, 2]]
 [[3, 0, 0], [1, 0, 1], [0, 1, 1], [0, 0, 2]]
 [[3, 0, 0], [1, 1, 1], [0, 0, 3]]
 [[3, 0, 0], [1, 1, 0], [0, 0, 4]]
 [[4, 0, 0], [0, 1, 1], [0, 0, 3]]
 [[4, 0, 0], [0, 1, 0], [0, 0, 4]]

all_hn_types(M::QuiverModuli; unstable::Bool=false, ordered::Bool=true)

Returns all Harder-Narasimhan types of the moduli space.

Input

• M::QuiverModuli: a moduli space or stack of representations of a quiver.

Keyword arguments:

• unstable::Bool: if true, returns only Harder-Narasimhan types

corresponding to unstable representations. Default is false

• ordered::Bool: if true, returns the Harder-Narasimhan types in

the order introduced by [MR1974891]. Default is true.

Output

• a list of Harder-Narasimhan types for the dimension vector and slope of M.

Examples

The HN types for a 3-Kronecker quiver with dimension vector [2, 3]:

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

julia> all_hn_types(M)
8-element Vector{HNType}:
 [[2, 3]]
 [[1, 1], [1, 2]]
 [[2, 2], [0, 1]]
 [[2, 1], [0, 2]]
 [[1, 0], [1, 3]]
 [[1, 0], [1, 2], [0, 1]]
 [[1, 0], [1, 1], [0, 2]]
 [[2, 0], [0, 3]]

julia> all_hn_types(M; unstable = true)
7-element Vector{HNType}:
 [[1, 1], [1, 2]]
 [[2, 2], [0, 1]]
 [[2, 1], [0, 2]]
 [[1, 0], [1, 3]]
 [[1, 0], [1, 2], [0, 1]]
 [[1, 0], [1, 1], [0, 2]]
 [[2, 0], [0, 3]]

is_hn_type(Q::Quiver, d::AbstractVector{Int}, dstar::HNType, theta::AbstractVector{Int}=canonical_stability(Q, d), denom::Function=sum)

Check if the given ordered list of subdimension vectors dstar is a Harder–Narasimhan type for the datum Q, d and the slope function theta/denom.

Input

• Q::Quiver a quiver.
• d::AbstractVector{Int} a dimension vector.
• dstar::HNType an Harder–Narasimhan type.
• theta::AbstractVector{Int} a stability parameter.
• denom::Function a function to compute the denominator. Default is sum.

Output

• true if dstar is a Harder–Narasimhan type for Q, d and the slope theta/denom, false otherwise.

Examples

julia> Q = kronecker_quiver(3);

julia> d = [2, 3]; dstar = [d];

julia> is_hn_type(Q, d, dstar)
true

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

Checks if the given sequence of dimension vectors is a valid HN type for the moduli space.

Input

• M::QuiverModuli: a moduli space or stack of representations of a quiver.
• hn_type::HNType: a Harder–Narasimhan type.

Output

• whether the given sequence is a valid Harder-Narasimhan type for M.

Examples

Some HN types for the 3-Kronecker quiver with dimension vector [2, 3]:

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

julia> is_hn_type(M, [[2, 3]])
true

julia> is_hn_type(M, [[1, 1], [1, 2]])
true

julia> is_hn_type(M, [[1, 2], [1, 1]])
false

codimension_hn_stratum(Q::Quiver, stratum::HNType)

Compute the codimension of the given Harder–Narasimhan stratum.

Input

• Q::Quiver a quiver.
• stratum::HNType: a Harder–Narasimhan type.

Output

• the codimension of the Harder–Narasimhan stratum as an integer.

Examples

julia> Q = kronecker_quiver(3); d = [2,3]; theta = [3,-2];

julia> HN = all_hn_types(Q, d, theta; ordered=true);

julia> [codimension_hn_stratum(Q, stratum) for stratum in HN]
8-element Vector{Int64}:
  0
  3
  4
 10
  8
  9
 12
 18

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

Computes the codimension of the Harder-Narasimhan stratum corresponding to the given HN type.

Input

• M::QuiverModuli: a moduli space or stack of representations of a quiver.
• hn_type::HNType: a Harder–Narasimhan type

Output

• the codimension of the Harder-Narasimhan stratum corresponding to the given HN type.

Examples

Codimensions for the 3-Kronecker quiver with dimension vector [2, 3]:

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

julia> codimension_hn_stratum(M, [[2, 3]])
0

julia> codimension_hn_stratum(M, [[1, 1], [1, 2]])
3

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

Check whether the dimension vector d is amply stable with respect to the slope function theta/denominator.

This means that the codimension of the unstable locus in the parameter space is at least $2$.

Input

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

Output

• true if d is amply stable, false otherwise.

Examples

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

julia> is_amply_stable(Q, d, [3, -2])
true

julia> is_amply_stable(Q, d, [-3, 2])
false

julia> is_amply_stable(Q, [3, 0], [0, -3])
true

is_amply_stable(M::QuiverModuli)

Checks whether the dimension vector $d$ is amply stable with respect to the slope function theta/denominator.

This means that the codimension of the unstable locus in the parameter space is at least $2$.

Input

• M::QuiverModuli: a moduli space or stack of representations of a quiver.

Output

• true if the codimension of the unstable locus is at least 2, false otherwise.

Examples

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

julia> is_amply_stable(M)
true

Summary

struct LunaType{T}

A struct to encode Luna types.

Fields

data :: Dict{SVector{T,Int},Vector{Int}

all_luna_types(M::QuiverModuli; stable::Bool = true)

Returns all Luna types of the moduli space.

Input

• M::QuiverModuli: a moduli space or stack of representations of a quiver.

Keyword arguments:

• stable::Bool: if false, excludes the stable Luna type. Default is true

Output

• a list of Luna types for the dimension vector and slope of M.

Examples

Luna types for a 3-Kronecker quiver:

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

julia> all_luna_types(M)
5-element Vector{LunaType{2}}:
 Dict([3, 3] => [1])
 Dict([1, 1] => [1], [2, 2] => [1])
 Dict([1, 1] => [3])
 Dict([1, 1] => [2, 1])
 Dict([1, 1] => [1, 1, 1])

all_luna_types(Q::Quiver, d, theta, denom; stable=true)

Computes all the possible Luna types for the given data.

Input

• Q::Quiver: a quiver.
• d::AbstractVector{Int}: a dimension vector.
• theta::AbstractVector{Int}: a stability parameter. Defaults to canonical_stability(Q, d).
• denom::Function: a function defining the denominator of the slope. Defaults to sum.

Keyword arguments:

• stable::Bool: if false, excludes the stable Luna type. Default is true

Output

• a list of Luna types.

Examples

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

julia> all_luna_types(M)
5-element Vector{LunaType{2}}:
 Dict([3, 3] => [1])
 Dict([1, 1] => [1], [2, 2] => [1])
 Dict([1, 1] => [3])
 Dict([1, 1] => [2, 1])
 Dict([1, 1] => [1, 1, 1])

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

julia> all_luna_types(X)
1-element Vector{LunaType{2}}:
 Dict([2, 3] => [1])

is_luna_type(M::QuiverModuli, tau)

Checks if the given tau is a valid Luna type for M.

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

• whether the given tau is a valid Luna type for M.

Examples

Nontrivial Luna types for the 3-Kronecker quiver:

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

julia> l = Dict([1, 1] => [1], [2, 2] => [1]);

julia> is_luna_type(M, l)
true

The zero dimensional case:

julia> Q = kronecker_quiver(3); X = QuiverModuliSpace(Q, [0, 0]);

julia> is_luna_type(X, Dict([0, 0] => [1]))
true

dimension_of_luna_stratum(M::QuiverModuli, tau)

Computes the dimension of the Luna stratum corresponding to the given Luna type in the moduli space.

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

• the dimension of the Luna stratum corresponding to the given Luna type.

Examples

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

julia> luna = all_luna_types(M)
2-element Vector{LunaType{2}}:
 Dict([1, 1] => [2])
 Dict([1, 1] => [1, 1])

julia> [dimension_of_luna_stratum(M, tau) for tau in luna]
2-element Vector{Int64}:
 1
 2

semisimple_moduli_space(M::QuiverModuli)

Returns the moduli space with the zero stability parameter.

Any quiver moduli space is (quasi)projective-over-affine; this is the affine base.

Input

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

Output

• the moduli space with the zero stability parameter.

Examples

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

julia> dimension(semisimple_moduli_space(M))
0

hodge_diamond(Q::Quiver, d::AbstractVector{Int}, theta::AbstractVector{Int}=canonical_stability(Q, d))

Compute the Hodge diamond of the moduli space of theta-semistable representations of Q with dimension vector d.

Input

• Q::Quiver: a quiver.
• d::AbstractVector{Int}: a dimension vector.
• theta::AbstractVector{Int}: a stability parameter. Default is the canonical stability.

Output

• the Hodge diamond of the moduli space.

Examples

The Hodge diamond of our favourite 6-fold:

julia> Q = kronecker_quiver(3);

julia> hodge_diamond(Q, [2, 3])
7×7 Matrix{Int64}:
 1  0  0  0  0  0  0
 0  1  0  0  0  0  0
 0  0  3  0  0  0  0
 0  0  0  3  0  0  0
 0  0  0  0  3  0  0
 0  0  0  0  0  1  0
 0  0  0  0  0  0  1

This method correctly handles the moduli spaces being empty or 0-dimensional:

julia> Q = kronecker_quiver(3);

julia> hodge_diamond(Q, [2, 3], [-3, 2])
0×0 Matrix{Int64}

hodge_diamond(M::QuiverModuliSpace)

Compute the Hodge diamond of the moduli space M.

Input

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

Output

• the Hodge diamond of the moduli space.

Examples

The Hodge diamond of our favourite 6-fold:

julia> Q = kronecker_quiver(3);

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

julia> hodge_diamond(M)
7×7 Matrix{Int64}:
 1  0  0  0  0  0  0
 0  1  0  0  0  0  0
 0  0  3  0  0  0  0
 0  0  0  3  0  0  0
 0  0  0  0  3  0  0
 0  0  0  0  0  1  0
 0  0  0  0  0  0  1

hodge_polynomial(Q::Quiver, d::AbstractVector{Int}, theta::AbstractVector{Int}=canonical_stability(Q, d))

Return the Hodge polynomial of the moduli space of theta-semistable representations of Q with dimension vector d.

The algorithm is based on []MR1974891], and the current implementation is translated from the Hodge diamond cutter.

Input

• Q::Quiver: a quiver.
• d::AbstractVector{Int}: a dimension vector.
• theta::AbstractVector{Int}: a stability parameter. Default is canonical_stability(Q, d).

Output

• the Hodge polynomial of the moduli space.

Examples

The Hodge polynomial of our favourite 6-fold:

julia> Q = kronecker_quiver(3);

julia> d = [2, 3];

julia> theta = [3, -2];

julia> hodge_polynomial(Q, d, theta)
x^6*y^6 + x^5*y^5 + 3*x^4*y^4 + 3*x^3*y^3 + 3*x^2*y^2 + x*y + 1

hodge_polynomial(M::QuiverModuliSpace)

Compute the Hodge polynomial of the moduli space M.

Input

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

Output

• the Hodge polynomial of the moduli space.

Examples

The Hodge polynomial of our favourite 6-fold:

julia> Q = kronecker_quiver(3);

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

julia> hodge_polynomial(M)
x^6*y^6 + x^5*y^5 + 3*x^4*y^4 + 3*x^3*y^3 + 3*x^2*y^2 + x*y + 1

betti_numbers(M::QuiverModuliSpace)

Compute the Betti numbers of the moduli space M.

Input

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

Output

• a list of Betti numbers of the moduli space.

Examples

julia> Q = kronecker_quiver(2);

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

julia> betti_numbers(M)
3-element Vector{Int64}:
 1
 0
 1

Our favourite 6-fold:

julia> Q = kronecker_quiver(3);

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

julia> betti_numbers(M)
13-element Vector{Int64}:
 1
 0
 1
 0
 3
 0
 3
 0
 3
 0
 1
 0
 1