Literature Models
In the landscape of F-theory model building, many constructions introduced over the years remain relevant and influential. However, revisiting or building upon these models can be challenging—especially when prior computations must be repeated manually due to evolving mathematical techniques or notation. This not only hinders efficiency but can also deter newcomers from engaging deeply with the field.
To overcome these obstacles, we introduce the concept of a literature model: a well-established F-theory construction from the research literature, made accessible in a fully computational format.
What is a Literature Model?
A Computational Interface to the Literature
The LiteratureModels
framework provides a curated database of such models, drawn from influential F-theory papers. Each entry is preprocessed to automate core calculations, store topological and geometric data, and support further exploration. Rather than repeating extensive algebraic or topological derivations, researchers can immediately load a literature model and apply the full power of FTheoryTools
to study or extend it.
This offers several advantages:
- Rapid access to existing constructions: Retrieve previously published models without manually reproducing their setup.
- Integrated results: Access known data, such as intersection numbers, crepant resolutions, or gauge groups.
- Targeted search: Filter models by desired features (e.g., gauge symmetry, fiber type).
- Seamless analysis: Load a model and perform further computations using the broader functionality of
FTheoryTools
.
The current database includes a wide range of examples, including models:
- Krause, Mayrhofer, Weigand 2011,
- Morrison, Park 2012,
- Lawrie, Schafer-Nameki 2013,
- Klevers, Mayorga, Damian, Oehlmann, Piragua, Reuter 2015,
- Cvetič, Klevers, Piragua, Taylor 2015,
- Taylor, Wang 2015,
- Cvetič, Halverson, Ling, Liu, Tian 2019.
This collection is actively expanding.
Interoperable and Reproducible Model Storage
All literature models are stored in a structured and platform-independent format based on JSON. The framework is transitioning toward the MaRDI file format, a standardized data format developed as part of the Mathematics Research Data Initiative (MaRDI). This format ensures that models built in FTheoryTools
can be used across a wide range of computer algebra systems, including Oscar
, Sage
, Macaulay
, and others.
The benefits of this include:
- Interoperability: Models can be exported, shared, and loaded across different systems.
- Data compression: Efficient storage of complex models (via subtree reduction).
- Machine-readability: Makes it easy to contribute new models or verify existing ones.
- Transparency: Published models can be peer-reviewed in both mathematical and computational terms.
We envision literature models not only as a computational resource, but also as a new standard for reproducibility in F-theory research. Authors can supplement future publications with accompanying data files, making it easier for others to explore, verify, and build upon their work. This aligns with growing community efforts—such as those within MaRDI—to ensure that mathematical software and data are as verifiable and accessible as the results they support.
Constructing Literature Models
The constructor for literature models is necessarily complex, reflecting the wide range of constructions explored in the F-theory literature. While some keyword arguments are self-explanatory—for example, the string doi
uniquely identifies a publication—others are more technical or use terminology that may be non-standard. A prominent example is model_sections
, which plays a key role in defining the geometry of the model.
We defer a detailed discussion of these technical inputs (and outputs) to the next section. The examples in the constructor below serve as a high-level overview of how literature models are initialized in practice:
literature_model
— Methodliterature_model(; doi::String="", arxiv_id::String="", version::String="", equation::String="", model_parameters::Dict{String,<:Any} = Dict{String,Any}(), base_space::FTheorySpace = affine_space(NormalToricVariety, 0), model_sections::Dict{String, <:Any} = Dict{String,Any}(), defining_classes::Dict{String, <:Any} = Dict{String,Any}(), completeness_check::Bool = true)
Return a model from the F-theory literature identified by bibliographic metadata such as arXiv ID, DOI, or equation reference. Many such models are well-known in the field—e.g., the U(1)-restricted SU(5)-GUT model Krause, Mayrhofer, Weigand 2011—and are stored in a curated database accessible through this method.
To identify and retrieve a model from the database, supply one or more of the following optional arguments:
doi
: A string representing the DOI of the publication in which the model was introduced.arxiv_id
: A string specifying the arXiv identifier of the preprint version or the journal print version.version
: A string specifying the arXiv version (e.g."v1"
).equation
: A string indicating the equation label used to define the model within the source publication.
The method attempts to match the given identifiers with a unique entry in the database. If no match is found, or if the information is ambiguous (i.e., multiple matches exist), an error is raised.
Some literature models require additional input to be uniquely determined and constructed. For such cases, more optional arguments must be provided:
model_parameters
: A dictionary specifying parameters needed to fix a model within a family, e.g.Dict("k" => 5)
.defining_classes
: A dictionary specifying divisor classes necessary to fully define the geometry.base_space
: Optionally specify a concrete base over which the model should be constructed. Currently, only toric base spaces are supported.completeness_check
: Set this tofalse
to skip time consuming completeness checks of the base geometry to gain more performance.
See the Literature Models documentation page for a deeper discussion of these fields.
First, notice how you can create the global Tate model from Krause, Mayrhofer, Weigand 2011 over an unspecified base:
Examples
julia> t = literature_model(arxiv_id = "1109.3454", equation = "3.1")
Assuming that the first row of the given grading is the grading under Kbar
Global Tate model over a not fully specified base -- SU(5)xU(1) restricted Tate model based on arXiv paper 1109.3454 Eq. (3.1)
julia> coordinate_ring(ambient_space(t))
Multivariate polynomial ring in 8 variables over QQ graded by
w -> [0 1 0]
a1 -> [1 0 0]
a21 -> [2 -1 0]
a32 -> [3 -2 0]
a43 -> [4 -3 0]
x -> [2 0 2]
y -> [3 0 3]
z -> [0 0 1]
Certainly, this is also possible over a concrete base, provided that the defining classes are provided:
Examples
julia> B3 = projective_space(NormalToricVariety, 3)
Normal toric variety
julia> w = torusinvariant_prime_divisors(B3)[1]
Torus-invariant, prime divisor on a normal toric variety
julia> t = literature_model(arxiv_id = "1109.3454", equation = "3.1", base_space = B3, defining_classes = Dict("w" => w), completeness_check = false)
Construction over concrete base may lead to singularity enhancement. Consider computing singular_loci. However, this may take time!
Global Tate model over a concrete base -- SU(5)xU(1) restricted Tate model based on arXiv paper 1109.3454 Eq. (3.1)
Certainly, this can be mimiced for Weierstrass models, e.g. Morrison, Park 2012:
Examples
julia> B2 = projective_space(NormalToricVariety, 2)
Normal toric variety
julia> b = torusinvariant_prime_divisors(B2)[1]
Torus-invariant, prime divisor on a normal toric variety
julia> w = literature_model(arxiv_id = "1208.2695", equation = "B.19", base_space = B2, defining_classes = Dict("b" => b), completeness_check = false)
Construction over concrete base may lead to singularity enhancement. Consider computing singular_loci. However, this may take time!
Weierstrass model over a concrete base -- U(1) Weierstrass model based on arXiv paper 1208.2695 Eq. (B.19)
julia> length(singular_loci(w))
1
For convenience, we also support a simplified constructor. Instead of the meta data of the article, this constructor accepts an integer, which specifies the position of this model in our database. Here is how this can be used to create the model Morrison, Park 2012:
Examples
julia> B2 = projective_space(NormalToricVariety, 2)
Normal toric variety
julia> b = torusinvariant_prime_divisors(B2)[1]
Torus-invariant, prime divisor on a normal toric variety
julia> w = literature_model(3, base_space = B2, defining_classes = Dict("b" => b), completeness_check = false)
Construction over concrete base may lead to singularity enhancement. Consider computing singular_loci. However, this may take time!
Weierstrass model over a concrete base -- U(1) Weierstrass model based on arXiv paper 1208.2695 Eq. (B.19)
julia> length(singular_loci(w))
1
Finally, let us showcase that we also support hypersurface model constructions from the literature. For this, we stay with Morrison, Park 2012, but this time create this model as a hypersurface model. This works as follows:
Examples
julia> h = literature_model(arxiv_id = "1208.2695", equation = "B.5")
Assuming that the first row of the given grading is the grading under Kbar
Hypersurface model over a not fully specified base
julia> explicit_model_sections(h)
Dict{String, MPolyRingElem} with 5 entries:
"c2" => c2
"c1" => c1
"c3" => c3
"b" => b
"c0" => c0
julia> B2 = projective_space(NormalToricVariety, 2)
Normal toric variety
julia> b = torusinvariant_prime_divisors(B2)[1]
Torus-invariant, prime divisor on a normal toric variety
julia> h2 = literature_model(arxiv_id = "1208.2695", equation = "B.5", base_space = B2, defining_classes = Dict("b" => b))
Construction over concrete base may lead to singularity enhancement. Consider computing singular_loci. However, this may take time!
Hypersurface model over a concrete base
julia> hypersurface_equation_parametrization(h2)
b*w*v^2 - c0*u^4 - c1*u^3*v - c2*u^2*v^2 - c3*u*v^3 + w^2
This function is part of the experimental code in Oscar. Please read here for more details.
Model Parameters, Defining Classes, and Related Concepts
General Overview
The literature_model
constructor in FTheoryTools
is designed to support a broad spectrum of input parameters, ranging from discrete numerical values to divisor classes. While most users will interact primarily with the geometric or physical properties of a model, understanding its internal structure is essential for advanced applications such as extending the model database, computing fluxes, or constructing custom geometries.
Some literature models require discrete input parameters. For instance, the constructions in Lawrie, Schafer-Nameki 2013 describe a family of global Tate models with gauge group $\mathrm{SU}(2k)$, where the integer parameter $k$ must be specified to define a concrete model. Similarly, in Cvetič, Halverson, Ling, Liu, Tian 2019, models are indexed by three-dimensional reflexive polytopes, each identified by an integer. A specific base geometry is selected by choosing a fine, regular, star triangulation of the chosen polytope. We refer to such discrete data—e.g., integers fixing singularity types, triangulation choices—as model parameters.
Let us now focus on the hypersurface equation of a model. Regardless of whether the model is a Weierstrass, global Tate, or hypersurface model, the hypersurface equation is constructed from global sections of line bundles over the base. These sections fall into two conceptual categories:
Structural sections, such as the Weierstrass or Tate coefficients, are determined by the type of model being constructed. To preserve the model's nature, these sections must retain their prescribed divisor classes. Altering them would fundamentally change the type of the model, e.g. turning a global Tate model into a Weierstrass model.
Tunable sections: These are sections in the defining equation that can be freely varied or further factorized without altering the qualitative structure of the model. In other words, they preserve the type of the model.
These two categories are not mutually exclusive. Unless factorized at construction time, a structural section can also be a tunable section.
Together, structural and tunable sections form the set of model sections. Since each model section is a global section of a line bundle, it has an associated divisor class. However, not all of these classes are needed to construct the model. Only a subset—the classes of certain tunable sections—are generally required. These are called the defining classes.
The defining classes play a central role in specifying literature models. The literature_model
constructor accepts an optional defining_classes
argument, which should be a dictionary mapping class symbols to their corresponding divisor classes. Note that because divisor classes are only supported over concrete base spaces, this assignment can only be made for explicitly chosen bases. For unspecified base families, the model is constructed to be compatible with a more general divisor class structure.
In summary, the defining classes form the minimal set of divisor classes needed to distinguish a given F-theory model from its most generic Weierstrass, Tate, or hypersurface formulation.
Example: Global Tate Model
Consider the global Tate model introduced in Krause, Mayrhofer, Weigand 2011. The Tate coefficients are factorized as:
a1 = a10
a2 = a21 * w
a3 = a32 * w^2
a4 = a43 * w^3
a6 = 0
From this, we find:
- Structural sections:
a1
,a2
,a3
,a4
,a6
- Tunable sections:
w
,a10
,a21
,a32
,a43
- Model sections:
w
,a10
,a21
,a32
,a43
,a1
,a2
,a3
,a4
,a6
- Defining classes:
W
, the divisor class ofw
The next section introduces accessor functions that allow users to retrieve defining classes, model sections, tunable sections, and related properties. Several examples are also included to demonstrate how to construct literature models by specifying defining classes.
Accessor Functions
Retrieve the defining classes:
defining_classes
— Methoddefining_classes(m::AbstractFTheoryModel)
Return the defining divisor classes of the given F-theory model.
For a detailed explanation of the concept, see Model Parameters, Defining Classes, and Related Concepts.
Examples
julia> B3 = projective_space(NormalToricVariety, 3)
Normal toric variety
julia> w = torusinvariant_prime_divisors(B3)[1]
Torus-invariant, prime divisor on a normal toric variety
julia> t = literature_model(arxiv_id = "1109.3454", equation = "3.1", base_space = B3, defining_classes = Dict("w" => w), completeness_check = false)
Construction over concrete base may lead to singularity enhancement. Consider computing singular_loci. However, this may take time!
Global Tate model over a concrete base -- SU(5)xU(1) restricted Tate model based on arXiv paper 1109.3454 Eq. (3.1)
julia> defining_classes(t)
Dict{String, ToricDivisorClass} with 1 entry:
"w" => Divisor class on a normal toric variety
This function is part of the experimental code in Oscar. Please read here for more details.
Access all model and tunable sections:
model_sections
— Methodmodel_sections(m::AbstractFTheoryModel)
Return the model sections of the given F-theory model.
For a detailed explanation of the concept, see Model Parameters, Defining Classes, and Related Concepts.
Examples
julia> m = literature_model(arxiv_id = "1109.3454", equation = "3.1")
Assuming that the first row of the given grading is the grading under Kbar
Global Tate model over a not fully specified base -- SU(5)xU(1) restricted Tate model based on arXiv paper 1109.3454 Eq. (3.1)
julia> model_sections(m)
9-element Vector{String}:
"a6"
"a21"
"a3"
"w"
"a2"
"a1"
"a4"
"a43"
"a32"
This function is part of the experimental code in Oscar. Please read here for more details.
tunable_sections
— Methodtunable_sections(m::AbstractFTheoryModel)
Return the tunable sections of the given F-theory model.
For a detailed explanation of the concept, see Model Parameters, Defining Classes, and Related Concepts.
Examples
julia> m = literature_model(arxiv_id = "1109.3454", equation = "3.1")
Assuming that the first row of the given grading is the grading under Kbar
Global Tate model over a not fully specified base -- SU(5)xU(1) restricted Tate model based on arXiv paper 1109.3454 Eq. (3.1)
julia> tunable_sections(m)
5-element Vector{String}:
"a21"
"w"
"a1"
"a43"
"a32"
This function is part of the experimental code in Oscar. Please read here for more details.
The tunable sections parametrize structural sections. The following method expresses each model section in terms of the tunable sections:
model_section_parametrization
— Methodmodel_section_parametrization(m::AbstractFTheoryModel)
Return a dictionary that defines how the structural sections of the given F-theory model are parametrized by the tunable sections.
For a detailed explanation of the concept, see Model Parameters, Defining Classes, and Related Concepts.
Examples
julia> t = literature_model(arxiv_id = "1109.3454", equation = "3.1")
Assuming that the first row of the given grading is the grading under Kbar
Global Tate model over a not fully specified base -- SU(5)xU(1) restricted Tate model based on arXiv paper 1109.3454 Eq. (3.1)
julia> model_section_parametrization(t)
Dict{String, MPolyRingElem} with 4 entries:
"a6" => 0
"a3" => w^2*a32
"a2" => w*a21
"a4" => w^3*a43
This function is part of the experimental code in Oscar. Please read here for more details.
The hypersurface equation can also be written explicitly in terms of structural and tunable sections. This is accessible via:
Currently supported only for Hypersurface Models.
hypersurface_equation_parametrization
— Methodhypersurface_equation_parametrization(h::HypersurfaceModel)
Return the parametrization of the hypersurface equation by the model sections.
Examples
julia> h = literature_model(arxiv_id = "1208.2695", equation = "B.5")
Assuming that the first row of the given grading is the grading under Kbar
Hypersurface model over a not fully specified base
julia> explicit_model_sections(h)
Dict{String, MPolyRingElem} with 5 entries:
"c2" => c2
"c1" => c1
"c3" => c3
"b" => b
"c0" => c0
julia> hypersurface_equation_parametrization(h)
b*w*v^2 - c0*u^4 - c1*u^3*v - c2*u^2*v^2 - c3*u*v^3 + w^2
This function is part of the experimental code in Oscar. Please read here for more details.
To study the divisor classes of the tunable sections in more detail, the following method provides their expression in a basis consisting of the anticanonical divisor $\overline{K}_B$ of the base and the model's defining classes. Each column of the returned matrix corresponds to a tunable section, while each row represents a basis element:
classes_of_tunable_sections_in_basis_of_Kbar_and_defining_classes
— Methodclasses_of_tunable_sections_in_basis_of_Kbar_and_defining_classes(m::AbstractFTheoryModel)
Return the divisor classes of the tunable sections expressed in the basis of the anticanonical divisor of the base and the defining classes of the given model.
For a detailed explanation of the concept, see Model Parameters, Defining Classes, and Related Concepts.
Examples
julia> m = literature_model(arxiv_id = "1109.3454", equation = "3.1")
Assuming that the first row of the given grading is the grading under Kbar
Global Tate model over a not fully specified base -- SU(5)xU(1) restricted Tate model based on arXiv paper 1109.3454 Eq. (3.1)
julia> classes_of_tunable_sections_in_basis_of_Kbar_and_defining_classes(m)
Dict{String, Vector{Int64}} with 5 entries:
"a21" => [2, -1]
"w" => [0, 1]
"a1" => [1, 0]
"a43" => [4, -3]
"a32" => [3, -2]
This function is part of the experimental code in Oscar. Please read here for more details.
Once the base of the elliptic fibration is a concrete toric variety, we can obtain further explicit information about the model sections.
Retrieve the toric divisor class of each model section:
classes_of_model_sections
— Methodclasses_of_model_sections(m::AbstractFTheoryModel)
Return the divisor classes of all model sections of the given F-theory model.
For a detailed explanation of the concept, see Model Parameters, Defining Classes, and Related Concepts.
Examples
julia> B3 = projective_space(NormalToricVariety, 3)
Normal toric variety
julia> w = torusinvariant_prime_divisors(B3)[1]
Torus-invariant, prime divisor on a normal toric variety
julia> t = literature_model(arxiv_id = "1109.3454", equation = "3.1", base_space = B3, defining_classes = Dict("w" => w), completeness_check = false)
Construction over concrete base may lead to singularity enhancement. Consider computing singular_loci. However, this may take time!
Global Tate model over a concrete base -- SU(5)xU(1) restricted Tate model based on arXiv paper 1109.3454 Eq. (3.1)
julia> classes_of_model_sections(t)
Dict{String, ToricDivisorClass} with 9 entries:
"a21" => Divisor class on a normal toric variety
"a6" => Divisor class on a normal toric variety
"a3" => Divisor class on a normal toric variety
"w" => Divisor class on a normal toric variety
"a2" => Divisor class on a normal toric variety
"a1" => Divisor class on a normal toric variety
"a43" => Divisor class on a normal toric variety
"a4" => Divisor class on a normal toric variety
"a32" => Divisor class on a normal toric variety
This function is part of the experimental code in Oscar. Please read here for more details.
Express model sections explicitly as polynomials in the Cox ring of the base space:
If the base is a family of spaces, the polynomial expressions are equivalent to the return values of model_section_parametrization(::AbstractFTheoryModel)
.
explicit_model_sections
— Methodexplicit_model_sections(m::AbstractFTheoryModel)
Return the explicit polynomial expressions for all model sections of the given F-theory model.
For a detailed explanation of the concept, see Model Parameters, Defining Classes, and Related Concepts.
Examples
julia> t = literature_model(arxiv_id = "1109.3454", equation = "3.1")
Assuming that the first row of the given grading is the grading under Kbar
Global Tate model over a not fully specified base -- SU(5)xU(1) restricted Tate model based on arXiv paper 1109.3454 Eq. (3.1)
julia> explicit_model_sections(t)
Dict{String, MPolyDecRingElem{QQFieldElem, QQMPolyRingElem}} with 9 entries:
"a6" => 0
"a21" => a21
"a3" => w^2*a32
"w" => w
"a2" => w*a21
"a1" => a1
"a4" => w^3*a43
"a43" => a43
"a32" => a32
julia> B3 = projective_space(NormalToricVariety, 3)
Normal toric variety
julia> w = torusinvariant_prime_divisors(B3)[1]
Torus-invariant, prime divisor on a normal toric variety
julia> t2 = literature_model(arxiv_id = "1109.3454", equation = "3.1", base_space = B3, defining_classes = Dict("w" => w), completeness_check = false)
Construction over concrete base may lead to singularity enhancement. Consider computing singular_loci. However, this may take time!
Global Tate model over a concrete base -- SU(5)xU(1) restricted Tate model based on arXiv paper 1109.3454 Eq. (3.1)
julia> explicit_model_sections(t2);
This function is part of the experimental code in Oscar. Please read here for more details.
Metadata Attributes
We provide the following metadata attributes for literature models, each of which returns the corresponding attribute if it exists and otherwise throws an error:
associated_literature_models
— Methodassociated_literature_models(m::AbstractFTheoryModel)
Return associated_literature_models
of the F-theory model if known, otherwise throws an error.
See Metadata Attributes for more details.
This function is part of the experimental code in Oscar. Please read here for more details.
arxiv_doi
— Methodarxiv_doi(m::AbstractFTheoryModel)
Return arxiv_doi
of the F-theory model if known, otherwise throws an error.
See Metadata Attributes for more details.
This function is part of the experimental code in Oscar. Please read here for more details.
arxiv_id
— Methodarxiv_id(m::AbstractFTheoryModel)
Return arxiv_id
of the F-theory model if known, otherwise throws an error.
See Metadata Attributes for more details.
This function is part of the experimental code in Oscar. Please read here for more details.
arxiv_link
— Methodarxiv_link(m::AbstractFTheoryModel)
Return arxiv_link
of the F-theory model if known, otherwise throws an error.
See Metadata Attributes for more details.
This function is part of the experimental code in Oscar. Please read here for more details.
arxiv_model_equation_number
— Methodarxiv_model_equation_number(m::AbstractFTheoryModel)
Return arxiv_model_equation_number
of the F-theory model if known, otherwise throws an error.
See Metadata Attributes for more details.
This function is part of the experimental code in Oscar. Please read here for more details.
arxiv_model_page
— Methodarxiv_model_page(m::AbstractFTheoryModel)
Return arxiv_model_page
of the F-theory model if known, otherwise throws an error.
See Metadata Attributes for more details.
This function is part of the experimental code in Oscar. Please read here for more details.
arxiv_model_section
— Methodarxiv_model_section(m::AbstractFTheoryModel)
Return arxiv_model_section
of the F-theory model if known, otherwise throws an error.
See Metadata Attributes for more details.
This function is part of the experimental code in Oscar. Please read here for more details.
arxiv_version
— Methodarxiv_version(m::AbstractFTheoryModel)
Return arxiv_version
of the F-theory model if known, otherwise throws an error.
See Metadata Attributes for more details.
This function is part of the experimental code in Oscar. Please read here for more details.
birational_literature_models
— Methodbirational_literature_models(m::AbstractFTheoryModel)
Return birational_literature_models
of the F-theory model if known, otherwise throws an error.
See Metadata Attributes for more details.
This function is part of the experimental code in Oscar. Please read here for more details.
journal_doi
— Methodjournal_doi(m::AbstractFTheoryModel)
Return journal_doi
of the F-theory model if known, otherwise throws an error.
See Metadata Attributes for more details.
This function is part of the experimental code in Oscar. Please read here for more details.
journal_link
— Methodjournal_link(m::AbstractFTheoryModel)
Return journal_link
of the F-theory model if known, otherwise throws an error.
See Metadata Attributes for more details.
This function is part of the experimental code in Oscar. Please read here for more details.
journal_model_equation_number
— Methodjournal_model_equation_number(m::AbstractFTheoryModel)
Return journal_model_equation_number
of the F-theory model if known, otherwise throws an error.
See Metadata Attributes for more details.
This function is part of the experimental code in Oscar. Please read here for more details.
journal_model_page
— Methodjournal_model_page(m::AbstractFTheoryModel)
Return journal_model_page
of the F-theory model if known, otherwise throws an error.
See Metadata Attributes for more details.
This function is part of the experimental code in Oscar. Please read here for more details.
journal_model_section
— Methodjournal_model_section(m::AbstractFTheoryModel)
Return journal_model_section
of the F-theory model if known, otherwise throws an error.
See Metadata Attributes for more details.
This function is part of the experimental code in Oscar. Please read here for more details.
journal_pages
— Methodjournal_pages(m::AbstractFTheoryModel)
Return journal_pages
of the F-theory model if known, otherwise throws an error.
See Metadata Attributes for more details.
This function is part of the experimental code in Oscar. Please read here for more details.
journal_report_numbers
— Methodjournal_report_numbers(m::AbstractFTheoryModel)
Return journal_report_numbers
of the F-theory model if known, otherwise throws an error.
See Metadata Attributes for more details.
This function is part of the experimental code in Oscar. Please read here for more details.
journal_volume
— Methodjournal_volume(m::AbstractFTheoryModel)
Return journal_volume
of the F-theory model if known, otherwise throws an error.
See Metadata Attributes for more details.
This function is part of the experimental code in Oscar. Please read here for more details.
journal_name
— Methodjournal_name(m::AbstractFTheoryModel)
Return journal_name
of the F-theory model if known, otherwise throws an error.
See Metadata Attributes for more details.
This function is part of the experimental code in Oscar. Please read here for more details.
journal_year
— Methodjournal_year(m::AbstractFTheoryModel)
Return journal_year
of the F-theory model if known, otherwise throws an error.
See Metadata Attributes for more details.
This function is part of the experimental code in Oscar. Please read here for more details.
literature_identifier
— Methodliterature_identifier(m::AbstractFTheoryModel)
Return literature_identifier
of the F-theory model if known, otherwise throws an error.
See Metadata Attributes for more details.
This function is part of the experimental code in Oscar. Please read here for more details.
model_description
— Methodmodel_description(m::AbstractFTheoryModel)
Return model_description
of the F-theory model if known, otherwise throws an error.
See Metadata Attributes for more details.
This function is part of the experimental code in Oscar. Please read here for more details.
model_parameters
— Methodmodel_parameters(m::AbstractFTheoryModel)
Return model_parameters
of the F-theory model if known, otherwise throws an error.
See Metadata Attributes for more details.
This function is part of the experimental code in Oscar. Please read here for more details.
paper_authors
— Methodpaper_authors(m::AbstractFTheoryModel)
Return paper_authors
of the F-theory model if known, otherwise throws an error.
See Metadata Attributes for more details.
This function is part of the experimental code in Oscar. Please read here for more details.
paper_buzzwords
— Methodpaper_buzzwords(m::AbstractFTheoryModel)
Return paper_buzzwords
of the F-theory model if known, otherwise throws an error.
See Metadata Attributes for more details.
This function is part of the experimental code in Oscar. Please read here for more details.
paper_description
— Methodpaper_description(m::AbstractFTheoryModel)
Return paper_description
of the F-theory model if known, otherwise throws an error.
See Metadata Attributes for more details.
This function is part of the experimental code in Oscar. Please read here for more details.
paper_title
— Methodpaper_title(m::AbstractFTheoryModel)
Return paper_title
of the F-theory model if known, otherwise throws an error.
See Metadata Attributes for more details.
This function is part of the experimental code in Oscar. Please read here for more details.
For metadata fields that are collections, we provide helper functions to add new entries:
add_associated_literature_model
— Methodadd_associated_literature_model(m::AbstractFTheoryModel, addition::String)
Add a new entry to the list of associated literature models for the F-theory model. If the entry is already present, nothing is changed.
See Literature Models for more details.
This function is part of the experimental code in Oscar. Please read here for more details.
add_birational_literature_model
— Methodadd_birational_literature_model(m::AbstractFTheoryModel, addition::String)
Add a new entry to the list of birational models for the F-theory model. If the entry is already present, nothing is changed.
See Literature Models for more details.
This function is part of the experimental code in Oscar. Please read here for more details.
add_journal_report_number
— Methodadd_journal_report_number(m::AbstractFTheoryModel, addition::String)
Add a new entry to the list of journal report numbers for the F-theory model. If the entry is already present, nothing is changed.
See Literature Models for more details.
This function is part of the experimental code in Oscar. Please read here for more details.
add_model_parameter
— Methodadd_model_parameter(m::AbstractFTheoryModel, addition::String)
Add a new entry to the list of model parameters for the F-theory model. If the entry is already present, nothing is changed.
See Literature Models for more details.
This function is part of the experimental code in Oscar. Please read here for more details.
add_paper_author
— Methodadd_paper_author(m::AbstractFTheoryModel, addition::String)
Add a new entry to the list of paper authors for the F-theory model. If the entry is already present, nothing is changed.
See Literature Models for more details.
This function is part of the experimental code in Oscar. Please read here for more details.
add_paper_buzzword
— Methodadd_paper_buzzword(m::AbstractFTheoryModel, addition::String)
Add a new entry to the list of paper buzzwords for the F-theory model. If the entry is already present, nothing is changed.
See Literature Models for more details.
This function is part of the experimental code in Oscar. Please read here for more details.
We do not provide set_*
functions to overwrite attributes, in order to reduce the risk of accidental data loss. If you truly need to replace a value, use set_attribute!(m, :attribute_name, value)
.