Rename issubset to is_subscheme for subschemes (#3202)

docs/src/AlgebraicGeometry/Schemes/AffineSchemes.md

@@ -17,7 +17,7 @@ defined over the integers, a finite field or algebraic field extensions of ``\ma
 
 ### General constructors
 
-Besides `Spec(R)` for `R` of either one of the types `MPolyRing`, `MPolyQuoRing`, `MPolyLocRing`, or 
+Besides `Spec(R)` for `R` of either one of the types `MPolyRing`, `MPolyQuoRing`, `MPolyLocRing`, or
 `MPolyQuoLocRing`, we have the following constructors:
 ```@docs
 Spec(R::MPolyRing, I::MPolyIdeal)
@@ -90,7 +90,7 @@ OO(X::AbsSpec)
 ### Type getters
 
 We support functions which return the types of
-schemes, associated rings, and their elements. See the 
+schemes, associated rings, and their elements. See the
 source code for details.
 
 
@@ -100,7 +100,7 @@ source code for details.
 is_open_embedding(X::AbsSpec, Y::AbsSpec)
 is_closed_embedding(X::AbsSpec, Y::AbsSpec)
 isempty(X::AbsSpec)
-issubset(X::AbsSpec, Y::AbsSpec)
+is_subscheme(X::AbsSpec, Y::AbsSpec)
 ```
 
 

experimental/Schemes/CoveredScheme.jl

@@ -7,7 +7,7 @@ export morphism_type
 ### essential getters
 
 #function add_affine_refinement!(
-#    C::Covering, U::SpecOpen; 
+#    C::Covering, U::SpecOpen;
 #    a::Vector{RingElemType}=as_vector(coordinates(one(OO(ambient_scheme(U))),
 #                                                  ideal(OO(ambient_scheme(U)),
 #                                                        OO(ambient_scheme(U)).(gens(U)))),
@@ -77,8 +77,8 @@ end
 #open_subset_type(::Type{Covering{R, S, T}}) where {R, S, T} = T
 #open_subset_type(C::Covering) = open_subset_type(typeof(C))
 
-# TODO: For some reason, the `indexin` method won't work. In the long 
-# run, one should probably find out why and fix it. 
+# TODO: For some reason, the `indexin` method won't work. In the long
+# run, one should probably find out why and fix it.
 
 
 affine_refinements(C::Covering) = C.affine_refinements
@@ -247,8 +247,8 @@ end
   r = relative_ambient_dimension(X)
   U = Vector{AbsSpec}()
 
-  # The case of ℙ⁰-bundles appears frequently in blowups when the 
-  # ideal sheaf is trivial on some affine open part. 
+  # The case of ℙ⁰-bundles appears frequently in blowups when the
+  # ideal sheaf is trivial on some affine open part.
   if r == 0
     result = Covering(Y)
     set_decomposition_info!(result, Y, elem_type(OO(Y))[])
@@ -263,7 +263,7 @@ end
 
   # TODO: Check that all weights are equal to one. Otherwise the routine is not implemented.
   s = symbols(S)
-  # for each homogeneous variable, set up the chart 
+  # for each homogeneous variable, set up the chart
   chart_dict, projection_dict = _generate_affine_charts(X)
   isempty(chart_dict) && return empty_covering(base_ring(Y))
 
@@ -341,7 +341,7 @@ refinements(X::AbsCoveredScheme) = refinements(underlying_scheme(X))::Dict{<:Tup
 ### getter methods
 refinements(X::CoveredScheme) = X.refinements
 
-#function set_default_covering!(X::CoveredScheme, C::Covering) 
+#function set_default_covering!(X::CoveredScheme, C::Covering)
 #  C in coverings(X) || error("covering is not listed")
 #  X.default_covering = C
 #  return X
@@ -372,7 +372,7 @@ _compose_along_path(X::CoveredScheme, p::Vector{Int}) = _compose_along_path(X, [
 #    push!(p, Ni[1])
 #    Ni = neighbors(G, Ni[1])
 #  end
-#  q = [j] 
+#  q = [j]
 #  Nj = neighbors(G, j)
 #  while length(Nj) > 0
 #    push!(p, Nj[1])
@@ -385,8 +385,8 @@ _compose_along_path(X::CoveredScheme, p::Vector{Int}) = _compose_along_path(X, [
 #@doc raw"""
 #    common_refinement(X::CoveredScheme, C1::T, C2::T) where {T<:Covering}
 #
-#Given two coverings of ``X``, return a triple `(C_new, f, g)` consisting 
-#of a common refinement `C_new` of `C1` and `C2` and the refinement morphisms 
+#Given two coverings of ``X``, return a triple `(C_new, f, g)` consisting
+#of a common refinement `C_new` of `C1` and `C2` and the refinement morphisms
 #`f : C_new → C1` and `g : C_new → C2`.
 #"""
 #function common_refinement(X::CoveredScheme, C1::T, C2::T) where {T<:Covering}
@@ -403,7 +403,7 @@ _compose_along_path(X::CoveredScheme, p::Vector{Int}) = _compose_along_path(X, [
 #  if length(p2) == 0
 #    return (C1, _compose_along_path(X, p1), identity_map(C2))
 #  end
-#  
+#
 #  # now we may assume that neither one of the coverings is contained in the other
 #  C0 = X[r]
 #  f = _compose_along_path(X, p1)
@@ -421,8 +421,8 @@ _compose_along_path(X::CoveredScheme, p::Vector{Int}) = _compose_along_path(X, [
 #    # first try to find a patch in C2 which fully includes U
 #    patch_found = false
 #    while length(V_candidates) > 0
-#      V = pop!(V_candidates) 
-#      if issubset(U, V) 
+#      V = pop!(V_candidates)
+#      if is_subscheme(U, V)
 #        inc1[U] = identity_map(U)
 #        inc2[U] = inclusion_morphism(U, V)
 #        inc0[U] = f[U]
@@ -442,7 +442,7 @@ _compose_along_path(X::CoveredScheme, p::Vector{Int}) = _compose_along_path(X, [
 #      push!(new_patches, UV)
 #    end
 #  end
-#  
+#
 #  # cook up the gluings for the new patches from those in the common root.
 #  new_gluings = IdDict{Tuple{affine_patch_type(X), affine_patch_type(X)}, gluing_type(affine_patch_type(X))}()
 #  for (W1, W2) in keys(gluings(C0))
@@ -529,7 +529,7 @@ underlying_morphism(phi::CoveredClosedEmbedding) = phi.f
 image_ideal(phi::CoveredClosedEmbedding) = phi.I
 
 ### user facing constructors
-function CoveredClosedEmbedding(X::AbsCoveredScheme, I::IdealSheaf; 
+function CoveredClosedEmbedding(X::AbsCoveredScheme, I::IdealSheaf;
         covering::Covering=default_covering(X), check::Bool=true)
   space(I) === X || error("ideal sheaf is not defined on the correct scheme")
   mor_dict = IdDict{AbsSpec, ClosedEmbedding}() # Stores the morphism fᵢ : Uᵢ → Vᵢ for some covering Uᵢ ⊂ Z(I) ⊂ X.
@@ -549,7 +549,7 @@ function CoveredClosedEmbedding(X::AbsCoveredScheme, I::IdealSheaf;
     U = codomain(mor_dict[Unew])
     for Vnew in keys(mor_dict)
       V = codomain(mor_dict[Vnew])
-      gluing_dict[(Unew, Vnew)] = LazyGluing(Unew, Vnew, _compute_restriction, 
+      gluing_dict[(Unew, Vnew)] = LazyGluing(Unew, Vnew, _compute_restriction,
                                                RestrictionDataClosedEmbedding(covering[U, V], Unew, Vnew)
                                               )
     end
@@ -576,28 +576,28 @@ end
                                  CoveredSchemeMorphism
                                 }
 
-A special concrete type of an `AbsCoveredSchemeMorphism` of the 
-form ``f = hᵣ ∘ hᵣ₋₁ ∘ … ∘ h₁: X → Y`` for arbitrary 
-`AbsCoveredSchemeMorphism`s ``h₁ : X → Z₁``, ``h₂ : Z₁ → Z₂``, ..., 
-``hᵣ : Zᵣ₋₁ → Y``. 
+A special concrete type of an `AbsCoveredSchemeMorphism` of the
+form ``f = hᵣ ∘ hᵣ₋₁ ∘ … ∘ h₁: X → Y`` for arbitrary
+`AbsCoveredSchemeMorphism`s ``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 
+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. 
+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 
+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. 
+to obtain a list of the ``hⱼ`` and `map(f, j)` to obtain the `j`-th map
+directly.
 """
 @attributes mutable struct CompositeCoveredSchemeMorphism{
     DomainType<:AbsCoveredScheme,
@@ -659,8 +659,8 @@ end
 @doc raw"""
     composite_map(f::AbsCoveredSchemeMorphism, g::AbsCoveredSchemeMorphism)
 
-Realize the composition ``x → g(f(x))`` as a composite map, i.e. an 
-instance of `CompositeCoveredSchemeMorphism`. 
+Realize the composition ``x → g(f(x))`` as a composite map, i.e. an
+instance of `CompositeCoveredSchemeMorphism`.
 
 # Examples
 ```jldoctest
@@ -744,7 +744,7 @@ function pushforward(f::CompositeCoveredSchemeMorphism, a::VarietyFunctionFieldE
   return result
 end
 
-function pullback(f::CompositeCoveredSchemeMorphism, a::VarietyFunctionFieldElem) 
+function pullback(f::CompositeCoveredSchemeMorphism, a::VarietyFunctionFieldElem)
   result = a
   for g in reverse(maps(f))
     result = pullback(g, result)