[FTheoryTools] First implementation of 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

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/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(abs))^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(abs))^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

experimental/FTheoryTools/src/G4Fluxes/constructors.jl

@@ -0,0 +1,120 @@
+################
+# 1: Constructor
+################
+
+@doc raw"""
+    g4_flux(model::AbstractFTheoryModel, class::CohomologyClass)
+
+Construct a G4-flux candidate on an F-theory model. This functionality is
+currently limited to
+- Weierstrass models,
+- global Tate models,
+- hypersurface models.
+Furthermore, our functionality requires a concrete geometry. That is,
+the base space as well as the ambient space must be toric varieties.
+In the toric ambient space $X_\Sigma$, the elliptically fibered space $Y$
+that defines the F-theory model, is given by a hypersurface (cut out by
+the Weierstrass, Tate or hypersurface polynomial, respectively).
+
+In this setting, we assume that a $G_4$-flux candidate is represented by a
+cohomology class $h$ in $H^{(2,2)} (X_\Sigma)$. The actual $G_4$-flux candidate
+is then obtained by restricting $h$ to $Y$.
+
+It is worth recalling that the $G_4$-flux candidate is subject to the quantization
+condition $G_4 + \frac{1}{2} c_2(Y) \in H^{/2,2)}( Y_, \mathbb{Z})$ (see [Wit97](@cite)).
+This condition is very hard to verify. However, it is relatively easy to gather
+evidence for this condition to be satisfied/show that it is violated. To this end, let
+$D_1$, $D_2$ be two toric divisors in $X_\Sigma$, then the topological intersection number
+$\left[ h|_Y \right] \cdot \left[ P \right] \cdot \left[ D_1 \right] \cdot \left[ D_2 \right]$
+must be an integer. Even this rather elementary check can be computationally expensive.
+Users can therefore decide to skip this check upon construction by setting the parameter
+`check` to the value `false`.
+
+Another bottleneck can be the computation of the cohomology ring, which is necessary to
+work with cohomology classes on the toric ambient space, which in turn define the G4-flux,
+as explained above. The reason for this is, that by employing the theory explained in
+[CLS11](@cite), we can only work out the cohomology ring of simpicial and complete (i.e. compact)
+toric varieties. However, checking if a toric variety is complete (i.e. compact) can take
+a long time. If the geometry in question is involved and you already know that the variety
+is simplicial and complete, then we recommend to trigger the computation of the cohomology
+ring with `check = false`. This will avoid this time consuming test.
+
+An example is in order.
+
+# Examples
+```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(abs))^2;
+
+julia> g4f = g4_flux(qsm_model, g4_class)
+G4-flux candidate
+
+julia> g4f2 = g4_flux(qsm_model, g4_class, check = false)
+G4-flux candidate lacking elementary quantization checks
+```
+"""
+function g4_flux(m::AbstractFTheoryModel, g4_class::CohomologyClass; check::Bool = true)
+  @req (m isa WeierstrassModel || m isa GlobalTateModel || m isa HypersurfaceModel) "G4-fluxes only supported for Weierstrass, global Tate and hypersurface models"
+  @req base_space(m) isa NormalToricVariety "G4-flux currently supported only for toric base"
+  @req ambient_space(m) isa NormalToricVariety "G4-flux currently supported only for toric ambient space"
+  g4_candidate = G4Flux(m, g4_class)
+  if check && !passes_elementary_quantization_checks(g4_candidate)
+    error("Given G4-flux candidate found to violate quantization condition")
+  end
+  return g4_candidate
+end
+
+
+################################################
+# 2: Equality and hash
+################################################
+
+function Base.:(==)(gf1::G4Flux, gf2::G4Flux)
+  # G4-fluxes can only be equal if they are defined for identically the same model
+  model(gf1) !== model(gf2) && return false
+
+  # Currently, can only decide equality for Weierstrass, global Tate and hypersurface models
+  if (m isa WeierstrassModel || m isa GlobalTateModel || m isa HypersurfaceModel) == false
+    error("Can currently only decide equality of G4-fluxes for Weierstrass, global Tate and hypersurface models")
+  end
+
+  # 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)
+
+  # Now can return the result
+  return cy * cohomology_class(gf1) == cy * cohomology_class(gf2)
+
+end
+
+function Base.hash(gf::G4Flux, h::UInt)
+  b = 0x92bd6ac4f87d834e % UInt
+  h = hash(model(gf), h)
+  h = hash(cohomology_class(gf), h)
+  return xor(h, b)
+end
+
+
+################################################
+# 3: Display
+################################################
+
+function Base.show(io::IO, g4::G4Flux)
+  properties_string = String["G4-flux candidate"]
+  if !has_attribute(g4, :passes_elementary_quantization_checks)
+    push!(properties_string, "lacking elementary quantization checks")
+  end
+  join(io, properties_string, " ")
+end

experimental/FTheoryTools/src/G4Fluxes/properties.jl

@@ -0,0 +1,69 @@
+#####################################################
+# 1 Basic properties
+#####################################################
+
+@doc raw"""
+    passes_elementary_quantization_checks(gf::G4Flux)
+
+G4-fluxes are subject to the quantization condition
+[Wit97](@cite) $G_4 + \frac{1}{2} c_2(Y) \in H^{(2,2)}(Y, \mathbb{Z})$.
+It is hard to verify that this condition is met. However,
+we can execute a number of simple consistency checks, by
+verifying that $\int_{Y}{G_4 \wedge [D_1] \wedge [D_2]} \in \mathbb{Z}$
+for any two toric divisors $D_1$, $D_2$. If all of these
+simple consistency checks are met, this method will return
+`true` and otherwise `false`.
+
+It is worth mentioning that currently (July 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.
+
+```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(abs))^2;
+
+julia> g4 = g4_flux(qsm_model, g4_class, check = false)
+G4-flux candidate lacking elementary quantization checks
+
+julia> passes_elementary_quantization_checks(g4)
+true
+```
+"""
+@attr Bool function passes_elementary_quantization_checks(g4::G4Flux)
+  m = model(g4)
+  @req (m isa WeierstrassModel || m isa GlobalTateModel || m isa HypersurfaceModel) "Elementary quantization checks for  G4-fluxes only supported for Weierstrass, global Tate and hypersurface models"
+  @req base_space(m) isa NormalToricVariety "Elementary quantization checks for G4-flux currently supported only for toric base"
+  @req ambient_space(m) isa NormalToricVariety "Elementary quantization checks for G4-flux currently supported only for toric ambient space"
+
+  # 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 = polynomial(cohomology_class(cl))
+
+  # Now check quantization condition G4 + 1/2 c2 is integral.
+  c_ds = [polynomial(cohomology_class(d)) for d in torusinvariant_prime_divisors(ambient_space(m))]
+
+  # explicitly switched off an expensive test in the following line
+  twist_g4 = polynomial(cohomology_class(g4) + 1//2 * chern_class_c2(m; check = false))
+
+  # 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)
+      !is_integer(numb) && return false
+    end
+  end
+  return true
+end

experimental/FTheoryTools/src/exports.jl

@@ -53,6 +53,7 @@ export estimated_number_of_triangulations
 export explicit_model_sections
 export family_of_spaces
 export fiber_ambient_space
+export g4_flux
 export gauge_algebra
 export genera_of_ci_curves
 export genera_of_components_of_dual_graph
@@ -123,13 +124,15 @@ export kbar3
 export literature_identifier
 export literature_model
 export max_lattice_pts_in_facet
+export model
 export model_description
 export model_index
 export model_parameters
 export paper_authors
 export paper_buzzwords
 export paper_description
 export paper_title
+export passes_elementary_quantization_checks
 export polytope_index
 export put_over_concrete_base
 export birational_literature_models

experimental/FTheoryTools/src/types.jl

@@ -226,3 +226,14 @@ struct QSMModel
   genus_of_components_of_simplified_dual_graph::Dict{String, Int64}
 
 end
+
+
+################################################
+# 4: The julia type for G4-fluxes
+################################################
+
+@attributes mutable struct G4Flux
+  model::AbstractFTheoryModel
+  class::CohomologyClass
+  G4Flux(model::AbstractFTheoryModel, class::CohomologyClass) = new(model, class)
+end