# 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
```

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

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:

- The names of the homogeneous coordinates of the coordinate ring of the generic member

of the family of bsae spaces.

- The grading of the coordinate ring of the generic member of the family of base spaces.
- The weights telling us how the fiber ambient space coordinates transform under the base.
- The dimension of the generic member of the family of base spaces.
- The fiber ambient space.
- 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
```

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

For convenience, the fiber*twist*divisor_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);
```

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

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
```

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

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
```

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

### 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.

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

`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.

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

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 latter is known.

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

`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.

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

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.

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

`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.

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

## Methods

### Tuning

Tuning is possible with the `tune`

function, cf. Functionality for all F-theory models.