G4-Fluxes

\[G_4\]

-fluxes are at the heart of F-theory model building.

Constructors

We currently support the following constructor:

g4_fluxMethod
g4_flux(model::AbstractFTheoryModel, class::CohomologyClass)

Construct a G4-flux candidate on an F-theory model. This functionality is currently limited to

  • Weierstrass models,
  • global Tate models,
  • hypersurface models.

Furthermore, our functionality requires a concrete geometry. That is, the base space as well as the ambient space must be toric varieties. In the toric ambient space $X_\Sigma$, the elliptically fibered space $Y$ that defines the F-theory model, is given by a hypersurface (cut out by the Weierstrass, Tate or hypersurface polynomial, respectively).

In this setting, we assume that a $G_4$-flux candidate is represented by a cohomology class $h$ in $H^{(2,2)} (X_\Sigma)$. The actual $G_4$-flux candidate is then obtained by restricting $h$ to $Y$.

It is worth recalling that the $G_4$-flux candidate is subject to the quantization condition $G_4 + \frac{1}{2} c_2(Y) \in H^{/2,2)}( Y_, \mathbb{Z})$ (see [Wit97]). This condition is very hard to verify. However, it is relatively easy to gather evidence for this condition to be satisfied/show that it is violated. To this end, let $D_1$, $D_2$ be two toric divisors in $X_\Sigma$, then the topological intersection number $\left[ h|_Y \right] \cdot \left[ P \right] \cdot \left[ D_1 \right] \cdot \left[ D_2 \right]$ must be an integer. Even this rather elementary check can be computationally expensive. Users can therefore decide to skip this check upon construction by setting the parameter check to the value false.

Another bottleneck can be the computation of the cohomology ring, which is necessary to work with cohomology classes on the toric ambient space, which in turn define the G4-flux, as explained above. The reason for this is, that by employing the theory explained in [CLS11], we can only work out the cohomology ring of simpicial and complete (i.e. compact) toric varieties. However, checking if a toric variety is complete (i.e. compact) can take a long time. If the geometry in question is involved and you already know that the variety is simplicial and complete, then we recommend to trigger the computation of the cohomology ring with check = false. This will avoid this time consuming test.

An example is in order.

Examples

julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 4))
Hypersurface model over a concrete base

julia> cohomology_ring(ambient_space(qsm_model), check = false);

julia> g4_class = cohomology_class(anticanonical_divisor_class(ambient_space(qsm_model)))^2;

julia> g4f = g4_flux(qsm_model, g4_class)
G4-flux candidate
  - Elementary quantization checks: satisfied
  - Verticality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole cancellation check: not executed

julia> g4f2 = g4_flux(qsm_model, g4_class, check = false)
G4-flux candidate
  - Elementary quantization checks: not executed
  - Verticality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole cancellation check: not executed
Experimental

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

source

Attributes

We currently support the following attributes:

modelMethod
model(gf::G4Flux)

Return the F-theory model for which this $G_4$-flux candidate is defined.

julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 4))
Hypersurface model over a concrete base

julia> cohomology_ring(ambient_space(qsm_model), check = false);

julia> g4_class = cohomology_class(anticanonical_divisor_class(ambient_space(qsm_model)))^2;

julia> g4f = g4_flux(qsm_model, g4_class, check = false)
G4-flux candidate
  - Elementary quantization checks: not executed
  - Verticality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed  
  - Tadpole cancellation check: not executed

julia> model(g4f)
Hypersurface model over a concrete base
Experimental

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

source
cohomology_classMethod
cohomology_class(gf::G4Flux)

Return the cohomology class which defines the $G_4$-flux candidate.

julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 4))
Hypersurface model over a concrete base

julia> cohomology_ring(ambient_space(qsm_model), check = false);

julia> g4_class = cohomology_class(anticanonical_divisor_class(ambient_space(qsm_model)))^2;

julia> g4f = g4_flux(qsm_model, g4_class, check = false)
G4-flux candidate
  - Elementary quantization checks: not executed
  - Verticality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole cancellation check: not executed

julia> cohomology_class(g4f) == g4_class
true
Experimental

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

source
d3_tadpole_constraintMethod
d3_tadpole_constraint(gf::G4Flux; check::Bool = true)

Return the d3-tapdole constraint of a G4-flux, that is compute the quantity $- \frac{1}{2} \cdot G_4^2 + \frac{1}{24} \cdot \chi(\widehat{Y}_4) \stackrel{!}{\geq} 0$.

julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 4))
Hypersurface model over a concrete base

julia> divs = torusinvariant_prime_divisors(ambient_space(qsm_model));

julia> e1 = cohomology_class(divs[35]);e2 = cohomology_class(divs[32]);e4 = cohomology_class(divs[34]);

julia> u = cohomology_class(divs[33]);v = cohomology_class(divs[30]);pb_Kbar = cohomology_class(sum([divs[k] for k in 1:29]));

julia> g4_class = (-3) // kbar3(qsm_model) * (5 * e1 * e4 + pb_Kbar * (-3 * e1 - 2 * e2 - 6 * e4 + pb_Kbar - 4 * u + v));

julia> g4 = g4_flux(qsm_model, g4_class, check = false)
G4-flux candidate
  - Elementary quantization checks: not executed
  - Verticality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole cancellation check: not executed

julia> d3_tadpole_constraint(g4, check = false)
12

julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 2021))
Hypersurface model over a concrete base

julia> gfs = special_flux_family(qsm_model, check = false)
A family of G4 fluxes:
  - Elementary quantization checks: satisfied
  - Verticality checks: failed
  - Non-abelian gauge group: broken
  - Tadpole constraint: not analyzed

julia> g4_2 = random_flux_instance(gfs, check = false)
G4-flux candidate
  - Elementary quantization checks: satisfied
  - Verticality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole cancellation check: not executed

julia> dv2 = d3_tadpole_constraint(g4_2, check = false);

julia> int_comb = integral_coefficients(g4_2);

julia> rat_comb = rational_coefficients(g4_2);

julia> g4_3 = flux_instance(gfs, int_comb, rat_comb, check = false)
G4-flux candidate
  - Elementary quantization checks: satisfied
  - Verticality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole cancellation check: not executed

julia> d3_tadpole_constraint(gfs, check = false);

julia> dv3 = d3_tadpole_constraint(g4_3, check = false);

julia> dv2 == dv3
true
Experimental

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

source
g4_flux_familyMethod
g4_flux_family(gf::G4Flux; check::Bool = true)

Return the family of $G_4$-fluxes that possesses, such that all fluxes in this family share the following properties with the given $G_4$-flux: Verticality and breaking of the non-Abelian gauge group.

julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 2021))
Hypersurface model over a concrete base

julia> gfs = special_flux_family(qsm_model, check = false)
A family of G4 fluxes:
  - Elementary quantization checks: satisfied
  - Verticality checks: failed
  - Non-abelian gauge group: broken
  - Tadpole constraint: not analyzed

julia> g4 = random_flux_instance(gfs, check = false)
G4-flux candidate
  - Elementary quantization checks: satisfied
  - Verticality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole cancellation check: not executed

julia> g4_flux_family(g4, check = false)
A family of G4 fluxes:
  - Elementary quantization checks: satisfied
  - Verticality checks: failed
  - Non-abelian gauge group: broken
  - Tadpole constraint: not analyzed
Experimental

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

source

Note that such a family of $G_4$-fluxes expresses its elements as linear combinations of the basis elements. Crucially, some of the coefficients must only be integers, whilst the remaining coefficients can be any rational number. With the following methods one can extract those coefficients for a given $G_4$-flux.

integral_coefficientsMethod
integral_coefficients(gf::G4Flux)

Return the integral coefficients of a given $G_4$-flux. If these coefficients are not known, an error is raised.

julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 2021))
Hypersurface model over a concrete base

julia> gfs = special_flux_family(qsm_model, check = false)
A family of G4 fluxes:
  - Elementary quantization checks: satisfied
  - Verticality checks: failed
  - Non-abelian gauge group: broken
  - Tadpole constraint: not analyzed

julia> g4 = random_flux_instance(gfs, check = false)
G4-flux candidate
  - Elementary quantization checks: satisfied
  - Verticality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole cancellation check: not executed

julia> integral_coefficients(g4);
Experimental

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

source
rational_coefficientsMethod
rational_coefficients(gf::G4Flux)

Return the integral coefficients of a given $G_4$-flux. If these coefficients are not known, an error is raised.

julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 2021))
Hypersurface model over a concrete base

julia> gfs = special_flux_family(qsm_model, check = false)
A family of G4 fluxes:
  - Elementary quantization checks: satisfied
  - Verticality checks: failed
  - Non-abelian gauge group: broken
  - Tadpole constraint: not analyzed

julia> g4 = random_flux_instance(gfs, check = false)
G4-flux candidate
  - Elementary quantization checks: satisfied
  - Verticality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole cancellation check: not executed

julia> rational_coefficients(g4);
Experimental

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

source

Methods

You can create instances of families of G4-fluxes, i.e. a flux that is contained in said family. For this, we support the following:

flux_instanceMethod
flux_instance(fgs::FamilyOfG4Fluxes, int_combination::ZZMatrix, rat_combination::QQMatrix; check::Bool = true)

Create an element of a family of G4-fluxes.

Examples

julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 2021))
Hypersurface model over a concrete base

julia> mat_int = zero_matrix(QQ, 37, 1);

julia> mat_int[1,1] = 1;

julia> mat_rat = zero_matrix(QQ, 37, 1);

julia> mat_rat[2,1] = 1;

julia> fgs = family_of_g4_fluxes(qsm_model, mat_int, mat_rat, check = false)
A family of G4 fluxes:
  - Elementary quantization checks: not executed
  - Verticality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole constraint: not analyzed

julia> int_combination = matrix(ZZ, [[3]])
[3]

julia> rat_combination = matrix(QQ, [[5//2]])
[5//2]

julia> flux_instance(fgs, int_combination, rat_combination, check = false)
G4-flux candidate
  - Elementary quantization checks: not executed
  - Verticality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole cancellation check: not executed
Experimental

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

source
random_flux_instanceMethod
random_flux_instance(fgs::FamilyOfG4Fluxes; check::Bool = true)

Create a random element of a family of G4-fluxes.

Examples

julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 2021))
Hypersurface model over a concrete base

julia> mat_int = zero_matrix(QQ, 37, 1);

julia> mat_int[1,1] = 1;

julia> mat_rat = zero_matrix(QQ, 37, 1);

julia> mat_rat[2,1] = 1;

julia> fgs = family_of_g4_fluxes(qsm_model, mat_int, mat_rat, check = false)
A family of G4 fluxes:
  - Elementary quantization checks: not executed
  - Verticality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole constraint: not analyzed

julia> random_flux_instance(fgs, check = false)
G4-flux candidate
  - Elementary quantization checks: not executed
  - Verticality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole cancellation check: not executed
Experimental

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

source

For convenience, we also support the following method to create a random $G_4$-flux with prescribed properties on a given F-theory model:

random_fluxMethod
random_flux(m::AbstractFTheoryModel; vert::Bool = false, not_breaking::Bool = false, check::Bool = true)

Create a random $G_4$-flux on a given F-theory model.

Examples

julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 2021))
Hypersurface model over a concrete base

julia> rf = random_flux(qsm_model, vert = true, check = false)
G4-flux candidate
  - Elementary quantization checks: satisfied
  - Verticality checks: satisfied
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole cancellation check: not executed
Experimental

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

source

Properties

We currently support the following properties:

is_well_quantizedMethod
is_well_quantized(gf::G4Flux)

G4-fluxes are subject to the quantization condition [Wit97] $G_4 + \frac{1}{2} c_2(Y) \in H^{(2,2)}(Y, \mathbb{Z})$. It is hard to verify that this condition is met. However, we can execute a number of simple consistency checks, by verifying that $\int_{Y}{G_4 \wedge [D_1] \wedge [D_2]} \in \mathbb{Z}$ for any two toric divisors $D_1$, $D_2$. If all of these simple consistency checks are met, this method will return true and otherwise false.

It is worth mentioning that currently (August 2024), we only support this check for $G_4$-fluxes defined on Weierstrass, global Tate and hypersurface models. If this condition is not met, this method will return an error.

julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 4))
Hypersurface model over a concrete base

julia> cohomology_ring(ambient_space(qsm_model), check = false);

julia> g4_class = cohomology_class(anticanonical_divisor_class(ambient_space(qsm_model)))^2;

julia> g4 = g4_flux(qsm_model, g4_class, check = false)
G4-flux candidate
  - Elementary quantization checks: not executed
  - Verticality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole cancellation check: not executed

julia> is_well_quantized(g4)
true

julia> g4
G4-flux candidate
  - Elementary quantization checks: satisfied
  - Verticality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole cancellation check: not executed
Experimental

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

source
is_verticalMethod
is_vertical(gf::G4Flux)

G4-fluxes are subject to verticality conditions described first in [GH12] and in more detail in [Wei18]. It is hard to verify that these condition are met. However, we can execute a number of simple consistency checks, by verifying that $\int_{Y}{G_4 \wedge [D_1] \wedge [zero section]} = 0$ and $\int_{Y}{G_4 \wedge [D_1] \wedge [D_2]} = 0$ for all toric base divisors $D_1$ and $D_2$. If all of these simple consistency checks are met, this method will return true and otherwise false

julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 4))
Hypersurface model over a concrete base

julia> divs = torusinvariant_prime_divisors(ambient_space(qsm_model));

julia> e1 = cohomology_class(divs[35]);e2 = cohomology_class(divs[32]);e4 = cohomology_class(divs[34]);

julia> u = cohomology_class(divs[33]);v = cohomology_class(divs[30]);pb_Kbar = cohomology_class(sum([divs[k] for k in 1:29]));

julia> g4_class = (-3) // kbar3(qsm_model) * (5 * e1 * e4 + pb_Kbar * (-3 * e1 - 2 * e2 - 6 * e4 + pb_Kbar - 4 * u + v));

julia> g4 = g4_flux(qsm_model, g4_class, check = false)
G4-flux candidate
  - Elementary quantization checks: not executed
  - Verticality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole cancellation check: not executed

julia> is_vertical(g4)
true

julia> g4
G4-flux candidate
  - Elementary quantization checks: not executed
  - Verticality checks: satisfied
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole cancellation check: not executed
Experimental

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

source
passes_tadpole_cancellation_checkMethod
passes_tadpole_cancellation_check(gf::G4Flux)

G4-fluxes are subject to the D3-tadpole cancellation condition described in [Wei18]. This check verifies that $euler_characteristic(Y)/24 - 1/2 * \int_{Y}{G_4 \wedge G_4}$ is a non-negative integer.

julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 4))
Hypersurface model over a concrete base

julia> divs = torusinvariant_prime_divisors(ambient_space(qsm_model));

julia> e1 = cohomology_class(divs[35]);e2 = cohomology_class(divs[32]);e4 = cohomology_class(divs[34]);

julia> u = cohomology_class(divs[33]);v = cohomology_class(divs[30]);pb_Kbar = cohomology_class(sum([divs[k] for k in 1:29]));

julia> g4_class = (-3) // kbar3(qsm_model) * (5 * e1 * e4 + pb_Kbar * (-3 * e1 - 2 * e2 - 6 * e4 + pb_Kbar - 4 * u + v));

julia> g4 = g4_flux(qsm_model, g4_class, check = false)
G4-flux candidate
  - Elementary quantization checks: not executed
  - Verticality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole cancellation check: not executed

julia> passes_tadpole_cancellation_check(g4)
true

julia> g4
G4-flux candidate
  - Elementary quantization checks: not executed
  - Verticality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole cancellation check: satisfied
Experimental

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

source
breaks_non_abelian_gauge_groupMethod
breaks_non_abelian_gauge_group(gf::G4Flux)

G4-fluxes may break the non-abelian gauge group (cf. [Wei18]). This function verifies if this is the case for the given G4-flux. If it does not break any non-abelian gauge factor, we return true and otherwise false

julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 4))
Hypersurface model over a concrete base

julia> divs = torusinvariant_prime_divisors(ambient_space(qsm_model));

julia> e1 = cohomology_class(divs[35]);e2 = cohomology_class(divs[32]);e4 = cohomology_class(divs[34]);

julia> u = cohomology_class(divs[33]);v = cohomology_class(divs[30]);pb_Kbar = cohomology_class(sum([divs[k] for k in 1:29]));

julia> g4_class = (-3) // kbar3(qsm_model) * (5 * e1 * e4 + pb_Kbar * (-3 * e1 - 2 * e2 - 6 * e4 + pb_Kbar - 4 * u + v));

julia> g4 = g4_flux(qsm_model, g4_class, check = false)
G4-flux candidate
  - Elementary quantization checks: not executed
  - Verticality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole cancellation check: not executed

julia> breaks_non_abelian_gauge_group(g4)
false

julia> g4
G4-flux candidate
  - Elementary quantization checks: not executed
  - Verticality checks: not executed
  - Non-abelian gauge group: not broken
  - Tadpole cancellation check: not executed
Experimental

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

source

Ambient Space Models for G4-Fluxes

Focus on 4-dimensional F-theory models $m$, such that the resolution $\widehat{Y}_4$ of the defining singular elliptically fibered CY 4-fold $\Y_4 \twoheadrightarrow B_3$ is defined as hypersurface in a complete and simplicial toric variety $X_\Sigma$. In such a setup, it is convenient to focus on $G_4$-fluxes modelled from the restriction of elements of $H^{(2,2)}( X_\Sigma, \mathbb{Q})$ to $\widehat{Y}_4$. This method identifies a basis of $H^{(2,2)}( X_\Sigma, \mathbb{Q})$ and filters out elements, whose restricton to $\widehat{Y}_4$ is obviously trivial.

It is important to elaborate a bit more on the meaning of "obviously". To this end, fix a basis element of $H^{(2,2)}( X_\Sigma, \mathbb{Q})$. Let us denote a corresponding algebraic cycle by $A = \mathbb{V}(x_i, x_j) \subset X_\Sigma$, where $x_i$, $x_j$ are suitable homogeneous coordinates. Furthermore, let $\widehat{Y}_4 = \mathbb{V}( p ) \subset X_\Sigma$. Then of course, we can look at the set-theoretic intersection $\mathbb{V}( p, x_i, x_j)$. Provided that $p(x_i = 0, x_j = 0)$ is a non-zero constant, this set-theoretic intersection is trivial. This is exactly the check conducted by the method chosen_g4_flux_basis below. However, for reasons of simplicity, this approach is avoid a number of sutleties.

Namely, we really have to work out the intersection in the Chow ring, that is we should consider the rational equivalence class of the algebraic cycle $A$ and intersect this class with the rational equivalence class of the algebraic cycle $\mathbb{V}( p )$. In particular, for "unlucky" choices of $i, j$, the algebraic cycles $\mathbb{V}( p )$ and $\mathbb{V}(x_i, x_j)$ may not intersect transversely. This is for instance the case if $i = j$. Such phenomena are addressed in theory by "moving the algebraic cycles into general position", but in practice this somewhat tricky. Instances include the following:

  1. \[i = j\]

    : Then apparently, a self-intersection of $\mathbb{V}(x_i)$ is involved.
  2. \[p(x_i, x_j) \equiv 0\]

    : This is unexpected for dimensional reasons, and indicates a

non-transverse intersection.

In both instances, one makes use of the linear relations of $X_\Sigma$ to replace the cycle $\mathbb{V}(x_i)$ (and/or $\mathbb{V}(x_j)$) with a rational combination of algebraic cycles $R = \sum_{k = 1}^{N}{c_k \cdot A_k}$, such that $R$ is rationally equivalent to $\mathbb{V}(x_i)$. From experience, it is then rather common that $R$ and $\mathbb{V}(x_i)$ intersect transversely. And if not, then modify the non-transverse intersections by using the linear relations again to replace an involved algebraic cycle.

chosen_g4_flux_basisMethod
chosen_g4_flux_basis(m::AbstractFTheoryModel; check::Bool = true)::Vector{CohomologyClass}

Given an F-theory model m defined as a hypersurface in a simplicial and complete toric base, this method computes a basis of $H^{2,2}(X, \mathbb{Q})$ (using the method basis_of_h22) and then filters out certain basis elements whose restriction to the hypersurface in question is trivial. The criteria for "certain" elements are explained in the documentation above this method.

Note: Checking whether a toric variety $X$ is complete and simplicial can be computationally expensive. The optional argument check can be set to false to skip these tests.

Examples

julia> B3 = projective_space(NormalToricVariety, 3)
Normal toric variety

julia> Kbar = anticanonical_divisor_class(B3)
Divisor class on a normal toric variety

julia> t = literature_model(arxiv_id = "1109.3454", equation = "3.1", base_space = B3, defining_classes = Dict("w"=>Kbar))
Construction over concrete base may lead to singularity enhancement. Consider computing singular_loci. However, this may take time!

Global Tate model over a concrete base -- SU(5)xU(1) restricted Tate model based on arXiv paper 1109.3454 Eq. (3.1)

julia> g4_basis = chosen_g4_flux_basis(t);

julia> length(g4_basis)
2

julia> g4_basis[1]
G4-flux candidate
  - Elementary quantization checks: not executed
  - Verticality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole cancellation check: not executed

julia> cohomology_class(g4_basis[1])
Cohomology class on a normal toric variety given by z^2

julia> cohomology_class(g4_basis[2])
Cohomology class on a normal toric variety given by y^2

julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 8))
Hypersurface model over a concrete base

julia> g4_basis = chosen_g4_flux_basis(qsm_model, check = false);

julia> cohomology_class(g4_basis[1])
Cohomology class on a normal toric variety given by x15*e2

julia> length(g4_basis) == 172
true
Experimental

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

source
basis_of_h22Method
basis_of_h22(v::NormalToricVariety; check::Bool = true)::Vector{CohomologyClass}

By virtue of Theorem 12.4.1 in [CLS11], one can compute a monomial basis of $H^4(X, \mathbb{Q})$ for a simplicial, complete toric variety $X$ by truncating its cohomology ring to degree $2$. Inspired by this, this method identifies a basis of $H^{(2,2)}(X, \mathbb{Q})$ by multiplying pairs of cohomology classes associated with toric coordinates.

By definition, $H^{(2,2)}(X, \mathbb{Q})$ is a subset of $H^{4}(X, \mathbb{Q})$. However, by Theorem 9.3.2 in [CLS11], for complete and simplicial toric varieties and $p \neq q$ it holds $H^{(p,q)}(X, \mathbb{Q}) = 0$. It follows that for such varieties $H^{(2,2)}(X, \mathbb{Q}) = H^4(X, \mathbb{Q})$ and the vector space dimension of those spaces agrees with the Betti number $b_4(X)$.

Note that it can be computationally very demanding to check if a toric variety $X$ is complete (and simplicial). The optional argument check can be set to false to skip these tests.

Examples

julia> Y1 = hirzebruch_surface(NormalToricVariety, 2)
Normal toric variety

julia> Y2 = hirzebruch_surface(NormalToricVariety, 2)
Normal toric variety

julia> Y = Y1 * Y2
Normal toric variety

julia> h22_basis = basis_of_h22(Y, check = false)
6-element Vector{CohomologyClass}:
 Cohomology class on a normal toric variety given by xx2*yx2
 Cohomology class on a normal toric variety given by xt2*yt2
 Cohomology class on a normal toric variety given by xx2*yt2
 Cohomology class on a normal toric variety given by xt2*yx2
 Cohomology class on a normal toric variety given by yx2^2
 Cohomology class on a normal toric variety given by xx2^2

julia> betti_number(Y, 4) == length(h22_basis)
true
Experimental

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

source

Families of G4-Fluxes

Constructor

Physics often is interested in families of G4-fluxes, that are expressed in terms of integral or rational combinations of the ambient space models of G4-fluxes, that we described above. For such families, we currently support the following constructor:

family_of_g4_fluxesMethod
family_of_g4_fluxes(m::AbstractFTheoryModel, mat_int::QQMatrix, mat_rat::QQMatrix; check::Bool = true)

Given an F-theory model with a toric ambient space, we can identify ambient space candidates of G4-fluxes. In terms of these candidates, we can define a family of G4-fluxes as:

  • \[\mathbb{Z}\]

    -linear combinations, provided by a matrix $mat_int$,
  • \[\mathbb{Q}\]

    -linear combinations, provided by a matrix $mat_rat$.

An example is in order.

Examples

julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 2021))
Hypersurface model over a concrete base

julia> mat_int = zero_matrix(QQ, 37, 1);

julia> mat_int[1,1] = 1;

julia> mat_rat = zero_matrix(QQ, 37, 1);

julia> mat_rat[2,1] = 1;

julia> family_of_g4_fluxes(qsm_model, mat_int, mat_rat, check = false)
A family of G4 fluxes:
  - Elementary quantization checks: not executed
  - Verticality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole constraint: not analyzed
Experimental

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

source

Attributes

Families of G4-fluxes currently support the following attributes:

modelMethod
model(gf::FamilyOfG4Fluxes)

Return the F-theory model for which this family of $G_4$-flux candidates is defined.

julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 2021))
Hypersurface model over a concrete base

julia> mat_int = zero_matrix(QQ, 37, 1);

julia> mat_int[1,1] = 1;

julia> mat_rat = zero_matrix(QQ, 37, 1);

julia> mat_rat[2,1] = 1;

julia> f_gs = family_of_g4_fluxes(qsm_model, mat_int, mat_rat, check = false)
A family of G4 fluxes:
  - Elementary quantization checks: not executed
  - Verticality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole constraint: not analyzed

julia> model(f_gs) == qsm_model
true
Experimental

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

source
matrix_integralMethod
matrix_integral(gf::FamilyOfG4Fluxes)

Return the matrix whose columns specify those combinations of ambient space G4-flux candidates, of which integral linear combinations are contained in this family of G4-fluxes.

julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 2021))
Hypersurface model over a concrete base

julia> mat_int = zero_matrix(QQ, 37, 1);

julia> mat_int[1,1] = 1;

julia> mat_rat = zero_matrix(QQ, 37, 1);

julia> mat_rat[2,1] = 1;

julia> f_gs = family_of_g4_fluxes(qsm_model, mat_int, mat_rat, check = false)
A family of G4 fluxes:
  - Elementary quantization checks: not executed
  - Verticality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole constraint: not analyzed

julia> matrix_integral(f_gs) == mat_int
true
Experimental

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

source
matrix_rationalMethod
matrix_rational(gf::FamilyOfG4Fluxes)

Return the matrix whose columns specify those combinations of ambient space G4-flux candidates, of which rational linear combinations are contained in this family of G4-fluxes.

julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 2021))
Hypersurface model over a concrete base

julia> mat_int = zero_matrix(QQ, 37, 1);

julia> mat_int[1,1] = 1;

julia> mat_rat = zero_matrix(QQ, 37, 1);

julia> mat_rat[2,1] = 1;

julia> f_gs = family_of_g4_fluxes(qsm_model, mat_int, mat_rat, check = false)
A family of G4 fluxes:
  - Elementary quantization checks: not executed
  - Verticality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole constraint: not analyzed

julia> matrix_rational(f_gs) == mat_rat
true
Experimental

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

source
d3_tadpole_constraintMethod
d3_tadpole_constraint(fgs::FamilyOfG4Fluxes; check::Bool = true)

Return the d3-tapdole constraint of a family of G4-fluxes. Recall that for a given $G_4$-flux, this constraint is $- \frac{1}{2} \cdot G_4^2 + \frac{1}{24} \cdot \chi(\widehat{Y}_4) \stackrel{!}{\geq} 0$.

Note that the family of fluxes is specified by linear combination of cohomology classes, some with rational and some with integral coefficients. In terms of these coefficients the d3-tadpole constraint is the demand that a quadratic polynomial in the coefficients evaluates to a non-negative number. This method returns said polynomial in the cofficients. In order to evaluate the D3-tadpole for a particular $G_4$-flux, one has to evaluate this polynomial for the numeric coefficient values that correspond to the given $G_4$-flux.

We use symbols $a_i$ to indicate integral coefficients and $r_i$ to indicate rational coefficients.

julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 2021))
Hypersurface model over a concrete base

julia> fgs = special_flux_family(qsm_model, check = false)
A family of G4 fluxes:
  - Elementary quantization checks: satisfied
  - Verticality checks: failed
  - Non-abelian gauge group: broken
  - Tadpole constraint: not analyzed

julia> d3_tadpole_constraint(fgs);

julia> fgs
A family of G4 fluxes:
  - Elementary quantization checks: satisfied
  - Verticality checks: failed
  - Non-abelian gauge group: broken
  - Tadpole constraint: evaluated
Experimental

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

source

Properties

Families of G4-fluxes currently support the following properties:

is_well_quantizedMethod
is_well_quantized(fgs::FamilyOfG4Fluxes; check::Bool = true)

Executes elementary tests (they are necessary but not sufficient) to tell if a family of $G_4$-fluxes is well-quantized. In case any of these tests fails, we know that this family of $G_4$-fluxes is definitely not well-quantized. This method then returns false.

In the opposite case that all elementary tests pass, this method returns true. Note however that this does not imply that the family is well-quantized. At least, according to the current theoretical understanding it does not. Rather, this means that to the best of our current means, this family of fluxes appears to be well-quantized.

julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 2021))
Hypersurface model over a concrete base

julia> gf = special_flux_family(qsm_model, check = false)
A family of G4 fluxes:
  - Elementary quantization checks: satisfied
  - Verticality checks: failed
  - Non-abelian gauge group: broken
  - Tadpole constraint: not analyzed

julia> is_well_quantized(gf)
true

julia> m1 = matrix_integral(gf);

julia> m2 = matrix_rational(gf);

julia> gf2 = family_of_g4_fluxes(qsm_model, m1, m2, check = false)
A family of G4 fluxes:
  - Elementary quantization checks: not executed
  - Verticality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole constraint: not analyzed

julia> is_well_quantized(gf2, check = false)
true
Experimental

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

source
is_verticalMethod
is_vertical(fgs::FamilyOfG4Fluxes; check::Bool = true)

Checks if the given family of $G_4$-fluxes is vertical. If so, this method returns true and otherwise false.

julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 2021))
Hypersurface model over a concrete base

julia> gf = special_flux_family(qsm_model, check = false)
A family of G4 fluxes:
  - Elementary quantization checks: satisfied
  - Verticality checks: failed
  - Non-abelian gauge group: broken
  - Tadpole constraint: not analyzed

julia> is_vertical(gf, check = false)
false

julia> gf2 = special_flux_family(qsm_model, vert = true, check = false)
A family of G4 fluxes:
  - Elementary quantization checks: satisfied
  - Verticality checks: satisfied
  - Non-abelian gauge group: broken
  - Tadpole constraint: not analyzed

julia> is_vertical(gf2, check = false)
true

julia> m1 = matrix_integral(gf2);

julia> m2 = matrix_rational(gf2);

julia> gf3 = family_of_g4_fluxes(qsm_model, m1, m2, check = false)
A family of G4 fluxes:
  - Elementary quantization checks: not executed
  - Verticality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole constraint: not analyzed

julia> is_vertical(gf3)
true
Experimental

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

source
breaks_non_abelian_gauge_groupMethod
breaks_non_abelian_gauge_group(fgs::FamilyOfG4Fluxes; check::Bool = true)

Checks if a family of G4-fluxes breaks the non-abelian gauge group. If so, this method returns true and otherwise false.

julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 2021))
Hypersurface model over a concrete base

julia> gf = special_flux_family(qsm_model, check = false)
A family of G4 fluxes:
  - Elementary quantization checks: satisfied
  - Verticality checks: failed
  - Non-abelian gauge group: broken
  - Tadpole constraint: not analyzed

julia> breaks_non_abelian_gauge_group(gf)
true

julia> gf2 = special_flux_family(qsm_model, vert = true, check = false)
A family of G4 fluxes:
  - Elementary quantization checks: satisfied
  - Verticality checks: satisfied
  - Non-abelian gauge group: broken
  - Tadpole constraint: not analyzed

julia> breaks_non_abelian_gauge_group(gf2)
true

julia> gf3 = special_flux_family(qsm_model, vert = true, not_breaking = true, check = false)
A family of G4 fluxes:
  - Elementary quantization checks: satisfied
  - Verticality checks: satisfied
  - Non-abelian gauge group: not broken
  - Tadpole constraint: not analyzed

julia> breaks_non_abelian_gauge_group(gf3)
false

julia> m1 = matrix_integral(gf3);

julia> m2 = matrix_rational(gf3);

julia> gf4 = family_of_g4_fluxes(qsm_model, m1, m2, check = false)
A family of G4 fluxes:
  - Elementary quantization checks: not executed
  - Verticality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole constraint: not analyzed

julia> breaks_non_abelian_gauge_group(gf4, check = false)
false
Experimental

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

source

Special Families of G4-Fluxes

Among the $G_4$-flux candidates, the physics is interested in the well-quantized fluxes. That is, those cohomology classes which integrate to an integer against any other 2-cycle in the elliptic 4-fold $\widehat{Y}_4$. Even in theory, this is a hard task. In practice, one therefore focuses on consistency checks. In the case at hand, we can integrate any ambient space $G_4$-flux candidate against a pair of (algebraic cycles associated to) toric divisors. If for any two toric divisors, the result is an integer, then this $G_4$-flux candidate passes a rather non-trivial and necessary test.

Similarly, we have a method for all vertical and well-quantized ambient space $G_4$-flux candidates, as well as those vertical and well-quantized ambient space $G_4$-flux candidates, which do not break the non-abelian gauge group.

For these families, we support the following constructor. Please note that this method may take a long time to execute for involved geometries $\widehat{Y}_4$.

special_flux_familyMethod
special_flux_family(m::AbstractFTheoryModel; vert::Bool = false, not_breaking::Bool = false, check::Bool = true)

Computes a family of G4-fluxes with specified properties for a given F-theory model m, defined as a hypersurface in a simplicial and complete toric ambient space.

Description

This method models the G4-flux family using the restriction of cohomology classes on the toric ambient space to the hypersurface. In the toric ambient space, these classes are vertical, meaning they are of the form $a \wedge b$, where $a, b \in H^(1,1)(X_\Sigma)$, with $X_\Sigma$ denoting the toric ambient space. However, this does not imply that the classes remain vertical on the hypersurface, which defines the actual F-theory geometry.

The resulting family is subjected to consistency conditions to ensure it satisfies elementary quantization requirements. By default, the method returns ambient space G4-flux candidates that meet these conditions, unless explicitly specified otherwise.

Optional Arguments

  • vert = true: Refines the family to include only fluxes that are vertical on the hypersurface.
  • not_breaking = true: Ensures the flux family preserves the non-abelian gauge group.
  • check = false: Skips computational checks for whether the toric ambient space $X_\Sigma$ is complete and simplicial, which can be resource-intensive.

Notes

Warning

This method assumes that $c_2( \widehat{Y}_4)$ is even. No checks or errors are implemented for this condition, so use cautiously.

This assumption relates to the quantization condition, which requires verifying if the twist of a given $G_4$-flux by $1/2 \cdot c_2( \widehat{Y}_4)$ is even. For many F-theory models, such as compactifications on smooth Calabi-Yau 4-folds with globally defined Weierstrass models ([CS12]), $c_2( \widehat{Y}_4)$ is known to be even. This also applies to all F-theory QSMs ([CHLLT19]).

Computational Details

The method internally identifies two matrices related to the family of fluxes:

  1. matrix_integral: Specifies rational combinations of ambient space G4-flux candidates that can only form $\mathbb{Z}$-linear combinations without violating elementary flux quantization conditions.
  2. matrix_rational: Specifies rational combinations of flux candidates for which any rational linear combination satisfies the elementary flux quantization conditions.

These matrices are accessible for further analysis.

Examples

julia> B3 = projective_space(NormalToricVariety, 3)
Normal toric variety

julia> Kbar = anticanonical_divisor_class(B3)
Divisor class on a normal toric variety

julia> t = literature_model(arxiv_id = "1109.3454", equation = "3.1", base_space = B3, defining_classes = Dict("w"=>Kbar))
Construction over concrete base may lead to singularity enhancement. Consider computing singular_loci. However, this may take time!

Global Tate model over a concrete base -- SU(5)xU(1) restricted Tate model based on arXiv paper 1109.3454 Eq. (3.1)

julia> fg1 = special_flux_family(t, check = false)
A family of G4 fluxes:
  - Elementary quantization checks: satisfied
  - Verticality checks: failed
  - Non-abelian gauge group: broken
  - Tadpole constraint: not analyzed

julia> matrix_integral(fg1)
[1//4   -3//16]
[   0   1//144]

julia> matrix_rational(fg1)
2 by 0 empty matrix

julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 2021))
Hypersurface model over a concrete base

julia> length(chosen_g4_flux_basis(qsm_model, check = false))
37

julia> fg2 = special_flux_family(qsm_model, check = false)
A family of G4 fluxes:
  - Elementary quantization checks: satisfied
  - Verticality checks: failed
  - Non-abelian gauge group: broken
  - Tadpole constraint: not analyzed

julia> g4 = random_flux_instance(fg2, check = false)
G4-flux candidate
  - Elementary quantization checks: satisfied
  - Verticality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole cancellation check: not executed

julia> is_well_quantized(g4)
true

Next, let us focus on vertical and well-quantized fluxes.

julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 2021))
Hypersurface model over a concrete base

julia> fg = special_flux_family(qsm_model, vert = true, check = false)
A family of G4 fluxes:
  - Elementary quantization checks: satisfied
  - Verticality checks: satisfied
  - Non-abelian gauge group: broken
  - Tadpole constraint: not analyzed

julia> g4_tester = random_flux_instance(fg, check = false)
G4-flux candidate
  - Elementary quantization checks: satisfied
  - Verticality checks: satisfied
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole cancellation check: not executed

julia> g4_tester_double = g4_flux(qsm_model, cohomology_class(g4_tester), check = false);

julia> is_well_quantized(g4_tester_double)
true

julia> is_vertical(g4_tester_double)
true

julia> c = [60, 51, 90, 0, 24, 51, -24, 45, 30, 0, -48, 90, -57, 60, 30, 15, 120, 0, -60, 0, -720, -420, -270, -60, -2190];

julia> qsm_g4_flux = flux_instance(fg, transpose(matrix(ZZ, [c])), zero_matrix(QQ, 0, 1), check = false)
G4-flux candidate
  - Elementary quantization checks: satisfied
  - Verticality checks: satisfied
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole cancellation check: not executed

julia> is_vertical(qsm_g4_flux)
true

julia> is_well_quantized(qsm_g4_flux)
true

Finally, we demonstrate the computation of the well-quantized, vertical $G_4$-fluxes, which do not break the non-abelian gauge group.

julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 2021))
Hypersurface model over a concrete base

julia> fg = special_flux_family(qsm_model, vert = true, not_breaking = true, check = false)
A family of G4 fluxes:
  - Elementary quantization checks: satisfied
  - Verticality checks: satisfied
  - Non-abelian gauge group: not broken
  - Tadpole constraint: not analyzed

julia> g4_tester = random_flux_instance(fg, check = false)
G4-flux candidate
  - Elementary quantization checks: satisfied
  - Verticality checks: satisfied
  - Non-abelian gauge group: not broken
  - Tadpole cancellation check: not executed

julia> g4_tester_double = g4_flux(qsm_model, cohomology_class(g4_tester), check = false);

julia> is_well_quantized(g4_tester_double)
true

julia> is_vertical(g4_tester_double)
true

julia> breaks_non_abelian_gauge_group(g4_tester_double)
false

julia> c = [3];

julia> qsm_g4_flux = flux_instance(fg, matrix(ZZ, [[3]]), zero_matrix(QQ, 0, 1), check = false)
G4-flux candidate
  - Elementary quantization checks: satisfied
  - Verticality checks: satisfied
  - Non-abelian gauge group: not broken
  - Tadpole cancellation check: not executed

julia> is_well_quantized(qsm_g4_flux)
true

julia> is_vertical(qsm_g4_flux)
true

julia> breaks_non_abelian_gauge_group(qsm_g4_flux)
false

julia> divs = torusinvariant_prime_divisors(ambient_space(qsm_model));

julia> e1 = cohomology_class(divs[15]);

julia> e2 = cohomology_class(divs[12]);

julia> e4 = cohomology_class(divs[14]);

julia> u = cohomology_class(divs[13]);

julia> v = cohomology_class(divs[10]);

julia> pb_Kbar = cohomology_class(sum([divs[k] for k in 1:9]));

julia> g4_class = (-3) // kbar3(qsm_model) * (5 * e1 * e4 + pb_Kbar * (-3 * e1 - 2 * e2 - 6 * e4 + pb_Kbar - 4 * u + v));

julia> qsm_g4_flux == g4_flux(qsm_model, g4_class)
true
Experimental

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

source