[FTheoryTools] Implement G4-fluxes

docs/oscar_references.bib

@@ -2238,6 +2238,19 @@ @Article{Wit88
   reportnumber  = {IASSNS-HEP-88/7}
 }
 
+@Article{Wit97,
+  author        = {Witten, Edward},
+  title         = {{On flux quantization in M theory and the effective action}},
+  journal       = {J. Geom. Phys.},
+  volume        = {22},
+  pages         = {1--13},
+  year          = {1997},
+  doi           = {10.1016/S0393-0440(96)00042-3},
+  eprint        = {hep-th/9609122},
+  archiveprefix = {arXiv},
+  reportnumber  = {IASSNS-HEP-96-96}
+}
+
 @Article{Yam18,
   author        = {Yamagishi, Ryo},
   title         = {On smoothness of minimal models of quotient singularities by finite subgroups of ${\rm SL}_n(\mathbb

docs/src/AlgebraicGeometry/ToricVarieties/CohomologyClasses.md

@@ -54,14 +54,14 @@ polynomial(ring::MPolyQuoRing, c::CohomologyClass)
 ## Methods
 
 ```@docs
-integrate(c::CohomologyClass)
+integrate(c::CohomologyClass; check::Bool = true)
 ```
 
 
 ## Special attributes of toric varieties
 
 ```@docs
-cohomology_ring(v::NormalToricVarietyType)
+cohomology_ring(v::NormalToricVarietyType; check::Bool = true)
 volume_form(v::NormalToricVariety)
 intersection_form(v::NormalToricVariety)
 ```

experimental/FTheoryTools/docs/doc.main

@@ -5,6 +5,7 @@
       "weierstrass.md",
       "tate.md",
       "hypersurface.md",
-      "literature.md"
+      "literature.md",
+      "g4.md"
    ],
 ]

experimental/FTheoryTools/docs/src/g4.md

@@ -0,0 +1,35 @@
+```@meta
+CurrentModule = Oscar
+```
+
+# G4-Fluxes
+
+$G_4$-fluxes are at the heart of F-theory model building.
+
+
+## Constructors
+
+We currently support the following constructor:
+```@docs
+g4_flux(model::AbstractFTheoryModel, class::CohomologyClass)
+```
+
+
+## Attributes
+
+We currently support the following attributes:
+```@docs
+model(gf::G4Flux)
+cohomology_class(gf::G4Flux)
+```
+
+
+## Properties
+
+We currently support the following properties:
+```@docs
+passes_elementary_quantization_checks(gf::G4Flux)
+```
+
+
+## Methods

experimental/FTheoryTools/docs/src/generalities.md

@@ -59,6 +59,8 @@ classes_of_model_sections(m::AbstractFTheoryModel)
 defining_classes(m::AbstractFTheoryModel)
 gauge_algebra(m::AbstractFTheoryModel)
 global_gauge_quotients(m::AbstractFTheoryModel)
+chern_class_c1(m::AbstractFTheoryModel; check::Bool = true)
+chern_class_c2(m::AbstractFTheoryModel; check::Bool = true)
 ```
 
 

experimental/FTheoryTools/src/AbstractFTheoryModels/attributes.jl

@@ -1096,6 +1096,133 @@
 end
 
 
+@doc raw"""
+    chern_class_c1(m::AbstractFTheoryModel)
+
+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 first Chern class
+$c_1$ of the tangent bundle of $Y_n$. If those assumptions are satisfied, this method returns
+this very cohomology class $h$, otherwise it raises and error.
+
+Note that $Y_n$ is a Calabi-Yau variety precisely if $c_1$ is trivial. Thus, the restriction
+of $h$ to the hypersurface $Y_n$ must be trivial. Upon closer inspection, in the given toric
+setting, this is equivalent to $h$ being trivial.
+
+The computation of the cohomology ring verifies if the toric variety is simplicial and
+complete. The check for it to be complete can be very time consuming. This can be switched
+off by setting the optional argument `check` to the value `falue`, as in the example below.
+
+```jldoctest
+julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 4))
+Hypersurface model over a concrete base
+
+julia> h = chern_class_c1(qsm_model; check = false)
+Cohomology class on a normal toric variety given by 0
+
+julia> is_trivial(h)
+true
+```
+"""
+function chern_class_c1(m::AbstractFTheoryModel; check::Bool = true)
+  @req (m isa WeierstrassModel || m isa GlobalTateModel || m isa HypersurfaceModel) "First Chern class of F-theory model supported for Weierstrass, global Tate and hypersurface models only"
+  @req base_space(m) isa NormalToricVariety "First Chern class of F-theory model currently supported only for toric base"
+  @req ambient_space(m) isa NormalToricVariety "Firfalsest Chern class of F-theory model currently supported only for toric ambient space"
+
+  # Check if the answer is known
+  if has_attribute(m, :chern_class_c1)
+    return get_attribute(m, :chern_class_c1)
+  end
+
+  # Trigger potential short-cut computation of cohomology ring
+  cohomology_ring(ambient_space(m); check)
+
+  # Compute the cohomology class corresponding to the hypersurface equation
+  if m isa WeierstrassModel
+    cl = toric_divisor_class(ambient_space(m), degree(weierstrass_polynomial(m)))
+  end
+  if m isa GlobalTateModel
+    cl = toric_divisor_class(ambient_space(m), degree(tate_polynomial(m)))
+  end
+  if m isa HypersurfaceModel
+    cl = toric_divisor_class(ambient_space(m), degree(hypersurface_equation(m)))
+  end
+  cy = cohomology_class(cl)
+
+  # Compute and set h
+  c1_t_ambient = cohomology_class(anticanonical_divisor(ambient_space(m)))
+  set_attribute!(m, :chern_class_c1, c1_t_ambient - cy)
+  return c1_t_ambient - cy
+end
+
+
+@doc raw"""
+    chern_class_c2(m::AbstractFTheoryModel)
+
+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 2nd Chern class
+$c_2$ of the tangent bundle of $Y_n$. If those assumptions are satisfied, this method returns
+this very cohomology class $h$, otherwise it raises and error.
+
+As of right now, this method is computationally quite expensive for involved toric varieties,
+such as in the example below. Therefore, think carefully if you truly want to compute this quantity.
+
+The computation of the cohomology ring verifies if the toric variety is simplicial and
+complete. The check for it to be complete can be very time consuming. This can be switched
+off by setting the optional argument `check` to the value `falue`, as in the example below.
+
+```jldoctest
+julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 4))
+Hypersurface model over a concrete base
+
+julia> h = chern_class_c2(qsm_model; check = false);
+
+julia> is_trivial(h)
+false
+```
+"""
+function chern_class_c2(m::AbstractFTheoryModel; check::Bool = true)
+  @req (m isa WeierstrassModel || m isa GlobalTateModel || m isa HypersurfaceModel) "First Chern class of F-theory model supported for Weierstrass, global Tate and hypersurface models only"
+  @req base_space(m) isa NormalToricVariety "First Chern class of F-theory model currently supported only for toric base"
+  @req ambient_space(m) isa NormalToricVariety "First Chern class of F-theory model currently supported only for toric ambient space"
+
+  # Check if the answer is known
+  if has_attribute(m, :chern_class_c2)
+    return get_attribute(m, :chern_class_c2)
+  end
+
+  # Trigger potential short-cut computation of cohomology ring
+  cohomology_ring(ambient_space(m); check)
+
+  # Compute the cohomology class corresponding to the hypersurface equation
+  if m isa WeierstrassModel
+    cl = toric_divisor_class(ambient_space(m), degree(weierstrass_polynomial(m)))
+  end
+  if m isa GlobalTateModel
+    cl = toric_divisor_class(ambient_space(m), degree(tate_polynomial(m)))
+  end
+  if m isa HypersurfaceModel
+    cl = toric_divisor_class(ambient_space(m), degree(hypersurface_equation(m)))
+  end
+  cy = cohomology_class(cl)
+
+  # Compute sum of products of cohomolgy classes of torus invariant prime divisors
+  c_ds = [polynomial(cohomology_class(d)) for d in torusinvariant_prime_divisors(ambient_space(m))]
+  c2_t_ambient = zero(cohomology_ring(ambient_space(m)))
+  for i in 1:length(c_ds)
+    for j in i+1:length(c_ds)
+      c2_t_ambient = c2_t_ambient + c_ds[i]*c_ds[j]
+    end
+  end
+  c2_t_ambient = cohomology_class(ambient_space(m), c2_t_ambient)
+
+  # Compute and set h
+  h = c2_t_ambient - cy * chern_class_c1(m; check = check)
+  set_attribute!(m, :chern_class_c2, h)
+  return h
+end
+
 
 ##########################################
 ### (4) Attributes specially for the QSMs

experimental/FTheoryTools/src/FTheoryTools.jl

@@ -26,6 +26,10 @@ include("standard_constructions.jl")
 include("LiteratureModels/constructors.jl")
 include("LiteratureModels/create_index.jl")
 
+include("G4Fluxes/constructors.jl")
+include("G4Fluxes/attributes.jl")
+include("G4Fluxes/properties.jl")
+
 include("Serialization/tate_models.jl")
 include("Serialization/weierstrass_models.jl")
 include("Serialization/hypersurface_models.jl")

experimental/FTheoryTools/src/G4Fluxes/attributes.jl

@@ -0,0 +1,48 @@
+#####################################################
+# 1 Basic attributes
+#####################################################
+
+@doc raw"""
+    model(gf::G4Flux)
+
+Return the F-theory model for which this $G_4$-flux candidate is defined.
+
+```jldoctest
+julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 4))
+Hypersurface model over a concrete base
+
+julia> cohomology_ring(ambient_space(qsm_model), check = false);
+
+julia> g4_class = cohomology_class(anticanonical_divisor_class(ambient_space(qsm_model)))^2;
+
+julia> g4f = g4_flux(qsm_model, g4_class, check = false)
+G4-flux candidate lacking elementary quantization checks
+
+julia> model(g4f)
+Hypersurface model over a concrete base
+```
+"""
+model(gf::G4Flux) = gf.model
+
+
+@doc raw"""
+    cohomology_class(gf::G4Flux)
+
+Return the cohomology class which defines the $G_4$-flux candidate.
+
+```jldoctest
+julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 4))
+Hypersurface model over a concrete base
+
+julia> cohomology_ring(ambient_space(qsm_model), check = false);
+
+julia> g4_class = cohomology_class(anticanonical_divisor_class(ambient_space(qsm_model)))^2;
+
+julia> g4f = g4_flux(qsm_model, g4_class, check = false)
+G4-flux candidate lacking elementary quantization checks
+
+julia> cohomology_class(g4f) == g4_class
+true
+```
+"""
+cohomology_class(gf::G4Flux) = gf.class