$G_4$-Fluxes

In F-theory compactifications on Calabi–Yau 4-folds, $G_4$-fluxes are essential ingredients for defining consistent and physically meaningful vacua. They affect various physical aspects, such as the chiral spectrum in the 4D effective theory, tadpole cancellation, and moduli stabilization. This page provides an accessible introduction to working with $G_4$-fluxes in FTheoryTools, including background, construction methods, and available functionality.


Background: What Is a $G_4$-Flux?

Let $\widehat{Y}_4$ be a smooth Calabi–Yau 4-fold obtained via crepant resolution of a singular elliptically fibered 4-fold $Y_4 \to B_3$. A $G_4$-flux is a cohomology class:

\[G_4 \in H^{2, 2}(\widehat{Y}_4, \mathbb{R}) \equiv H^{2, 2}(\widehat{Y}_4, \mathbb{C}) \cap H^4(\widehat{Y}_4, \mathbb{R})\]

subject to quantization, transversality, and several additional consistency conditions:

  1. Quantization (cf. Witten 1997): $G_4 + \frac{1}{2} c_2(\widehat{Y}_4) \in H^4(\widehat{Y}_4, \mathbb{Z})$

  2. Transversality: The flux must be orthogonal to both the base and the fiber in a precise cohomological sense.

  3. Additional constraints, such as D3-tadpole cancellation, self-duality, and primitivity, are also typically imposed. One often requires that the $G_4$-flux preserves the non-abelian gauge symmetry encoded in the fibration.

These conditions ensure compatibility with fundamental physical principles like anomaly cancellation and D3-brane charge quantization.

For further theoretical background, see the exposition in Weigand 2018.


Modeling $G_4$-Fluxes

In practice, FTheoryTools focuses on candidate $G_4$-fluxes: elements of the rational cohomology group $H^{2,2}(\widehat{Y}_4, \mathbb{Q})$, i.e.

\[G_4 \in H^{2, 2}(\widehat{Y}_4, \mathbb{Q}) \equiv H^{2, 2}(\widehat{Y}_4, \mathbb{C}) \cap H^4(\widehat{Y}_4, \mathbb{Q})\,.\]

We work with rational coefficients due to both the quantization condition–-which implies that valid fluxes must have rational coefficients–-and the practical advantages this offers in computation. Currently, FTheoryTools cannot fully verify the quantization condition, so we adopt the term candidate flux. We elaborate on our approach to the quantization condition below.

The space $H^{2,2}(\widehat{Y}_4, \mathbb{C})$ admits an orthogonal decomposition:

\[H^{2, 2}(\widehat{Y}_4, \mathbb{C}) = H^{2, 2}_\text{hor}(\widehat{Y}_4, \mathbb{C}) \oplus H^{2, 2}_\text{vert}(\widehat{Y}_4, \mathbb{C}) \oplus H^{2, 2}_\text{rem}(\widehat{Y}_4, \mathbb{C})\,.\]

  • Horizontal fluxes arise from variations of the complex structure,
  • Vertical fluxes are built from wedge products of (1,1)-forms,
  • Remainder fluxes account for the rest.

FTheoryTools focuses on the vertical part.

Standing Assumption

FTheoryTools assumes that $\widehat{Y}_4$ is defined as a hypersurface in a complete, smooth toric variety $X_\Sigma$. (In principle, it would suffice for the hypersurface to be smooth and the ambient space to be simplicial. However, we compute characteristic classes of the ambient space and restrict them to the hypersurface to obtain $c_2(\widehat{Y}_4)$, and this requires the ambient space to be smooth.)

Workflow

Under this assumption, we can access a subspace of the vertical cohomology:

\[\left. H^{2,2}(X_\Sigma, \mathbb{Q}) \right|_{\widehat{Y}_4} \subseteq H^{2,2}_{\text{vert}}(\widehat{Y}_4, \mathbb{Q}) \,.\]

We refer to elements in this subspace as ambient vertical fluxes.

Theorem 9.3.2 of Cox, Little, Schenck 2011 states that for complete, simplicial toric varieties, $H^{p, q}(X_\Sigma, \mathbb{Q}) = 0$ whenever $p \ne q$. Consequently, $H^{2, 2}(X_\Sigma, \mathbb{Q}) = H^4(X_\Sigma, \mathbb{Q})$. Furthermore, Theorem 12.4.1 of Cox, Little, Schenck 2011 establishes that $H^4(X_\Sigma, \mathbb{Q})$ is isomorphic to $R_{\mathbb{Q}}(\Sigma)_2$, the space of degree-2 monomials (under the standard grading) in the cohomology ring $R_{\mathbb{Q}}(\Sigma)$ of $X_\Sigma$. This cohomology ring is the quotient of $\mathbb{Q}[x_1, \dots, x_r]$, where $r$ is the number of rays in the polyhedral fan $\Sigma$ of the toric ambient space $X_\Sigma$, by the sum of the Stanley–Reisner ideal and the ideal of linear relations.

To construct a generating set of ambient candidate $G_4$-fluxes, we proceed as follows:

  1. Construct the cohomology ring $R_{\mathbb{Q}}(\Sigma)$.
  2. Identify a basis of degree-2 monomials in $R_{\mathbb{Q}}(\Sigma)$.
  3. Restrict these monomials to $\widehat{Y}_4$.

While performing the restriction to $\widehat{Y}_4$, dependencies may arise:

  • Some monomials vanish identically,
  • Others may become linearly dependent.

FTheoryTools currently detects only obviously trivial restrictions (e.g., cycles whose intersection with $\widehat{Y}_4$ is empty). It does not eliminate all possible dependencies–-hence the result is a generating set, not a minimal basis. This pragmatic choice enables efficient and scalable construction of vertical flux candidates across a wide range of F-theory geometries.

FTheoryTools includes specialized algorithms to perform steps 1 through 3. These algorithms—described in detail in the appendix of BMT25—are especially effective for large geometries such as those studied in Taylor, Wang 2015, where traditional Gröbner basis techniques are computationally impractical. Even for more manageable QSM geometries (cf. Cvetič, Halverson, Ling, Liu, Tian 2019), we observe a significant performance boost.

Necessary Conditions for Flux Quantization

Verifying the flux quantization condition (cf. Witten 1997) is generally difficult. In practice, FTheoryTools performs necessary consistency checks to gather evidence for (or against) proper quantization.

Let $H$ denote the hypersurface divisor class defining $\widehat{Y}_4$ inside the ambient toric variety $X_\Sigma$. Let $\{D_i\}$ be a basis for the toric divisor classes of $X_\Sigma$, and let $\hat{c}_2 \in H^{2,2}(X_\Sigma, \mathbb{Q})$ be a class whose restriction gives the second Chern class of the Calabi–Yau hypersurface, i.e., $\left. \hat{c}_2 \right|_{\widehat{Y}_4} = c_2(\widehat{Y}_4)$.

As elaborated above, in FTheoryTools, a $G_4$-flux candidate is modeled by a class $g \in H^{2,2}(X_\Sigma, \mathbb{Q})$, and its restriction to $\widehat{Y}_4$ defines the actual flux candidate. A necessary condition for quantization of this flux $G_4$—modelled by $g \in H^{2,2}(X_\Sigma, \mathbb{Q})$—is that, for all pairs of indices $i$, $j$, the following integral evaluates to an integer:

\[\int_{X_\Sigma}{\left(g + \frac{1}{2} \hat{c}_2 \right) \wedge [H] \wedge [D_i] \wedge [D_j]}\,,\]

where $[D]$ indicates the Poincaré dual cohomology class to the divisor $D$. It is these conditions that we check in FTheoryTools.

Even these elementary checks can be computationally expensive on large geometries. Therefore, FTheoryTools allows users to skip quantization checks during flux construction using the keyword argument check = false. This can be useful in early-stage explorations or for performance optimization.


Working with $G_4$-Fluxes

Constructing $G_4$-Fluxes

In FTheoryTools, $G_4$-fluxes are created from cohomology classes associated with a given resolved F-theory model.

g4_fluxMethod
g4_flux(model::AbstractFTheoryModel, class::CohomologyClass; check::Bool = true)

Constructs a candidate $G_4$-flux for a resolved F-theory model from a given cohomology class on the toric ambient space.

By default, check = true enables basic consistency and quantization checks. Set check = false to skip these checks, which can improve performance or allow for exploratory computations.

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)), quick = true)^2;

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

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

source

For the special class of quadrillion Standard models (QSMs) (cf. Cvetič, Halverson, Ling, Liu, Tian 2019), the chosen flux can be obtained conveniently.

qsm_fluxMethod
qsm_flux(qsm_model::AbstractFTheoryModel)

Returns the $G_4$-flux associated with one of the Quadrillion F-theory Standard models, as described in CHLLT19.

This flux has been pre-validated to pass essential consistency checks.

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

julia> qsm_flux(qsm_model)
G4-flux candidate
  - Elementary quantization checks: satisfied
  - Transversality checks: satisfied
  - Non-abelian gauge group: unbroken
  - Tadpole cancellation check: not computed
Experimental

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

source

Attributes of $G_4$-Fluxes

You can inspect a $G_4$-flux using the following attributes:

modelMethod
model(gf::G4Flux)

Returns the F-theory model used to construct 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> g4_candidate = qsm_flux(qsm_model)
G4-flux candidate
  - Elementary quantization checks: satisfied
  - Transversality checks: satisfied
  - Non-abelian gauge group: unbroken
  - Tadpole cancellation check: not computed

julia> model(g4_candidate)
Hypersurface model over a concrete base

julia> model(g4_candidate) == qsm_model
true
Experimental

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

source
cohomology_classMethod
cohomology_class(gf::G4Flux)

Returns the ambient space 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)), quick = true)^2;

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

julia> cohomology_class(g4f);
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)

Returns the d3-tapdole of a G4-flux, that is compute and return the quantity $- \frac{1}{2} \cdot \int_{\widehat{Y_4}}{G_4 \wedge G_4} + \frac{1}{24} \cdot \chi(\widehat{Y}_4)$.

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

julia> g4 = qsm_flux(qsm_model)
G4-flux candidate
  - Elementary quantization checks: satisfied
  - Transversality checks: satisfied
  - Non-abelian gauge group: unbroken
  - Tadpole cancellation check: not computed

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)
Family of G4 fluxes:
  - Elementary quantization checks: satisfied
  - Transversality checks: satisfied
  - Non-abelian gauge group: breaking pattern not analyzed

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

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
  - Transversality checks: satisfied
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole cancellation check: not computed

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

Properties of $G_4$-Fluxes

You can check whether a $G_4$-flux satisfies common physical constraints using:

is_well_quantizedMethod
is_well_quantized(gf::G4Flux)

Checks whether the given $G_4$-flux candidate satisfies necessary consistency conditions for flux quantization as formulated in [Wit97]:

\[G_4 + \frac{1}{2} c_2(\widehat{Y}_4) \in H^{(2,2)}(\widehat{Y}_4, \mathbb{Z})\,.\]

Since verifying this integrality condition is generally very difficult, this method performs a series of simpler checks. The flux candidate is modelled by $g \in H^{2,2}(X_\Sigma, \mathbb{Q})$. This method evaluates

\[\int_{X_\Sigma} \left(g + \frac{1}{2} \hat{c}_2 \right) \wedge [H] \wedge [D_i] \wedge [D_j]\]

for all pairs of toric divisors $D_i$, $D_j$ in the ambient variety, where $[H]$ denotes the class of the hypersurface divisor defining $\widehat{Y}_4$ and $\hat{c}_2 \in H^{2,2}(X_\Sigma, \mathbb{Q})$ restricts to $c_2(\widehat{Y}_4)$ on the hypersurface.

If all these integrals evaluate to integers, this method returns true; otherwise, it returns false.

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
  - Transversality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole cancellation check: not computed

julia> is_well_quantized(g4)
true

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

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

source
passes_transversality_checksMethod
passes_transversality_checks(gf::G4Flux)

Checks whether the $G_4$-flux satisfies the transversality conditions (cf. [Wei18]). Returns true if all conditions are met, 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
  - Transversality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole cancellation check: not computed

julia> passes_transversality_checks(g4)
true

julia> g4
G4-flux candidate
  - Elementary quantization checks: not executed
  - Transversality checks: satisfied
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole cancellation check: not computed
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)

Checks whether the given $G_4$-flux satisfies the D3-tadpole cancellation condition. This amounts to verifying that

\[\frac{\chi(\widehat{Y}_4)}{24} - \frac{1}{2} \int_{\widehat{Y}_4} 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
  - Transversality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole cancellation check: not computed

julia> passes_tadpole_cancellation_check(g4)
true

julia> g4
G4-flux candidate
  - Elementary quantization checks: not executed
  - Transversality 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)

Checks whether the given $G_4$-flux candidate breaks any non-abelian gauge symmetries. Returns true if any breaking occurs, and false otherwise.

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
  - Transversality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole cancellation check: not computed

julia> breaks_non_abelian_gauge_group(g4)
false

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

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

source

Working with Families of $G_4$-Fluxes

In many F-theory applications, it is useful to study entire families of fluxes rather than individual ones. FTheoryTools supports both the construction and analysis of such flux families.

Constructing a Flux Family from Parametrization and Offset

You can construct a flux family explicitly by specifying its parametrization in terms of the ambient $G_4$-flux generators:

chosen_g4_flux_gensMethod
chosen_g4_flux_gens(m::AbstractFTheoryModel; check::Bool = true)::Vector{CohomologyClass}

Given an F-theory model m defined as a hypersurface in a simplicial and complete toric space $X_\Sigma$, this method computes a basis of $H^{2,2}(X_\Sigma, \mathbb{Q})$ (using the method basis_of_h22) and then filters out—based on fairly elementary, sufficent but not necessary checks—basis elements whose restriction to the hypersurface in question is non-trivial. The list of these basis elements—cast into $G_4$-flux ambient space candidates—is then returned by this method.

Use check = false to skip completeness and simplicity verification.

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_gens(t);

julia> length(g4_basis)
2

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

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

julia> cohomology_class(g4_basis[2])
Cohomology class on a normal toric variety given by z^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_gens(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

To define a flux family in this way, you must provide:

  • Integral coefficients: Rational combinations of generators whose $\mathbb{Z}$-span lies within the family,
  • Rational coefficients: Rational combinations of generators forming the $\mathbb{Q}$-span of the family,
  • Offset vector: Typically representing the shift by $\frac{1}{2} c_2(\widehat{Y}_4)$ from the quantization condition.

The constructor is:

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 $\text{mat}_{\text{int}}$,
  • $\mathbb{Q}$-linear combinations, provided by a matrix $\text{mat}_{\text{rat}}$,
  • a shift—resembling the appearance of $\frac{1}{2} \cdot c_2$ in the flux quantization condition—provided by a vector $\text{offset}$.

For convenience we also allow to only provide $\text{mat}_{\text{int}}$or $\text{mat}_{\text{rat}}$. In this case, the shift is taken to be zero.

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> shift = [zero(QQ) for k in 1:37];

julia> family_of_g4_fluxes(qsm_model, mat_int, mat_rat, shift, check = false)
Family of G4 fluxes:
  - Elementary quantization checks: not executed
  - Transversality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
Experimental

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

source

Constructing a Flux Family Based on Physical Conditions

A common use case is to construct the family of all $G_4$-fluxes satisfying key physical constraints:

  • Passing the necessary quantization checks (as discussed earlier),
  • Satisfying all transversality conditions,
  • Optionally preserving the non-abelian gauge symmetry.

This method is less flexible than direct parametrization, but very convenient for typical model-building workflows.

Warning

This operation may be computationally expensive for large or complex geometries.

special_flux_familyMethod
special_flux_family(m::AbstractFTheoryModel; not_breaking::Bool = false, check::Bool = true, algorithm::String = "default")

Computes a family of $G_4$-fluxes for the F-theory model m, defined as a hypersurface in a simplicial, complete toric ambient space. The returned fluxes satisfy necessary quantization and transversality checks.

Optional keyword arguments:

  • not_breaking: if true, restricts to fluxes preserving the non-abelian gauge group.
  • check: if false, skips computational checks of completeness and simplicity of the ambient toric variety for improved performance.
  • algorithm: selects the computation method; the default uses Gröbner basis computations in the cohomology ring, while setting algorithm = "special" activates a faster variant described in BMT25.
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, check = false)
Family of G4 fluxes:
  - Elementary quantization checks: satisfied
  - Transversality checks: satisfied
  - Non-abelian gauge group: breaking pattern not analyzed

julia> fg = special_flux_family(qsm_model, not_breaking = true, check = false)
Family of G4 fluxes:
  - Elementary quantization checks: satisfied
  - Transversality checks: satisfied
  - Non-abelian gauge group: unbroken

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

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

julia> is_well_quantized(g4_tester_double)
true

julia> passes_transversality_checks(g4_tester_double)
true

julia> breaks_non_abelian_gauge_group(g4_tester_double)
false
Experimental

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

source

Attributes of a Flux Family

You can access key data about a flux family using the following attributes:

modelMethod
model(gf::FamilyOfG4Fluxes)

Returns 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> shift = [zero(QQ) for k in 1:37];

julia> f_gs = family_of_g4_fluxes(qsm_model, mat_int, mat_rat, shift, check = false)
Family of G4 fluxes:
  - Elementary quantization checks: not executed
  - Transversality checks: not executed
  - Non-abelian gauge group: breaking pattern 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)

Returns the matrix whose columns specify those combinations of ambient space $G_4$-flux candidates, of which integral linear combinations are contained in this family of $G_4$-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> shift = [zero(QQ) for k in 1:37];

julia> f_gs = family_of_g4_fluxes(qsm_model, mat_int, mat_rat, shift, check = false)
Family of G4 fluxes:
  - Elementary quantization checks: not executed
  - Transversality checks: not executed
  - Non-abelian gauge group: breaking pattern 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)

Returns the matrix whose columns specify those combinations of ambient space $G_4$-flux candidates, of which rational linear combinations are contained in this family of $G_4$-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> shift = [zero(QQ) for k in 1:37];

julia> f_gs = family_of_g4_fluxes(qsm_model, mat_int, mat_rat, shift, check = false)
Family of G4 fluxes:
  - Elementary quantization checks: not executed
  - Transversality checks: not executed
  - Non-abelian gauge group: breaking pattern 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
offsetMethod
offset(gf::FamilyOfG4Fluxes)

Returns the vector whose entries specify the offset by which fluxes in this family of $G_4$-fluxes are shifted away from the origin.

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> shift = [zero(QQ) for k in 1:37];

julia> f_gs = family_of_g4_fluxes(qsm_model, mat_int, mat_rat, shift, check = false)
Family of G4 fluxes:
  - Elementary quantization checks: not executed
  - Transversality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed

julia> offset(f_gs) == shift
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)

Returns the D3-tadpole constraint polynomial for a family of $G_4$-fluxes.

Recall that for a given flux $G_4$, the D3-tadpole constraint requires

\[- \frac{1}{2} \cdot G_4^2 + \frac{1}{24} \cdot \chi(\widehat{Y}_4)\]

to be a non-negative integer.

The family of fluxes is given as a linear combination of cohomology classes with integral (denoted by $a_i$) and rational (denoted by $r_i$) coefficients. This method returns the quadratic polynomial in these coefficients that encodes the $D3$-tadpole constraint. To evaluate the constraint for a specific flux, substitute the numerical coefficient values into this polynomial.

The optional keyword argument check enables or disables internal consistency checks.

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)
Family of G4 fluxes:
  - Elementary quantization checks: satisfied
  - Transversality checks: satisfied
  - Non-abelian gauge group: breaking pattern not analyzed

julia> d3_tadpole_constraint(fgs);
Experimental

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

source

Properties of a Flux Family

To test whether a family satisfies standard physical consistency conditions, use:

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

Performs elementary necessary (but not sufficient) tests to check if the family of $G_4$-fluxes is well-quantized.

If any test fails, the family is definitely not well-quantized and the method returns false. If all tests pass, it returns true, indicating the fluxes appear well-quantized based on current knowledge, but without guaranteeing it.

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)
Family of G4 fluxes:
  - Elementary quantization checks: satisfied
  - Transversality checks: satisfied
  - Non-abelian gauge group: breaking pattern 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)
Family of G4 fluxes:
  - Elementary quantization checks: not executed
  - Transversality checks: not executed
  - Non-abelian gauge group: breaking pattern 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
passes_transversality_checksMethod
passes_transversality_checks(fgs::FamilyOfG4Fluxes; check::Bool = true)

Checks if the given family of $G_4$-fluxes passes the transversality conditions. Returns true if the checks pass, and false otherwise.

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)
Family of G4 fluxes:
  - Elementary quantization checks: satisfied
  - Transversality checks: satisfied
  - Non-abelian gauge group: breaking pattern not analyzed

julia> passes_transversality_checks(gf, check = false)
true

julia> m1 = matrix_integral(gf);

julia> m2 = matrix_rational(gf);

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

julia> passes_transversality_checks(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 the given family of $G_4$-fluxes breaks the non-abelian gauge group. Returns true if it does, and false otherwise.

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)
Family of G4 fluxes:
  - Elementary quantization checks: satisfied
  - Transversality checks: satisfied
  - Non-abelian gauge group: breaking pattern not analyzed

julia> breaks_non_abelian_gauge_group(gf)
true

julia> gf3 = special_flux_family(qsm_model, not_breaking = true, check = false)
Family of G4 fluxes:
  - Elementary quantization checks: satisfied
  - Transversality checks: satisfied
  - Non-abelian gauge group: unbroken

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)
Family of G4 fluxes:
  - Elementary quantization checks: not executed
  - Transversality checks: not executed
  - Non-abelian gauge group: breaking pattern 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

Constructing Flux Instances from a Flux Family

You can generate specific fluxes within a family using:

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

Creates an element of a 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> shift = [zero(QQ) for k in 1:37];

julia> fgs = family_of_g4_fluxes(qsm_model, mat_int, mat_rat, shift, check = false)
Family of G4 fluxes:
  - Elementary quantization checks: not executed
  - Transversality checks: not executed
  - Non-abelian gauge group: breaking pattern 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
  - Transversality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole cancellation check: not computed

julia> flux_instance(fgs, Int[], [], check = false)
G4-flux candidate
  - Elementary quantization checks: not executed
  - Transversality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole cancellation check: not computed

julia> flux_instance(fgs, [3], [], check = false)
G4-flux candidate
  - Elementary quantization checks: not executed
  - Transversality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole cancellation check: not computed

julia> flux_instance(fgs, [], [5//2], check = false)
G4-flux candidate
  - Elementary quantization checks: not executed
  - Transversality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole cancellation check: not computed

julia> flux_instance(fgs, [3], [5//2], check = false)
G4-flux candidate
  - Elementary quantization checks: not executed
  - Transversality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole cancellation check: not computed
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)

Creates a random element of a 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> shift = [zero(QQ) for k in 1:37];

julia> fgs = family_of_g4_fluxes(qsm_model, mat_int, mat_rat, shift, check = false)
Family of G4 fluxes:
  - Elementary quantization checks: not executed
  - Transversality checks: not executed
  - Non-abelian gauge group: breaking pattern not analyzed

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

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

source

For convenience, a random physically consistent flux can also be generated directly from a model:

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

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

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, check = false)
G4-flux candidate
  - Elementary quantization checks: satisfied
  - Transversality checks: satisfied
  - Non-abelian gauge group: breaking pattern not analyzed
  - Tadpole cancellation check: not computed
Experimental

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

source

Recovering a Flux Family from a Flux Instance

Starting from a single $G_4$-flux, you can find the full family of fluxes that share its physical properties:

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

Returns the family of $G_4$-fluxes sharing the following properties with the given $G_4$-flux: transversality 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> g4 = qsm_flux(qsm_model)
G4-flux candidate
  - Elementary quantization checks: satisfied
  - Transversality checks: satisfied
  - Non-abelian gauge group: unbroken
  - Tadpole cancellation check: not computed

julia> g4_flux_family(g4, check = false)
Family of G4 fluxes:
  - Elementary quantization checks: satisfied
  - Transversality checks: satisfied
  - Non-abelian gauge group: unbroken
Experimental

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

source

To determine the location of the original flux within that family, retrieve its defining coefficients and offset:

integral_coefficientsMethod
integral_coefficients(gf::G4Flux)

Returns the integral coefficients of a $G_4$-flux.

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

julia> gfs = special_flux_family(qsm_model, check = false, algorithm = "special")
Family of G4 fluxes:
  - Elementary quantization checks: satisfied
  - Transversality checks: satisfied
  - Non-abelian gauge group: breaking pattern not analyzed

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

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)

Returns the rational coefficients of a $G_4$-flux.

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

julia> gfs = special_flux_family(qsm_model, check = false, algorithm = "special")
Family of G4 fluxes:
  - Elementary quantization checks: satisfied
  - Transversality checks: satisfied
  - Non-abelian gauge group: breaking pattern not analyzed

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

julia> rational_coefficients(g4);
Experimental

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

source
offsetMethod
offset(gf::G4Flux)

Returns the offset of a $G_4$-flux.

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)
Family of G4 fluxes:
  - Elementary quantization checks: satisfied
  - Transversality checks: satisfied
  - Non-abelian gauge group: breaking pattern not analyzed

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

julia> offset(g4);
Experimental

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

source

Advanced Methods

Let $X_\Sigma$ be a complete, simplicial toric variety.

According to Theorem 9.3.2 in Cox, Little, Schenck 2011, such varieties satisfy $H^{p, q}(X_\Sigma, \mathbb{Q}) = 0$ whenever $p \neq q$. This implies that $H^{2,2}(X_\Sigma, \mathbb{Q}) = H^4(X_\Sigma, \mathbb{Q})$.

Theorem 12.4.1 in Cox, Little, Schenck 2011 shows that $H^4(X_\Sigma, \mathbb{Q})$ is isomorphic to $R_\mathbb{Q}(\Sigma)_2$—the degree-2 part of the cohomology ring $R_\mathbb{Q}(\Sigma)$. This ring is given by

$R_\mathbb{Q}(\Sigma) = \mathbb{Q}[x_1, ..., x_r] / (I_{SR} + I_{lin})$

where $r$ is the number of rays in the fan $\Sigma$, $I_{SR}$ is the Stanley–Reisner ideal, and $I_{lin}$ is the ideal of linear relations.

The following method computes a basis for $H^{2,2}(X_\Sigma, \mathbb{Q})$ by multiplying pairs of cohomology classes associated with toric coordinates:

basis_of_h22_ambientMethod
basis_of_h22_ambient(m::AbstractFTheoryModel; check::Bool = true)

Computes a monomial basis for $H^{2,2}(X_\Sigma, \mathbb{Q})$ for a complete and simplicial toric variety $X_\Sigma$ by multiplying pairs of cohomology classes associated with the rays of $X_\Sigma$.

Use check = false to skip completeness and simplicity verification.

For mathematical background shared across related methods see Advanced Methods.

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

julia> length(basis_of_h22_ambient(qsm_model, check = false)) == betti_number(ambient_space(qsm_model), 4)
true
Experimental

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

source

By default, the method checks if the toric variety is complete and simplicial, but these checks can be skipped by setting check=false.

To identify which pairs of classes were used to compute the basis, use:

basis_of_h22_ambient_indicesMethod
basis_of_h22_ambient_indices(m::AbstractFTheoryModel; check::Bool = true)

Returns the index pairs of toric cohomology classes whose products span the basis of $H^{2,2}(X_\Sigma, \mathbb{Q})$ computed by basis_of_h22_ambient.

Each entry is a tuple (a, b), indicating that the product of the a-th and b-th variables in the Cox ring contributes to the chosen basis.

Use check = false to skip completeness and simplicity verification.

For mathematical background shared across related methods see Advanced Methods.

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

julia> bhi = basis_of_h22_ambient_indices(qsm_model, check = false);

julia> length(bhi) == betti_number(ambient_space(qsm_model), 4)
true
Experimental

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

source

A dictionary mapping any element of $H^{2,2}(X_\Sigma, \mathbb{Q})$ into this basis is available via:

converter_dict_h22_ambientMethod
converter_dict_h22_ambient(m::AbstractFTheoryModel; check::Bool = true)

Returns a dictionary that expresses arbitrary elements of $H^{2,2}(X_\Sigma, \mathbb{Q})$ in terms of the basis computed by basis_of_h22_ambient.

This is useful for rewriting cohomology classes in a fixed basis of the toric variety $X_\Sigma$.

Use check = false to skip completeness and simplicity verification.

For mathematical background shared across related methods see Advanced Methods.

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

julia> cdh22 = converter_dict_h22_ambient(qsm_model, check = false);

julia> length(collect(keys(cdh22)))
81
Experimental

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

source

Now consider a hypersurface $\widehat{Y}_4$ inside $X_\Sigma$. We can compute a subspace of its vertical middle cohomology:

$\left. H^{2,2}(X_\Sigma, \mathbb{Q}) \right|_{\widehat{Y}_4} \subseteq H^{2,2}_{\text{vert}}(\widehat{Y}_4, \mathbb{Q})$

To do this, we restrict the ambient basis (from basis_of_h22_ambient) to $\widehat{Y}_4$. Only basic checks are done to see if elements vanish upon restriction. No advanced vanishing checks or relation checks are executed.

The resulting list of generators is available with:

gens_of_h22_hypersurfaceMethod
gens_of_h22_hypersurface(m::AbstractFTheoryModel; check::Bool = true)

Computes a set of cohomology classes in the toric ambient space $X_\Sigma$ that restrict to generators of the subspace $S \subseteq H^{2,2}(\widehat{Y}_4, \mathbb{Q})$, where $\widehat{Y}_4$ is the (smooth) hypersurface in the ambient toric variety $X_\Sigma$ associated to the F-theory model and $S$ the restriction of $H^{2,2}(X_\Sigma, \mathbb{Q})$ to $\widehat{Y}_4$.

These classes are obtained by restricting the ambient $H^{2,2}(X_\Sigma, \mathbb{Q})$ basis (constructed from toric coordinate products) to the hypersurface $\widehat{Y}_4$.

Use check = false to skip completeness and simplicity verification.

For mathematical background shared across related methods see Advanced Methods.

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

julia> length(gens_of_h22_hypersurface(qsm_model, check = false))
25
Experimental

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

source

The corresponding index pairs used for multiplication are available via:

gens_of_h22_hypersurface_indicesMethod
gens_of_h22_hypersurface_indices(m::AbstractFTheoryModel; check::Bool = true)

Returns a vector of index pairs $(a, b)$, indicating that the product of the $a$-th and $b$-th toric variables defines a cohomology class on the ambient toric variety $X_\Sigma$ whose restriction to the hypersurface lies in the subspace $S \subseteq H^{2,2}(\widehat{Y}_4, \mathbb{Q})$ obtained from restricting $H^{2,2}(X_\Sigma, \mathbb{Q})$ to $\widehat{Y}_4$.

This symbolic representation can be used to reconstruct cohomology class generators via Cox ring monomials. For the actual cohomology class generators, see gens_of_h22_hypersurface.

Use check = false to skip completeness and simplicity verification.

For mathematical background shared across related methods see Advanced Methods.

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

julia> length(gens_of_h22_hypersurface_indices(qsm_model, check = false))
25
Experimental

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

source

To map classes from $H^{2,2}(X_\Sigma, \mathbb{Q})$ into the hypersurface basis, we use the following dictionary:

converter_dict_h22_hypersurfaceMethod
converter_dict_h22_hypersurface(m::AbstractFTheoryModel; check::Bool = true)

Returns a dictionary mapping cohomology classes in $H^{2,2}(X_\Sigma, \mathbb{Q})$ to linear combinations of generators of $S \subseteq H^{2,2}(\widehat{Y}_4, \mathbb{Q})$, where $\widehat{Y}_4$ is the (smooth) hypersurface associated to the F-theory model and $S$ the restriction of $H^{2,2}(X_\Sigma, \mathbb{Q})$ to $\widehat{Y}_4$.

The generating set of $S$ is the one returned by gens_of_h22_hypersurface, and this converter enables expressing any ambient class in terms of these restricted generators.

For the analogous map in the ambient toric variety, see converter_dict_h22_ambient.

Use check = false to skip completeness and simplicity verification.

For mathematical background shared across related methods see Advanced Methods.

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

julia> cdh22 = converter_dict_h22_hypersurface(qsm_model, check = false);

julia> length(collect(keys(cdh22)))
81
Experimental

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

source