Points
We provide an abstract interface for working with points on Mori dream spaces in terms of their Cox coordinates and orbit cone. An implementation for fixed points on $\mathbb{C}^*$-surfaces (elliptic, hyperbolic and parabolic) as well as toric fixed points on surfaces is provided.
Types
CStarSurfaces.MoriDreamSpacePoint
— TypeMoriDreamSpacePoint
A point on a Mori dream space.
Subtypes of MoriDreamSpacePoint
should at least implement the following methods: orbit_cone
, cox_coordinates
, is_quasismooth
.
CStarSurfaces.CStarSurfacePoint
— TypeCStarSurfacePoint{T <: CStarSurfaceCase} <: MoriDreamSpacePoint
A point on a $\mathbb{C}^*$-surface.
CStarSurfaces.ToricSurfacePoint
— TypeToricSurfacePoint <: MoriDreamSpacePoint
A point on a toric surface.
CStarSurfaces.SurfaceWithTorusActionPoint
— TypeSurfaceWithTorusActionPoint
The Union
of CStarSurfacePoint
and ToricSurfacePoint
.
CStarSurfaces.CStarSurfaceFixedPoint
— TypeCStarSurfaceFixedPoint{T <: CStarSurfaceCase} <: CStarSurfacePoint{T}
A fixed point on a $\mathbb{C}^*$-surface.
CStarSurfaces.ToricSurfaceFixedPoint
— TypeToricSurfaceFixedPoint <: ToricSurfacePoint
A toric fixed points on a toric surface.
CStarSurfaces.SurfaceWithTorusActionFixedPoint
— TypeSurfaceWithTorusActionFixedPoint
The Union
of CStarSurfaceFixedPoint
and ToricSurfaceFixedPoint
.
CStarSurfaces.EllipticFixedPoint
— TypeEllipticFixedPoint{T <: CStarSurfaceCase} <: CStarSurfaceFixedPoint{T}
An elliptic fixed point on a $\mathbb{C}^*$-surface.
CStarSurfaces.EllipticFixedPointPlus
— TypeEllipticFixedPointPlus{T <: Union{EE,EP}} <: EllipticFixedPoint{T}
An elliptic fixed point $x^+$ on a $\mathbb{C}^*$-surface of type (e-e) or (e-p). There should only ever be one instance of this type for any given CStarSurface
, which is accessible via x_plus
.
CStarSurfaces.EllipticFixedPointMinus
— TypeEllipticFixedPointMinus{T <: Union{EE,PE}} <: EllipticFixedMinus{T}
An elliptic fixed point $x^-$ on a $\mathbb{C}^*$-surface of type (e-e) or (p-e). There should only ever be one instance of this type for any given CStarSurface
, which is accessible via x_minus
.
CStarSurfaces.HyperbolicFixedPoint
— TypeHyperbolicFixedPoint{T <: CStarSurfaceCase} <: CStarSurfaceFixedPoint{T}
A hyperbolic fixed point on a $\mathbb{C}^*$-surface.
CStarSurfaces.ParabolicFixedPoint
— TypeParabolicFixedPoint{T <: CStarSurfaceCase} <: CStarSurfaceFixedPoint{T}
A parabolic fixed point on a $\mathbb{C}^*$-surface.
CStarSurfaces.ParabolicFixedPointPlus
— TypeParabolicFixedPointPlus{T<:Union{PE,PP}} <: ParabolicFixedPoint{T}
A parabolic fixed point $x^+_i$ on a $\mathbb{C}^*$-surface of type (p-e) or (p-p)
CStarSurfaces.ParabolicFixedPointMinus
— TypeParabolicFixedPointMinus{T<:Union{EP,PP}} <: ParabolicFixedPoint{T}
A parabolic fixed point $x^-_i$ on a $\mathbb{C}^*$-surface of type (e-p) or (p-p).
Constructors
CStarSurfaces.x_plus
— Functionx_plus(X :: CStarSurface{<:Union{EE,EP}})
Return the elliptic fixed point $x^+$ of a $\mathbb{C}^*$-surface of type (e-e) or (e-p).
Example
julia> X = cstar_surface([[3, 1], [3], [2]], [[-2, -1], [1], [1]], :ee)
C-star surface of type (e-e)
julia> x_plus(X)
elliptic fixed point x^+
CStarSurfaces.x_minus
— Functionx_minus(X :: CStarSurface{<:Union{EE,PE}})
Return the elliptic fixed point $x^-$ of a $\mathbb{C}^*$-surface of type (e-e) or (p-e).
Example
julia> X = cstar_surface([[3, 1], [3], [2]], [[-2, -1], [1], [1]], :ee)
C-star surface of type (e-e)
julia> x_minus(X)
elliptic fixed point x^-
CStarSurfaces.hyperbolic_fixed_point
— Functionhyperbolic_fixed_point(X :: CStarSurface, i :: Int, j :: Int)
Return the hyperbolic fixed point $x_{ij}$ of a $\mathbb{C}^*$-surface, where $0 ≤ i ≤ r$ and $1 ≤ j ≤ n_i - 1$.
Example
julia> X = cstar_surface([[3, 1], [3], [2]], [[-2, -1], [1], [1]], :ee)
C-star surface of type (e-e)
julia> hyperbolic_fixed_point(X, 0, 1)
hyperbolic fixed point x(0, 1)
CStarSurfaces.parabolic_fixed_point_plus
— Functionparabolic_fixed_point_plus(X :: CStarSurface{<:Union{PE,PP}}, i :: Int)
Return the parabolic fixed point $x_i^+$ of a $\mathbb{C}^*$-surface, where $0 ≤ i ≤ r$.
Example
julia> X = cstar_surface([[3, 1], [3], [2]], [[-2, -1], [1], [1]], :pe)
C-star surface of type (p-e)
julia> parabolic_fixed_point_plus(X, 0)
parabolic fixed point x^+(0)
CStarSurfaces.parabolic_fixed_point_minus
— Functionparabolic_fixed_point_minus(X :: CStarSurface{<:Union{EP,PP}}, i :: Int)
Return the parabolic fixed point $x_i^-$ of a $\mathbb{C}^*$-surface, where $0 ≤ i ≤ r$.
Example
julia> X = cstar_surface([[3, 1], [3], [2]], [[-2, -1], [1], [1]], :ep)
C-star surface of type (e-p)
julia> parabolic_fixed_point_minus(X, 0)
parabolic fixed point x^-(0)
Sets of fixed points
CStarSurfaces.elliptic_fixed_points
— Functionelliptic_fixed_points(X :: CStarSurface)
Return the elliptic fixed points of a $\mathbb{C}^*$-surface.
Example
julia> X = cstar_surface([[3, 1], [3], [2]], [[-2, -1], [1], [1]], :ee)
C-star surface of type (e-e)
julia> elliptic_fixed_points(X)
2-element Vector{EllipticFixedPoint{EE}}:
elliptic fixed point x^+
elliptic fixed point x^-
CStarSurfaces.hyperbolic_fixed_points
— Functionhyperbolic_fixed_points(X :: CStarSurface)
Return the hyperbolic fixed points of a $\mathbb{C}^*$-surface as a DoubleVector
.
Example
julia> X = cstar_surface([[1,2,1], [1,1], [1,1]], [[3,3,0], [0,-1], [0,-2]], :ee)
C-star surface of type (e-e)
julia> hyperbolic_fixed_points(X)
3-element OffsetArray(::Vector{Vector{HyperbolicFixedPoint{EE}}}, 0:2) with eltype Vector{HyperbolicFixedPoint{EE}} with indices 0:2:
[hyperbolic fixed point x(0, 1), hyperbolic fixed point x(0, 2)]
[hyperbolic fixed point x(1, 1)]
[hyperbolic fixed point x(2, 1)]
CStarSurfaces.parabolic_fixed_points_plus
— Functionparabolic_fixed_points_plus(X :: CStarSurface{T}) where {T <: Union{PE,PP}}
Return the parabolic fixed points $x_i^+$ of a $\mathbb{C}^*$-surface.
Example
julia> X = cstar_surface([[3, 1], [3], [2]], [[-2, -1], [1], [1]], :pe)
C-star surface of type (p-e)
julia> parabolic_fixed_points_plus(X)
3-element OffsetArray(::Vector{ParabolicFixedPointPlus{PE}}, 0:2) with eltype ParabolicFixedPointPlus{PE} with indices 0:2:
parabolic fixed point x^+(0)
parabolic fixed point x^+(1)
parabolic fixed point x^+(2)
CStarSurfaces.parabolic_fixed_points_minus
— Functionparabolic_fixed_points_minus(X :: CStarSurface{T}) where {T <: Union{EP,PP}}
Return the parabolic fixed points $x_i^-$ of a $\mathbb{C}^*$-surface.
Example
julia> X = cstar_surface([[3, 1], [3], [2]], [[-2, -1], [1], [1]], :ep)
C-star surface of type (e-p)
julia> parabolic_fixed_points_minus(X)
3-element OffsetArray(::Vector{ParabolicFixedPointMinus{EP}}, 0:2) with eltype ParabolicFixedPointMinus{EP} with indices 0:2:
parabolic fixed point x^-(0)
parabolic fixed point x^-(1)
parabolic fixed point x^-(2)
CStarSurfaces.parabolic_fixed_points
— Functionparabolic_fixed_points(X :: CStarSurface)
Return the parabolic fixed points of a $\mathbb{C}^*$-surface.
Example
julia> X = cstar_surface([[3, 1], [3], [2]], [[-2, -1], [1], [1]], :pp)
C-star surface of type (p-p)
julia> parabolic_fixed_points(X)
6-element Vector{ParabolicFixedPoint{PP}}:
parabolic fixed point x^+(0)
parabolic fixed point x^+(1)
parabolic fixed point x^+(2)
parabolic fixed point x^-(0)
parabolic fixed point x^-(1)
parabolic fixed point x^-(2)
CStarSurfaces.fixed_points
— Functionfixed_points(X :: CStarSurface)
Return all fixed points of a $\mathbb{C}^*$-action. This is the union of elliptic_fixed_points
, hyperbolic_fixed_points
and parabolic_fixed_points
.
Example
julia> X = cstar_surface([[3, 1], [3], [2]], [[-2, -1], [1], [1]], :ep)
C-star surface of type (e-p)
julia> fixed_points(X)
5-element Vector{CStarSurfaceFixedPoint{EP}}:
elliptic fixed point x^+
hyperbolic fixed point x(0, 1)
parabolic fixed point x^-(0)
parabolic fixed point x^-(1)
parabolic fixed point x^-(2)
Attributes
Base.parent
— Methodparent(x :: MoriDreamSpacePoint)
Return the Mori dream space where x
lives in.
Example
julia> X = cstar_surface([[3, 1], [3], [2]], [[-2, -1], [1], [1]], :ee)
C-star surface of type (e-e)
julia> x = x_plus(X)
elliptic fixed point x^+
julia> parent(x) === X
true
CStarSurfaces.orbit_cone
— Functionorbit_cone(x :: MoriDreamSpacePoint)
Given a point $x \in X$ on a Mori dream space, return the index vector of the cone $\sigma$ of the canonical toric ambient variety such that $x$ is contained in the toric orbit associated to $\sigma$.
Example
julia> X = cstar_surface([[3, 1], [3], [2]], [[-2, -1], [1], [1]], :ee)
C-star surface of type (e-e)
julia> orbit_cone(x_plus(X))
3-element Vector{Int64}:
1
3
4
CStarSurfaces.cox_coordinates
— Functioncox_coordinates(x :: MoriDreamSpacePoint)
Return the Cox coordinates of a point on a Mori dream space.
Example
julia> X = cstar_surface([[3, 1], [3], [2]], [[-2, -1], [1], [1]], :ee)
C-star surface of type (e-e)
julia> cox_coordinates(x_plus(X))
4-element Vector{Int64}:
0
1
0
0
Hecke.class_group
— Methodclass_group(x :: MoriDreamSpacePoint)
Return the local class group at a given point on a Mori dream space.
Example
julia> X = cstar_surface([[2, 2], [2], [4]], [[3, -3], [1], [1]], :ee)
C-star surface of type (e-e)
julia> class_group(x_plus(X))
GrpAb: Z/2 x Z/18
CStarSurfaces.class_group_rank
— Methodclass_group_rank(x :: MoriDreamSpacePoint)
Return the rank of the local class group at a point on a Mori Dream Space.
CStarSurfaces.class_group_torsion
— Methodclass_group_torsion(X :: MoriDreamSpacePoint)
Return the list of elementary divisors that make up the torsion part of the local class group of a point on a Mori Dream Space.
Example
julia> X = cstar_surface([[2, 2], [2], [4]], [[3, -3], [1], [1]], :ee)
C-star surface of type (e-e)
julia> class_group_torsion(x_plus(X))
2-element Vector{ZZRingElem}:
2
18
CStarSurfaces.class_group_torsion_order
— Methodclass_group_torsion_order(X :: MoriDreamSpacePoint)
Return the order of the torsion part of the class group of a Mori Dream Space.
Example
julia> X = cstar_surface([[2, 2], [2], [4]], [[3, -3], [1], [1]], :ee)
C-star surface of type (e-e)
julia> class_group_torsion_order(x_plus(X))
36
CStarSurfaces.map_from_class_group_to_local_class_group
— Methodmap_from_class_group_to_local_class_group(X :: MoriDreamSpacePoint)
Compute the canonical map from the class group of a Mori dream space to the local class group at a given point.
Example
julia> X = cstar_surface([[2, 2], [2], [4]], [[3, -3], [1], [1]], :ee)
C-star surface of type (e-e)
julia> map_from_class_group_to_local_class_group(x_plus(X))
Map with following data
Domain:
=======
Abelian group with structure: Z/2 x Z/6 x Z
Codomain:
=========
Abelian group with structure: Z/2 x Z/18
Oscar.gorenstein_index
— Methodgorenstein_index(X :: MoriDreamSpacePoint)
Return the local gorenstein index of a point on a Mori Dream Space.
Example
julia> X = cstar_surface([[2, 2], [2], [4]], [[3, -3], [1], [1]], :ee)
C-star surface of type (e-e)
julia> gorenstein_index(x_plus(X))
9
CStarSurfaces.is_quasismooth
— Functionis_quasismooth(x :: MoriDreamSpacePoint)
Checks whether a point on a Mori dream space is quasismooth.
Example
julia> X = cstar_surface([[3, 1], [3], [2]], [[-2, -1], [1], [1]], :ee)
C-star surface of type (e-e)
julia> is_quasismooth(x_plus(X))
false
CStarSurfaces.is_factorial
— Methodis_factorial(x :: MoriDreamSpacePoint)
Check whether a point on a Mori dream space is factorial, i.e. its local class group is trivial.
Example
julia> X = cstar_surface([[2, 2], [2], [4]], [[3, -3], [1], [1]], :ee)
C-star surface of type (e-e)
julia> is_factorial(x_plus(X))
false
Hecke.is_smooth
— Methodis_smooth(x :: MoriDreamSpacePoint)
Check whether a point on a Mori dream space is smooth, i.e. factorial and quasismooth.
Example
julia> X = cstar_surface([[3, 1], [3], [2]], [[-2, -1], [1], [1]], :ee)
C-star surface of type (e-e)
julia> is_smooth(x_plus(X))
false
CStarSurfaces.is_log_terminal
— Functionis_log_terminal(x :: SurfaceWithTorusActionFixedPoint)
Check whether a point on a surface with torus action is at most a log terminal singularity.
Example
The $E_6$ singular cubic.
julia> X = cstar_surface([[3, 1], [3], [2]], [[-2, -1], [1], [1]], :ee)
C-star surface of type (e-e)
julia> is_log_terminal(x_plus(X))
true
A non-log terminal singularity.
julia> X = cstar_surface([[5, 7],[3],[2]], [[-1, 2], [1], [-1]], :ee)
C-star surface of type (e-e)
julia> is_log_terminal(x_plus(X))
false
Resolution of singularities
CStarSurfaces.canonical_resolution
— Functioncanonical_resolution(x :: SurfaceWithTorusActionFixedPoint)
Return the canonical resolution of singularities of a given fixed point on a surface with torus action. The result is a triple (Y, ex_div, discr)
where Y
is the resulting surface after the resolution step, ex_div
contains the exceptional divisors over x
and discrepancies
contains their discrepancies.
Example
Resolving the elliptic fixed point $x^+$ of the $E_6$ singular cubic.
julia> X = cstar_surface([[3, 1], [3], [2]], [[-2, -1], [1], [1]], :ee)
C-star surface of type (e-e)
julia> (Y, ex_div, discr) = canonical_resolution(x_plus(X));
julia> gen_matrix(Y)
[-3 -1 -2 -1 3 2 1 0 0 0]
[-3 -1 -2 -1 0 0 0 2 1 0]
[-2 -1 -1 0 1 1 1 1 1 1]
julia> map(E -> E*E, ex_div)
6-element Vector{QQFieldElem}:
-2
-2
-2
-2
-2
-2
julia> discr
6-element Vector{Rational{Int64}}:
0//1
0//1
0//1
0//1
0//1
0//1
CStarSurfaces.minimal_resolution
— Functionminimal_resolution(x :: CStarSurfaceFixedPoint)
Return the minimal resolution of singularities of a $\mathbb{C}^*$-surface surface X
. The minimal resolution is obtained by contracting all (-1)-curves of the canonical resolution. The result is a triple (Y, ex_div, discr)
where Y
is the resulting $\mathbb{C}^*$-surface after the resolution step, ex_div
contains the exceptional divisors in the resolution and discrepancies
contains their discrepancies.
Example
julia> X = cstar_surface([[3, 1], [3], [2]], [[-2, -1], [1], [1]], :ee)
C-star surface of type (e-e)
julia> (Y, ex_div, discr) = minimal_resolution(x_plus(X));
julia> gen_matrix(Y)
[-3 -1 -2 -1 3 2 1 0 0 0]
[-3 -1 -2 -1 0 0 0 2 1 0]
[-2 -1 -1 0 1 1 1 1 1 1]
CStarSurfaces.log_canonicity
— Methodlog_canonicity(X :: SurfaceWithTorusActionFixedPoint)
Return the maximal rational number $\varepsilon$ such that a given point on a surface with torus action is $\varepsilon$-log canonical. By definition, this is the minimal discrepancy in the resolution of singularities plus one.
Example
julia> X = cstar_surface([[3, 1], [3], [2]], [[-2, -1], [1], [1]], :ee)
C-star surface of type (e-e)
julia> log_canonicity(x_plus(X))
1//1
CStarSurfaces.resolution_graph
— Methodresolution_graph(x :: SurfaceWithTorusActionFixedPoint)
Return the resolution graph of the minimal resolution at a given fixed point of a surface with torus action. The result is a pair with first entry a Graphs.SimpleGraph
and second entry the list of self intersection numbers of the exceptional divisors, which serve as node labels of the graph.
Example
The $E_6$ singular cubic surface.
julia> X = cstar_surface([[3, 1], [3], [2]], [[-2, -1], [1], [1]], :ee)
C-star surface of type (e-e)
julia> (graph, nodelabel) = resolution_graph(x_plus(X))
(Graphs.SimpleGraphs.SimpleGraph{Int64}(11, [[1, 2], [1, 2, 6], [3, 4], [3, 4, 6], [5, 6], [2, 4, 5, 6]]), Nemo.QQFieldElem[-2, -2, -2, -2, -2, -2])
The resolution graph can be visualized with GraphPlot.jl
:
julia> using GraphPlot
julia> gplothtml(graph, nodelabel = nodelabel)
CStarSurfaces.number_of_exceptional_prime_divisors
— Methodnumber_of_exceptional_prime_divisors(x :: SurfaceWithTorusActionFixedPoint)
Return the number of exceptional prime divisors over a given point in the minimal resolution of singularities.
Example
julia> X = cstar_surface([[3, 1], [3], [2]], [[-2, -1], [1], [1]], :ee)
C-star surface of type (e-e)
julia> number_of_exceptional_prime_divisors(x_plus(X))
6
Singularity types
CStarSurfaces.singularity_type
— Functionsingularity_type(x :: SurfaceWithTorusActionFixedPoint)
Return the singularity type of a fixed point on a surface with torus action.
Examples
The $E_6$ singular cubic.
julia> X = cstar_surface([[3, 1], [3], [2]], [[-2, -1], [1], [1]], :ee)
C-star surface of type (e-e)
julia> singularity_type(x_plus(X))
E6
A non-log terminal singularity.
julia> X = cstar_surface([[5, 7],[3],[2]], [[-1, 2], [1], [-1]], :ee)
C-star surface of type (e-e)
julia> singularity_type(x_plus(X))
Non log terminal singularity
CStarSurfaces.SingularityType
— TypeSingularityType
Abstract supertype of various "types" of singularities.
CStarSurfaces.SingularityTypeADE
— TypeSingularityTypeADE <: SingularityType
Abstract supertype of ADE singularities, i.e. log terminal ones.
CStarSurfaces.SingularityTypeA
— TypeSingularityTypeA <: SingularityTypeADE
The singularity type $A_n$. It has a single field n
that holds the number of nodes in the resolution graph.
CStarSurfaces.SingularityTypeD
— TypeSingularityTypeD <: SingularityTypeADE
The singularity type $D_n$. It has a single field n
that holds the number of nodes in the resolution graph.
CStarSurfaces.SingularityTypeE6
— TypeSingularityTypeE6 <: SingularityTypeADE
The singularity type $E_6$.
CStarSurfaces.SingularityTypeE7
— TypeSingularityTypeE7 <: SingularityTypeADE
The singularity type $E_7$.
CStarSurfaces.SingularityTypeE8
— TypeSingularityTypeE8 <: SingularityTypeADE
The singularity type $E_8$.
CStarSurfaces.SingularityTypeNonLogTerminal
— TypeSingularityTypeNonLogTerminal <: SingularityType
The singularity type of non log terminal singularities.