Covering

A covering of a scheme $X$ by affine charts $Uᵢ$ which are glued along isomorphisms $gᵢⱼ : Uᵢ⊃ Vᵢⱼ → Vⱼᵢ ⊂ Uⱼ$.

Note: The distinction between the different affine charts of the scheme is made from their hashes. Thus, an affine scheme must not appear more than once in any covering!

Covering(patches::Vector{<:AbsAffineScheme})

Return a Covering with pairwise disjoint affine charts $Uᵢ$ given by the entries of patches. This Covering will have no gluings except those gluings along the identity of every affine chart to itself.

Examples

julia> P1, (x,y) = QQ["x", "y"];

julia> P2, (u,v) = QQ["u", "v"];

julia> U1 = spec(P1);

julia> U2 = spec(P2);

julia> C = Covering([U1, U2]) # A Covering with two disjoint affine charts
Covering
  described by patches
    1: affine 2-space
    2: affine 2-space
  in the coordinate(s)
    1: [x, y]
    2: [u, v]

disjoint_union(C1::Covering, C2::Covering)

Return the Covering corresponding to the disjoint union of C1 and C2.

The charts and gluings of the disjoint union are given by the disjoint union of the charts and gluings of the covers C1 and C2.

Examples

julia> P1, (x,y) = QQ["x", "y"];

julia> P2, (u,v) = QQ["u", "v"];

julia> U1 = spec(P1);

julia> U2 = spec(P2);

julia> C1 = Covering(U1) # Set up the trivial covering with only one patch
Covering
  described by patches
    1: affine 2-space
  in the coordinate(s)
    1: [x, y]

julia> C2 = Covering(U2)
Covering
  described by patches
    1: affine 2-space
  in the coordinate(s)
    1: [u, v]

julia> C = disjoint_union(C1, C2)
Covering
  described by patches
    1: affine 2-space
    2: affine 2-space
  in the coordinate(s)
    1: [x, y]
    2: [u, v]

affine_charts(C::Covering)

Return the list of affine charts that make up the Covering C.

gluings(C::Covering)

Return a dictionary of gluings of the affine_charts of C.

The keys are pairs (U, V) of affine_charts. One can also use C[U, V] to obtain the respective gluing.

Note: Gluings are lazy in the sense that they are in general only computed when asked for. This method only returns the internal cache, but does not try to compute new gluings.

add_gluing!(C::Covering, G::AbsGluing)

Add a gluing G to the covering C.

The patches of G must be among the affine_charts of C.

Examples

julia> P1, (x,y) = QQ["x", "y"];

julia> P2, (u,v) = QQ["u", "v"];

julia> U1 = spec(P1);

julia> U2 = spec(P2);

julia> C = Covering([U1, U2]) # A Covering with two disjoint affine charts
Covering
  described by patches
    1: affine 2-space
    2: affine 2-space
  in the coordinate(s)
    1: [x, y]
    2: [u, v]

julia> V1 = PrincipalOpenSubset(U1, x); # Preparations for gluing

julia> V2 = PrincipalOpenSubset(U2, u);

julia> f = morphism(V1, V2, [1//x, y//x]); # The gluing isomorphism

julia> g = morphism(V2, V1, [1//u, v//u]); # and its inverse

julia> G = Gluing(U1, U2, f, g); # Construct the gluing

julia> add_gluing!(C, G) # Make the gluing part of the Covering
Covering
  described by patches
    1: affine 2-space
    2: affine 2-space
  in the coordinate(s)
    1: [x, y]
    2: [u, v]

julia> C[U1, U2] == G # Check whether the gluing of U1 and U2 in C is G.
true

AbsGluing

A gluing of two affine schemes $X$ and $Y$ (the patches) along open subsets $U$ in $X$ and $V$ in $Y$ (the gluing_domains) along mutual isomorphisms $f : U ↔ V : g$ (the gluing_morphisms).

Gluing

Concrete instance of an AbsGluing for gluings of affine schemes $X ↩ U ≅ V ↪ Y$ along open subsets $U$ and $V$ of type AffineSchemeOpenSubscheme.

SimpleGluing

Concrete instance of an AbsGluing for gluings of affine schemes $X ↩ U ≅ V ↪ Y$ along open subsets $U$ and $V$ of type PrincipalOpenSubset.

Gluing(X::AbsAffineScheme, Y::AbsAffineScheme, f::SchemeMor, g::SchemeMor)

Glue two affine schemes $X$ and $Y$ along mutual isomorphisms $f$ and $g$ of open subsets $U$ of $X$ and $V$ of $Y$.

Examples

julia> P1, (x,y) = QQ["x", "y"]; P2, (u,v) = QQ["u", "v"];

julia> U1 = spec(P1); U2 = spec(P2);

julia> V1 = PrincipalOpenSubset(U1, x); # Preparations for gluing

julia> V2 = PrincipalOpenSubset(U2, u);

julia> f = morphism(V1, V2, [1//x, y//x]); # The gluing isomorphism

julia> g = morphism(V2, V1, [1//u, v//u]); # and its inverse

julia> G = Gluing(U1, U2, f, g) # Construct the gluing
Gluing
  of affine 2-space
  and affine 2-space
along the open subsets
  [x, y]   AA^2 \ scheme(x)
  [u, v]   AA^2 \ scheme(u)
given by the pullback function
  u -> 1/x
  v -> y/x

julia> G isa SimpleGluing # Since the gluing domains were `PrincipalOpenSubsets`, this defaults to a `SimpleGluing`
true

julia> # Alternative using AffineSchemeOpenSubschemes as gluing domains:

julia> W1 = AffineSchemeOpenSubscheme(U1, [x]); W2 = AffineSchemeOpenSubscheme(U2, [u]);

julia> h1 = AffineSchemeOpenSubschemeMor(W1, W2, [1//x, y//x]);

julia> h2 = AffineSchemeOpenSubschemeMor(W2, W1, [1//u, v//u]);

julia> H = Gluing(U1, U2, h1, h2)
Gluing
  of affine 2-space
  and affine 2-space
along the open subsets
  [x, y]   complement to V(x) in affine scheme with coordinates [x, y]
  [u, v]   complement to V(u) in affine scheme with coordinates [u, v]
defined by the map
  affine scheme morphism
    from [x, y]  AA^2 \ scheme(x)
    to   [u, v]  affine 2-space
  given by the pullback function
    u -> 1/x
    v -> y/x

julia> H isa Gluing
true

patches(G::AbsGluing)

Return a pair of affine schemes (X, Y) which are glued by G.

gluing_domains(G::AbsGluing)

Return a pair of open subsets $U$ and $V$ of the respective patches of G which are glued by G along the gluing_morphisms of G.

gluing_morphisms(G::AbsGluing)

Return a pair of mutually inverse isomorphisms (f, g) of open subsets $U$ and $V$ of the respective patches of G which are used for the gluing identification.

inverse(G::AbsGluing)

Return the gluing H with patches, gluing_domains, and gluing_morphisms in opposite order compared to G.

compose(G::AbsGluing, H::AbsGluing)

Given gluings X ↩ U ≅ V ↪ Y and Y ↩ V' ≅ W ↪ Z, return the gluing X ↩ V ∩ V' ↪ Z.

WARNING: In general such a gluing will not provide a separated scheme. Use maximal_extension to extend the gluing.

maximal_extension(G::Gluing)

Given a gluing X ↩ U ≅ V ↪ Y, try to find the maximal extension to an open subset U' ⊃ U in X and V' ⊃ V in Y so that the resulting scheme is separated.

restrict(G::AbsGluing, f::AbsAffineSchemeMor, g::AbsAffineSchemeMor; check::Bool=true)

Given a gluing $X ↩ U ≅ V ↪ Y$ and isomorphisms $f : X → X'$ and $g: Y → Y'$, return the induced gluing of $X'$ and $Y'$.