Morphisms of covered schemes

Suppose $f : X \to Y$ is a morphism of AbsCoveredSchemes. Theoretically, and hence also technically, the required information behind $f$ is a list of morphisms of affine schemes $f_i : U_i \to V_{F(i)}$ for some pair of Coverings $\left\{U_i\right\}_{i \in I}$ of $X$ and $\left\{V_j\right\}_{j \in J}$ of $Y$ and a map of indices $F : I \to J$ This information is held by a CoveringMorphism:

CoveringMorphism — Type

CoveringMorphism

A morphism $f : C → D$ of two coverings. For every patch $U$ of $C$ this provides a map f[U'] of type AffineSchemeMorType from $U' ⊂ U$ to some patch codomain(f[U]) in D for some affine patches $U'$ covering $U$.

Note: For two affine patches $U₁, U₂ ⊂ U$ the codomains of f[U₁] and f[U₂] do not need to coincide! However, given the gluings in C and D, all affine maps have to coincide on their overlaps.

source

The basic functionality of CoveringMorphisms comprises domain and codomain which both return a Covering, together with

getindex(f::CoveringMorphism, U::AbsAffineScheme)

which for $U = U_i$ returns the AbsAffineSchemeMor $f_i : U_i \to V_{F(i)}$.

Note that, in general, neither the domain nor the codomain of the covering_morphism of f : X \to Y need to coincide with the default_covering of $X$, respectively $Y$. In fact, one will usually need to restrict to a refinement of the default_covering of $X$ in order to realize the covering morphism in the first place.

The interface for morphisms of covered schemes

Every AbsCoveredSchemeMorphism $f : X \to Y$ is required to implement the following minimal interface.

domain(f::AbsCoveredSchemeMorphism)                 # returns X
codomain(f::AbsCoveredSchemeMorphism)               # returns Y
covering_morphism(f::AbsCoveredSchemeMorphism)      # returns the underlying covering morphism {f_i}

For the user's convenience, also the domain and codomain of the underlying covering_morphism are forwarded as domain_covering and codomain_covering, respectively, together with getindex(phi::CoveringMorphism, U::AbsAffineScheme) as getindex(f::AbsCoveredSchemeMorphism, U::AbsAffineScheme).

The minimal concrete type of an AbsCoveredSchemeMorphism which implements this interface, is CoveredSchemeMorphism.

Special types of morphisms of covered schemes

Closed embeddings

CoveredClosedEmbedding — Type

CoveredClosedEmbedding <: AbsCoveredSchemeMorphism

Type for closed embeddings of covered schemes.

In addition to the closed embedding it stores the sheaf of ideals defining the image.

source

image_ideal — Method

image_ideal(phi::CoveredClosedEmbedding)

For a closed embedding $\phi \colon X \to Y$ return the sheaf of ideals on $Y$ defining the image of $\phi$.

source

Composite morphisms

CompositeCoveredSchemeMorphism — Type

CompositeCoveredSchemeMorphism{
    DomainType<:AbsCoveredScheme,
    CodomainType<:AbsCoveredScheme,
    BaseMorphismType
   } <: AbsCoveredSchemeMorphism{
                             DomainType,
                             CodomainType,
                             BaseMorphismType,
                             CoveredSchemeMorphism
                            }

A special concrete type of an AbsCoveredSchemeMorphism of the form $f = hᵣ ∘ hᵣ₋₁ ∘ … ∘ h₁: X → Y$ for arbitrary AbsCoveredSchemeMorphisms $h₁ : X → Z₁$, $h₂ : Z₁ → Z₂$, ..., $hᵣ : Zᵣ₋₁ → Y$.

Since every such morphism $hⱼ$ will in general have an underlying CoveringMorphism with domain and codomain covering actual composition of such a sequence of morphisms will lead to an exponential increase in complexity of these coverings because of the necessary refinements. Nevertheless, the pullback or pushforward of various objects on either $X$ or $Y$ through such a chain of maps is possible stepwise. This type allows one to have one concrete morphism rather than a list of morphisms and to reroute such calculations to iteration over the various maps.

In addition to the usual functionality of the AbsCoveredSchemeMorphism interface, this concrete type has the getters

maps(f::CompositeCoveredSchemeMorphism)

to obtain a list of the $hⱼ$ and map(f, j) to obtain the j-th map directly.

source

Morphisms from rational functions

Suppose $X$ and $Y$ are two irreducible and reduced varieties. Then a morphism $f : X \to Y$ might be given by means of the following data. Let $V \subset Y$ be some dense affine patch with coordinates $x_1,\dots,x_n$ (i.e. the gens of OO(V)).

These $x_i$ extend to rational functions $v_i$ on $Y$ and these pull back to rational functions $f^* v_i = u_i$ on $X$. On every affine patch $U \subset X$ there now exists some maximal Zariski-open subset $W \subset U$ (which need not be affine), such that all the $f^* v_i$ extend to regular functions on $W$. Hence, one can realize the morphisms of affine schemes $f_j : W_j \to V$ for some open covering of $W$.

Similarly, for every other non-empty patch $V_2$ of $Y$ the pullback of gens(OO(V_2)) can be computed from the $f^* v_i$ and extended maximally to some $W \subset U$ for every patch $U$ of $X$. Altogether, this allows to compute a full CoveringMorphism and – at least in theory – an instance of CoveredSchemeMorphism. In practice, however, this computation is usually much too expensive to really be carried out, while the data necessary to compute various pullbacks and/or pushforwards of objects defined on $X$ and $Y$ can be extracted from the $f^* v_i$ more directly.

A lazy concrete data structure to house this kind of morphism is

MorphismFromRationalFunctions — Type

MorphismFromRationalFunctions{DomainType<:AbsCoveredScheme, CodomainType<:AbsCoveredScheme}

A lazy type for a dominant morphism $φ : X → Y$ of AbsCoveredSchemes which is given by a set of rational functions $a₁,…,aₙ$ in the fraction field of the base_ring of $𝒪(U)$ for one of the dense open affine_charts $U$ of $X$. The $aᵢ$ represent the pullbacks of the coordinates (gens) of some affine_chart $V$ of the codomain $Y$ under this map.

julia> IP1 = covered_scheme(projective_space(QQ, [:s, :t]))
Scheme
  over rational field
with default covering
  described by patches
    1: affine 1-space
    2: affine 1-space
  in the coordinate(s)
    1: [(t//s)]
    2: [(s//t)]

julia> IP2 = projective_space(QQ, [:x, :y, :z]);

julia> S = homogeneous_coordinate_ring(IP2);

julia> x, y, z = gens(S);

julia> IPC, inc_IPC = sub(IP2, ideal(S, [x^2 - y*z]));

julia> C = covered_scheme(IPC);

julia> U = first(affine_charts(IP1))
Spectrum
  of multivariate polynomial ring in 1 variable (t//s)
    over rational field

julia> V = first(affine_charts(C))
Spectrum
  of quotient
    of multivariate polynomial ring in 2 variables (y//x), (z//x)
      over rational field
    by ideal (-(y//x)*(z//x) + 1)

julia> t = first(gens(OO(U)))
(t//s)

julia> Phi = MorphismFromRationalFunctions(IP1, C, U, V, [t//one(t), 1//t]);

julia> realizations = Oscar.realize_on_patch(Phi, U);

julia> realizations[3]
Affine scheme morphism
  from [(t//s)]          AA^1
  to   [(x//z), (y//z)]  scheme((x//z)^2 - (y//z))
given by the pullback function
  (x//z) -> (t//s)
  (y//z) -> (t//s)^2

source

Note that the key idea of this data type is to not use the underlying_morphism together with its covering_morphism, but to find cheaper ways to do computations! The computation of the underlying_morphism is triggered by any call to functions which have not been overwritten with a special method for f::MorphismFromRationalFunctions. However, this computation should be considered as way too expensive besides some small examples.

For instance, if one wants to pull back a prime ideal sheaf $\mathcal I$ on $Y$ along some isomorphism $f : X \to Y$, then one only needs to find one realization $f_j : U_j \to V_{F(j)}$ of $f$ on affine patches $U_j$ of $X$ and $V_{F(j)}$ of $Y$ such that $\mathcal I(V_{F(j)})\neq 0$ and $f_j^* \mathcal I(V_{F(j)}) \neq 0$. Then $f^* \mathcal I$ can be extended uniquely to all of $X$ from $U_j$ and there is no need to realize the full covering_morphism of $f$. In order to facilitate such computations as lazy as possible, there are various fine-grained entry points and caching mechanisms to realize $f$ on open subsets:

realize_on_patch — Method

realize_on_patch(Phi::MorphismFromRationalFunctions, U::AbsAffineScheme)

For $U$ in the domain_covering of Phi construct a list of morphisms $fₖ : U'ₖ → Vₖ$ from PrincipalOpenSubsets $U'ₖ$ of $U$ to patches $Vₖ$ in the codomain_covering so that altogether the fₖ can be assembled to a CoveringMorphism which realizes Phi.

source

realize_on_open_subset — Method

realize_on_open_subset(Phi::MorphismFromRationalFunctions, U::AbsAffineScheme, V::AbsAffineScheme)

Return a morphism f : U' → V from some PrincipalOpenSubset of U to V such that the restriction of Phi to U' is f. Note that U' need not be maximal with this property!

source

realization_preview — Method

realization_preview(Phi::MorphismFromRationalFunctions, U::AbsAffineScheme, V::AbsAffineScheme)

For a pair (U, V) of patches in the domain_covering and the codomain_covering of Phi, respectively, this returns a list of elements in the fraction field of the ambient_coordinate_ring of U which represent the pullbacks of gens(OO(V)) under Phi to U.

source

random_realization — Method

random_realization(Phi::MorphismFromRationalFunctions, U::AbsAffineScheme, V::AbsAffineScheme)

For a pair (U, V) of patches in the domain_covering and the codomain_covering of Phi, respectively, this creates a random PrincipalOpenSubset U' on which the restriction f : U' → V of Phi can be realized and returns that restriction. Note that U' need not (and usually will not) be maximal with this property.

source

cheap_realization — Method

cheap_realization(Phi::MorphismFromRationalFunctions, U::AbsAffineScheme, V::AbsAffineScheme)

This method is cheap in the sense that it simply inverts all representatives of the denominators occurring in the realization_preview(Phi, U, V).

source

realize_maximally_on_open_subset — Method

realize_maximally_on_open_subset(Phi::MorphismFromRationalFunctions, U::AbsAffineScheme, V::AbsAffineScheme)

For a pair (U, V) of patches in the domain_covering and the codomain_covering of Phi, respectively, this returns a list of morphisms fₖ : U'ₖ → V such that the restriction of Phi to U'ₖ and V is fₖ and altogether the U'ₖ cover the maximal open subset U'⊂ U on which the restriction U' → V of Phi can be realized.

source

realize — Method

realize(Phi::MorphismFromRationalFunctions)

Computes a full realization of Phi as a CoveredSchemeMorphism. Note that this computation is very expensive and usage of this method should be avoided.

source