[FTheoryTools] Introduce optional argument generic for literature mod…

…el constructor

experimental/FTheoryTools/src/AbstractFTheoryModels/methods.jl

@@ -699,7 +699,7 @@ Resolve a model with the index-th resolution that is known.
 julia> B3 = projective_space(NormalToricVariety, 3)
 Normal toric variety
 
-julia> w = 2 * torusinvariant_prime_divisors(B3)[1]
+julia> w = torusinvariant_prime_divisors(B3)[1]
 Torus-invariant, non-prime divisor on a normal toric variety
 
 julia> t = literature_model(arxiv_id = "1109.3454", equation = "3.1", base_space = B3, model_sections = Dict("w" => w), completeness_check = false)
@@ -709,6 +709,32 @@ Global Tate model over a concrete base -- SU(5)xU(1) restricted Tate model based
 
 julia> t2 = resolve(t, 1)
 Partially resolved global Tate model over a concrete base -- SU(5)xU(1) restricted Tate model based on arXiv paper 1109.3454 Eq. (3.1)
+
+julia> cox_ring(ambient_space(t2))
+Multivariate polynomial ring in 12 variables over QQ graded by
+  x1 -> [1 0 0 0 0 0 0]
+  x2 -> [0 1 0 0 0 0 0]
+  x3 -> [0 1 0 0 0 0 0]
+  x4 -> [0 1 0 0 0 0 0]
+  x -> [0 0 1 0 0 0 0]
+  y -> [0 0 0 1 0 0 0]
+  z -> [0 0 0 0 1 0 0]
+  e1 -> [0 0 0 0 0 1 0]
+  e4 -> [0 0 0 0 0 0 1]
+  e2 -> [-1 -3 -1 1 -1 -1 0]
+  e3 -> [0 4 1 -1 1 0 -1]
+  s -> [2 6 -1 0 2 1 1]
+
+julia> w2 = 2 * torusinvariant_prime_divisors(B3)[1]
+Torus-invariant, non-prime divisor on a normal toric variety
+
+julia> t3 = literature_model(arxiv_id = "1109.3454", equation = "3.1", base_space = B3, model_sections = Dict("w" => w2), completeness_check = false, generic = true)
+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> t4 = resolve(t3, 1)
+Partially resolved global Tate model over a concrete base -- SU(5)xU(1) restricted Tate model based on arXiv paper 1109.3454 Eq. (3.1)
 ```
 """
 function resolve(m::AbstractFTheoryModel, resolution_index::Int)

experimental/FTheoryTools/src/LiteratureModels/constructors.jl

@@ -32,6 +32,16 @@ Some literature models require additional parameters to specified to single out
 a model from a family of models. Such models can be provided using the optional
 argument `model_parameters`, which should be a dictionary such as `Dict("k" => 5)`.
 
+Notice that most F-theory models require the specification of sections of line
+bundles. Oftentimes, these sections appear in the singular loci of the models.
+Hence, generic sections also mean complicated singular loci. In case those loci
+are supposed to be blown up, then taking generic sections results in the most
+complicated situation with regard to singularity resolution. With that being said,
+we default to simple section consisting of a single monomial unless the optional
+argument `generic` is set to `true`. In other words, if you add
+`generic = true` to the argument list of `literature_model`, generic sections are
+used in the construction and subsequently resolution of the F-theory model in question.
+
 ```jldoctest
 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
@@ -125,17 +135,17 @@ julia> hypersurface_equation_parametrization(h2)
 b*w*v^2 - c0*u^4 - c1*u^3*v - c2*u^2*v^2 - c3*u*v^3 + w^2
 ```
 """
-function literature_model(; doi::String="", arxiv_id::String="", version::String="", equation::String="", model_parameters::Dict{String,<:Any} = Dict{String,Any}(), base_space::FTheorySpace = affine_space(NormalToricVariety, 0), model_sections::Dict{String, <:Any} = Dict{String,Any}(), completeness_check::Bool = true)
+function literature_model(; doi::String="", arxiv_id::String="", version::String="", equation::String="", model_parameters::Dict{String,<:Any} = Dict{String,Any}(), base_space::FTheorySpace = affine_space(NormalToricVariety, 0), model_sections::Dict{String, <:Any} = Dict{String,Any}(), completeness_check::Bool = true, generic::Bool = false)
   model_dict = _find_model(doi, arxiv_id, version, equation)
-  return literature_model(model_dict; model_parameters = model_parameters, base_space = base_space, model_sections = model_sections, completeness_check = completeness_check)
+  return literature_model(model_dict; model_parameters = model_parameters, base_space = base_space, model_sections = model_sections, completeness_check = completeness_check, generic = generic)
 end
 
-function literature_model(k::Int; model_parameters::Dict{String,<:Any} = Dict{String,Any}(), base_space::FTheorySpace = affine_space(NormalToricVariety, 0), model_sections::Dict{String, <:Any} = Dict{String,Any}(), completeness_check::Bool = true)
+function literature_model(k::Int; model_parameters::Dict{String,<:Any} = Dict{String,Any}(), base_space::FTheorySpace = affine_space(NormalToricVariety, 0), model_sections::Dict{String, <:Any} = Dict{String,Any}(), completeness_check::Bool = true, generic::Bool = false)
   model_dict = _find_model(k)
-  return literature_model(model_dict; model_parameters = model_parameters, base_space = base_space, model_sections = model_sections, completeness_check = completeness_check)
+  return literature_model(model_dict; model_parameters = model_parameters, base_space = base_space, model_sections = model_sections, completeness_check = completeness_check, generic = generic)
 end
 
-function literature_model(model_dict::Dict{String, Any}; model_parameters::Dict{String,<:Any} = Dict{String,Any}(), base_space::FTheorySpace = affine_space(NormalToricVariety, 0), model_sections::Dict{String, <:Any} = Dict{String,Any}(), completeness_check::Bool = true)
+function literature_model(model_dict::Dict{String, Any}; model_parameters::Dict{String,<:Any} = Dict{String,Any}(), base_space::FTheorySpace = affine_space(NormalToricVariety, 0), model_sections::Dict{String, <:Any} = Dict{String,Any}(), completeness_check::Bool = true, generic::Bool = false)
   #return model_dict
   # (1) Deal with model parameters
   if haskey(model_dict, "model_parameters")
@@ -175,7 +185,7 @@ function literature_model(model_dict::Dict{String, Any}; model_parameters::Dict{
     end
 
     # Construct the model
-    model = _construct_literature_model_over_concrete_base(model_dict, base_space, model_sections, completeness_check)
+    model = _construct_literature_model_over_concrete_base(model_dict, base_space, model_sections, completeness_check, generic)
     @vprint :FTheoryModelPrinter 0 "Construction over concrete base may lead to singularity enhancement. Consider computing singular_loci. However, this may take time!\n\n"
 
   # (2b) Construct the model over generic base
@@ -245,7 +255,7 @@ end
 #######################################################
 
 # Constructs literature model over concrete base
-function _construct_literature_model_over_concrete_base(model_dict::Dict{String,Any}, base_space::FTheorySpace, model_sections::Dict{String,ToricDivisor}, completeness_check::Bool)
+function _construct_literature_model_over_concrete_base(model_dict::Dict{String,Any}, base_space::FTheorySpace, model_sections::Dict{String,ToricDivisor}, completeness_check::Bool, generic::Bool)
 
   # We first create a polynomial ring in which we can read all model sections as polynomials of the defining sections
   @req ((model_dict["model_descriptors"]["type"] == "tate") || (model_dict["model_descriptors"]["type"] == "weierstrass") || (model_dict["model_descriptors"]["type"] == "hypersurface")) "Model is not a Tate or Weierstrass model"
@@ -269,9 +279,11 @@ function _construct_literature_model_over_concrete_base(model_dict::Dict{String,
   explicit_model_sections = Dict{String, MPolyDecRingElem{QQFieldElem, QQMPolyRingElem}}()
   for (key, value) in model_sections
     @req is_effective(toric_divisor_class(value)) "Encountered a non-effective model section"
-    explicit_model_sections[key] = generic_section(toric_line_bundle(value))
-    # Lead to error when computing singular loci - currently only monomials allowed...
-    #explicit_model_sections[key] = basis_of_global_sections(toric_line_bundle(value))[end]
+    if generic
+      explicit_model_sections[key] = generic_section(toric_line_bundle(value))
+    else
+      explicit_model_sections[key] = basis_of_global_sections(toric_line_bundle(value))[end]
+    end
   end
   for (key, value) in internal_model_sections
     @req is_effective(toric_divisor_class(value)) "Encountered a non-effective (internal) model section"