Functionality for all F-theory models

tune(w::WeierstrassModel, input_sections::Dict{String, <:Any}; completeness_check::Bool = true)

Takes a Weierstrass model w and returns a new model in which the tunable sections have been fixed to specific values provided by the user.

The input_sections argument is a dictionary mapping section names (as strings) to values, typically given as elements of a multivariate polynomial ring. It is also possible to set a section to zero.

Importantly, even if a section is tuned to zero, it is not removed from the model’s metadata (such as explicit_model_sections or classes_of_model_sections). This ensures the ability to later reintroduce non-trivial values for those sections, preserving model flexibility and reversibility.

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

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

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

Weierstrass model over a concrete base -- U(1) Weierstrass model based on arXiv paper 1208.2695 Eq. (B.19)

julia> x1, x2, x3 = gens(cox_ring(base_space(w)))
3-element Vector{MPolyDecRingElem{QQFieldElem, QQMPolyRingElem}}:
 x1
 x2
 x3

julia> my_choice = Dict("b" => x2, "c2" => x1^6)
Dict{String, MPolyDecRingElem{QQFieldElem, QQMPolyRingElem}} with 2 entries:
  "c2" => x1^6
  "b"  => x2

julia> tuned_w = tune(w, my_choice)
Weierstrass model over a concrete base

julia> explicit_model_sections(tuned_w)["c2"]
x1^6

julia> x1, x2, x3 = gens(cox_ring(base_space(tuned_w)))
3-element Vector{MPolyDecRingElem{QQFieldElem, QQMPolyRingElem}}:
 x1
 x2
 x3

julia> my_choice2 = Dict("b" => x2, "c2" => zero(parent(x1)))
Dict{String, MPolyDecRingElem{QQFieldElem, QQMPolyRingElem}} with 2 entries:
  "c2" => 0
  "b"  => x2

julia> tuned_w2 = tune(tuned_w, my_choice2)
Weierstrass model over a concrete base

julia> is_zero(explicit_model_sections(tuned_w2)["c2"])
true

julia> x1, x2, x3 = gens(cox_ring(base_space(tuned_w2)))
3-element Vector{MPolyDecRingElem{QQFieldElem, QQMPolyRingElem}}:
 x1
 x2
 x3

julia> my_choice3 = Dict("b" => x2, "c2" => x1^6)
Dict{String, MPolyDecRingElem{QQFieldElem, QQMPolyRingElem}} with 2 entries:
  "c2" => x1^6
  "b"  => x2

julia> tuned_w3 = tune(tuned_w2, my_choice3)
Weierstrass model over a concrete base

julia> is_zero(explicit_model_sections(tuned_w3)["c2"])
false

tune(t::GlobalTateModel, input_sections::Dict{String, <:Any}; completeness_check::Bool = true)

Tunes a global Tate model by specifying values for some of its defining sections.

This mechanism allows for specialized constructions—for example, setting certain sections to zero to engineer enhanced singularities. Note that trivial (zero) sections are retained internally, rather than deleted from attributes like explicit_model_sections or classes_of_model_sections. This design choice enables users to later reintroduce nontrivial values for such sections without loss of structure.

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

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

julia> t = literature_model(arxiv_id = "1109.3454", equation = "3.1", base_space = B3, defining_classes = Dict("w" => w), completeness_check = false)
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> x1, x2, x3, x4 = gens(cox_ring(base_space(t)))
4-element Vector{MPolyDecRingElem{QQFieldElem, QQMPolyRingElem}}:
 x1
 x2
 x3
 x4

julia> my_choice = Dict("a1" => x1^4, "w" => x2 - x3)
Dict{String, MPolyDecRingElem{QQFieldElem, QQMPolyRingElem}} with 2 entries:
  "w"  => x2 - x3
  "a1" => x1^4

julia> tuned_t = tune(t, my_choice)
Global Tate model over a concrete base

julia> tate_section_a1(tuned_t) == x1^4
true

julia> x1, x2, x3, x4 = gens(cox_ring(base_space(tuned_t)))
4-element Vector{MPolyDecRingElem{QQFieldElem, QQMPolyRingElem}}:
 x1
 x2
 x3
 x4

julia> my_choice2 = Dict("a1" => zero(parent(x1)), "w" => x2 - x3)
Dict{String, MPolyDecRingElem{QQFieldElem, QQMPolyRingElem}} with 2 entries:
  "w"  => x2 - x3
  "a1" => 0

julia> tuned_t2 = tune(tuned_t, my_choice2)
Global Tate model over a concrete base

julia> is_zero(explicit_model_sections(tuned_t2)["a1"])
true

julia> x1, x2, x3, x4 = gens(cox_ring(base_space(tuned_t2)))
4-element Vector{MPolyDecRingElem{QQFieldElem, QQMPolyRingElem}}:
 x1
 x2
 x3
 x4

julia> my_choice3 = Dict("a1" => x1^4, "w" => x2 - x3)
Dict{String, MPolyDecRingElem{QQFieldElem, QQMPolyRingElem}} with 2 entries:
  "w"  => x2 - x3
  "a1" => x1^4

julia> tuned_t3 = tune(tuned_t2, my_choice3)
Global Tate model over a concrete base

julia> is_zero(explicit_model_sections(tuned_t3)["a1"])
false

tune(h::HypersurfaceModel, input_sections::Dict{String, <:Any}; completeness_check::Bool = true)

Tune a hypersurface model by fixing a special choice for the model sections. Note that it is in particular possible to set a section to zero. We anticipate that people might want to be able to come back from this by assigning a non-trivial value to a section that was previously tuned to zero. This is why we keep such trivial sections and do not delete them, say from explicit_model_sections or classes_of_model_sections.

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

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

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

Hypersurface model over a concrete base

julia> x1, x2, x3 = gens(cox_ring(base_space(h)))
3-element Vector{MPolyDecRingElem{QQFieldElem, QQMPolyRingElem}}:
 x1
 x2
 x3

julia> my_choice = Dict("b" => x2, "c0" => zero(parent(x1)))
Dict{String, MPolyDecRingElem{QQFieldElem, QQMPolyRingElem}} with 2 entries:
  "b"  => x2
  "c0" => 0

julia> tuned_h = tune(h, my_choice)
Hypersurface model over a concrete base

julia> x1, x2, x3 = gens(cox_ring(base_space(tuned_h)))
3-element Vector{MPolyDecRingElem{QQFieldElem, QQMPolyRingElem}}:
 x1
 x2
 x3

julia> my_choice2 = Dict("b" => x2, "c0" => zero(parent(x1)))
Dict{String, MPolyDecRingElem{QQFieldElem, QQMPolyRingElem}} with 2 entries:
  "b"  => x2
  "c0" => 0

julia> tuned_h2 = tune(tuned_h, my_choice2)
Hypersurface model over a concrete base

julia> is_zero(explicit_model_sections(tuned_h2)["c0"])
true

julia> x1, x2, x3 = gens(cox_ring(base_space(tuned_h2)))
3-element Vector{MPolyDecRingElem{QQFieldElem, QQMPolyRingElem}}:
 x1
 x2
 x3

julia> my_choice3 = Dict("b" => x2, "c0" => x1^10)
Dict{String, MPolyDecRingElem{QQFieldElem, QQMPolyRingElem}} with 2 entries:
  "b"  => x2
  "c0" => x1^10

julia> tuned_h3 = tune(tuned_h2, my_choice3)
Hypersurface model over a concrete base

julia> is_zero(explicit_model_sections(tuned_h3)["c0"])
false

ambient_space(m::AbstractFTheoryModel)

Return the ambient space of the F-theory model.

julia> m = literature_model(arxiv_id = "1109.3454", equation = "3.1")
Assuming that the first row of the given grading is the grading under Kbar

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

julia> ambient_space(m)
Family of spaces of dimension d = 5

base_space(m::AbstractFTheoryModel)

Return the base space of the F-theory model.

julia> m = literature_model(arxiv_id = "1109.3454", equation = "3.1")
Assuming that the first row of the given grading is the grading under Kbar

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

julia> base_space(m)
Family of spaces of dimension d = 3

fiber_ambient_space(m::AbstractFTheoryModel)

Return the fiber ambient space of an F-theory model.

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

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

julia> t = literature_model(arxiv_id = "1109.3454", equation = "3.1", base_space = B3, defining_classes = Dict("w" => w), completeness_check = false)
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> fiber_ambient_space(t)
Normal toric variety

chern_class(m::AbstractFTheoryModel, k::Int; check::Bool = true)

If the elliptically fibered n-fold $Y_n$ underlying the F-theory model in question is given as a hypersurface in a toric ambient space, we can compute a cohomology class $h$ on the toric ambient space $X_\Sigma$, such that its restriction to $Y_n$ is the k-th Chern class $c_k$ of the tangent bundle of $Y_n$. If those assumptions are satisfied, this method returns this very cohomology class $h$, otherwise it raises an error.

The theory guarantees that the implemented algorithm works for toric ambient spaces which are smooth and complete. The check for completeness can be very time consuming. This check can be switched off by setting the optional argument check to the value false, as demonstrated below.

!!!warning This method works ONLY for F-theory models which are hypersurfaces in a toric ambient space.

!!!warning This method represents the Chern classes of said hypersurface by cohomology classes on the toric ambient space. These classes counterparts must be restricted to the hypersurface to truly represent the Chern class in question. Internally, we integrate those ambient space classes against the class of the hypersurface, which automatically executes the restriction to the hypersurface.

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

julia> h = chern_class(qsm_model, 4; check = false);

julia> is_trivial(h)
false

chern_classes(m::AbstractFTheoryModel; check::Bool = true)

If the elliptically fibered n-fold $Y_n$ underlying the F-theory model in question is given as a hypersurface in a toric ambient space, we can compute a cohomology class $h$ on the toric ambient space $X_\Sigma$, such that its restriction to $Y_n$ is the k-th Chern class $c_k$ of the tangent bundle of $Y_n$. If those assumptions are satisfied, this method returns a vector with the cohomology classes corresponding to all non-trivial Chern classes $c_k$ of $Y_n$. Otherwise, this methods raises an error.

As of right now, this method is computationally expensive for involved toric ambient spaces, such as in the example below.

The theory guarantees that the implemented algorithm works for toric ambient spaces which are simplicial and complete. The check for completeness can be very time consuming. This check can be switched off by setting the optional argument check to the value false, as demonstrated below.

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

julia> h = chern_classes(qsm_model; check = false);

julia> is_one(polynomial(h[0]))
true

julia> is_trivial(h[1])
true

julia> is_trivial(h[2])
false

euler_characteristic(m::AbstractFTheoryModel; check::Bool = true)

If the elliptically fibered n-fold $Y_n$ underlying the F-theory model in question is given as a hypersurface in a toric ambient space, we can compute the Euler characteristic. If this assumptions is satisfied, this method returns the Euler characteristic, otherwise it raises an error.

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

julia> h = euler_characteristic(qsm_model; check = false)
378

julia> h = euler_characteristic(qsm_model; check = false)
378

is_base_space_fully_specified(m::AbstractFTheoryModel)

Return true if the F-theory model has a concrete base space and false otherwise.

julia> t = literature_model(arxiv_id = "1109.3454", equation = "3.1")
Assuming that the first row of the given grading is the grading under Kbar

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

julia> is_base_space_fully_specified(t)
false

is_calabi_yau(m::AbstractFTheoryModel; check::Bool = true)

Verify if the first Chern class of the tangent bundle of the F-theory geometry $Y_n$ vanishes. If so, this confirms that this geometry is indeed Calabi-Yau, as required by the reasoning of F-theory.

The implemented algorithm works for hypersurface, Weierstrass and global Tate models, which are defined in a toric ambient space. It expresses $c_1(Y_n)$ as the restriction of a cohomology class $h$ on the toric ambient space. This in turn requires that the toric ambient space is simplicial and complete. We provide a switch to turn off these computationally very demanding checks. This is demonstrated in the example below.

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

julia> is_calabi_yau(qsm_model, check = false)
true

verify_euler_characteristic_from_hodge_numbers(m::AbstractFTheoryModel; check::Bool = true)

Verify if the Euler characteristic, as computed from integrating the 4-th Chern class, agrees with the results obtained from using the alternating sum of the Hodge numbers. If so, this method returns true. However, should information be missing, (e.g. some Hodge numbers), or the dimension of the F-theory model differ form 4, then this method raises an error.

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

julia> verify_euler_characteristic_from_hodge_numbers(qsm_model; check = false)
true

put_over_concrete_base(m::AbstractFTheoryModel, concrete_data::Dict{String, <:Any}; completeness_check::Bool = true)

Put an F-theory model defined over a family of spaces over a concrete base.

Currently, this functionality is limited to Tate and Weierstrass models.

julia> t = literature_model(arxiv_id = "1109.3454", equation = "3.1", completeness_check = false)
Assuming that the first row of the given grading is the grading under Kbar

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

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

julia> w_bundle = toric_line_bundle(torusinvariant_prime_divisors(B3)[1])
Toric line bundle on a normal toric variety

julia> kbar = anticanonical_bundle(B3)
Toric line bundle on a normal toric variety

julia> w = generic_section(w_bundle);

julia> a21 = generic_section(kbar^2 * w_bundle^(-1));

julia> a32 = generic_section(kbar^3 * w_bundle^(-2));

julia> a43 = generic_section(kbar^4 * w_bundle^(-3));

julia> t2 = put_over_concrete_base(t, Dict("base" => B3, "w" => w, "a21" => a21, "a32" => a32, "a43" => a43), completeness_check = false)
Global Tate model over a concrete base