The F-Theory QSMs
The Quadrillion F-Theory Standard Models (QSMs) were introduced in [CHLLT19] as a large class of compactifications within F-theory that exhibit promising features for particle physics model building. Due to their richness and physical relevance, these models have been extensively studied; see for example [Bie24] and the references therein.
The detailed geometric and physical properties of the QSMs are captured within FTheoryTools
through the framework of Literature Models, enabling computations and explorations of their characteristics.
What are the QSM?
The QSMs correspond to a vast ensemble of F-theory compactifications constructed on elliptically fibered Calabi–Yau fourfolds with carefully chosen base geometries. Their defining feature is that they yield low-energy effective theories closely resembling the Standard Model of particle physics, including realistic gauge groups and chiral matter spectra.
The geometries arise from systematically classifying certain favorable base threefolds, often toric, and then carefully engineering elliptic fibrations that produce the Standard Model gauge group and chiral matter spectrum.
In FTheoryTools
, we focus on the QSMs built over toric base spaces. It turned out that there are exactly 708 families of such QSM geometries. Each family corresponds to the fine, regular, star triangulation of one reflexive 3-dimensional polytope. Since the number of such triangulations can be astronomical — more specifically, the largest such number is a quadrillion ($10^{15}$), which gives this family of F-theory models its name — in FTheoryTools
one such triangulation is chosen. In other words, we could read this as a chosen representative for each family, that can be constructed via the framework of Literature Models.
Constructing QSMs
The construction of QSMs happens via the literature model constructor. Here is an example:
julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 4))
Hypersurface model over a concrete base
The value assigned to the model parameter k
must be altered to construct different QSMs. Recall that there are exactly 708 distinct classes of QSMs, each family corresponding to the fine, regular, star triangulations of the k-th reflexive polytope in the Kreuzer-Skarke list (cf. [KS98]).
Accordingly, k
corresponds exactly to the index of the polytopes as they appear in the Kreuzer-Skarke list. The "first" QSM is associated with the 4th polytope, and the last one with index k = 4291
. Between these, 706 other values correspond to QSMs. If a given k
does not correspond to a QSM, the constructor raises an error.
It is worth recalling that this classifcation of base spaces is rooted in the triple intersection number of the anticanonical class of the base space. This triple intersection number can be accessed with FTheoryTools
, see Base Intersection Numbers.
The Underlying Polytope
Each QSM corresponds to a family of models associated with the fine regular star triangulations of a reflexive 3-dimensional polytope. The following methods provide detailed information about the underlying polytope and its triangulations.
Vertices
Return the vertices of the underlying polytope. Vertices are normalized to rational numbers following the Polymake standard.
vertices
— Methodvertices(m::AbstractFTheoryModel)
Return vertices
of the F-theory model if known, otherwise throw an error.
See Underlying Polytope for more details.
Examples
julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 4))
Hypersurface model over a concrete base
julia> vertices(qsm_model)
4-element Vector{Vector{QQFieldElem}}:
[-1, -1, -1]
[1, -1//2, -1//2]
[-1, 2, -1]
[-1, -1, 5]
This function is part of the experimental code in Oscar. Please read here for more details.
Polytope Index
Return the index of the underlying polytope within the Kreuzer-Skarke list ([KS98]).
polytope_index
— Methodpolytope_index(m::AbstractFTheoryModel)
Return polytope_index
of the F-theory model if known, otherwise throw an error.
See Underlying Polytope for more details.
Examples
julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 4))
Hypersurface model over a concrete base
julia> polytope_index(qsm_model)
4
This function is part of the experimental code in Oscar. Please read here for more details.
Quick Triangulation Feasibility
Enumerating all full, regular, star triangulations of a 3-dimensional reflexive polytope can be extremely time-consuming. This method returns true
if enumerating all such triangulations is expected to complete in a reasonable time (e.g., within 5 minutes on a personal computer), and false
otherwise.
has_quick_triangulation
— Methodhas_quick_triangulation(m::AbstractFTheoryModel)
Return has_quick_triangulation
of the F-theory model if known, otherwise throw an error.
See Underlying Polytope for more details.
Examples
julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 4))
Hypersurface model over a concrete base
julia> has_quick_triangulation(qsm_model)
true
This function is part of the experimental code in Oscar. Please read here for more details.
Maximal Number of Lattice Points in a Facet
To enumerate all full, regular, star triangulations of the underlying polytope, one can first work out the corresponding triangulations of all facets [HT17]. A rough estimate for the complexity of finding all triangulations of a facet is its number of lattice points. This method returns the maximal number of lattice points over all facets of the underlying polytope.
max_lattice_pts_in_facet
— Methodmax_lattice_pts_in_facet(m::AbstractFTheoryModel)
Return max_lattice_pts_in_facet
of the F-theory model if known, otherwise throw an error.
See Underlying Polytope for more details.
Examples
julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 4))
Hypersurface model over a concrete base
julia> max_lattice_pts_in_facet(qsm_model)
16
This function is part of the experimental code in Oscar. Please read here for more details.
Estimated Number of Triangulations
Provide an estimate of the total number of full, regular, star triangulations of the underlying polytope.
estimated_number_of_triangulations
— Methodestimated_number_of_triangulations(m::AbstractFTheoryModel)
Return estimated_number_of_triangulations
of the F-theory model if known, otherwise throw an error.
See Underlying Polytope for more details.
Examples
julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 4))
Hypersurface model over a concrete base
julia> estimated_number_of_triangulations(qsm_model)
212533333333
This function is part of the experimental code in Oscar. Please read here for more details.
The Nodal Curve
Recent studies (see [Bie24]) have refined the exact massless spectrum estimates for F-theory QSMs. These developments rely on deeper geometric data, much of which is accessible via the FTheoryTools
database.
Recall that for FTheoryTools
, the base of a QSM is a 3-dimensional toric variety $B_3$. Let $s \in H^0(B_3, \bar{K}_{B_3})$ be a generic section of the anticanonical bundle. Then $V(s) \subset B_3$ defines a K3 surface. Additionally, each homogeneous coordinate $x_i$ of the Cox ring of $B_3$ defines a divisor $V(x_i) \subset B_3$, and we define the curve:
\[C_i := V(x_i) \cap V(s)\,.\]
Collectively, the curves $C_i$ form a nodal curve, which plays a crucial role in the exact massless spectrum estimates (see [Bie24] and references therein).
The following quantities associated to the curves $C_i$ are supported.
Genera of the Curves $C_i$
Return the genera of all $C_i = V(x_i, s)$, labeled by their respective Cox ring coordinate indices.
genera_of_ci_curves
— Methodgenera_of_ci_curves(m::AbstractFTheoryModel)
Return genera_of_ci_curves
of the F-theory model if known, otherwise throw an error.
See The Nodal Curve for more details.
Examples
julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 4))
Hypersurface model over a concrete base
julia> typeof(genera_of_ci_curves(qsm_model))
Dict{MPolyDecRingElem, Int64}
This function is part of the experimental code in Oscar. Please read here for more details.
Degrees of $\bar{K}_{B_3}|_{C_i}$
Compute the degree of the restriction of the anticanonical bundle $\bar{K}_{B_3}$ to each curve $C_i$.
degrees_of_kbar_restrictions_to_ci_curves
— Methoddegrees_of_kbar_restrictions_to_ci_curves(m::AbstractFTheoryModel)
Return degrees_of_kbar_restrictions_to_ci_curves
of the F-theory model if known, otherwise throw an error.
See The Nodal Curve for more details.
Examples
julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 4))
Hypersurface model over a concrete base
julia> typeof(degrees_of_kbar_restrictions_to_ci_curves(qsm_model))
Dict{MPolyDecRingElem, Int64}
This function is part of the experimental code in Oscar. Please read here for more details.
Topological Intersection Numbers Among All $C_i$
Returns the intersection matrix among the $C_i$ curves.
topological_intersection_numbers_among_ci_curves
— Methodtopological_intersection_numbers_among_ci_curves(m::AbstractFTheoryModel)
Return topological_intersection_numbers_among_ci_curves
of the F-theory model if known, otherwise throw an error.
See The Nodal Curve for more details.
Examples
julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 4))
Hypersurface model over a concrete base
julia> size(topological_intersection_numbers_among_ci_curves(qsm_model))
(29, 29)
This function is part of the experimental code in Oscar. Please read here for more details.
Indices of Trivial Curves
Some intersections $V(x_i, s)$ may be empty. This function returns the list of all indices $i$ such that $C_i = \emptyset$.
indices_of_trivial_ci_curves
— Methodindices_of_trivial_ci_curves(m::AbstractFTheoryModel)
Return indices_of_trivial_ci_curves
of the F-theory model if known, otherwise throw an error.
See The Nodal Curve for more details.
Examples
julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 4))
Hypersurface model over a concrete base
julia> indices_of_trivial_ci_curves(qsm_model)
10-element Vector{Int64}:
23
22
18
19
20
26
10
11
12
15
This function is part of the experimental code in Oscar. Please read here for more details.
Intersection Matrix of Non-trivial Curves
Returns the intersection matrix among the non-trivial $C_i$.
topological_intersection_numbers_among_nontrivial_ci_curves
— Methodtopological_intersection_numbers_among_nontrivial_ci_curves(m::AbstractFTheoryModel)
Return topological_intersection_numbers_among_nontrivial_ci_curves
of the F-theory model if known, otherwise throw an error.
See The Nodal Curve for more details.
Examples
julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 4))
Hypersurface model over a concrete base
julia> size(topological_intersection_numbers_among_nontrivial_ci_curves(qsm_model))
(19, 19)
This function is part of the experimental code in Oscar. Please read here for more details.
The Dual Graph
The collection of $C_i$-curves described above forms a nodal curve. To such a curve, one can associate a dual graph:
- Each irreducible component of the nodal curve corresponds to a vertex (or node) in the graph.
- Each nodal intersection (i.e. a singular point where two components meet) becomes an edge.
Only non-trivial $C_i = V(x_i, s)$ curves are included in this graph. If a curve $C_i$ is reducible, its irreducible components each get their own vertex. The number of edges between any two vertices is determined by the topological intersection number of their corresponding components.
The following methods allow access to this graph and its associated data.
The Dual Graph
Returns the unlabelled, undirected dual graph for the given QSM. Each node corresponds to an irreducible component of a non-trivial $C_i$ curve.
dual_graph
— Methoddual_graph(m::AbstractFTheoryModel)
Return dual_graph
of the F-theory model if known, otherwise throw an error.
See The Dual Graph for more details.
Examples
julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 4))
Hypersurface model over a concrete base
julia> dual_graph(qsm_model)
Undirected graph with 21 nodes and the following edges:
(5, 1)(6, 5)(7, 6)(8, 7)(9, 4)(9, 8)(10, 1)(11, 4)(12, 3)(12, 10)(13, 3)(13, 11)(14, 1)(15, 4)(16, 3)(17, 3)(18, 2)(18, 14)(19, 2)(19, 15)(20, 2)(20, 16)(21, 2)(21, 17)
This function is part of the experimental code in Oscar. Please read here for more details.
This function is part of the experimental code in Oscar. Please read here for more details.
Component Labels
Returns the labels — each a string — for each node in the dual graph, indicating the geometric origin of the corresponding irreducible component. If $C_i$ is irreducible, the label is "Ci"
. If $C_i$ is reducible, its components are labeled as "Ci-0"
, "Ci-1"
, etc.
components_of_dual_graph
— Methodcomponents_of_dual_graph(m::AbstractFTheoryModel)
Return components_of_dual_graph
of the F-theory model if known, otherwise throw an error.
See The Dual Graph for more details.
Examples
julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 4))
Hypersurface model over a concrete base
julia> length(components_of_dual_graph(qsm_model))
21
This function is part of the experimental code in Oscar. Please read here for more details.
Degrees of the restriction of $\bar{K}_{B_3}$ to the Components
Computes the degree of the anticanonical bundle $\bar{K}_{B_3}$ when restricted to each component (node) of the dual graph.
degrees_of_kbar_restrictions_to_components_of_dual_graph
— Methoddegrees_of_kbar_restrictions_to_components_of_dual_graph(m::AbstractFTheoryModel)
Return degrees_of_kbar_restrictions_to_components_of_dual_graph
of the F-theory model if known, otherwise throw an error.
See The Dual Graph for more details.
Examples
julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 4))
Hypersurface model over a concrete base
julia> typeof(degrees_of_kbar_restrictions_to_components_of_dual_graph(qsm_model))
Dict{String, Int64}
This function is part of the experimental code in Oscar. Please read here for more details.
Genera of the Components
Returns the genus of each irreducible component represented by a node in the dual graph.
genera_of_components_of_dual_graph
— Methodgenera_of_components_of_dual_graph(m::AbstractFTheoryModel)
Return genera_of_components_of_dual_graph
of the F-theory model if known, otherwise throw an error.
See The Dual Graph for more details.
Examples
julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 4))
Hypersurface model over a concrete base
julia> typeof(genera_of_components_of_dual_graph(qsm_model))
Dict{String, Int64}
This function is part of the experimental code in Oscar. Please read here for more details.
The Simplified Dual Graph
The estimates for the exact massless spectrum of the QSMs are based on root bundle counting (cf. [BCL21]). This in turn employs the dual graph described in the previous section. However, it turns out, that the dual graph can often be simplified without loss of relevant information for the root bundle counting. This leads to a reduced version of the graph on which the root bundle computations are easier to perform. The following functions provide access to this simplified dual graph.
simplified_dual_graph
— Methodsimplified_dual_graph(m::AbstractFTheoryModel)
Return simplified_dual_graph
of the F-theory model if known, otherwise throw an error.
See The Simplified Dual Graph for more details.
Examples
julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 4))
Hypersurface model over a concrete base
julia> simplified_dual_graph(qsm_model)
Undirected graph with 4 nodes and the following edges:
(2, 1)(3, 1)(3, 2)(4, 1)(4, 2)(4, 3)
This function is part of the experimental code in Oscar. Please read here for more details.
Component Labels
Returns the labels — each a string — for each vertex in the simplified dual graph. These labels correspond to irreducible components of non-trivial $C_i = V(x_i, s)$ curves.
components_of_simplified_dual_graph
— Methodcomponents_of_simplified_dual_graph(m::AbstractFTheoryModel)
Return components_of_simplified_dual_graph
of the F-theory model if known, otherwise throw an error.
See The Simplified Dual Graph for more details.
Examples
julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 4))
Hypersurface model over a concrete base
julia> length(components_of_simplified_dual_graph(qsm_model))
4
This function is part of the experimental code in Oscar. Please read here for more details.
Degrees of $\bar{K}_{B_3}$ on the Components
Returns the degrees of the anticanonical bundle $\bar{K}_{B_3}$ restricted to the components (nodes) of the simplified dual graph.
degrees_of_kbar_restrictions_to_components_of_simplified_dual_graph
— Methoddegrees_of_kbar_restrictions_to_components_of_simplified_dual_graph(m::AbstractFTheoryModel)
Return degrees_of_kbar_restrictions_to_components_of_simplified_dual_graph
of the F-theory model if known, otherwise throw an error.
See The Simplified Dual Graph for more details.
Examples
julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 4))
Hypersurface model over a concrete base
julia> typeof(degrees_of_kbar_restrictions_to_components_of_simplified_dual_graph(qsm_model))
Dict{String, Int64}
This function is part of the experimental code in Oscar. Please read here for more details.
Genera of the Components
Returns the genus of each irreducible component corresponding to a node in the simplified dual graph.
genera_of_components_of_simplified_dual_graph
— Methodgenera_of_components_of_simplified_dual_graph(m::AbstractFTheoryModel)
Return genera_of_components_of_simplified_dual_graph
of the F-theory model if known, otherwise throw an error.
See The Simplified Dual Graph for more details.
Examples
julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 4))
Hypersurface model over a concrete base
julia> typeof(genera_of_components_of_simplified_dual_graph(qsm_model))
Dict{String, Int64}
This function is part of the experimental code in Oscar. Please read here for more details.