File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean

full_name: ProjectiveSpectrum.asHomogeneousIdeal
code: /-- The projective spectrum of a graded commutative ring is the subtype of all homogenous ideals
that are prime and do not contain the irrelevant ideal. -/
@[ext]
structure ProjectiveSpectrum where
  asHomogeneousIdeal : HomogeneousIdeal 𝒜
  isPrime : asHomogeneousIdeal.toIdeal.IsPrime
  not_irrelevant_le : ¬HomogeneousIdeal.irrelevant 𝒜 ≤ asHomogeneousIdeal
goal: HomogeneousIdeal 𝒜

full_name: ProjectiveSpectrum.isPrime
code: /-- The projective spectrum of a graded commutative ring is the subtype of all homogenous ideals
that are prime and do not contain the irrelevant ideal. -/
@[ext]
structure ProjectiveSpectrum where
  asHomogeneousIdeal : HomogeneousIdeal 𝒜
  isPrime : asHomogeneousIdeal.toIdeal.IsPrime
  not_irrelevant_le : ¬HomogeneousIdeal.irrelevant 𝒜 ≤ asHomogeneousIdeal
goal: self.asHomogeneousIdeal.toIdeal.IsPrime

full_name: ProjectiveSpectrum
code: /-- The projective spectrum of a graded commutative ring is the subtype of all homogenous ideals
that are prime and do not contain the irrelevant ideal. -/
@[ext]
structure ProjectiveSpectrum where
  asHomogeneousIdeal : HomogeneousIdeal 𝒜
  isPrime : asHomogeneousIdeal.toIdeal.IsPrime
  not_irrelevant_le : ¬HomogeneousIdeal.irrelevant 𝒜 ≤ asHomogeneousIdeal
goal: Type u_2

full_name: ProjectiveSpectrum.not_irrelevant_le
code: /-- The projective spectrum of a graded commutative ring is the subtype of all homogenous ideals
that are prime and do not contain the irrelevant ideal. -/
@[ext]
structure ProjectiveSpectrum where
  asHomogeneousIdeal : HomogeneousIdeal 𝒜
  isPrime : asHomogeneousIdeal.toIdeal.IsPrime
  not_irrelevant_le : ¬HomogeneousIdeal.irrelevant 𝒜 ≤ asHomogeneousIdeal
goal: ¬HomogeneousIdeal.irrelevant 𝒜 ≤ self.asHomogeneousIdeal

full_name: ProjectiveSpectrum.zeroLocus
code: /-- The zero locus of a set `s` of elements of a commutative ring `A` is the set of all relevant
homogeneous prime ideals of the ring that contain the set `s`.

An element `f` of `A` can be thought of as a dependent function on the projective spectrum of `𝒜`.
At a point `x` (a homogeneous prime ideal) the function (i.e., element) `f` takes values in the
quotient ring `A` modulo the prime ideal `x`. In this manner, `zeroLocus s` is exactly the subset
of `ProjectiveSpectrum 𝒜` where all "functions" in `s` vanish simultaneously. -/
def zeroLocus (s : Set A) : Set (ProjectiveSpectrum 𝒜) 
goal: Set (ProjectiveSpectrum 𝒜)

full_name: ProjectiveSpectrum.mem_zeroLocus
code: @[simp]
theorem mem_zeroLocus (x : ProjectiveSpectrum 𝒜) (s : Set A) :
    x ∈ zeroLocus 𝒜 s ↔ s ⊆ x.asHomogeneousIdeal 
goal: x ∈ ProjectiveSpectrum.zeroLocus 𝒜 s ↔ s ⊆ ↑x.asHomogeneousIdeal

full_name: ProjectiveSpectrum.zeroLocus_span
code: @[simp]
theorem zeroLocus_span (s : Set A) : zeroLocus 𝒜 (Ideal.span s) = zeroLocus 𝒜 s 
goal: ProjectiveSpectrum.zeroLocus 𝒜 ↑(Ideal.span s) = ProjectiveSpectrum.zeroLocus 𝒜 s

full_name: ProjectiveSpectrum.vanishingIdeal
code: /-- The vanishing ideal of a set `t` of points of the projective spectrum of a commutative ring `R`
is the intersection of all the relevant homogeneous prime ideals in the set `t`.

An element `f` of `A` can be thought of as a dependent function on the projective spectrum of `𝒜`.
At a point `x` (a homogeneous prime ideal) the function (i.e., element) `f` takes values in the
quotient ring `A` modulo the prime ideal `x`. In this manner, `vanishingIdeal t` is exactly the
ideal of `A` consisting of all "functions" that vanish on all of `t`. -/
def vanishingIdeal (t : Set (ProjectiveSpectrum 𝒜)) : HomogeneousIdeal 𝒜 
goal: HomogeneousIdeal 𝒜

full_name: ProjectiveSpectrum.coe_vanishingIdeal
code: theorem coe_vanishingIdeal (t : Set (ProjectiveSpectrum 𝒜)) :
    (vanishingIdeal t : Set A) =
      { f | ∀ x : ProjectiveSpectrum 𝒜, x ∈ t → f ∈ x.asHomogeneousIdeal } 
goal: ↑(ProjectiveSpectrum.vanishingIdeal t) = {f | ∀ x ∈ t, f ∈ x.asHomogeneousIdeal}

full_name: ProjectiveSpectrum.mem_vanishingIdeal
code: theorem mem_vanishingIdeal (t : Set (ProjectiveSpectrum 𝒜)) (f : A) :
    f ∈ vanishingIdeal t ↔ ∀ x : ProjectiveSpectrum 𝒜, x ∈ t → f ∈ x.asHomogeneousIdeal 
goal: f ∈ ProjectiveSpectrum.vanishingIdeal t ↔ ∀ x ∈ t, f ∈ x.asHomogeneousIdeal

full_name: ProjectiveSpectrum.vanishingIdeal_singleton
code: @[simp]
theorem vanishingIdeal_singleton (x : ProjectiveSpectrum 𝒜) :
    vanishingIdeal ({x} : Set (ProjectiveSpectrum 𝒜)) = x.asHomogeneousIdeal 
goal: ProjectiveSpectrum.vanishingIdeal {x} = x.asHomogeneousIdeal

full_name: ProjectiveSpectrum.subset_zeroLocus_iff_le_vanishingIdeal
code: theorem subset_zeroLocus_iff_le_vanishingIdeal (t : Set (ProjectiveSpectrum 𝒜)) (I : Ideal A) :
    t ⊆ zeroLocus 𝒜 I ↔ I ≤ (vanishingIdeal t).toIdeal 
goal: t ⊆ ProjectiveSpectrum.zeroLocus 𝒜 ↑I ↔ I ≤ (ProjectiveSpectrum.vanishingIdeal t).toIdeal

full_name: ProjectiveSpectrum.gc_ideal
code: /-- `zeroLocus` and `vanishingIdeal` form a galois connection. -/
theorem gc_ideal :
    @GaloisConnection (Ideal A) (Set (ProjectiveSpectrum 𝒜))ᵒᵈ _ _
      (fun I => zeroLocus 𝒜 I) fun t => (vanishingIdeal t).toIdeal 
goal: GaloisConnection (fun I => ProjectiveSpectrum.zeroLocus 𝒜 ↑I) fun t => (ProjectiveSpectrum.vanishingIdeal t).toIdeal

full_name: ProjectiveSpectrum.gc_set
code: /-- `zeroLocus` and `vanishingIdeal` form a galois connection. -/
theorem gc_set :
    @GaloisConnection (Set A) (Set (ProjectiveSpectrum 𝒜))ᵒᵈ _ _
      (fun s => zeroLocus 𝒜 s) fun t => vanishingIdeal t 
goal: GaloisConnection (fun s => ProjectiveSpectrum.zeroLocus 𝒜 s) fun t => ↑(ProjectiveSpectrum.vanishingIdeal t)

full_name: ProjectiveSpectrum.gc_homogeneousIdeal
code: theorem gc_homogeneousIdeal :
    @GaloisConnection (HomogeneousIdeal 𝒜) (Set (ProjectiveSpectrum 𝒜))ᵒᵈ _ _
      (fun I => zeroLocus 𝒜 I) fun t => vanishingIdeal t 
goal: GaloisConnection (fun I => ProjectiveSpectrum.zeroLocus 𝒜 ↑I) fun t => ProjectiveSpectrum.vanishingIdeal t

full_name: ProjectiveSpectrum.subset_zeroLocus_iff_subset_vanishingIdeal
code: theorem subset_zeroLocus_iff_subset_vanishingIdeal (t : Set (ProjectiveSpectrum 𝒜)) (s : Set A) :
    t ⊆ zeroLocus 𝒜 s ↔ s ⊆ vanishingIdeal t 
goal: t ⊆ ProjectiveSpectrum.zeroLocus 𝒜 s ↔ s ⊆ ↑(ProjectiveSpectrum.vanishingIdeal t)

full_name: ProjectiveSpectrum.subset_vanishingIdeal_zeroLocus
code: theorem subset_vanishingIdeal_zeroLocus (s : Set A) : s ⊆ vanishingIdeal (zeroLocus 𝒜 s) 
goal: s ⊆ ↑(ProjectiveSpectrum.vanishingIdeal (ProjectiveSpectrum.zeroLocus 𝒜 s))

full_name: ProjectiveSpectrum.ideal_le_vanishingIdeal_zeroLocus
code: theorem ideal_le_vanishingIdeal_zeroLocus (I : Ideal A) :
    I ≤ (vanishingIdeal (zeroLocus 𝒜 I)).toIdeal 
goal: I ≤ (ProjectiveSpectrum.vanishingIdeal (ProjectiveSpectrum.zeroLocus 𝒜 ↑I)).toIdeal

full_name: ProjectiveSpectrum.homogeneousIdeal_le_vanishingIdeal_zeroLocus
code: theorem homogeneousIdeal_le_vanishingIdeal_zeroLocus (I : HomogeneousIdeal 𝒜) :
    I ≤ vanishingIdeal (zeroLocus 𝒜 I) 
goal: I ≤ ProjectiveSpectrum.vanishingIdeal (ProjectiveSpectrum.zeroLocus 𝒜 ↑I)

full_name: ProjectiveSpectrum.subset_zeroLocus_vanishingIdeal
code: theorem subset_zeroLocus_vanishingIdeal (t : Set (ProjectiveSpectrum 𝒜)) :
    t ⊆ zeroLocus 𝒜 (vanishingIdeal t) 
goal: t ⊆ ProjectiveSpectrum.zeroLocus 𝒜 ↑(ProjectiveSpectrum.vanishingIdeal t)

full_name: ProjectiveSpectrum.zeroLocus_anti_mono
code: theorem zeroLocus_anti_mono {s t : Set A} (h : s ⊆ t) : zeroLocus 𝒜 t ⊆ zeroLocus 𝒜 s 
goal: ProjectiveSpectrum.zeroLocus 𝒜 t ⊆ ProjectiveSpectrum.zeroLocus 𝒜 s

full_name: ProjectiveSpectrum.zeroLocus_anti_mono_ideal
code: theorem zeroLocus_anti_mono_ideal {s t : Ideal A} (h : s ≤ t) :
    zeroLocus 𝒜 (t : Set A) ⊆ zeroLocus 𝒜 (s : Set A) 
goal: ProjectiveSpectrum.zeroLocus 𝒜 ↑t ⊆ ProjectiveSpectrum.zeroLocus 𝒜 ↑s

full_name: ProjectiveSpectrum.zeroLocus_anti_mono_homogeneousIdeal
code: theorem zeroLocus_anti_mono_homogeneousIdeal {s t : HomogeneousIdeal 𝒜} (h : s ≤ t) :
    zeroLocus 𝒜 (t : Set A) ⊆ zeroLocus 𝒜 (s : Set A) 
goal: ProjectiveSpectrum.zeroLocus 𝒜 ↑t ⊆ ProjectiveSpectrum.zeroLocus 𝒜 ↑s

full_name: ProjectiveSpectrum.vanishingIdeal_anti_mono
code: theorem vanishingIdeal_anti_mono {s t : Set (ProjectiveSpectrum 𝒜)} (h : s ⊆ t) :
    vanishingIdeal t ≤ vanishingIdeal s 
goal: ProjectiveSpectrum.vanishingIdeal t ≤ ProjectiveSpectrum.vanishingIdeal s

full_name: ProjectiveSpectrum.zeroLocus_bot
code: theorem zeroLocus_bot : zeroLocus 𝒜 ((⊥ : Ideal A) : Set A) = Set.univ 
goal: ProjectiveSpectrum.zeroLocus 𝒜 ↑⊥ = Set.univ

full_name: ProjectiveSpectrum.zeroLocus_singleton_zero
code: @[simp]
theorem zeroLocus_singleton_zero : zeroLocus 𝒜 ({0} : Set A) = Set.univ 
goal: ProjectiveSpectrum.zeroLocus 𝒜 {0} = Set.univ

full_name: ProjectiveSpectrum.zeroLocus_empty
code: @[simp]
theorem zeroLocus_empty : zeroLocus 𝒜 (∅ : Set A) = Set.univ 
goal: ProjectiveSpectrum.zeroLocus 𝒜 ∅ = Set.univ

full_name: ProjectiveSpectrum.vanishingIdeal_univ
code: @[simp]
theorem vanishingIdeal_univ : vanishingIdeal (∅ : Set (ProjectiveSpectrum 𝒜)) = ⊤ 
goal: ProjectiveSpectrum.vanishingIdeal ∅ = ⊤

full_name: ProjectiveSpectrum.zeroLocus_empty_of_one_mem
code: theorem zeroLocus_empty_of_one_mem {s : Set A} (h : (1 : A) ∈ s) : zeroLocus 𝒜 s = ∅ 
goal: ProjectiveSpectrum.zeroLocus 𝒜 s = ∅

full_name: ProjectiveSpectrum.zeroLocus_singleton_one
code: @[simp]
theorem zeroLocus_singleton_one : zeroLocus 𝒜 ({1} : Set A) = ∅ 
goal: ProjectiveSpectrum.zeroLocus 𝒜 {1} = ∅

full_name: ProjectiveSpectrum.zeroLocus_univ
code: @[simp]
theorem zeroLocus_univ : zeroLocus 𝒜 (Set.univ : Set A) = ∅ 
goal: ProjectiveSpectrum.zeroLocus 𝒜 Set.univ = ∅

full_name: ProjectiveSpectrum.zeroLocus_sup_ideal
code: theorem zeroLocus_sup_ideal (I J : Ideal A) :
    zeroLocus 𝒜 ((I ⊔ J : Ideal A) : Set A) = zeroLocus _ I ∩ zeroLocus _ J 
goal: ProjectiveSpectrum.zeroLocus 𝒜 ↑(I ⊔ J) = ProjectiveSpectrum.zeroLocus 𝒜 ↑I ∩ ProjectiveSpectrum.zeroLocus 𝒜 ↑J

full_name: ProjectiveSpectrum.zeroLocus_sup_homogeneousIdeal
code: theorem zeroLocus_sup_homogeneousIdeal (I J : HomogeneousIdeal 𝒜) :
    zeroLocus 𝒜 ((I ⊔ J : HomogeneousIdeal 𝒜) : Set A) = zeroLocus _ I ∩ zeroLocus _ J 
goal: ProjectiveSpectrum.zeroLocus 𝒜 ↑(I ⊔ J) = ProjectiveSpectrum.zeroLocus 𝒜 ↑I ∩ ProjectiveSpectrum.zeroLocus 𝒜 ↑J

full_name: ProjectiveSpectrum.zeroLocus_union
code: theorem zeroLocus_union (s s' : Set A) : zeroLocus 𝒜 (s ∪ s') = zeroLocus _ s ∩ zeroLocus _ s' 
goal: ProjectiveSpectrum.zeroLocus 𝒜 (s ∪ s') = ProjectiveSpectrum.zeroLocus 𝒜 s ∩ ProjectiveSpectrum.zeroLocus 𝒜 s'

full_name: ProjectiveSpectrum.vanishingIdeal_union
code: theorem vanishingIdeal_union (t t' : Set (ProjectiveSpectrum 𝒜)) :
    vanishingIdeal (t ∪ t') = vanishingIdeal t ⊓ vanishingIdeal t' 
goal: ProjectiveSpectrum.vanishingIdeal (t ∪ t') = ProjectiveSpectrum.vanishingIdeal t ⊓ ProjectiveSpectrum.vanishingIdeal t'

full_name: ProjectiveSpectrum.zeroLocus_iSup_ideal
code: theorem zeroLocus_iSup_ideal {γ : Sort*} (I : γ → Ideal A) :
    zeroLocus _ ((⨆ i, I i : Ideal A) : Set A) = ⋂ i, zeroLocus 𝒜 (I i) 
goal: ProjectiveSpectrum.zeroLocus 𝒜 ↑(⨆ i, I i) = ⋂ i, ProjectiveSpectrum.zeroLocus 𝒜 ↑(I i)

full_name: ProjectiveSpectrum.zeroLocus_iSup_homogeneousIdeal
code: theorem zeroLocus_iSup_homogeneousIdeal {γ : Sort*} (I : γ → HomogeneousIdeal 𝒜) :
    zeroLocus _ ((⨆ i, I i : HomogeneousIdeal 𝒜) : Set A) = ⋂ i, zeroLocus 𝒜 (I i) 
goal: ProjectiveSpectrum.zeroLocus 𝒜 ↑(⨆ i, I i) = ⋂ i, ProjectiveSpectrum.zeroLocus 𝒜 ↑(I i)

full_name: ProjectiveSpectrum.zeroLocus_iUnion
code: theorem zeroLocus_iUnion {γ : Sort*} (s : γ → Set A) :
    zeroLocus 𝒜 (⋃ i, s i) = ⋂ i, zeroLocus 𝒜 (s i) 
goal: ProjectiveSpectrum.zeroLocus 𝒜 (⋃ i, s i) = ⋂ i, ProjectiveSpectrum.zeroLocus 𝒜 (s i)

full_name: ProjectiveSpectrum.zeroLocus_bUnion
code: theorem zeroLocus_bUnion (s : Set (Set A)) :
    zeroLocus 𝒜 (⋃ s' ∈ s, s' : Set A) = ⋂ s' ∈ s, zeroLocus 𝒜 s' 
goal: ProjectiveSpectrum.zeroLocus 𝒜 (⋃ s' ∈ s, s') = ⋂ s' ∈ s, ProjectiveSpectrum.zeroLocus 𝒜 s'

full_name: ProjectiveSpectrum.vanishingIdeal_iUnion
code: theorem vanishingIdeal_iUnion {γ : Sort*} (t : γ → Set (ProjectiveSpectrum 𝒜)) :
    vanishingIdeal (⋃ i, t i) = ⨅ i, vanishingIdeal (t i) 
goal: ProjectiveSpectrum.vanishingIdeal (⋃ i, t i) = ⨅ i, ProjectiveSpectrum.vanishingIdeal (t i)

full_name: ProjectiveSpectrum.zeroLocus_inf
code: theorem zeroLocus_inf (I J : Ideal A) :
    zeroLocus 𝒜 ((I ⊓ J : Ideal A) : Set A) = zeroLocus 𝒜 I ∪ zeroLocus 𝒜 J 
goal: ProjectiveSpectrum.zeroLocus 𝒜 ↑(I ⊓ J) = ProjectiveSpectrum.zeroLocus 𝒜 ↑I ∪ ProjectiveSpectrum.zeroLocus 𝒜 ↑J

full_name: ProjectiveSpectrum.union_zeroLocus
code: theorem union_zeroLocus (s s' : Set A) :
    zeroLocus 𝒜 s ∪ zeroLocus 𝒜 s' = zeroLocus 𝒜 (Ideal.span s ⊓ Ideal.span s' : Ideal A) 
goal: ProjectiveSpectrum.zeroLocus 𝒜 s ∪ ProjectiveSpectrum.zeroLocus 𝒜 s' =
  ProjectiveSpectrum.zeroLocus 𝒜 ↑(Ideal.span s ⊓ Ideal.span s')

full_name: ProjectiveSpectrum.zeroLocus_mul_ideal
code: theorem zeroLocus_mul_ideal (I J : Ideal A) :
    zeroLocus 𝒜 ((I * J : Ideal A) : Set A) = zeroLocus 𝒜 I ∪ zeroLocus 𝒜 J 
goal: ProjectiveSpectrum.zeroLocus 𝒜 ↑(I * J) = ProjectiveSpectrum.zeroLocus 𝒜 ↑I ∪ ProjectiveSpectrum.zeroLocus 𝒜 ↑J

full_name: ProjectiveSpectrum.zeroLocus_mul_homogeneousIdeal
code: theorem zeroLocus_mul_homogeneousIdeal (I J : HomogeneousIdeal 𝒜) :
    zeroLocus 𝒜 ((I * J : HomogeneousIdeal 𝒜) : Set A) = zeroLocus 𝒜 I ∪ zeroLocus 𝒜 J 
goal: ProjectiveSpectrum.zeroLocus 𝒜 ↑(I * J) = ProjectiveSpectrum.zeroLocus 𝒜 ↑I ∪ ProjectiveSpectrum.zeroLocus 𝒜 ↑J

full_name: ProjectiveSpectrum.zeroLocus_singleton_mul
code: theorem zeroLocus_singleton_mul (f g : A) :
    zeroLocus 𝒜 ({f * g} : Set A) = zeroLocus 𝒜 {f} ∪ zeroLocus 𝒜 {g} 
goal: ProjectiveSpectrum.zeroLocus 𝒜 {f * g} = ProjectiveSpectrum.zeroLocus 𝒜 {f} ∪ ProjectiveSpectrum.zeroLocus 𝒜 {g}

full_name: ProjectiveSpectrum.zeroLocus_singleton_pow
code: @[simp]
theorem zeroLocus_singleton_pow (f : A) (n : ℕ) (hn : 0 < n) :
    zeroLocus 𝒜 ({f ^ n} : Set A) = zeroLocus 𝒜 {f} 
goal: ProjectiveSpectrum.zeroLocus 𝒜 {f ^ n} = ProjectiveSpectrum.zeroLocus 𝒜 {f}

full_name: ProjectiveSpectrum.sup_vanishingIdeal_le
code: theorem sup_vanishingIdeal_le (t t' : Set (ProjectiveSpectrum 𝒜)) :
    vanishingIdeal t ⊔ vanishingIdeal t' ≤ vanishingIdeal (t ∩ t') 
goal: ProjectiveSpectrum.vanishingIdeal t ⊔ ProjectiveSpectrum.vanishingIdeal t' ≤ ProjectiveSpectrum.vanishingIdeal (t ∩ t')

full_name: ProjectiveSpectrum.mem_compl_zeroLocus_iff_not_mem
code: theorem mem_compl_zeroLocus_iff_not_mem {f : A} {I : ProjectiveSpectrum 𝒜} :
    I ∈ (zeroLocus 𝒜 {f} : Set (ProjectiveSpectrum 𝒜))ᶜ ↔ f ∉ I.asHomogeneousIdeal 
goal: I ∈ (ProjectiveSpectrum.zeroLocus 𝒜 {f})ᶜ ↔ f ∉ I.asHomogeneousIdeal

full_name: ProjectiveSpectrum.zariskiTopology
code: /-- The Zariski topology on the prime spectrum of a commutative ring is defined via the closed sets
of the topology: they are exactly those sets that are the zero locus of a subset of the ring. -/
instance zariskiTopology : TopologicalSpace (ProjectiveSpectrum 𝒜) 
goal: TopologicalSpace (ProjectiveSpectrum 𝒜)

full_name: ProjectiveSpectrum.top
code: /-- The underlying topology of `Proj` is the projective spectrum of graded ring `A`. -/
def top : TopCat 
goal: TopCat

full_name: ProjectiveSpectrum.isOpen_iff
code: theorem isOpen_iff (U : Set (ProjectiveSpectrum 𝒜)) : IsOpen U ↔ ∃ s, Uᶜ = zeroLocus 𝒜 s 
goal: IsOpen U ↔ ∃ s, Uᶜ = ProjectiveSpectrum.zeroLocus 𝒜 s

full_name: ProjectiveSpectrum.isClosed_iff_zeroLocus
code: theorem isClosed_iff_zeroLocus (Z : Set (ProjectiveSpectrum 𝒜)) :
    IsClosed Z ↔ ∃ s, Z = zeroLocus 𝒜 s 
goal: IsClosed Z ↔ ∃ s, Z = ProjectiveSpectrum.zeroLocus 𝒜 s

full_name: ProjectiveSpectrum.isClosed_zeroLocus
code: theorem isClosed_zeroLocus (s : Set A) : IsClosed (zeroLocus 𝒜 s) 
goal: IsClosed (ProjectiveSpectrum.zeroLocus 𝒜 s)

full_name: ProjectiveSpectrum.zeroLocus_vanishingIdeal_eq_closure
code: theorem zeroLocus_vanishingIdeal_eq_closure (t : Set (ProjectiveSpectrum 𝒜)) :
    zeroLocus 𝒜 (vanishingIdeal t : Set A) = closure t 
goal: ProjectiveSpectrum.zeroLocus 𝒜 ↑(ProjectiveSpectrum.vanishingIdeal t) = closure t

full_name: ProjectiveSpectrum.vanishingIdeal_closure
code: theorem vanishingIdeal_closure (t : Set (ProjectiveSpectrum 𝒜)) :
    vanishingIdeal (closure t) = vanishingIdeal t 
goal: ProjectiveSpectrum.vanishingIdeal (closure t) = ProjectiveSpectrum.vanishingIdeal t

full_name: ProjectiveSpectrum.basicOpen
code: /-- `basicOpen r` is the open subset containing all prime ideals not containing `r`. -/
def basicOpen (r : A) : TopologicalSpace.Opens (ProjectiveSpectrum 𝒜) 
goal: TopologicalSpace.Opens (ProjectiveSpectrum 𝒜)

full_name: ProjectiveSpectrum.mem_basicOpen
code: @[simp]
theorem mem_basicOpen (f : A) (x : ProjectiveSpectrum 𝒜) :
    x ∈ basicOpen 𝒜 f ↔ f ∉ x.asHomogeneousIdeal 
goal: x ∈ ProjectiveSpectrum.basicOpen 𝒜 f ↔ f ∉ x.asHomogeneousIdeal

full_name: ProjectiveSpectrum.mem_coe_basicOpen
code: theorem mem_coe_basicOpen (f : A) (x : ProjectiveSpectrum 𝒜) :
    x ∈ (↑(basicOpen 𝒜 f) : Set (ProjectiveSpectrum 𝒜)) ↔ f ∉ x.asHomogeneousIdeal 
goal: x ∈ ↑(ProjectiveSpectrum.basicOpen 𝒜 f) ↔ f ∉ x.asHomogeneousIdeal

full_name: ProjectiveSpectrum.isOpen_basicOpen
code: theorem isOpen_basicOpen {a : A} : IsOpen (basicOpen 𝒜 a : Set (ProjectiveSpectrum 𝒜)) 
goal: IsOpen ↑(ProjectiveSpectrum.basicOpen 𝒜 a)

full_name: ProjectiveSpectrum.basicOpen_eq_zeroLocus_compl
code: @[simp]
theorem basicOpen_eq_zeroLocus_compl (r : A) :
    (basicOpen 𝒜 r : Set (ProjectiveSpectrum 𝒜)) = (zeroLocus 𝒜 {r})ᶜ 
goal: ↑(ProjectiveSpectrum.basicOpen 𝒜 r) = (ProjectiveSpectrum.zeroLocus 𝒜 {r})ᶜ

full_name: ProjectiveSpectrum.basicOpen_one
code: @[simp]
theorem basicOpen_one : basicOpen 𝒜 (1 : A) = ⊤ 
goal: ProjectiveSpectrum.basicOpen 𝒜 1 = ⊤

full_name: ProjectiveSpectrum.basicOpen_zero
code: @[simp]
theorem basicOpen_zero : basicOpen 𝒜 (0 : A) = ⊥ 
goal: ProjectiveSpectrum.basicOpen 𝒜 0 = ⊥

full_name: ProjectiveSpectrum.basicOpen_mul
code: theorem basicOpen_mul (f g : A) : basicOpen 𝒜 (f * g) = basicOpen 𝒜 f ⊓ basicOpen 𝒜 g 
goal: ProjectiveSpectrum.basicOpen 𝒜 (f * g) = ProjectiveSpectrum.basicOpen 𝒜 f ⊓ ProjectiveSpectrum.basicOpen 𝒜 g

full_name: ProjectiveSpectrum.basicOpen_mul_le_left
code: theorem basicOpen_mul_le_left (f g : A) : basicOpen 𝒜 (f * g) ≤ basicOpen 𝒜 f 
goal: ProjectiveSpectrum.basicOpen 𝒜 (f * g) ≤ ProjectiveSpectrum.basicOpen 𝒜 f

full_name: ProjectiveSpectrum.basicOpen_mul_le_right
code: theorem basicOpen_mul_le_right (f g : A) : basicOpen 𝒜 (f * g) ≤ basicOpen 𝒜 g 
goal: ProjectiveSpectrum.basicOpen 𝒜 (f * g) ≤ ProjectiveSpectrum.basicOpen 𝒜 g

full_name: ProjectiveSpectrum.basicOpen_pow
code: @[simp]
theorem basicOpen_pow (f : A) (n : ℕ) (hn : 0 < n) : basicOpen 𝒜 (f ^ n) = basicOpen 𝒜 f 
goal: ProjectiveSpectrum.basicOpen 𝒜 (f ^ n) = ProjectiveSpectrum.basicOpen 𝒜 f

full_name: ProjectiveSpectrum.basicOpen_eq_union_of_projection
code: theorem basicOpen_eq_union_of_projection (f : A) :
    basicOpen 𝒜 f = ⨆ i : ℕ, basicOpen 𝒜 (GradedAlgebra.proj 𝒜 i f) 
goal: ProjectiveSpectrum.basicOpen 𝒜 f = ⨆ i, ProjectiveSpectrum.basicOpen 𝒜 ((GradedAlgebra.proj 𝒜 i) f)

full_name: ProjectiveSpectrum.isTopologicalBasis_basic_opens
code: theorem isTopologicalBasis_basic_opens :
    TopologicalSpace.IsTopologicalBasis
      (Set.range fun r : A => (basicOpen 𝒜 r : Set (ProjectiveSpectrum 𝒜))) 
goal: TopologicalSpace.IsTopologicalBasis (Set.range fun r => ↑(ProjectiveSpectrum.basicOpen 𝒜 r))

full_name: ProjectiveSpectrum.instPartialOrder
code: instance : PartialOrder (ProjectiveSpectrum 𝒜) 
goal: PartialOrder (ProjectiveSpectrum 𝒜)

full_name: ProjectiveSpectrum.as_ideal_le_as_ideal
code: @[simp]
theorem as_ideal_le_as_ideal (x y : ProjectiveSpectrum 𝒜) :
    x.asHomogeneousIdeal ≤ y.asHomogeneousIdeal ↔ x ≤ y 
goal: x.asHomogeneousIdeal ≤ y.asHomogeneousIdeal ↔ x ≤ y

full_name: ProjectiveSpectrum.as_ideal_lt_as_ideal
code: @[simp]
theorem as_ideal_lt_as_ideal (x y : ProjectiveSpectrum 𝒜) :
    x.asHomogeneousIdeal < y.asHomogeneousIdeal ↔ x < y 
goal: x.asHomogeneousIdeal < y.asHomogeneousIdeal ↔ x < y

full_name: ProjectiveSpectrum.le_iff_mem_closure
code: theorem le_iff_mem_closure (x y : ProjectiveSpectrum 𝒜) :
    x ≤ y ↔ y ∈ closure ({x} : Set (ProjectiveSpectrum 𝒜)) 
goal: x ≤ y ↔ y ∈ closure {x}