[FTheoryTools] Improve construction of models over arbitrary base spaces

docs/src/AlgebraicGeometry/ToricVarieties/NormalToricVarieties.md

@@ -53,15 +53,49 @@ projective_space(::Type{NormalToricVariety}, d::Int; set_attributes::Bool = true
 weighted_projective_space(::Type{NormalToricVariety}, w::Vector{T}; set_attributes::Bool = true) where {T <: IntegerUnion}
 ```
 
+### Constructions based on triangulations
+
+It is possible to associate toric varieties to star triangulations
+of the lattice points of polyhedrons. Specifically, we can associate
+to any full star triangulation of the lattice points of the polyhedron
+in question a toric variety. For this task, we provide the following
+constructors.
+```@docs
+normal_toric_variety_from_star_triangulation(P::Polyhedron; set_attributes::Bool = true)
+normal_toric_varieties_from_star_triangulations(P::Polyhedron; set_attributes::Bool = true)
+```
+An application of this functionality exists in the physics.
+Witten's Generalized-Sigma models (GLSM) [Wit88](@cite)
+originally sparked interest in the physics community in toric varieties.
+On a mathematical level, this establishes a construction of toric
+varieties for which a Z^n grading of the Cox ring is provided. See
+for example [FJR17](@cite), which describes this as GIT
+construction [CLS11](@cite).
+
+Explicitly, given the grading of the Cox ring, the map from
+the group of torus invariant Weil divisors to the class group
+is known. Under the assumption that the variety in question
+has no torus factor, we can then identify the map from the
+lattice to the group of torus invariant Weil divisors as the
+kernel of the map from the torus invariant Weil divisor to the
+class group. The latter is a map between free Abelian groups, i.e.
+is provided by an integer valued matrix. The rows of this matrix
+are nothing but the ray generators of the fan of the toric variety.
+It then remains to triangulate these rays, hence in general for
+a GLSM the toric variety is only unique up to fine regular
+star triangulations. We provide the following two constructors:
+```@docs
+normal_toric_variety_from_glsm(charges::ZZMatrix; set_attributes::Bool = true)
+normal_toric_varieties_from_glsm(charges::ZZMatrix; set_attributes::Bool = true)
+```
+
 ### Further Constructions
 
 ```@docs
 blow_up(v::AbstractNormalToricVariety, I::MPolyIdeal; coordinate_name::String = "e", set_attributes::Bool = true)
 blow_up(v::AbstractNormalToricVariety, new_ray::AbstractVector{<:IntegerUnion}; coordinate_name::String = "e", set_attributes::Bool = true)
 blow_up(v::AbstractNormalToricVariety, n::Int; coordinate_name::String = "e", set_attributes::Bool = true)
 Base.:*(v::AbstractNormalToricVariety, w::AbstractNormalToricVariety; set_attributes::Bool = true)
-normal_toric_varieties_from_star_triangulations(P::Polyhedron; set_attributes::Bool = true)
-normal_toric_varieties_from_glsm(charges::ZZMatrix; set_attributes::Bool = true)
 ```
 
 

experimental/FTheoryTools/src/LiteratureModels/attributes.jl

@@ -164,6 +164,17 @@ the given model. These are either other presentations (Weierstrass, Tate, ...)
 of the given model, or other version of the same model from a different paper
 in the literature. If no `associated_literature_models` are known,
 an error is raised.
+
+```jldoctest
+julia> m = literature_model(arxiv_id = "1507.05954", equation = "A.1")
+Assuming that the first row of the given grading is the grading under Kbar
+
+Weierstrass model over a not fully specified base -- U(1)xU(1) Weierstrass model based on arXiv paper 1507.05954 Eq. (A.1)
+
+julia> associated_literature_models(m)
+1-element Vector{String}:
+ "1507_05954-1"
+```
 """
 function associated_literature_models(m::AbstractFTheoryModel)
   @req has_associated_literature_models(m) "No associated models known for this model"
@@ -329,6 +340,19 @@ end
 
 Return the `journal_report_numbers` of the published paper in which the given model was introduced.
 If no `journal_report_numbers` is known, an error is raised.
+
+```jldoctest
+julia> m = literature_model(arxiv_id = "1507.05954", equation = "A.1")
+Assuming that the first row of the given grading is the grading under Kbar
+
+Weierstrass model over a not fully specified base -- U(1)xU(1) Weierstrass model based on arXiv paper 1507.05954 Eq. (A.1)
+
+julia> journal_report_numbers(m)
+3-element Vector{String}:
+ "UPR-1274-T"
+ "CERN-PH-TH-2015-157"
+ "MIT-CTP-4678"
+```
 """
 function journal_report_numbers(m::AbstractFTheoryModel)
   @req has_journal_report_numbers(m) "No journal pages known for this model"

experimental/FTheoryTools/src/LiteratureModels/constructors.jl

@@ -253,7 +253,6 @@ function _construct_literature_tate_model(model_dict::Dict{String,Any})
   @req haskey(model_dict["model_data"], "auxiliary_base_grading") "Currently, only literature models over arbitrary bases are supported"
   auxiliary_base_grading = matrix(ZZ, transpose(hcat([[eval_poly(weight, ZZ) for weight in vec] for vec in model_dict["model_data"]["auxiliary_base_grading"]]...)))
   auxiliary_base_grading = vcat([[Int(k) for k in auxiliary_base_grading[i,:]] for i in 1:nrows(auxiliary_base_grading)]...)
-
   return global_tate_model(auxiliary_base_ring, auxiliary_base_grading, base_dim, [a1, a2, a3, a4, a6])
 end
 
@@ -270,6 +269,5 @@ function _construct_literature_weierstrass_model(model_dict::Dict{String,Any})
   @req haskey(model_dict["model_data"], "auxiliary_base_grading") "Currently, only literature models over arbitrary bases are supported"
   auxiliary_base_grading = matrix(ZZ, transpose(hcat([[eval_poly(weight, ZZ) for weight in vec] for vec in model_dict["model_data"]["auxiliary_base_grading"]]...)))
   auxiliary_base_grading = vcat([[Int(k) for k in auxiliary_base_grading[i,:]] for i in 1:nrows(auxiliary_base_grading)]...)
-
   return weierstrass_model(auxiliary_base_ring, auxiliary_base_grading, base_dim, f, g)
 end

experimental/FTheoryTools/src/WeierstrassModels/constructors.jl

@@ -195,6 +195,7 @@ function weierstrass_model(auxiliary_base_ring::MPolyRing, auxiliary_base_gradin
 
   # convert Weierstrass sections into polynomials of the auxiliary base
   auxiliary_base_space = _auxiliary_base_space(gens_base_names, auxiliary_base_grading, d)
+
   S = cox_ring(auxiliary_base_space)
   ring_map = hom(auxiliary_base_ring, S, gens(S)[1:ngens(auxiliary_base_ring)])
   f = ring_map(weierstrass_f)
@@ -232,7 +233,7 @@ function Base.show(io::IO, w::WeierstrassModel)
   end
   if has_model_description(w)
     push!(properties_string, "-- " * string(get_attribute(w, :model_description)))
-    if has_model_parameters(t)
+    if has_model_parameters(w)
       push!(properties_string, "with parameter values (" * join(["$key = $(string(val))" for (key, val) in model_parameters(t)], ", ") * ")")
     end
   end

experimental/FTheoryTools/src/auxiliary.jl

@@ -2,36 +2,44 @@
 # 1: Construct auxiliary base space
 ################################################################
 
+
 function _auxiliary_base_space(auxiliary_base_variable_names::Vector{String}, auxiliary_base_grading::Matrix{Int64}, d::Int)
+
+  # We now try to guess one toric base space with the desired grading and maximal dimension
+  charges = matrix(ZZ, auxiliary_base_grading)
+  variety = normal_toric_variety_from_glsm(charges)
+  G1 = free_abelian_group(ncols(charges))
+  G2 = free_abelian_group(nrows(charges))
+  set_attribute!(variety, :map_from_torusinvariant_weil_divisor_group_to_class_group, hom(G1, G2, transpose(charges)))
+  set_attribute!(variety, :class_group, G2)
+  set_attribute!(variety, :torusinvariant_weil_divisor_group, G1)
 
-  # Find candidate base spaces
-  candidates = normal_toric_varieties_from_glsm(matrix(ZZ, auxiliary_base_grading))
-  @req length(candidates) > 0 "Could not find a full star triangulation"
-  f = candidates[1]
-  @req dim(f) >= d "Cannot construct an auxiliary base space of the desired dimension"
+  # Check if dimensional requirement is met
+  @req dim(variety) >= d "Cannot construct an auxiliary base space of the desired dimension"
 
   # Construct one base space of desired dimension
-  fan_rays = matrix(ZZ, rays(f))
-  fan_rays = [vec([Int(a) for a in fan_rays[k,:]]) for k in 1:nrows(fan_rays)]
-  fan_max_cone_matrix = matrix(ZZ, cones(f))
-  new_max_cones = Vector{Int}[]
-  for k in 1:nrows(fan_max_cone_matrix)
-    indices = findall(x -> x == 1, vec(fan_max_cone_matrix[k,:]))
-    if length(indices) == d
-      push!(new_max_cones, indices)
+  auxiliary_base_space = variety
+  if dim(auxiliary_base_space) != d
+    integral_rays = matrix(ZZ, rays(variety))
+    integral_rays = [vec([Int(a) for a in integral_rays[k,:]]) for k in 1:nrows(integral_rays)]
+    all_cones = cones(variety)
+    fan_max_cone_matrix = matrix(ZZ, cones(variety))
+    new_max_cones = Vector{Int}[]
+    for k in 1:nrows(fan_max_cone_matrix)
+      cone = positive_hull(integral_rays[all_cones[k,:]])
+      if dim(cone) == d
+        indices = findall(x -> x == 1, vec(fan_max_cone_matrix[k,:]))
+        push!(new_max_cones, indices)
+      end
     end
+    auxiliary_base_space = normal_toric_variety(integral_rays, new_max_cones; non_redundant = true)
   end
-  auxiliary_base_space = normal_toric_variety(fan_rays, new_max_cones; non_redundant = true)
-
-  # Set attributes for this base space
+
+  # Set attributes of this base space and return it
   set_coordinate_names(auxiliary_base_space, auxiliary_base_variable_names)
-  G1 = free_abelian_group(ncols(auxiliary_base_grading))
-  G2 = free_abelian_group(nrows(auxiliary_base_grading))
-  grading_of_cox_ring = hom(G1, G2, transpose(matrix(ZZ, auxiliary_base_grading)))
-  set_attribute!(auxiliary_base_space, :map_from_torusinvariant_weil_divisor_group_to_class_group, grading_of_cox_ring)
+  set_attribute!(auxiliary_base_space, :map_from_torusinvariant_weil_divisor_group_to_class_group, hom(G1, G2, transpose(charges)))
   set_attribute!(auxiliary_base_space, :class_group, G2)
   set_attribute!(auxiliary_base_space, :torusinvariant_weil_divisor_group, G1)
-
   return auxiliary_base_space
 end
 

src/AlgebraicGeometry/ToricVarieties/NormalToricVarieties/standard_constructions.jl

@@ -491,6 +491,49 @@ end
 
 
 
+@doc raw"""
+    normal_toric_variety_from_star_triangulation(P::Polyhedron; set_attributes::Bool = true)
+
+Returns a toric variety that was obtained from a fine regular
+star triangulation of the lattice points of the polyhedron P.
+This is particularly useful when the lattice points of the
+polyhedron in question admit many triangulations.
+
+# Examples
+```jldoctest
+julia> P = convex_hull([0 0 0; 0 0 1; 1 0 1; 1 1 1; 0 1 1])
+Polyhedron in ambient dimension 3
+
+julia> v = normal_toric_variety_from_star_triangulation(P)
+Normal toric variety
+```
+"""
+function normal_toric_variety_from_star_triangulation(P::Polyhedron; set_attributes::Bool = true)
+  # Find position of origin in the lattices points of the polyhedron P
+  pts = matrix(ZZ, lattice_points(P))
+  zero = [0 for i in 1:ambient_dim(P)]
+  indices = findall(k -> pts[k,:] == matrix(ZZ, [zero]), 1:nrows(pts))
+  @req length(indices) == 1 "Polyhedron must contain origin (exactly once)"
+
+  # Change order of lattice points s.t. zero is the first point
+  tmp = pts[1,:]
+  pts[1,:] = pts[indices[1],:]
+  pts[indices[1],:] = tmp
+
+  # Find one triangulation and turn it into the maximal cones of the toric variety in question. Note that:
+  # (a) needs to be converted to incidence matrix
+  # (b) one has to remove origin from list of indices (as removed above)
+  max_cones = IncidenceMatrix([[c[i]-1 for i in 2:length(c)] for c in _find_full_star_triangulation(pts)])
+
+  # Rays are all but the zero vector at the first position of pts
+  integral_rays = vcat([pts[k,:] for k in 2:nrows(pts)])
+
+  # construct the variety
+  return normal_toric_variety(integral_rays, max_cones; non_redundant = true)
+end
+
+
+
 @doc raw"""
     normal_toric_varieties_from_star_triangulations(P::Polyhedron; set_attributes::Bool = true)
 
@@ -545,28 +588,68 @@ end
 
 
 
+@doc raw"""
+  normal_toric_variety_from_glsm(charges::ZZMatrix; set_attributes::Bool = true)
+
+This function returns one toric variety with the desired
+GLSM charges. This can be particularly useful provided that
+there are many such toric varieties.
+
+# Examples
+```jldoctest
+julia> charges = [[1, 1, 1]]
+1-element Vector{Vector{Int64}}:
+ [1, 1, 1]
+
+julia> normal_toric_variety_from_glsm(charges)
+Normal toric variety
+```
+
+For convenience, we also support:
+- normal_toric_variety_from_glsm(charges::Vector{Vector{Int}})
+- normal_toric_variety_from_glsm(charges::Vector{Vector{ZZRingElem}})
+"""
+function normal_toric_variety_from_glsm(charges::ZZMatrix; set_attributes::Bool = true)
+
+  # find the ray generators
+  G1 = free_abelian_group(ncols(charges))
+  G2 = free_abelian_group(nrows(charges))
+  map = hom(G1, G2, transpose(charges))
+  ker = kernel(map)
+  embedding = snf(ker[1])[2] * ker[2]
+  rays = transpose(embedding.map)
+
+  # identify the points to be triangulated
+  pts = zeros(ZZ, nrows(rays), ncols(charges)-nrows(charges))
+  for i in 1:nrows(rays)
+    pts[i, :] = [ZZRingElem(c) for c in rays[i, :]]
+  end
+  zero = [0 for i in 1:ncols(charges)-nrows(charges)]
+  pts = vcat(matrix(ZZ, transpose(zero)), matrix(ZZ, pts))
+
+  # construct varieties
+  integral_rays = vcat([pts[k,:] for k in 2:nrows(pts)])
+  max_cones = IncidenceMatrix([[c[i]-1 for i in 2:length(c)] for c in _find_full_star_triangulation(pts)])
+  variety = normal_toric_variety(integral_rays, max_cones; non_redundant = true)
+
+  # set the attributes and return the variety
+  if set_attributes
+    set_attribute!(variety, :map_from_torusinvariant_weil_divisor_group_to_class_group, map)
+    set_attribute!(variety, :class_group, G2)
+    set_attribute!(variety, :torusinvariant_weil_divisor_group, G1)
+  end
+  return variety
+end
+normal_toric_variety_from_glsm(charges::Vector{Vector{T}}; set_attributes::Bool = true) where {T <: IntegerUnion} = normal_toric_variety_from_glsm(matrix(ZZ, charges); set_attributes = set_attributes)
+
+
+
 @doc raw"""
     normal_toric_varieties_from_glsm(charges::ZZMatrix; set_attributes::Bool = true)
 
-Witten's Generalized-Sigma models (GLSM) [Wit88](@cite)
-originally sparked interest in the physics community in toric varieties.
-On a mathematical level, this establishes a construction of toric
-varieties for  which a Z^n grading of the Cox ring is provided. See
-for example [FJR17](@cite), which describes this as GIT
-construction [CLS11](@cite).
-
-Explicitly, given the grading of the Cox ring, the map from
-the group of torus invariant Weil divisors to the class group
-is known. Under the assumption that the variety in question
-has no torus factor, we can then identify the map from the
-lattice to the group of torus invariant Weil divisors as the
-kernel of the map from the torus invariant Weil divisor to the
-class group. The latter is a map between free Abelian groups, i.e.
-is provided by an integer valued matrix. The rows of this matrix
-are nothing but the ray generators of the fan of the toric variety.
-It then remains to triangulate these rays, hence in general for
-a GLSM the toric variety is only unique up to fine regular
-star triangulations.
+This function returns all toric variety with the desired
+GLSM charges. This computation may take a long time if
+there are many such toric varieties.
 
 # Examples
 ```jldoctest
@@ -597,11 +680,11 @@ For convenience, we also support:
 - normal_toric_varieties_from_glsm(charges::Vector{Vector{ZZRingElem}})
 """
 function normal_toric_varieties_from_glsm(charges::ZZMatrix; set_attributes::Bool = true)
-    
+
     # find the ray generators
-    source = free_abelian_group(ncols(charges))
-    range = free_abelian_group(nrows(charges))
-    map = hom(source, range, transpose(charges))
+    G1 = free_abelian_group(ncols(charges))
+    G2 = free_abelian_group(nrows(charges))
+    map = hom(G1, G2, transpose(charges))
     ker = kernel(map)
     embedding = snf(ker[1])[2] * ker[2]
     rays = transpose(embedding.map)
@@ -620,12 +703,9 @@ function normal_toric_varieties_from_glsm(charges::ZZMatrix; set_attributes::Boo
     varieties = [normal_toric_variety(integral_rays, cones; non_redundant = true) for cones in max_cones]
 
     # set the map from Div_T -> Cl to the desired matrix
-    for v in varieties
-      G1 = free_abelian_group(ncols(charges))
-      G2 = free_abelian_group(nrows(charges))
-      grading_of_cox_ring = hom(G1, G2, transpose(charges))
-      if set_attributes
-        set_attribute!(v, :map_from_torusinvariant_weil_divisor_group_to_class_group, grading_of_cox_ring)
+    if set_attributes
+      for v in varieties
+        set_attribute!(v, :map_from_torusinvariant_weil_divisor_group_to_class_group, map)
         set_attribute!(v, :class_group, G2)
         set_attribute!(v, :torusinvariant_weil_divisor_group, G1)
       end
@@ -635,6 +715,3 @@ function normal_toric_varieties_from_glsm(charges::ZZMatrix; set_attributes::Boo
     return varieties
 end
 normal_toric_varieties_from_glsm(charges::Vector{Vector{T}}; set_attributes::Bool = true) where {T <: IntegerUnion} = normal_toric_varieties_from_glsm(matrix(ZZ, charges); set_attributes = set_attributes)
-
-
-