[FTheoryTools] Added more checks for G4 fluxes

docs/oscar_references.bib

@@ -1068,6 +1068,18 @@ @Book{Ful98
   doi           = {10.1007/978-1-4612-1700-8}
 }
 
+@Article{GH12,
+  author        = {Grimm, Thomas W. and Hayashi, Hirotaka},
+  title         = {F-theory fluxes, chirality and Chern-Simons theories},
+  journal       = {Journal of High Energy Physics},
+  volume        = {2012},
+  number        = {3},
+  publisher     = {Springer Science and Business Media LLC},
+  year          = {2012},
+  month         = mar,
+  doi           = {10.1007/jhep03(2012)027}
+}
+
 @InProceedings{GHJ16,
   author        = {Gawrilow, Ewgenij and Hampe, Simon and Joswig, Michael},
   title         = {The polymake XML File Format},

experimental/FTheoryTools/docs/src/literature.md

@@ -100,6 +100,7 @@ following methods:
 * `has_weighted_resolution_generating_sections(m::AbstractFTheoryModel)`,
 * `has_weighted_resolution_zero_sections(m::AbstractFTheoryModel)`,
 * `has_zero_section(m::AbstractFTheoryModel)`,
+* `has_zero_section_coordinates(m::AbstractFTheoryModel)`,
 * `has_gauge_algebra(m::AbstractFTheoryModel)`,
 * `has_global_gauge_quotients(m::AbstractFTheoryModel)`.
 

experimental/FTheoryTools/src/AbstractFTheoryModels/attributes.jl

@@ -1039,6 +1039,28 @@ function zero_section(m::AbstractFTheoryModel)
 end
 
 
+@doc raw"""
+    zero_section_class(m::AbstractFTheoryModel)
+
+Return the zero section class of a model as a cohomology class in the toric ambient space.
+If no zero section class is known, an error is raised.
+This information is not typically available for
+Weierstrass and global Tate models, whose zero section classs are known.
+
+```jldoctest; setup = :(Oscar.LazyArtifacts.ensure_artifact_installed("QSMDB", Oscar.LazyArtifacts.find_artifacts_toml(Oscar.oscardir)))
+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 x32 + 2*x33 + 3*x34 + x35 - x36
+```
+"""
+function zero_section_class(m::AbstractFTheoryModel)
+  @req has_zero_section_class(m) "No zero section class stored for this model"
+  return get_attribute(m, :zero_section_class)
+end
+
+
 @doc raw"""
     gauge_algebra(m::AbstractFTheoryModel)
 
@@ -1212,6 +1234,9 @@ 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
 ```

experimental/FTheoryTools/src/AbstractFTheoryModels/methods.jl

@@ -640,6 +640,15 @@ function set_zero_section(m::AbstractFTheoryModel, desired_value::Vector{String}
   set_attribute!(m, :zero_section => [f(eval_poly(l, R)) for l in desired_value])
 end
 
+function set_zero_section_class(m::AbstractFTheoryModel, desired_value::String)
+  divs = torusinvariant_prime_divisors(ambient_space(m))
+  cohomology_ring(ambient_space(m); check=false)
+  cox_gens = string.(gens(cox_ring(ambient_space(m))))
+  @req desired_value in cox_gens "Specified zero section is invalid"
+  index = findfirst(x -> x==desired_value, cox_gens)
+  set_attribute!(m, :zero_section_class => cohomology_class(divs[index]))
+end
+
 function set_gauge_algebra(m::AbstractFTheoryModel, algebras::Vector{String})
   C = algebraic_closure(QQ)
   function _construct(g::String)

experimental/FTheoryTools/src/AbstractFTheoryModels/properties.jl

@@ -97,6 +97,7 @@ has_weighted_resolutions(m::AbstractFTheoryModel) = has_attribute(m, :weighted_r
 has_weighted_resolution_generating_sections(m::AbstractFTheoryModel) = has_attribute(m, :weighted_resolution_generating_sections)
 has_weighted_resolution_zero_sections(m::AbstractFTheoryModel) = has_attribute(m, :weighted_resolution_zero_sections)
 has_zero_section(m::AbstractFTheoryModel) = has_attribute(m, :zero_section)
+has_zero_section_class(m::AbstractFTheoryModel) = has_attribute(m, :zero_section_class)
 has_gauge_algebra(m::AbstractFTheoryModel) = has_attribute(m, :gauge_algebra)
 has_global_gauge_quotients(m::AbstractFTheoryModel) = has_attribute(m, :global_gauge_quotients)
 

experimental/FTheoryTools/src/G4Fluxes/properties.jl

@@ -14,7 +14,7 @@
 simple consistency checks are met, this method will return
 `true` and otherwise `false`.
 
-It is worth mentioning that currently (July 2024), we only
+It is worth mentioning that currently (August 2024), we only
 support this check for $G_4$-fluxes defined on Weierstrass,
 global Tate and hypersurface models. If this condition is not
 met, this method will return an error.
@@ -52,9 +52,111 @@
   # now execute elementary checks of the quantization condition
   for i in 1:length(c_ds)
     for j in i:length(c_ds)
-      numb = integrate(cohomology_class(ambient_space(m), twist_g4 * cy * c_ds[i] * c_ds[j]); check = false)
+      numb = integrate(cohomology_class(ambient_space(m), twist_g4 * c_ds[i] * c_ds[j] * cy); check = false)
       !is_integer(numb) && return false
     end
   end
   return true
 end
+
+
+@doc raw"""
+    passes_verticality_checks(gf::G4Flux)
+
+G4-fluxes are subject to verticality conditions described first in [GH12](@cite) and in more detail in [Wei18](@cite).
+It is hard to verify that these condition are met. However,
+we can execute a number of simple consistency checks, by
+verifying that $\int_{Y}{G_4 \wedge [D_1] \wedge [zero section]} = 0$ and $\int_{Y}{G_4 \wedge [D_1] \wedge [D_2]} = 0$
+for all toric base divisors $D_1$ and $D_2$. If all of these
+simple consistency checks are met, this method will return
+`true` and otherwise `false`
+
+```jldoctest; setup = :(Oscar.LazyArtifacts.ensure_artifact_installed("QSMDB", Oscar.LazyArtifacts.find_artifacts_toml(Oscar.oscardir)))
+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 lacking elementary quantization checks
+
+julia> passes_verticality_checks(g4)
+true
+```
+"""
+@attr Bool function passes_verticality_checks(g4::G4Flux)
+  m = model(g4)
+  @req (m isa WeierstrassModel || m isa GlobalTateModel || m isa HypersurfaceModel) "Tadpole cancellation checks for  G4-fluxes only supported for Weierstrass, global Tate and hypersurface models"
+  @req base_space(m) isa NormalToricVariety "Tadpole cancellation checks for G4-flux currently supported only for toric base"
+  @req ambient_space(m) isa NormalToricVariety "Tadpole cancellation checks for G4-flux currently supported only for toric ambient space"
+  @req has_zero_section_class(m) "For verticality checks, a model zero section class needs to be specified"
+
+  # Compute the cohomology class corresponding to the hypersurface equation
+  cy = polynomial(cohomology_class(toric_divisor_class(ambient_space(m), degree(hypersurface_equation(m)))))
+
+  n = length(gens(cox_ring(base_space(m))))
+  c_ds = [polynomial(cohomology_class(d)) for d in torusinvariant_prime_divisors(ambient_space(m))[1:n]]
+  zero_sec = zero_section_class(m)
+
+  # now execute verticality checks
+  for i in 1:n
+    numb = integrate(cohomology_class(ambient_space(m), polynomial(cohomology_class(g4)) * c_ds[i] * cy) * zero_sec; check = false)
+    numb!=0 && return false
+  end
+  for i in 1:n
+    for j in i:n
+      numb = integrate(cohomology_class(ambient_space(m), polynomial(cohomology_class(g4)) * c_ds[i] * c_ds[j] * cy); check = false)
+      numb!=0 && return false
+    end
+  end
+  return true
+end
+
+
+@doc raw"""
+    passes_tadpole_cancellation_check(gf::G4Flux)
+
+G4-fluxes are subject to the D3-tadpole cancellation condition described in [Wei18](@cite).
+This check verifies that $euler_characteristic(Y)/24 - 1/2 * \int_{Y}{G_4 \wedge G_4}$ is a non-negative integer.
+
+```jldoctest; setup = :(Oscar.LazyArtifacts.ensure_artifact_installed("QSMDB", Oscar.LazyArtifacts.find_artifacts_toml(Oscar.oscardir)))
+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 lacking elementary quantization checks
+
+julia> passes_tadpole_cancellation_check(g4)
+true
+```
+"""
+@attr Bool function passes_tadpole_cancellation_check(g4::G4Flux)
+  m = model(g4)
+  @req (m isa WeierstrassModel || m isa GlobalTateModel || m isa HypersurfaceModel) "Tadpole cancellation checks for  G4-fluxes only supported for Weierstrass, global Tate and hypersurface models"
+  @req base_space(m) isa NormalToricVariety "Tadpole cancellation checks for G4-flux currently supported only for toric base"
+  @req ambient_space(m) isa NormalToricVariety "Tadpole cancellation checks for G4-flux currently supported only for toric ambient space"
+
+  # Compute the cohomology class corresponding to the hypersurface equation
+  cy = polynomial(cohomology_class(toric_divisor_class(ambient_space(m), degree(hypersurface_equation(m)))))
+
+  # Now check if the D3-tadpole cancellation condition holds
+  numb = euler_characteristic(m; check = false)/24 - 1/2*integrate(cohomology_class(ambient_space(m), polynomial(cohomology_class(g4)) * polynomial(cohomology_class(g4)) * cy); check = false)
+  if numb > 0 && is_integer(numb)
+    return true
+  end
+  return false
+end