Common Model Ops

ambient_space(m::AbstractFTheoryModel)

Return the ambient space of the F-theory model.

Examples

julia> w = weierstrass_model_over_projective_space(2);

julia> dim(ambient_space(w))
4

base_space(m::AbstractFTheoryModel)

Return the base space of the F-theory model.

Examples

julia> w = weierstrass_model_over_projective_space(2);

julia> dim(base_space(w))
2

fiber_ambient_space(m::AbstractFTheoryModel)

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

Examples

julia> w = weierstrass_model_over_projective_space(2);

julia> dim(fiber_ambient_space(w))
2

calabi_yau_hypersurface(m::AbstractFTheoryModel)

Return the Calabi–Yau hypersurface that defines the hypersurface model as a closed subvariety of its toric ambient space.

Examples

julia> w =  weierstrass_model_over_projective_space(3)
Weierstrass model over a concrete base

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

julia> t = global_tate_model_over_projective_space(2)
Global Tate model over a concrete base

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

julia> b = projective_space(NormalToricVariety, 2);

julia> kb = anticanonical_divisor_class(b);

julia> fiber_ambient = weighted_projective_space(NormalToricVariety, [2, 3, 1]);

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

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

julia> h = hypersurface_model(b, fiber_ambient, [2 * kb, 3 * kb], p; completeness_check=false)
Hypersurface model over a concrete base

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

is_base_space_fully_specified(m::AbstractFTheoryModel)

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

Examples

julia> t = literature_model(arxiv_id = "1109.3454", equation = "3.1")
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

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.

Examples

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.

Examples

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

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.

Examples

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

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.

Examples

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

hodge_h11(m::AbstractFTheoryModel)

Return hodge_h11 of the F-theory model if known, otherwise throw an error.

See Advanced Mathematical Attributes for more details.

Examples

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

julia> hodge_h11(qsm_model)
31

hodge_h12(m::AbstractFTheoryModel)

Return hodge_h12 of the F-theory model if known, otherwise throw an error.

See Advanced Mathematical Attributes for more details.

Examples

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

julia> hodge_h12(qsm_model)
10

hodge_h13(m::AbstractFTheoryModel)

Return hodge_h13 of the F-theory model if known, otherwise throw an error.

See Advanced Mathematical Attributes for more details.

Examples

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

julia> hodge_h13(qsm_model)
34

hodge_h22(m::AbstractFTheoryModel)

Return hodge_h22 of the F-theory model if known, otherwise throw an error.

See Advanced Mathematical Attributes for more details.

Examples

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

julia> hodge_h22(qsm_model)
284

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.

Examples

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

kbar3(m::AbstractFTheoryModel)

Return kbar3 of the F-theory model if known, otherwise throw an error.

See Topological Data of a QSM for more details.

Examples

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

julia> kbar3(qsm_model)
6

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.

Examples

julia> t = literature_model(arxiv_id = "1109.3454", equation = "3.1", completeness_check = false)
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

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.

Examples

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

Examples

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

Examples

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

zero_section(m::AbstractFTheoryModel)

Return zero_section of the F-theory model if known, otherwise throw an error.

See Zero Section for more details.

Examples

julia> h = literature_model(arxiv_id = "1208.2695", equation = "B.5")
Hypersurface model over a not fully specified base

julia> zero_section(h)
3-element Vector{MPolyDecRingElem{QQFieldElem, QQMPolyRingElem}}:
 0
 1
 0

zero_section_class(m::AbstractFTheoryModel)

Return zero_section_class of the F-theory model if known, otherwise throw an error.

See Zero Section for more details.

Examples

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

julia> zero_section_class(qsm_model)
Cohomology class on a normal toric variety given by e2 + 2*u + 3*e4 + e1 - w

zero_section_index(m::AbstractFTheoryModel)

Return zero_section_index of the F-theory model if known, otherwise throw an error.

See Zero Section for more details.

Examples

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

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

julia> foah15_B3 = literature_model(arxiv_id = "1408.4808", equation = "3.190", type = "hypersurface", base_space = B3, defining_classes = Dict("s7" => Kbar, "s9" => Kbar))
Hypersurface model over a concrete base

julia> zero_section_index(foah15_B3)
5

generating_sections(m::AbstractFTheoryModel)

Return generating_sections of the F-theory model if known, otherwise throw an error.

See Advanced Mathematical Attributes for more details.

Examples

julia> m = literature_model(arxiv_id = "1109.3454", equation = "3.1")
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> generating_sections(m)
1-element Vector{Vector{MPolyDecRingElem{QQFieldElem, QQMPolyRingElem}}}:
 [0, 0, 1]

torsion_sections(m::AbstractFTheoryModel)

Return torsion_sections of the F-theory model if known, otherwise throw an error.

See Advanced Mathematical Attributes for more details.

Examples

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

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

julia> foah15_B3 = literature_model(arxiv_id = "1408.4808", equation = "3.190", type = "hypersurface", base_space = B3, defining_classes = Dict("s7" => Kbar, "s9" => Kbar))
Hypersurface model over a concrete base

julia> length(torsion_sections(foah15_B3))
1

add_generating_section!(m::AbstractFTheoryModel, addition::Vector{String})

Add a generating section for a model.

See Mordell–Weil Group for more details.

Examples

julia> m = literature_model(arxiv_id = "1109.3454", equation = "3.1")
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> add_generating_section!(m, ["0","0","1"])

julia> length(generating_sections(m))
1

add_torsion_section!(m::AbstractFTheoryModel, addition::Vector{String})

Add a torsion section for a model.

See Mordell–Weil Group for more details.

Examples

julia> m = literature_model(arxiv_id = "1408.4808", equation = "3.190", type = "hypersurface")
Hypersurface model over a not fully specified base

julia> add_torsion_section!(m, ["1", "s5", "-s2", "1", "1", "1", "1", "0"])

julia> length(torsion_sections(m))
1

gauge_algebra(m::AbstractFTheoryModel)

Return gauge_algebra of the F-theory model if known, otherwise throw an error.

See Gauge Group for more details.

Examples

julia> t = literature_model(arxiv_id = "1408.4808", equation = "3.190", type = "hypersurface")
Hypersurface model over a not fully specified base

julia> gauge_algebra(t)
Direct sum Lie algebra
  of dimension 13
with summands
  sl_2
  sl_2
  sl_2
  sl_2
  linear Lie algebra
over algebraic closure of rational field

global_gauge_group_quotient(m::AbstractFTheoryModel)

Return global_gauge_group_quotient of the F-theory model if known, otherwise throw an error.

See Gauge Group for more details.

Examples

julia> t = literature_model(arxiv_id = "1408.4808", equation = "3.190", type = "hypersurface")
Hypersurface model over a not fully specified base

julia> global_gauge_group_quotient(t)
5-element Vector{Vector{String}}:
 ["-identity_matrix(C,2)", "-identity_matrix(C,2)"]
 ["-identity_matrix(C,2)"]
 ["-identity_matrix(C,2)"]
 ["-identity_matrix(C,2)", "-identity_matrix(C,2)"]
 ["-identity_matrix(C,1)"]