File: Mathlib/Geometry/RingedSpace/Basic.lean

full_name: AlgebraicGeometry.RingedSpace
code: /-- The type of Ringed spaces, as an abbreviation for `SheafedSpace CommRingCat`. -/
abbrev RingedSpace : TypeMax.{u+1, v+1} 
goal: TypeMax

full_name: AlgebraicGeometry.RingedSpace.instCoeSortType
code: instance : CoeSort RingedSpace Type* 
goal: CoeSort AlgebraicGeometry.RingedSpace (Type u_1)

full_name: AlgebraicGeometry.RingedSpace.isUnit_res_of_isUnit_germ
code: /--
If the germ of a section `f` is a unit in the stalk at `x`, then `f` must be a unit on some small
neighborhood around `x`.
-/
theorem isUnit_res_of_isUnit_germ (U : Opens X) (f : X.presheaf.obj (op U)) (x : U)
    (h : IsUnit (X.presheaf.germ x f)) :
    ∃ (V : Opens X) (i : V ⟶ U) (_ : x.1 ∈ V), IsUnit (X.presheaf.map i.op f) 
goal: ∃ V i, ∃ (_ : ↑x ∈ V), IsUnit ((X.presheaf.map i.op) f)

full_name: AlgebraicGeometry.RingedSpace.isUnit_of_isUnit_germ
code: /-- If a section `f` is a unit in each stalk, `f` must be a unit. -/
theorem isUnit_of_isUnit_germ (U : Opens X) (f : X.presheaf.obj (op U))
    (h : ∀ x : U, IsUnit (X.presheaf.germ x f)) : IsUnit f 
goal: IsUnit f

full_name: AlgebraicGeometry.RingedSpace.basicOpen
code: /-- The basic open of a section `f` is the set of all points `x`, such that the germ of `f` at
`x` is a unit.
-/
def basicOpen {U : Opens X} (f : X.presheaf.obj (op U)) : Opens X 
goal: TopologicalSpace.Opens ↑↑X.toPresheafedSpace

full_name: AlgebraicGeometry.RingedSpace.mem_basicOpen
code: @[simp]
theorem mem_basicOpen {U : Opens X} (f : X.presheaf.obj (op U)) (x : U) :
    ↑x ∈ X.basicOpen f ↔ IsUnit (X.presheaf.germ x f) 
goal: ↑x ∈ X.basicOpen f ↔ IsUnit ((X.presheaf.germ x) f)

full_name: AlgebraicGeometry.RingedSpace.mem_top_basicOpen
code: @[simp]
theorem mem_top_basicOpen (f : X.presheaf.obj (op ⊤)) (x : X) :
    x ∈ X.basicOpen f ↔ IsUnit (X.presheaf.germ ⟨x, show x ∈ (⊤ : Opens X) by trivial⟩ f) 
goal: x ∈ X.basicOpen f ↔ IsUnit ((X.presheaf.germ ⟨x, ⋯⟩) f)

full_name: AlgebraicGeometry.RingedSpace.basicOpen_le
code: theorem basicOpen_le {U : Opens X} (f : X.presheaf.obj (op U)) : X.basicOpen f ≤ U 
goal: X.basicOpen f ≤ U

full_name: AlgebraicGeometry.RingedSpace.isUnit_res_basicOpen
code: /-- The restriction of a section `f` to the basic open of `f` is a unit. -/
theorem isUnit_res_basicOpen {U : Opens X} (f : X.presheaf.obj (op U)) :
    IsUnit (X.presheaf.map (@homOfLE (Opens X) _ _ _ (X.basicOpen_le f)).op f) 
goal: IsUnit ((X.presheaf.map (CategoryTheory.homOfLE ⋯).op) f)

full_name: AlgebraicGeometry.RingedSpace.basicOpen_res
code: @[simp]
theorem basicOpen_res {U V : (Opens X)ᵒᵖ} (i : U ⟶ V) (f : X.presheaf.obj U) :
    @basicOpen X (unop V) (X.presheaf.map i f) = unop V ⊓ @basicOpen X (unop U) f 
goal: X.basicOpen ((X.presheaf.map i) f) = Opposite.unop V ⊓ X.basicOpen f

full_name: AlgebraicGeometry.RingedSpace.basicOpen_res_eq
code: @[simp (high)]
theorem basicOpen_res_eq {U V : (Opens X)ᵒᵖ} (i : U ⟶ V) [IsIso i] (f : X.presheaf.obj U) :
    @basicOpen X (unop V) (X.presheaf.map i f) = @RingedSpace.basicOpen X (unop U) f 
goal: X.basicOpen ((X.presheaf.map i) f) = X.basicOpen f

full_name: AlgebraicGeometry.RingedSpace.basicOpen_mul
code: @[simp]
theorem basicOpen_mul {U : Opens X} (f g : X.presheaf.obj (op U)) :
    X.basicOpen (f * g) = X.basicOpen f ⊓ X.basicOpen g 
goal: X.basicOpen (f * g) = X.basicOpen f ⊓ X.basicOpen g

full_name: AlgebraicGeometry.RingedSpace.basicOpen_pow
code: @[simp]
lemma basicOpen_pow {U : Opens X} (f : X.presheaf.obj (op U)) (n : ℕ) (h : 0 < n) :
    X.basicOpen (f ^ n) = X.basicOpen f 
goal: X.basicOpen (f ^ n) = X.basicOpen f

full_name: AlgebraicGeometry.RingedSpace.basicOpen_of_isUnit
code: theorem basicOpen_of_isUnit {U : Opens X} {f : X.presheaf.obj (op U)} (hf : IsUnit f) :
    X.basicOpen f = U 
goal: X.basicOpen f = U

full_name: AlgebraicGeometry.RingedSpace.zeroLocus
code: /--
The zero locus of a set of sections `s` over an open set `U` is the closed set consisting of
the complement of `U` and of all points of `U`, where all elements of `f` vanish.
-/
def zeroLocus {U : Opens X} (s : Set (X.presheaf.obj (op U))) : Set X 
goal: Set ↑↑X.toPresheafedSpace

full_name: AlgebraicGeometry.RingedSpace.zeroLocus_isClosed
code: lemma zeroLocus_isClosed {U : Opens X} (s : Set (X.presheaf.obj (op U))) :
    IsClosed (X.zeroLocus s) 
goal: IsClosed (X.zeroLocus s)

full_name: AlgebraicGeometry.RingedSpace.zeroLocus_singleton
code: lemma zeroLocus_singleton {U : Opens X} (f : X.presheaf.obj (op U)) :
    X.zeroLocus {f} = (X.basicOpen f).carrierᶜ 
goal: X.zeroLocus {f} = (X.basicOpen f).carrierᶜ

full_name: AlgebraicGeometry.RingedSpace.zeroLocus_empty_eq_univ
code: @[simp]
lemma zeroLocus_empty_eq_univ {U : Opens X} :
    X.zeroLocus (∅ : Set (X.presheaf.obj (op U))) = Set.univ 
goal: X.zeroLocus ∅ = Set.univ

full_name: AlgebraicGeometry.RingedSpace.mem_zeroLocus_iff
code: @[simp]
lemma mem_zeroLocus_iff {U : Opens X} (s : Set (X.presheaf.obj (op U))) (x : X) :
    x ∈ X.zeroLocus s ↔ ∀ f ∈ s, x ∉ X.basicOpen f 
goal: x ∈ X.zeroLocus s ↔ ∀ f ∈ s, x ∉ X.basicOpen f