GitHub

Hypersurface models

Introduction

A hypersurface model describes a particular form of an elliptic fibration. We make the following assumptions:

  • The generic fiber is a hypersurface in a 2-dimensional toric fiber ambient space $F$.
  • The first two (homogeneous) coordinates in the coordinate ring of $F$ transform in the

divisor classes $D_1$ and $D_2$ over the base $B$ of the elliptic fibration. The remaining coordinates of $F$ are assumed to transform in the trivial bundle over $B$. See [KM-POPR15] for more details.

Our tools are most powerful if the base space $B$ is a toric variety. Then, based on the above information, it is possible to compute a toric ambient space $A$ for the elliptic fibration. The elliptic fibration is then a hypersurface in this toric space $A$. Furthermore, since we assume that this fibration is Calabi-Yau, it is clear that the hypersurface equation is a (potentially very special) section of the $\overline{K}_A$. This hypersurface equation completes the information required about a hypersurface model.

Certainly, one often wishes to extend beyond this setting:

  • Oftentimes, a special hypersurface equation is chosen. In the toric setting above, this will

be a polynomial in the Cox ring of the toric ambient space. Since said ambient space, and therefore also its Cox ring, are computed in the cause of the above construction, we do not support one constructor, which immediately accepts a special hypersurface equation. Rather, in this case, the user must first use one of the general constructors described in the next section. Subsequently, the tune function, described in the methods section below, can be employed.

  • Bases other than toric spaces matter. Often, the F-theory literature will not even assume

one particular base space but rather an entire family of base spaces. We extend our machinery to these cases, but such more general settings are typically significantly more limited than the toric setting. This limitation originates from the nature of the matter – the more general the geometry, the less is known.

Constructors

We aim to provide support for hypersurface models over the following bases:

  • a toric variety,
  • a toric scheme,
  • a (covered) scheme.

[Often, one also wishes to obtain information about a hypersurface model without explicitly specifying the base space. For this, please use our tune function, described in the methods section below.]

Finally, we provide support for some standard constructions.

Before we detail these constructors, we must comment on the constructors over toric base spaces. Namely, in order to construct a hypersurface model, we first have to construct the ambient space in question. For a toric base, one way to achieve this is by means of triangulations. However, this is a rather time consuming and computationally challenging task, which leads to a huge number of ambient spaces. Even more, typically one wishes to only pick one of thees many ambient spaces. For instance, a common and often appropriate choice is a toric ambient space which contains the toric base space in a manifest way.

To circumvent this very demanding computation, our constructors operate in the opposite direction. That is, they begin by extracting the rays and maximal cones of the chosen toric base space. Subsequently, those rays and cones are extended to form one of the many toric ambient spaces. This proves hugely superior in performance than going through the triangulation task of enumerating all possible toric ambient spaces. One downside of this strategy is that the so-constructed ambient space need not be smooth.

A toric variety as base space

We require that the provided toric base space is complete. This is a technical limitation as of now. The functionality of OSCAR only allows us to compute a section basis (or a finite subset thereof) for complete toric varieties. In the future, this could be extended.

Completeness is an expensive check. Therefore, we provide an optional argument which one can use to disable this check if desired. To this end, one passes the optional argument completeness_check = false as last argument to the constructor. Here is how we can construct a hypersurface model in OSCAR:

hypersurface_model — Method
function hypersurface_model(base::NormalToricVariety, fiber_ambient_space::NormalToricVariety, fiber_twist_divisor_classes::Vector{ToricDivisorClass}, p::MPolyRingElem; completeness_check::Bool = true)

Construct a hypersurface model, for which the user can specify a fiber ambient space as well as divisor classes of the toric base space, in which the first two homogeneous coordinates of the fiber ambient space transform.

Examples

julia> b = projective_space(NormalToricVariety, 2)
Normal toric variety

julia> fiber_ambient_space = weighted_projective_space(NormalToricVariety, [2,3,1])
Normal toric variety

julia> set_coordinate_names(fiber_ambient_space, ["x", "y", "z"])

julia> D1 = 2 * anticanonical_divisor_class(b)
Divisor class on a normal toric variety

julia> D2 = 3 * anticanonical_divisor_class(b)
Divisor class on a normal toric variety

julia> D3 = trivial_divisor_class(b)
Divisor class on a normal toric variety

julia> new_gens = string.(vcat(gens(cox_ring(b)), gens(cox_ring(fiber_ambient_space))))
6-element Vector{String}:
 "x1"
 "x2"
 "x3"
 "x"
 "y"
 "z"

julia> ambient_ring, (x1, x2, x3, x, y, z) = polynomial_ring(QQ, new_gens, cached=false)
(Multivariate polynomial ring in 6 variables over QQ, QQMPolyRingElem[x1, x2, x3, x, y, z])

julia> p = x^3 - y^2 + x1^12 * x * z^4 + x2^18 * z^6 + 13 * x3^3*x*y*z
x1^12*x*z^4 + x2^18*z^6 + 13*x3^3*x*y*z + x^3 - y^2

julia> h = hypersurface_model(b, fiber_ambient_space, [D1, D2, D3], p; completeness_check = false)
Hypersurface model over a concrete base
Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

source

For convenience, it also possible to provide the hypersurface polynomial p as a string.

A (covered) scheme as base space

This functionality does not yet exist.

Base space not specified

This method constructs a hypersurface model over a base space, where this base space is not (fully) specified. We currently provide the following constructors:

hypersurface_model — Method
hypersurface_model(auxiliary_base_vars::Vector{String}, auxiliary_base_grading::Matrix{Int64}, d::Int, fiber_ambient_space::NormalToricVariety, fiber_twist_divisor_classes::Vector{Vector{Int64}}, p::MPolyRingElem)

This method constructs a hypersurface model over a base space that is not fully specified. In the background, we construct a family of spaces to represent the base space. This method requires the following information:

  1. The names of the homogeneous coordinates of the coordinate ring of the generic member

of the family of bsae spaces.

  1. The grading of the coordinate ring of the generic member of the family of base spaces.
  2. The weights telling us how the fiber ambient space coordinates transform under the base.
  3. The dimension of the generic member of the family of base spaces.
  4. The fiber ambient space.
  5. The hypersurface equation.

Note that many studies in the literature use the class of the anticanonical bundle in their analysis. We anticipate this by adding this class as a variable of the coordinate ring of the generic member of the family of base space, unless the user already provides this grading. Our convention is that the first row of the grading matrix refers to Kbar and that the homogeneous variable corresponding to this class carries the name "Kbar".

The following example exemplifies this constructor.

Examples

julia> auxiliary_base_vars = ["a1", "a21", "a32", "a43", "a65", "w"]
6-element Vector{String}:
 "a1"
 "a21"
 "a32"
 "a43"
 "a65"
 "w"

julia> auxiliary_base_grading = [1 2 3 4 6 0; 0 -1 -2 -3 -5 1]
2×6 Matrix{Int64}:
 1   2   3   4   6  0
 0  -1  -2  -3  -5  1

julia> D1 = [4,0]
2-element Vector{Int64}:
 4
 0

julia> D2 = [6,0]
2-element Vector{Int64}:
 6
 0

julia> D3 = [0,0]
2-element Vector{Int64}:
 0
 0
 
julia> d = 3
3

julia> fiber_ambient_space = weighted_projective_space(NormalToricVariety, [2,3,1])
Normal toric variety

julia> set_coordinate_names(fiber_ambient_space, ["x", "y", "z"])

julia> auxiliary_ambient_ring, (a1, a21, a32, a43, a65, w, x, y, z)  = QQ[:a1, :a21, :a32, :a43, :a65, :w, :x, :y, :z]
(Multivariate polynomial ring in 9 variables over QQ, QQMPolyRingElem[a1, a21, a32, a43, a65, w, x, y, z])

julia> p = x^3 - y^2 - x * y * z * a1 + x^2 * z^2 * a21 * w - y * z^3 * a32 * w^2 + x * z^4 * a43 * w^3 + z^6 * a65 * w^5
-a1*x*y*z + a21*w*x^2*z^2 - a32*w^2*y*z^3 + a43*w^3*x*z^4 + a65*w^5*z^6 + x^3 - y^2

julia> h = hypersurface_model(auxiliary_base_vars, auxiliary_base_grading, d, fiber_ambient_space, [D1, D2, D3], p)
Assuming that the first row of the given grading is the grading under Kbar

Hypersurface model over a not fully specified base
Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

source

For convenience, the fibertwistdivisor_classes can also be provided as ZZMatrix.

Attributes

Basic attributes

All hypersurface models come with a hypersurface equation:

hypersurface_equation — Method
hypersurface_equation(h::HypersurfaceModel)

Return the hypersurface equation.

julia> B2 = projective_space(NormalToricVariety, 2)
Normal toric variety

julia> b = torusinvariant_prime_divisors(B2)[1]
Torus-invariant, prime divisor on a normal toric variety

julia> h = literature_model(arxiv_id = "1208.2695", equation = "B.5", base_space = B2, defining_classes = Dict("b" => b))
Construction over concrete base may lead to singularity enhancement. Consider computing singular_loci. However, this may take time!

Hypersurface model over a concrete base

julia> hypersurface_equation(h);
Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

source

Note that this equation is a polynomial in the coordinate ring of a suitable ambient space. This ambient space is computed by our constructors. Consequently, the coordinate ring, in which the hypersurface equation is an element, is only available after the model has been constructed.

Some hypersurface models parametrize the hypersurface equation with sections of line bundles of the base space. One can obtain those sections and their explicit polynomial expressions over the base with explicit_model_sections. The parametrization of the hypersurface equation by these sections is found as follows:

hypersurface_equation_parametrization — Method
hypersurface_equation_parametrization(h::HypersurfaceModel)

Return the parametrization of the hypersurface equation by the model sections.

julia> h = literature_model(arxiv_id = "1208.2695", equation = "B.5")
Assuming that the first row of the given grading is the grading under Kbar

Hypersurface model over a not fully specified base

julia> explicit_model_sections(h)
Dict{String, MPolyRingElem} with 5 entries:
  "c2" => c2
  "c1" => c1
  "c3" => c3
  "b"  => b
  "c0" => c0

julia> hypersurface_equation_parametrization(h)
b*w*v^2 - c0*u^4 - c1*u^3*v - c2*u^2*v^2 - c3*u*v^3 + w^2
Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

source

To specify a custom value for the hypersurface equation, first use one of the above constructors. Once completed, employ the tune function described in the methods section to set the hypersurface equation to your desired value.

The base space can be obtained with base_space, the ambient space with ambient_space and the fiber ambient space with fiber_ambient_space. Recall that is_base_space_fully_specified will tell if the model has been constructed over a concrete space (in which case the function returns true) or a family of spaces (returning false).

Attributes in toric settings

If the base space of the hypersurface model is a toric space, then we also provide a special type for the Calabi-Yau hypersurface:

calabi_yau_hypersurface — Method
calabi_yau_hypersurface(h::HypersurfaceModel)

Return the Calabi-Yau hypersurface in the toric ambient space which defines the hypersurface model.

julia> B2 = projective_space(NormalToricVariety, 2)
Normal toric variety

julia> b = torusinvariant_prime_divisors(B2)[1]
Torus-invariant, prime divisor on a normal toric variety

julia> h = literature_model(arxiv_id = "1208.2695", equation = "B.5", base_space = B2, defining_classes = Dict("b" => b))
Construction over concrete base may lead to singularity enhancement. Consider computing singular_loci. However, this may take time!

Hypersurface model over a concrete base

julia> calabi_yau_hypersurface(h)
Closed subvariety of a normal toric variety
Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

source

Attributes based on the corresponding global Tate and Weierstrass models

Currently, we do not provide functionality to convert a hypersurface model into a Weierstrass or global Tate model. Still, for some constructions this might be known or detailed in the literature. If the user wishes, one can then associate a corresponding Weierstrass or global Tate model as follows:

set_weierstrass_model — Method
set_weierstrass_model(h::HypersurfaceModel, w::WeierstrassModel)

Allows to define the Weierstrass model corresponding to the hypersurface model.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

source
set_global_tate_model — Method
set_global_tate_model(h::HypersurfaceModel, w::GlobalTateModel)

Allows to define the global Tate model corresponding to the hypersurface model.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

source

These models can then be accessed with the following functions:

weierstrass_model — Method
weierstrass_model(h::HypersurfaceModel)

Return the Weierstrass model corresponding to the hypersurface model, provided that the former is known.

julia> t = literature_model(14)
Assuming that the first row of the given grading is the grading under Kbar

Hypersurface model over a not fully specified base

julia> weierstrass_model(t)
Assuming that the first row of the given grading is the grading under Kbar

Weierstrass model over a not fully specified base -- F-theory weierstrass model dual to hypersurface model with fiber ambient space F_1 based on arXiv paper 1408.4808 Eq. (3.4)
Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

source
global_tate_model — Method
global_tate_model(h::HypersurfaceModel)

Return the global Tate model corresponding to the hypersurface model, provided that the latter is known.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

source

Provided that the corresponding Weierstrass model is known for a hypersurface model, the following functionality is available. It returns the attribute in question of the corresponding Weierstrass model.

discriminant — Method
discriminant(h::HypersurfaceModel)

Return the discriminant of the hypersurface model.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

source
singular_loci — Method
singular_loci(h::HypersurfaceModel)

Return the singular loci of the hypersurface model, along with the order of vanishing of the Weierstrass sections and discriminant $(f, g, \Delta)$` at each locus. Also the refined Tate fiber type is returned.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

source

Methods

Tuning

Tuning is possible with the tune function, cf. Functionality for all F-theory models.