-
Notifications
You must be signed in to change notification settings - Fork 133
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Move EllipticSurface to src and document it. (#4294)
* move EllipticSurface and BlowupMorphism to src * Document EllipticSurface, exports, deprecate mordell_weil_lattice --------- Co-authored-by: Co-authored-by: HechtiDerLachs <[email protected]> Co-authored-by: Lars Göttgens <[email protected]>
- Loading branch information
3 people
authored
Nov 14, 2024
1 parent
f96891f
commit 499f7ce
Showing
21 changed files
with
3,718 additions
and
3,430 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,97 @@ | ||
| ```@meta | ||
| CurrentModule = Oscar | ||
| ``` | ||
|
|
||
| # Elliptic Surfaces | ||
| See [SS19](@cite) for the theory of elliptic surfaces. | ||
|
|
||
| ```@docs | ||
| EllipticSurface | ||
| ``` | ||
|
|
||
| ## Constructors | ||
| ```@docs | ||
| elliptic_surface | ||
| kodaira_neron_model(E::EllipticCurve) | ||
| ``` | ||
|
|
||
| ## Attributes | ||
| ```@docs | ||
| generic_fiber(S::EllipticSurface) | ||
| zero_section(S::EllipticSurface) | ||
| euler_characteristic(X::EllipticSurface) | ||
| fibration(X::EllipticSurface) | ||
| weierstrass_chart(X::EllipticSurface) | ||
| weierstrass_chart_on_minimal_model(X::EllipticSurface) | ||
| weierstrass_model(X::EllipticSurface) | ||
| weierstrass_contraction(X::EllipticSurface) | ||
| fibration_on_weierstrass_model(X::EllipticSurface) | ||
| ``` | ||
|
|
||
| ## Reducible fibers and the trivial lattice | ||
| ```@docs | ||
| trivial_lattice(X::EllipticSurface) | ||
| reducible_fibers(S::EllipticSurface) | ||
| fiber_cartier(S::EllipticSurface, P::Vector = ZZ.([0,1])) | ||
| fiber_components(S::EllipticSurface, P; algorithm=:exceptional_divisors) | ||
| ``` | ||
|
|
||
| ## Mordell Weil group and related lattices | ||
| Since we require that ``\pi \colon X \to C`` has a section, the generic fibre of ``\pi`` is an elliptic curve ``E/k(C)``. The group ``E(k(C))`` of its rational points is called the Mordell-Weil group. It is a finitely generated abelian group. In general it is difficult to compute. | ||
|
|
||
| The height paring gives the free part of the Mordell-Weil group the structure of a quadratic lattice over the integers -- the so called Mordell-Weil lattice. | ||
|
|
||
| ```@docs | ||
| algebraic_lattice(X::EllipticSurface) | ||
| mordell_weil_sublattice(S::EllipticSurface) | ||
| mordell_weil_torsion(S::EllipticSurface) | ||
| section(X::EllipticSurface, P::EllipticCurvePoint) | ||
| basis_representation(X::EllipticSurface, D::AbsWeilDivisor) | ||
| ``` | ||
|
|
||
| ### Updating the Mordell Weil group | ||
| Since the Mordell-Weil group is hard to compute, the user has to provide its generators, or at least generators of a subgroup | ||
| at construction of the surface. In some cases it may be convenient to enter the basis after creation, although it is in general not recommended. The following function are meant for this purpose. | ||
| ```@docs | ||
| set_mordell_weil_basis!(X::EllipticSurface, mwl_basis::Vector{<:EllipticCurvePoint}) | ||
| update_mwl_basis!(S::EllipticSurface, mwl_gens::Vector{<:EllipticCurvePoint}) | ||
| algebraic_lattice_primitive_closure!(S::EllipticSurface) | ||
| algebraic_lattice_primitive_closure(S::EllipticSurface, p) | ||
| ``` | ||
|
|
||
| ## Morphisms | ||
| ```@docs | ||
| isomorphism_from_generic_fibers | ||
| isomorphisms(X::EllipticSurface, Y::EllipticSurface) | ||
| translation_morphism(X::EllipticSurface, P::EllipticCurvePoint) | ||
| ``` | ||
|
|
||
| ## Fibration hopping | ||
| The methods in this section are available only for elliptically fibered K3 surfaces. | ||
| A K3 surface ``X`` may admit several elliptic fibrations | ||
| ```math | ||
| \pi \colon X \to \mathbb{P}^1. | ||
| ``` | ||
| Fibration hopping is a way to compute them. | ||
| See e.g. [BE23](@cite) and [BZ23](@cite). | ||
|
|
||
| A divisor ``F`` on ``X`` is called elliptic if it is primitive, isotropic and nef. | ||
| The linear system ``|F|`` of an elliptic divisor ``F`` induces a genus one fibration on ``X``. | ||
| Conversely, the class of a fiber ``F`` of an elliptic fibration is an elliptic divisor. | ||
| Two elliptic fibrations on ``X`` with elliptic divisors ``F_1`` and ``F_2`` are called ``n``-neighbors if their intersection number is ``F_1.F_2=n``. | ||
|
|
||
| ```@docs | ||
| linear_system(X::EllipticSurface, P::EllipticCurvePoint, k::Int) | ||
| two_neighbor_step(X::EllipticSurface, F::Vector{QQFieldElem}) | ||
| elliptic_parameter(X::EllipticSurface, F::Vector{QQFieldElem}) | ||
| pushforward_on_algebraic_lattices(f::MorphismFromRationalFunctions{<:EllipticSurface, <:EllipticSurface}) | ||
| ``` | ||
| ## Contact | ||
|
|
||
| Please direct questions about this part of OSCAR to the following people: | ||
| * [Simon Brandhorst](https://www.math.uni-sb.de/ag/brandhorst/index.php?lang=en). | ||
| * [Matthias Zach](https://math.rptu.de/en/wgs/agag/people/members), | ||
|
|
||
| You can ask questions in the [OSCAR Slack](https://www.oscar-system.org/community/#slack). | ||
|
|
||
| Alternatively, you can [raise an issue on github](https://www.oscar-system.org/community/#how-to-report-issues). |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -1,185 +0,0 @@ | ||
| export AbsProjectiveScheme | ||
| export EmptyScheme | ||
| export ProjectiveScheme | ||
| export ProjectiveSchemeMor | ||
| export VarietyFunctionField | ||
| export VarietyFunctionFieldElem | ||
|
|
||
| abstract type AbsProjectiveGluing{ | ||
| GluingType<:AbsGluing, | ||
| } | ||
| end | ||
|
|
||
| @doc raw""" | ||
| LazyProjectiveGluing( | ||
| X::AbsProjectiveScheme, | ||
| Y::AbsProjectiveScheme, | ||
| BG::AbsGluing, | ||
| compute_function::Function, | ||
| gluing_data | ||
| ) | ||
| Produce a container `pg` to host a non-computed `ProjectiveGluing` of ``X`` with ``Y``. | ||
| The arguments consist of | ||
| * the patches ``X`` and ``Y`` to be glued; | ||
| * a gluing `BG` of the `base_scheme`s of ``X`` and ``Y`` over which the | ||
| `ProjectiveGluing` to be computed sits; | ||
| * a function `compute_function` which takes a single argument `gluing_data` | ||
| of arbitrary type and actually carries out the computation; | ||
| * an arbitrary struct `gluing_data` that the user can fill with whatever | ||
| information is needed to properly feed their `compute_function`. | ||
| The container `pg` can then be stored as the gluing of ``X`` and ``Y``. As soon | ||
| as it is asked about any data on the gluing beyond its two `patches`, it will | ||
| invoke the internally stored `compute_function` to actually carry out the computation | ||
| of the gluing and then serve the incoming request on the basis of that result. | ||
| The latter actual `ProjectiveGluing` will then be cached. | ||
| """ | ||
| mutable struct LazyProjectiveGluing{ | ||
| GluingType<:AbsGluing, | ||
| GluingDataType | ||
| } <: AbsProjectiveGluing{GluingType} | ||
| base_gluing::GluingType | ||
| patches::Tuple{AbsProjectiveScheme, AbsProjectiveScheme} | ||
| compute_function::Function | ||
| gluing_data::GluingDataType | ||
| underlying_gluing::AbsProjectiveGluing | ||
|
|
||
| function LazyProjectiveGluing( | ||
| X::AbsProjectiveScheme, | ||
| Y::AbsProjectiveScheme, | ||
| BG::AbsGluing, | ||
| compute_function::Function, | ||
| gluing_data | ||
| ) | ||
| (base_scheme(X), base_scheme(Y)) == patches(BG) || error("gluing is incompatible with provided patches") | ||
| return new{typeof(BG), typeof(gluing_data)}(BG, (X, Y), compute_function, gluing_data) | ||
| end | ||
| end | ||
|
|
||
| @doc raw""" | ||
| ProjectiveGluing( | ||
| G::GluingType, | ||
| incP::IncType, incQ::IncType, | ||
| f::IsoType, g::IsoType; | ||
| check::Bool=true | ||
| ) where {GluingType<:AbsGluing, IncType<:ProjectiveSchemeMor, IsoType<:ProjectiveSchemeMor} | ||
| The `AbsProjectiveSchemeMorphism`s `incP` and `incQ` are open embeddings over open | ||
| embeddings of their respective `base_scheme`s. | ||
| PX ↩ PU ≅ QV ↪ QY | ||
| π ↓ ↓ ↓ ↓ π | ||
| G : X ↩ U ≅ V ↪ Y | ||
| This creates a gluing of the projective schemes `codomain(incP)` and `codomain(incQ)` | ||
| over a gluing `G` of their `base_scheme`s along the morphisms of `AbsProjectiveScheme`s | ||
| `f` and `g`, identifying `domain(incP)` and `domain(incQ)`, respectively. | ||
| """ | ||
| mutable struct ProjectiveGluing{ | ||
| GluingType<:AbsGluing, | ||
| IsoType1<:ProjectiveSchemeMor, | ||
| IncType1<:ProjectiveSchemeMor, | ||
| IsoType2<:ProjectiveSchemeMor, | ||
| IncType2<:ProjectiveSchemeMor, | ||
| } <: AbsProjectiveGluing{GluingType} | ||
| G::GluingType # the underlying gluing of the base schemes | ||
| inc_to_P::IncType1 | ||
| inc_to_Q::IncType2 | ||
| f::IsoType1 | ||
| g::IsoType2 | ||
|
|
||
| ### | ||
| # Given two relative projective schemes and a gluing | ||
| # | ||
| # PX ↩ PU ≅ QV ↪ QY | ||
| # π ↓ ↓ ↓ ↓ π | ||
| # G : X ↩ U ≅ V ↪ Y | ||
| # | ||
| # this constructs the gluing of PX and QY along | ||
| # their open subsets PU and QV, given the two inclusions | ||
| # and isomorphisms over the gluing G in the base schemes. | ||
| function ProjectiveGluing( | ||
| G::GluingType, | ||
| incP::IncType1, incQ::IncType2, | ||
| f::IsoType1, g::IsoType2; | ||
| check::Bool=true | ||
| ) where {GluingType<:AbsGluing, IncType1<:ProjectiveSchemeMor,IncType2<:ProjectiveSchemeMor, IsoType1<:ProjectiveSchemeMor, IsoType2<:ProjectiveSchemeMor} | ||
| (X, Y) = patches(G) | ||
| (U, V) = gluing_domains(G) | ||
| @vprint :Gluing 1 "computing projective gluing\n" | ||
| @vprint :Gluing 2 "$(X), coordinates $(ambient_coordinates(X))\n" | ||
| @vprint :Gluing 2 "and\n" | ||
| @vprint :Gluing 2 "$(Y) coordinates $(ambient_coordinates(X))\n" | ||
| (fb, gb) = gluing_morphisms(G) | ||
| (PX, QY) = (codomain(incP), codomain(incQ)) | ||
| (PU, QV) = (domain(incP), domain(incQ)) | ||
| (base_scheme(PX) === X && base_scheme(QY) === Y) || error("base gluing is incompatible with the projective schemes") | ||
| domain(f) === codomain(g) === PU && domain(g) === codomain(f) === QV || error("maps are not compatible") | ||
| SPU = homogeneous_coordinate_ring(domain(f)) | ||
| SQV = homogeneous_coordinate_ring(codomain(f)) | ||
| @check begin | ||
| # check the commutativity of the pullbacks | ||
| all(y->(pullback(f)(SQV(OO(V)(y))) == SPU(pullback(fb)(OO(V)(y)))), gens(base_ring(OO(Y)))) || error("maps do not commute") | ||
| all(x->(pullback(g)(SPU(OO(U)(x))) == SQV(pullback(gb)(OO(U)(x)))), gens(base_ring(OO(X)))) || error("maps do not commute") | ||
| fc = map_on_affine_cones(f, check=false) | ||
| gc = map_on_affine_cones(g, check=false) | ||
| idCPU = compose(fc, gc) | ||
| idCPU == identity_map(domain(fc)) || error("composition of maps is not the identity") | ||
| idCQV = compose(gc, fc) | ||
| idCQV == identity_map(domain(gc)) || error("composition of maps is not the identity") | ||
| # idPU = compose(f, g) | ||
| # all(t->(pullback(idPU)(t) == t), gens(SPU)) || error("composition of maps is not the identity") | ||
| # idQV = compose(g, f) | ||
| # all(t->(pullback(idQV)(t) == t), gens(SQV)) || error("composition of maps is not the identity") | ||
| end | ||
| @vprint :Gluing 1 "done computing the projective gluing\n" | ||
| return new{GluingType, IsoType1, IncType1, IsoType2, IncType2}(G, incP, incQ, f, g) | ||
| end | ||
| end | ||
|
|
||
| ### Proper schemes π : Z → X over a covered base scheme X | ||
| # | ||
| # When {Uᵢ} is an affine covering of X, the datum stored | ||
| # consists of a list of projective schemes | ||
| # | ||
| # Zᵢ ⊂ ℙʳ⁽ⁱ⁾(𝒪(Uᵢ)) → Uᵢ | ||
| # | ||
| # with varying ambient spaces ℙʳ⁽ⁱ⁾(𝒪(Uᵢ)) and a list of | ||
| # identifications (transitions) | ||
| # | ||
| # Zᵢ ∩ π⁻¹(Uⱼ) ≅ Zⱼ ∩ π⁻¹(Uᵢ) | ||
| # | ||
| # of projective schemes over Uᵢ∩ Uⱼ for all pairs (i,j). | ||
| # | ||
| # These structs are designed to accommodate blowups of | ||
| # covered schemes along arbitrary centers, as well as | ||
| # projective bundles. | ||
|
|
||
| @attributes mutable struct CoveredProjectiveScheme{BRT} <: Scheme{BRT} | ||
| Y::AbsCoveredScheme # the base scheme | ||
| BC::Covering # the reference covering of the base scheme | ||
| patches::IdDict{AbsAffineScheme, AbsProjectiveScheme} # the projective spaces over the affine patches in the base covering | ||
| gluings::IdDict{Tuple{AbsAffineScheme, AbsAffineScheme}, AbsProjectiveGluing} # the transitions sitting over the affine patches in the gluing domains of the base scheme | ||
|
|
||
| function CoveredProjectiveScheme( | ||
| Y::AbsCoveredScheme, | ||
| C::Covering, | ||
| projective_patches::IdDict{AbsAffineScheme, AbsProjectiveScheme}, | ||
| projective_gluings::IdDict{Tuple{AbsAffineScheme, AbsAffineScheme}, AbsProjectiveGluing}; | ||
| check::Bool=true | ||
| ) | ||
| C in coverings(Y) || error("covering not listed") | ||
| for P in values(projective_patches) | ||
| any(x->x===base_scheme(P), patches(C)) || error("base scheme not found in covering") | ||
| end | ||
| for (U, V) in keys(gluings(C)) | ||
| (U, V) in keys(projective_gluings) || error("not all projective gluings were provided") | ||
| end | ||
| return new{base_ring_type(Y)}(Y, C, projective_patches, projective_gluings) | ||
| end | ||
| end | ||
|
|
||
|
|
||
Oops, something went wrong.