topology.sober | Mathlib porting status

Changes since the initial port

The following section lists changes to this file in mathlib3 and mathlib4 that occured after the initial port. Most recent changes are shown first. Hovering over a commit will show all commits associated with the same mathlib3 commit.

Changes in mathlib3

0a0ec350

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

3e32bc90

bump to nightly-2024-04-10-08

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

cd0c1af5

Diff

@@ -46,11 +46,11 @@ theorem isGenericPoint_def {x : α} {S : Set α} : IsGenericPoint x S ↔ closur
 #align is_generic_point_def isGenericPoint_def
 -/
 
-#print IsGenericPoint.def' /-
-theorem IsGenericPoint.def' {x : α} {S : Set α} (h : IsGenericPoint x S) :
+#print IsGenericPoint.def /-
+theorem IsGenericPoint.def {x : α} {S : Set α} (h : IsGenericPoint x S) :
     closure ({x} : Set α) = S :=
   h
-#align is_generic_point.def IsGenericPoint.def'
+#align is_generic_point.def IsGenericPoint.def
 -/
 
 #print isGenericPoint_closure /-

3e32bc90

bump to nightly-2024-04-06-08

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

e34029c9

Diff

@@ -46,11 +46,11 @@ theorem isGenericPoint_def {x : α} {S : Set α} : IsGenericPoint x S ↔ closur
 #align is_generic_point_def isGenericPoint_def
 -/
 
-#print IsGenericPoint.def /-
-theorem IsGenericPoint.def {x : α} {S : Set α} (h : IsGenericPoint x S) :
+#print IsGenericPoint.def' /-
+theorem IsGenericPoint.def' {x : α} {S : Set α} (h : IsGenericPoint x S) :
     closure ({x} : Set α) = S :=
   h
-#align is_generic_point.def IsGenericPoint.def
+#align is_generic_point.def IsGenericPoint.def'
 -/
 
 #print isGenericPoint_closure /-

3e32bc90

bump to nightly-2024-03-17-08

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

22f01ce4

Diff

@@ -242,7 +242,7 @@ theorem ClosedEmbedding.quasiSober {f : α → β} (hf : ClosedEmbedding f) [Qua
   obtain ⟨x, hx⟩ := QuasiSober.sober hS'' (hf.is_closed_map _ hS')
   obtain ⟨y, hy, rfl⟩ := hx.mem
   use y
-  change _ = _ at hx 
+  change _ = _ at hx
   apply set.image_injective.mpr hf.inj
   rw [← hx, ← hf.closure_image_eq, Set.image_singleton]
 #align closed_embedding.quasi_sober ClosedEmbedding.quasiSober
@@ -256,7 +256,7 @@ theorem OpenEmbedding.quasiSober {f : α → β} (hf : OpenEmbedding f) [QuasiSo
   have hS'' := hS.image f hf.continuous.continuous_on
   obtain ⟨x, hx⟩ := QuasiSober.sober hS''.closure isClosed_closure
   obtain ⟨T, hT, rfl⟩ := hf.to_inducing.is_closed_iff.mp hS'
-  rw [Set.image_preimage_eq_inter_range] at hx hS'' 
+  rw [Set.image_preimage_eq_inter_range] at hx hS''
   have hxT : x ∈ T := by rw [← hT.closure_eq]; exact closure_mono (Set.inter_subset_left _ _) hx.mem
   have hxU : x ∈ Set.range f :=
     by
@@ -291,7 +291,7 @@ theorem quasiSober_of_open_cover (S : Set (Set α)) (hS : ∀ s : S, IsOpen (s :
   replace H : IsIrreducible (coe ⁻¹' t : Set U) := ⟨⟨⟨x, hU'⟩, by simpa using hx⟩, H⟩
   use H.generic_point
   have := continuous_subtype_coe.closure_preimage_subset _ H.generic_point_spec.mem
-  rw [h'.closure_eq] at this 
+  rw [h'.closure_eq] at this
   apply le_antisymm
   · apply h'.closure_subset_iff.mpr; simpa using this
   rw [← Set.image_singleton, ← closure_closure]

3e32bc90

bump to nightly-2023-09-24-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce64cd319bb6b3e82f31c2d38e79080d377be451

5655435f

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2021 Andrew Yang. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Andrew Yang
 -/
-import Mathbin.Topology.Separation
+import Topology.Separation
 
 #align_import topology.sober from "leanprover-community/mathlib"@"3e32bc908f617039c74c06ea9a897e30c30803c2"

3e32bc90

bump to nightly-2023-07-20-09

mathlib commit https://github.com/leanprover-community/mathlib/commit/8ea5598db6caeddde6cb734aa179cc2408dbd345

9c56d0dd

Diff

@@ -2,14 +2,11 @@
 Copyright (c) 2021 Andrew Yang. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Andrew Yang
-
-! This file was ported from Lean 3 source module topology.sober
-! leanprover-community/mathlib commit 3e32bc908f617039c74c06ea9a897e30c30803c2
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Topology.Separation
 
+#align_import topology.sober from "leanprover-community/mathlib"@"3e32bc908f617039c74c06ea9a897e30c30803c2"
+
 /-!
 # Sober spaces

3e32bc90

bump to nightly-2023-06-13-21

mathlib commit https://github.com/leanprover-community/mathlib/commit/9fb8964792b4237dac6200193a0d533f1b3f7423

829520ac

Diff

@@ -109,13 +109,17 @@ protected theorem eq [T0Space α] (h : IsGenericPoint x S) (h' : IsGenericPoint
 #align is_generic_point.eq IsGenericPoint.eq
 -/
 
+#print IsGenericPoint.mem_open_set_iff /-
 theorem mem_open_set_iff (h : IsGenericPoint x S) (hU : IsOpen U) : x ∈ U ↔ (S ∩ U).Nonempty :=
   ⟨fun h' => ⟨x, h.Mem, h'⟩, fun ⟨y, hyS, hyU⟩ => (h.Specializes hyS).mem_open hU hyU⟩
 #align is_generic_point.mem_open_set_iff IsGenericPoint.mem_open_set_iff
+-/
 
+#print IsGenericPoint.disjoint_iff /-
 theorem disjoint_iff (h : IsGenericPoint x S) (hU : IsOpen U) : Disjoint S U ↔ x ∉ U := by
   rw [h.mem_open_set_iff hU, ← not_disjoint_iff_nonempty_inter, Classical.not_not]
 #align is_generic_point.disjoint_iff IsGenericPoint.disjoint_iff
+-/
 
 #print IsGenericPoint.mem_closed_set_iff /-
 theorem mem_closed_set_iff (h : IsGenericPoint x S) (hZ : IsClosed Z) : x ∈ Z ↔ S ⊆ Z := by
@@ -123,6 +127,7 @@ theorem mem_closed_set_iff (h : IsGenericPoint x S) (hZ : IsClosed Z) : x ∈ Z
 #align is_generic_point.mem_closed_set_iff IsGenericPoint.mem_closed_set_iff
 -/
 
+#print IsGenericPoint.image /-
 protected theorem image (h : IsGenericPoint x S) {f : α → β} (hf : Continuous f) :
     IsGenericPoint (f x) (closure (f '' S)) :=
   by
@@ -131,6 +136,7 @@ protected theorem image (h : IsGenericPoint x S) {f : α → β} (hf : Continuou
     subset.antisymm (closure_mono (image_subset _ subset_closure))
       (closure_minimal (image_closure_subset_closure_image hf) isClosed_closure)
 #align is_generic_point.image IsGenericPoint.image
+-/
 
 end IsGenericPoint
 
@@ -188,15 +194,19 @@ noncomputable def genericPoint [QuasiSober α] [IrreducibleSpace α] : α :=
 #align generic_point genericPoint
 -/
 
+#print genericPoint_spec /-
 theorem genericPoint_spec [QuasiSober α] [IrreducibleSpace α] : IsGenericPoint (genericPoint α) ⊤ :=
   by simpa using (IrreducibleSpace.isIrreducible_univ α).genericPoint_spec
 #align generic_point_spec genericPoint_spec
+-/
 
+#print genericPoint_closure /-
 @[simp]
 theorem genericPoint_closure [QuasiSober α] [IrreducibleSpace α] :
     closure ({genericPoint α} : Set α) = ⊤ :=
   genericPoint_spec α
 #align generic_point_closure genericPoint_closure
+-/
 
 variable {α}
 
@@ -226,6 +236,7 @@ noncomputable def irreducibleSetEquivPoints [QuasiSober α] [T0Space α] :
 #align irreducible_set_equiv_points irreducibleSetEquivPoints
 -/
 
+#print ClosedEmbedding.quasiSober /-
 theorem ClosedEmbedding.quasiSober {f : α → β} (hf : ClosedEmbedding f) [QuasiSober β] :
     QuasiSober α := by
   constructor
@@ -238,7 +249,9 @@ theorem ClosedEmbedding.quasiSober {f : α → β} (hf : ClosedEmbedding f) [Qua
   apply set.image_injective.mpr hf.inj
   rw [← hx, ← hf.closure_image_eq, Set.image_singleton]
 #align closed_embedding.quasi_sober ClosedEmbedding.quasiSober
+-/
 
+#print OpenEmbedding.quasiSober /-
 theorem OpenEmbedding.quasiSober {f : α → β} (hf : OpenEmbedding f) [QuasiSober β] : QuasiSober α :=
   by
   constructor
@@ -264,7 +277,9 @@ theorem OpenEmbedding.quasiSober {f : α → β} (hf : OpenEmbedding f) [QuasiSo
     ⟨fun h => hT.closure_eq ▸ closure_mono (Set.inter_subset_left _ _) h, fun h =>
       subset_closure ⟨h, hy⟩⟩
 #align open_embedding.quasi_sober OpenEmbedding.quasiSober
+-/
 
+#print quasiSober_of_open_cover /-
 /-- A space is quasi sober if it can be covered by open quasi sober subsets. -/
 theorem quasiSober_of_open_cover (S : Set (Set α)) (hS : ∀ s : S, IsOpen (s : Set α))
     [hS' : ∀ s : S, QuasiSober s] (hS'' : ⋃₀ S = ⊤) : QuasiSober α :=
@@ -292,6 +307,7 @@ theorem quasiSober_of_open_cover (S : Set (Set α)) (hS : ∀ s : S, IsOpen (s :
   rw [← Subtype.image_preimage_coe]
   exact Set.image_subset _ subset_closure
 #align quasi_sober_of_open_cover quasiSober_of_open_cover
+-/
 
 #print T2Space.quasiSober /-
 instance (priority := 100) T2Space.quasiSober [T2Space α] : QuasiSober α :=

3e32bc90

bump to nightly-2023-06-04-18

mathlib commit https://github.com/leanprover-community/mathlib/commit/5f25c089cb34db4db112556f23c50d12da81b297

3fb4268b

Diff

@@ -211,7 +211,7 @@ attribute [local instance 10] specializationOrder
 #print irreducibleSetEquivPoints /-
 /-- The closed irreducible subsets of a sober space bijects with the points of the space. -/
 noncomputable def irreducibleSetEquivPoints [QuasiSober α] [T0Space α] :
-    { s : Set α | IsIrreducible s ∧ IsClosed s } ≃o α
+    {s : Set α | IsIrreducible s ∧ IsClosed s} ≃o α
     where
   toFun s := s.Prop.1.genericPoint
   invFun x := ⟨closure ({x} : Set α), isIrreducible_singleton.closure, isClosed_closure⟩

3e32bc90

bump to nightly-2023-06-01-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/cca40788df1b8755d5baf17ab2f27dacc2e17acb

b9c87c70

Diff

@@ -234,7 +234,7 @@ theorem ClosedEmbedding.quasiSober {f : α → β} (hf : ClosedEmbedding f) [Qua
   obtain ⟨x, hx⟩ := QuasiSober.sober hS'' (hf.is_closed_map _ hS')
   obtain ⟨y, hy, rfl⟩ := hx.mem
   use y
-  change _ = _ at hx
+  change _ = _ at hx 
   apply set.image_injective.mpr hf.inj
   rw [← hx, ← hf.closure_image_eq, Set.image_singleton]
 #align closed_embedding.quasi_sober ClosedEmbedding.quasiSober
@@ -246,7 +246,7 @@ theorem OpenEmbedding.quasiSober {f : α → β} (hf : OpenEmbedding f) [QuasiSo
   have hS'' := hS.image f hf.continuous.continuous_on
   obtain ⟨x, hx⟩ := QuasiSober.sober hS''.closure isClosed_closure
   obtain ⟨T, hT, rfl⟩ := hf.to_inducing.is_closed_iff.mp hS'
-  rw [Set.image_preimage_eq_inter_range] at hx hS''
+  rw [Set.image_preimage_eq_inter_range] at hx hS'' 
   have hxT : x ∈ T := by rw [← hT.closure_eq]; exact closure_mono (Set.inter_subset_left _ _) hx.mem
   have hxU : x ∈ Set.range f :=
     by
@@ -279,7 +279,7 @@ theorem quasiSober_of_open_cover (S : Set (Set α)) (hS : ∀ s : S, IsOpen (s :
   replace H : IsIrreducible (coe ⁻¹' t : Set U) := ⟨⟨⟨x, hU'⟩, by simpa using hx⟩, H⟩
   use H.generic_point
   have := continuous_subtype_coe.closure_preimage_subset _ H.generic_point_spec.mem
-  rw [h'.closure_eq] at this
+  rw [h'.closure_eq] at this 
   apply le_antisymm
   · apply h'.closure_subset_iff.mpr; simpa using this
   rw [← Set.image_singleton, ← closure_closure]

3e32bc90

bump to nightly-2023-05-28-18

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

8d353152

Diff

@@ -208,6 +208,7 @@ theorem genericPoint_specializes [QuasiSober α] [IrreducibleSpace α] (x : α)
 
 attribute [local instance 10] specializationOrder
 
+#print irreducibleSetEquivPoints /-
 /-- The closed irreducible subsets of a sober space bijects with the points of the space. -/
 noncomputable def irreducibleSetEquivPoints [QuasiSober α] [T0Space α] :
     { s : Set α | IsIrreducible s ∧ IsClosed s } ≃o α
@@ -223,6 +224,7 @@ noncomputable def irreducibleSetEquivPoints [QuasiSober α] [T0Space α] :
     change _ ⤳ _ ↔ _; rw [specializes_iff_closure_subset]
     simp [s.prop.2.closure_eq, t.prop.2.closure_eq, ← Subtype.coe_le_coe]
 #align irreducible_set_equiv_points irreducibleSetEquivPoints
+-/
 
 theorem ClosedEmbedding.quasiSober {f : α → β} (hf : ClosedEmbedding f) [QuasiSober β] :
     QuasiSober α := by

3e32bc90

bump to nightly-2023-05-28-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

ba5d8b97

Diff

@@ -109,22 +109,10 @@ protected theorem eq [T0Space α] (h : IsGenericPoint x S) (h' : IsGenericPoint
 #align is_generic_point.eq IsGenericPoint.eq
 -/
 
-/- warning: is_generic_point.mem_open_set_iff -> IsGenericPoint.mem_open_set_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {x : α} {S : Set.{u1} α} {U : Set.{u1} α}, (IsGenericPoint.{u1} α _inst_1 x S) -> (IsOpen.{u1} α _inst_1 U) -> (Iff (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x U) (Set.Nonempty.{u1} α (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) S U)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {x : α} {S : Set.{u1} α} {U : Set.{u1} α}, (IsGenericPoint.{u1} α _inst_1 x S) -> (IsOpen.{u1} α _inst_1 U) -> (Iff (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x U) (Set.Nonempty.{u1} α (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) S U)))
-Case conversion may be inaccurate. Consider using '#align is_generic_point.mem_open_set_iff IsGenericPoint.mem_open_set_iffₓ'. -/
 theorem mem_open_set_iff (h : IsGenericPoint x S) (hU : IsOpen U) : x ∈ U ↔ (S ∩ U).Nonempty :=
   ⟨fun h' => ⟨x, h.Mem, h'⟩, fun ⟨y, hyS, hyU⟩ => (h.Specializes hyS).mem_open hU hyU⟩
 #align is_generic_point.mem_open_set_iff IsGenericPoint.mem_open_set_iff
 
-/- warning: is_generic_point.disjoint_iff -> IsGenericPoint.disjoint_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {x : α} {S : Set.{u1} α} {U : Set.{u1} α}, (IsGenericPoint.{u1} α _inst_1 x S) -> (IsOpen.{u1} α _inst_1 U) -> (Iff (Disjoint.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) S U) (Not (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x U)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {x : α} {S : Set.{u1} α} {U : Set.{u1} α}, (IsGenericPoint.{u1} α _inst_1 x S) -> (IsOpen.{u1} α _inst_1 U) -> (Iff (Disjoint.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α)))))) (BoundedOrder.toOrderBot.{u1} (Set.{u1} α) (Preorder.toLE.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α)))))))) (CompleteLattice.toBoundedOrder.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α)))))) S U) (Not (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x U)))
-Case conversion may be inaccurate. Consider using '#align is_generic_point.disjoint_iff IsGenericPoint.disjoint_iffₓ'. -/
 theorem disjoint_iff (h : IsGenericPoint x S) (hU : IsOpen U) : Disjoint S U ↔ x ∉ U := by
   rw [h.mem_open_set_iff hU, ← not_disjoint_iff_nonempty_inter, Classical.not_not]
 #align is_generic_point.disjoint_iff IsGenericPoint.disjoint_iff
@@ -135,12 +123,6 @@ theorem mem_closed_set_iff (h : IsGenericPoint x S) (hZ : IsClosed Z) : x ∈ Z
 #align is_generic_point.mem_closed_set_iff IsGenericPoint.mem_closed_set_iff
 -/
 
-/- warning: is_generic_point.image -> IsGenericPoint.image is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_2 : TopologicalSpace.{u2} β] {x : α} {S : Set.{u1} α}, (IsGenericPoint.{u1} α _inst_1 x S) -> (forall {f : α -> β}, (Continuous.{u1, u2} α β _inst_1 _inst_2 f) -> (IsGenericPoint.{u2} β _inst_2 (f x) (closure.{u2} β _inst_2 (Set.image.{u1, u2} α β f S))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} α] [_inst_2 : TopologicalSpace.{u1} β] {x : α} {S : Set.{u2} α}, (IsGenericPoint.{u2} α _inst_1 x S) -> (forall {f : α -> β}, (Continuous.{u2, u1} α β _inst_1 _inst_2 f) -> (IsGenericPoint.{u1} β _inst_2 (f x) (closure.{u1} β _inst_2 (Set.image.{u2, u1} α β f S))))
-Case conversion may be inaccurate. Consider using '#align is_generic_point.image IsGenericPoint.imageₓ'. -/
 protected theorem image (h : IsGenericPoint x S) {f : α → β} (hf : Continuous f) :
     IsGenericPoint (f x) (closure (f '' S)) :=
   by
@@ -206,22 +188,10 @@ noncomputable def genericPoint [QuasiSober α] [IrreducibleSpace α] : α :=
 #align generic_point genericPoint
 -/
 
-/- warning: generic_point_spec -> genericPoint_spec is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : TopologicalSpace.{u1} α] [_inst_3 : QuasiSober.{u1} α _inst_1] [_inst_4 : IrreducibleSpace.{u1} α _inst_1], IsGenericPoint.{u1} α _inst_1 (genericPoint.{u1} α _inst_1 _inst_3 _inst_4) (Top.top.{u1} (Set.{u1} α) (CompleteLattice.toHasTop.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))
-but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : TopologicalSpace.{u1} α] [_inst_3 : QuasiSober.{u1} α _inst_1] [_inst_4 : IrreducibleSpace.{u1} α _inst_1], IsGenericPoint.{u1} α _inst_1 (genericPoint.{u1} α _inst_1 _inst_3 _inst_4) (Top.top.{u1} (Set.{u1} α) (CompleteLattice.toTop.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α))))))
-Case conversion may be inaccurate. Consider using '#align generic_point_spec genericPoint_specₓ'. -/
 theorem genericPoint_spec [QuasiSober α] [IrreducibleSpace α] : IsGenericPoint (genericPoint α) ⊤ :=
   by simpa using (IrreducibleSpace.isIrreducible_univ α).genericPoint_spec
 #align generic_point_spec genericPoint_spec
 
-/- warning: generic_point_closure -> genericPoint_closure is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : TopologicalSpace.{u1} α] [_inst_3 : QuasiSober.{u1} α _inst_1] [_inst_4 : IrreducibleSpace.{u1} α _inst_1], Eq.{succ u1} (Set.{u1} α) (closure.{u1} α _inst_1 (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) (genericPoint.{u1} α _inst_1 _inst_3 _inst_4))) (Top.top.{u1} (Set.{u1} α) (CompleteLattice.toHasTop.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))
-but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : TopologicalSpace.{u1} α] [_inst_3 : QuasiSober.{u1} α _inst_1] [_inst_4 : IrreducibleSpace.{u1} α _inst_1], Eq.{succ u1} (Set.{u1} α) (closure.{u1} α _inst_1 (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) (genericPoint.{u1} α _inst_1 _inst_3 _inst_4))) (Top.top.{u1} (Set.{u1} α) (CompleteLattice.toTop.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α))))))
-Case conversion may be inaccurate. Consider using '#align generic_point_closure genericPoint_closureₓ'. -/
 @[simp]
 theorem genericPoint_closure [QuasiSober α] [IrreducibleSpace α] :
     closure ({genericPoint α} : Set α) = ⊤ :=
@@ -238,12 +208,6 @@ theorem genericPoint_specializes [QuasiSober α] [IrreducibleSpace α] (x : α)
 
 attribute [local instance 10] specializationOrder
 
-/- warning: irreducible_set_equiv_points -> irreducibleSetEquivPoints is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_3 : QuasiSober.{u1} α _inst_1] [_inst_4 : T0Space.{u1} α _inst_1], OrderIso.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Set.{u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Set.{u1} α)) (setOf.{u1} (Set.{u1} α) (fun (s : Set.{u1} α) => And (IsIrreducible.{u1} α _inst_1 s) (IsClosed.{u1} α _inst_1 s)))) α (Subtype.hasLe.{u1} (Set.{u1} α) (Set.hasLe.{u1} α) (fun (x : Set.{u1} α) => Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) x (setOf.{u1} (Set.{u1} α) (fun (s : Set.{u1} α) => And (IsIrreducible.{u1} α _inst_1 s) (IsClosed.{u1} α _inst_1 s))))) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (specializationOrder.{u1} α _inst_1 _inst_4)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_3 : QuasiSober.{u1} α _inst_1] [_inst_4 : T0Space.{u1} α _inst_1], OrderIso.{u1, u1} (Set.Elem.{u1} (Set.{u1} α) (setOf.{u1} (Set.{u1} α) (fun (s : Set.{u1} α) => And (IsIrreducible.{u1} α _inst_1 s) (IsClosed.{u1} α _inst_1 s)))) α (Subtype.le.{u1} (Set.{u1} α) (Set.instLESet.{u1} α) (fun (x : Set.{u1} α) => Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) x (setOf.{u1} (Set.{u1} α) (fun (s : Set.{u1} α) => And (IsIrreducible.{u1} α _inst_1 s) (IsClosed.{u1} α _inst_1 s))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (specializationOrder.{u1} α _inst_1 _inst_4)))
-Case conversion may be inaccurate. Consider using '#align irreducible_set_equiv_points irreducibleSetEquivPointsₓ'. -/
 /-- The closed irreducible subsets of a sober space bijects with the points of the space. -/
 noncomputable def irreducibleSetEquivPoints [QuasiSober α] [T0Space α] :
     { s : Set α | IsIrreducible s ∧ IsClosed s } ≃o α
@@ -260,12 +224,6 @@ noncomputable def irreducibleSetEquivPoints [QuasiSober α] [T0Space α] :
     simp [s.prop.2.closure_eq, t.prop.2.closure_eq, ← Subtype.coe_le_coe]
 #align irreducible_set_equiv_points irreducibleSetEquivPoints
 
-/- warning: closed_embedding.quasi_sober -> ClosedEmbedding.quasiSober is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_2 : TopologicalSpace.{u2} β] {f : α -> β}, (ClosedEmbedding.{u1, u2} α β _inst_1 _inst_2 f) -> (forall [_inst_3 : QuasiSober.{u2} β _inst_2], QuasiSober.{u1} α _inst_1)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} α] [_inst_2 : TopologicalSpace.{u1} β] {f : α -> β}, (ClosedEmbedding.{u2, u1} α β _inst_1 _inst_2 f) -> (forall [_inst_3 : QuasiSober.{u1} β _inst_2], QuasiSober.{u2} α _inst_1)
-Case conversion may be inaccurate. Consider using '#align closed_embedding.quasi_sober ClosedEmbedding.quasiSoberₓ'. -/
 theorem ClosedEmbedding.quasiSober {f : α → β} (hf : ClosedEmbedding f) [QuasiSober β] :
     QuasiSober α := by
   constructor
@@ -279,12 +237,6 @@ theorem ClosedEmbedding.quasiSober {f : α → β} (hf : ClosedEmbedding f) [Qua
   rw [← hx, ← hf.closure_image_eq, Set.image_singleton]
 #align closed_embedding.quasi_sober ClosedEmbedding.quasiSober
 
-/- warning: open_embedding.quasi_sober -> OpenEmbedding.quasiSober is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_2 : TopologicalSpace.{u2} β] {f : α -> β}, (OpenEmbedding.{u1, u2} α β _inst_1 _inst_2 f) -> (forall [_inst_3 : QuasiSober.{u2} β _inst_2], QuasiSober.{u1} α _inst_1)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} α] [_inst_2 : TopologicalSpace.{u1} β] {f : α -> β}, (OpenEmbedding.{u2, u1} α β _inst_1 _inst_2 f) -> (forall [_inst_3 : QuasiSober.{u1} β _inst_2], QuasiSober.{u2} α _inst_1)
-Case conversion may be inaccurate. Consider using '#align open_embedding.quasi_sober OpenEmbedding.quasiSoberₓ'. -/
 theorem OpenEmbedding.quasiSober {f : α → β} (hf : OpenEmbedding f) [QuasiSober β] : QuasiSober α :=
   by
   constructor
@@ -311,12 +263,6 @@ theorem OpenEmbedding.quasiSober {f : α → β} (hf : OpenEmbedding f) [QuasiSo
       subset_closure ⟨h, hy⟩⟩
 #align open_embedding.quasi_sober OpenEmbedding.quasiSober
 
-/- warning: quasi_sober_of_open_cover -> quasiSober_of_open_cover is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] (S : Set.{u1} (Set.{u1} α)), (forall (s : coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Set.{u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Set.{u1} α)) S), IsOpen.{u1} α _inst_1 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Set.{u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Set.{u1} α)) S) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Set.{u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Set.{u1} α)) S) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Set.{u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Set.{u1} α)) S) (Set.{u1} α) (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Set.{u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Set.{u1} α)) S) (Set.{u1} α) (coeSubtype.{succ u1} (Set.{u1} α) (fun (x : Set.{u1} α) => Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) x S))))) s)) -> (forall [hS' : forall (s : coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Set.{u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Set.{u1} α)) S), QuasiSober.{u1} (coeSort.{succ u1, succ (succ u1)} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Set.{u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Set.{u1} α)) S) Type.{u1} (coeSortTrans.{succ (succ u1), succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Set.{u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Set.{u1} α)) S) (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (coeBaseAux.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Set.{u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Set.{u1} α)) S) (Set.{u1} α) (coeSubtype.{succ u1} (Set.{u1} α) (fun (x : Set.{u1} α) => Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) x S)))) s) (Subtype.topologicalSpace.{u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (HasCoeTAux.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Set.{u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Set.{u1} α)) S) (Set.{u1} α) (coeBaseAux.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Set.{u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Set.{u1} α)) S) (Set.{u1} α) (coeSubtype.{succ u1} (Set.{u1} α) (fun (x : Set.{u1} α) => Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) x S))) s)) _inst_1)], (Eq.{succ u1} (Set.{u1} α) (Set.sUnion.{u1} α S) (Top.top.{u1} (Set.{u1} α) (CompleteLattice.toHasTop.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) -> (QuasiSober.{u1} α _inst_1))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] (S : Set.{u1} (Set.{u1} α)), (forall (s : Set.Elem.{u1} (Set.{u1} α) S), IsOpen.{u1} α _inst_1 (Subtype.val.{succ u1} (Set.{u1} α) (fun (x : Set.{u1} α) => Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) x S) s)) -> (forall [hS' : forall (s : Set.Elem.{u1} (Set.{u1} α) S), QuasiSober.{u1} (Set.Elem.{u1} α (Subtype.val.{succ u1} (Set.{u1} α) (fun (x : Set.{u1} α) => Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) x S) s)) (instTopologicalSpaceSubtype.{u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (Subtype.val.{succ u1} (Set.{u1} α) (fun (x : Set.{u1} α) => Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) x S) s)) _inst_1)], (Eq.{succ u1} (Set.{u1} α) (Set.sUnion.{u1} α S) (Top.top.{u1} (Set.{u1} α) (CompleteLattice.toTop.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α))))))) -> (QuasiSober.{u1} α _inst_1))
-Case conversion may be inaccurate. Consider using '#align quasi_sober_of_open_cover quasiSober_of_open_coverₓ'. -/
 /-- A space is quasi sober if it can be covered by open quasi sober subsets. -/
 theorem quasiSober_of_open_cover (S : Set (Set α)) (hS : ∀ s : S, IsOpen (s : Set α))
     [hS' : ∀ s : S, QuasiSober s] (hS'' : ⋃₀ S = ⊤) : QuasiSober α :=

3e32bc90

bump to nightly-2023-05-28-04

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

6797a637

Diff

@@ -254,12 +254,9 @@ noncomputable def irreducibleSetEquivPoints [QuasiSober α] [T0Space α] :
     Subtype.eq <| Eq.trans s.Prop.1.genericPoint_spec <| closure_eq_iff_isClosed.mpr s.2.2
   right_inv x :=
     isIrreducible_singleton.closure.genericPoint_spec.Eq
-      (by
-        convert isGenericPoint_closure using 1
-        rw [closure_closure])
+      (by convert isGenericPoint_closure using 1; rw [closure_closure])
   map_rel_iff' s t := by
-    change _ ⤳ _ ↔ _
-    rw [specializes_iff_closure_subset]
+    change _ ⤳ _ ↔ _; rw [specializes_iff_closure_subset]
     simp [s.prop.2.closure_eq, t.prop.2.closure_eq, ← Subtype.coe_le_coe]
 #align irreducible_set_equiv_points irreducibleSetEquivPoints
 
@@ -296,9 +293,7 @@ theorem OpenEmbedding.quasiSober {f : α → β} (hf : OpenEmbedding f) [QuasiSo
   obtain ⟨x, hx⟩ := QuasiSober.sober hS''.closure isClosed_closure
   obtain ⟨T, hT, rfl⟩ := hf.to_inducing.is_closed_iff.mp hS'
   rw [Set.image_preimage_eq_inter_range] at hx hS''
-  have hxT : x ∈ T := by
-    rw [← hT.closure_eq]
-    exact closure_mono (Set.inter_subset_left _ _) hx.mem
+  have hxT : x ∈ T := by rw [← hT.closure_eq]; exact closure_mono (Set.inter_subset_left _ _) hx.mem
   have hxU : x ∈ Set.range f :=
     by
     rw [hx.mem_open_set_iff hf.open_range]
@@ -329,9 +324,7 @@ theorem quasiSober_of_open_cover (S : Set (Set α)) (hS : ∀ s : S, IsOpen (s :
   rw [quasiSober_iff]
   intro t h h'
   obtain ⟨x, hx⟩ := h.1
-  obtain ⟨U, hU, hU'⟩ : x ∈ ⋃₀ S := by
-    rw [hS'']
-    trivial
+  obtain ⟨U, hU, hU'⟩ : x ∈ ⋃₀ S := by rw [hS'']; trivial
   haveI : QuasiSober U := hS' ⟨U, hU⟩
   have H : IsPreirreducible (coe ⁻¹' t : Set U) :=
     h.2.Preimage (hS ⟨U, hU⟩).openEmbedding_subtype_val
@@ -340,8 +333,7 @@ theorem quasiSober_of_open_cover (S : Set (Set α)) (hS : ∀ s : S, IsOpen (s :
   have := continuous_subtype_coe.closure_preimage_subset _ H.generic_point_spec.mem
   rw [h'.closure_eq] at this
   apply le_antisymm
-  · apply h'.closure_subset_iff.mpr
-    simpa using this
+  · apply h'.closure_subset_iff.mpr; simpa using this
   rw [← Set.image_singleton, ← closure_closure]
   have := closure_mono (image_closure_subset_closure_image (@continuous_subtype_val α _ U))
   refine' Set.Subset.trans _ this

3e32bc90

bump to nightly-2023-05-16-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8

9cb92e8c

Diff

@@ -238,7 +238,12 @@ theorem genericPoint_specializes [QuasiSober α] [IrreducibleSpace α] (x : α)
 
 attribute [local instance 10] specializationOrder
 
-#print irreducibleSetEquivPoints /-
+/- warning: irreducible_set_equiv_points -> irreducibleSetEquivPoints is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_3 : QuasiSober.{u1} α _inst_1] [_inst_4 : T0Space.{u1} α _inst_1], OrderIso.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Set.{u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Set.{u1} α)) (setOf.{u1} (Set.{u1} α) (fun (s : Set.{u1} α) => And (IsIrreducible.{u1} α _inst_1 s) (IsClosed.{u1} α _inst_1 s)))) α (Subtype.hasLe.{u1} (Set.{u1} α) (Set.hasLe.{u1} α) (fun (x : Set.{u1} α) => Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) x (setOf.{u1} (Set.{u1} α) (fun (s : Set.{u1} α) => And (IsIrreducible.{u1} α _inst_1 s) (IsClosed.{u1} α _inst_1 s))))) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (specializationOrder.{u1} α _inst_1 _inst_4)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] [_inst_3 : QuasiSober.{u1} α _inst_1] [_inst_4 : T0Space.{u1} α _inst_1], OrderIso.{u1, u1} (Set.Elem.{u1} (Set.{u1} α) (setOf.{u1} (Set.{u1} α) (fun (s : Set.{u1} α) => And (IsIrreducible.{u1} α _inst_1 s) (IsClosed.{u1} α _inst_1 s)))) α (Subtype.le.{u1} (Set.{u1} α) (Set.instLESet.{u1} α) (fun (x : Set.{u1} α) => Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) x (setOf.{u1} (Set.{u1} α) (fun (s : Set.{u1} α) => And (IsIrreducible.{u1} α _inst_1 s) (IsClosed.{u1} α _inst_1 s))))) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (specializationOrder.{u1} α _inst_1 _inst_4)))
+Case conversion may be inaccurate. Consider using '#align irreducible_set_equiv_points irreducibleSetEquivPointsₓ'. -/
 /-- The closed irreducible subsets of a sober space bijects with the points of the space. -/
 noncomputable def irreducibleSetEquivPoints [QuasiSober α] [T0Space α] :
     { s : Set α | IsIrreducible s ∧ IsClosed s } ≃o α
@@ -257,7 +262,6 @@ noncomputable def irreducibleSetEquivPoints [QuasiSober α] [T0Space α] :
     rw [specializes_iff_closure_subset]
     simp [s.prop.2.closure_eq, t.prop.2.closure_eq, ← Subtype.coe_le_coe]
 #align irreducible_set_equiv_points irreducibleSetEquivPoints
--/
 
 /- warning: closed_embedding.quasi_sober -> ClosedEmbedding.quasiSober is a dubious translation:
 lean 3 declaration is

3e32bc90

bump to nightly-2023-05-14-08

mathlib commit https://github.com/leanprover-community/mathlib/commit/e3fb84046afd187b710170887195d50bada934ee

d31da313

Diff

@@ -314,9 +314,9 @@ theorem OpenEmbedding.quasiSober {f : α → β} (hf : OpenEmbedding f) [QuasiSo
 
 /- warning: quasi_sober_of_open_cover -> quasiSober_of_open_cover is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] (S : Set.{u1} (Set.{u1} α)), (forall (s : coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Set.{u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Set.{u1} α)) S), IsOpen.{u1} α _inst_1 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Set.{u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Set.{u1} α)) S) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Set.{u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Set.{u1} α)) S) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Set.{u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Set.{u1} α)) S) (Set.{u1} α) (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Set.{u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Set.{u1} α)) S) (Set.{u1} α) (coeSubtype.{succ u1} (Set.{u1} α) (fun (x : Set.{u1} α) => Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) x S))))) s)) -> (forall [hS' : forall (s : coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Set.{u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Set.{u1} α)) S), QuasiSober.{u1} (coeSort.{succ u1, succ (succ u1)} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Set.{u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Set.{u1} α)) S) Type.{u1} (coeSortTrans.{succ (succ u1), succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Set.{u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Set.{u1} α)) S) (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (coeBaseAux.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Set.{u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Set.{u1} α)) S) (Set.{u1} α) (coeSubtype.{succ u1} (Set.{u1} α) (fun (x : Set.{u1} α) => Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) x S)))) s) (Subtype.topologicalSpace.{u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (HasCoeTAux.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Set.{u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Set.{u1} α)) S) (Set.{u1} α) (coeBaseAux.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Set.{u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Set.{u1} α)) S) (Set.{u1} α) (coeSubtype.{succ u1} (Set.{u1} α) (fun (x : Set.{u1} α) => Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) x S))) s)) _inst_1)], (Eq.{succ u1} (Set.{u1} α) (Set.unionₛ.{u1} α S) (Top.top.{u1} (Set.{u1} α) (CompleteLattice.toHasTop.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) -> (QuasiSober.{u1} α _inst_1))
+  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] (S : Set.{u1} (Set.{u1} α)), (forall (s : coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Set.{u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Set.{u1} α)) S), IsOpen.{u1} α _inst_1 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Set.{u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Set.{u1} α)) S) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Set.{u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Set.{u1} α)) S) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Set.{u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Set.{u1} α)) S) (Set.{u1} α) (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Set.{u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Set.{u1} α)) S) (Set.{u1} α) (coeSubtype.{succ u1} (Set.{u1} α) (fun (x : Set.{u1} α) => Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) x S))))) s)) -> (forall [hS' : forall (s : coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Set.{u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Set.{u1} α)) S), QuasiSober.{u1} (coeSort.{succ u1, succ (succ u1)} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Set.{u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Set.{u1} α)) S) Type.{u1} (coeSortTrans.{succ (succ u1), succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Set.{u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Set.{u1} α)) S) (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (coeBaseAux.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Set.{u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Set.{u1} α)) S) (Set.{u1} α) (coeSubtype.{succ u1} (Set.{u1} α) (fun (x : Set.{u1} α) => Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) x S)))) s) (Subtype.topologicalSpace.{u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (HasCoeTAux.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Set.{u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Set.{u1} α)) S) (Set.{u1} α) (coeBaseAux.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Set.{u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Set.{u1} α)) S) (Set.{u1} α) (coeSubtype.{succ u1} (Set.{u1} α) (fun (x : Set.{u1} α) => Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) x S))) s)) _inst_1)], (Eq.{succ u1} (Set.{u1} α) (Set.sUnion.{u1} α S) (Top.top.{u1} (Set.{u1} α) (CompleteLattice.toHasTop.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) -> (QuasiSober.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] (S : Set.{u1} (Set.{u1} α)), (forall (s : Set.Elem.{u1} (Set.{u1} α) S), IsOpen.{u1} α _inst_1 (Subtype.val.{succ u1} (Set.{u1} α) (fun (x : Set.{u1} α) => Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) x S) s)) -> (forall [hS' : forall (s : Set.Elem.{u1} (Set.{u1} α) S), QuasiSober.{u1} (Set.Elem.{u1} α (Subtype.val.{succ u1} (Set.{u1} α) (fun (x : Set.{u1} α) => Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) x S) s)) (instTopologicalSpaceSubtype.{u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (Subtype.val.{succ u1} (Set.{u1} α) (fun (x : Set.{u1} α) => Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) x S) s)) _inst_1)], (Eq.{succ u1} (Set.{u1} α) (Set.unionₛ.{u1} α S) (Top.top.{u1} (Set.{u1} α) (CompleteLattice.toTop.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α))))))) -> (QuasiSober.{u1} α _inst_1))
+  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] (S : Set.{u1} (Set.{u1} α)), (forall (s : Set.Elem.{u1} (Set.{u1} α) S), IsOpen.{u1} α _inst_1 (Subtype.val.{succ u1} (Set.{u1} α) (fun (x : Set.{u1} α) => Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) x S) s)) -> (forall [hS' : forall (s : Set.Elem.{u1} (Set.{u1} α) S), QuasiSober.{u1} (Set.Elem.{u1} α (Subtype.val.{succ u1} (Set.{u1} α) (fun (x : Set.{u1} α) => Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) x S) s)) (instTopologicalSpaceSubtype.{u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (Subtype.val.{succ u1} (Set.{u1} α) (fun (x : Set.{u1} α) => Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) x S) s)) _inst_1)], (Eq.{succ u1} (Set.{u1} α) (Set.sUnion.{u1} α S) (Top.top.{u1} (Set.{u1} α) (CompleteLattice.toTop.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α))))))) -> (QuasiSober.{u1} α _inst_1))
 Case conversion may be inaccurate. Consider using '#align quasi_sober_of_open_cover quasiSober_of_open_coverₓ'. -/
 /-- A space is quasi sober if it can be covered by open quasi sober subsets. -/
 theorem quasiSober_of_open_cover (S : Set (Set α)) (hS : ∀ s : S, IsOpen (s : Set α))

3e32bc90

bump to nightly-2023-04-24-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/09079525fd01b3dda35e96adaa08d2f943e1648c

ff662d55

Diff

@@ -236,7 +236,7 @@ theorem genericPoint_specializes [QuasiSober α] [IrreducibleSpace α] (x : α)
 #align generic_point_specializes genericPoint_specializes
 -/
 
-attribute [local instance] specializationOrder
+attribute [local instance 10] specializationOrder
 
 #print irreducibleSetEquivPoints /-
 /-- The closed irreducible subsets of a sober space bijects with the points of the space. -/

3e32bc90

bump to nightly-2023-02-21-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/bd9851ca476957ea4549eb19b40e7b5ade9428cc

1107b979

Changes in mathlib4

mathlib3

mathlib4

0a0ec350

chore: rename IsRoot.definition back to IsRoot.def (#11999)

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

1f25ef62

Diff

@@ -39,12 +39,10 @@ theorem isGenericPoint_def {x : α} {S : Set α} : IsGenericPoint x S ↔ closur
   Iff.rfl
 #align is_generic_point_def isGenericPoint_def
 
--- Adaptation note: 2024-03-15
--- Renamed to avoid the reserved name `IsGenericPoint.def`.
-theorem IsGenericPoint.def' {x : α} {S : Set α} (h : IsGenericPoint x S) :
+theorem IsGenericPoint.def {x : α} {S : Set α} (h : IsGenericPoint x S) :
     closure ({x} : Set α) = S :=
   h
-#align is_generic_point.def IsGenericPoint.def'
+#align is_generic_point.def IsGenericPoint.def
 
 theorem isGenericPoint_closure {x : α} : IsGenericPoint x (closure ({x} : Set α)) :=
   refl _
@@ -71,11 +69,11 @@ protected theorem mem (h : IsGenericPoint x S) : x ∈ S :=
 #align is_generic_point.mem IsGenericPoint.mem
 
 protected theorem isClosed (h : IsGenericPoint x S) : IsClosed S :=
-  h.def' ▸ isClosed_closure
+  h.def ▸ isClosed_closure
 #align is_generic_point.is_closed IsGenericPoint.isClosed
 
 protected theorem isIrreducible (h : IsGenericPoint x S) : IsIrreducible S :=
-  h.def' ▸ isIrreducible_singleton.closure
+  h.def ▸ isIrreducible_singleton.closure
 #align is_generic_point.is_irreducible IsGenericPoint.isIrreducible
 
 protected theorem inseparable (h : IsGenericPoint x S) (h' : IsGenericPoint y S) :
@@ -96,12 +94,12 @@ theorem disjoint_iff (h : IsGenericPoint x S) (hU : IsOpen U) : Disjoint S U ↔
 #align is_generic_point.disjoint_iff IsGenericPoint.disjoint_iff
 
 theorem mem_closed_set_iff (h : IsGenericPoint x S) (hZ : IsClosed Z) : x ∈ Z ↔ S ⊆ Z := by
-  rw [← h.def', hZ.closure_subset_iff, singleton_subset_iff]
+  rw [← h.def, hZ.closure_subset_iff, singleton_subset_iff]
 #align is_generic_point.mem_closed_set_iff IsGenericPoint.mem_closed_set_iff
 
 protected theorem image (h : IsGenericPoint x S) {f : α → β} (hf : Continuous f) :
     IsGenericPoint (f x) (closure (f '' S)) := by
-  rw [isGenericPoint_def, ← h.def', ← image_singleton, closure_image_closure hf]
+  rw [isGenericPoint_def, ← h.def, ← image_singleton, closure_image_closure hf]
 #align is_generic_point.image IsGenericPoint.image
 
 end IsGenericPoint
@@ -189,7 +187,7 @@ theorem ClosedEmbedding.quasiSober {f : α → β} (hf : ClosedEmbedding f) [Qua
     obtain ⟨y, -, rfl⟩ := hx.mem
     use y
     apply image_injective.mpr hf.inj
-    rw [← hx.def', ← hf.closure_image_eq, image_singleton]
+    rw [← hx.def, ← hf.closure_image_eq, image_singleton]
 #align closed_embedding.quasi_sober ClosedEmbedding.quasiSober
 
 theorem OpenEmbedding.quasiSober {f : α → β} (hf : OpenEmbedding f) [QuasiSober β] :
@@ -235,7 +233,7 @@ theorem quasiSober_of_open_cover (S : Set (Set α)) (hS : ∀ s : S, IsOpen (s :
   apply le_antisymm
   · apply h'.closure_subset_iff.mpr
     simpa using this
-  rw [← image_singleton, ← closure_image_closure continuous_subtype_val, H.genericPoint_spec.def']
+  rw [← image_singleton, ← closure_image_closure continuous_subtype_val, H.genericPoint_spec.def]
   refine' (subset_closure_inter_of_isPreirreducible_of_isOpen h.2 (hS ⟨U, hU⟩) ⟨x, hx, hU'⟩).trans
     (closure_mono _)
   rw [inter_comm t, ← Subtype.image_preimage_coe]

0a0ec350

chore: rename away from 'def' (#11548)

This will become an error in 2024-03-16 nightly, possibly not permanently.

Co-authored-by: Scott Morrison <scott@tqft.net>

b505e8e9

Diff

@@ -39,10 +39,12 @@ theorem isGenericPoint_def {x : α} {S : Set α} : IsGenericPoint x S ↔ closur
   Iff.rfl
 #align is_generic_point_def isGenericPoint_def
 
-theorem IsGenericPoint.def {x : α} {S : Set α} (h : IsGenericPoint x S) :
+-- Adaptation note: 2024-03-15
+-- Renamed to avoid the reserved name `IsGenericPoint.def`.
+theorem IsGenericPoint.def' {x : α} {S : Set α} (h : IsGenericPoint x S) :
     closure ({x} : Set α) = S :=
   h
-#align is_generic_point.def IsGenericPoint.def
+#align is_generic_point.def IsGenericPoint.def'
 
 theorem isGenericPoint_closure {x : α} : IsGenericPoint x (closure ({x} : Set α)) :=
   refl _
@@ -69,11 +71,11 @@ protected theorem mem (h : IsGenericPoint x S) : x ∈ S :=
 #align is_generic_point.mem IsGenericPoint.mem
 
 protected theorem isClosed (h : IsGenericPoint x S) : IsClosed S :=
-  h.def ▸ isClosed_closure
+  h.def' ▸ isClosed_closure
 #align is_generic_point.is_closed IsGenericPoint.isClosed
 
 protected theorem isIrreducible (h : IsGenericPoint x S) : IsIrreducible S :=
-  h.def ▸ isIrreducible_singleton.closure
+  h.def' ▸ isIrreducible_singleton.closure
 #align is_generic_point.is_irreducible IsGenericPoint.isIrreducible
 
 protected theorem inseparable (h : IsGenericPoint x S) (h' : IsGenericPoint y S) :
@@ -94,12 +96,12 @@ theorem disjoint_iff (h : IsGenericPoint x S) (hU : IsOpen U) : Disjoint S U ↔
 #align is_generic_point.disjoint_iff IsGenericPoint.disjoint_iff
 
 theorem mem_closed_set_iff (h : IsGenericPoint x S) (hZ : IsClosed Z) : x ∈ Z ↔ S ⊆ Z := by
-  rw [← h.def, hZ.closure_subset_iff, singleton_subset_iff]
+  rw [← h.def', hZ.closure_subset_iff, singleton_subset_iff]
 #align is_generic_point.mem_closed_set_iff IsGenericPoint.mem_closed_set_iff
 
 protected theorem image (h : IsGenericPoint x S) {f : α → β} (hf : Continuous f) :
     IsGenericPoint (f x) (closure (f '' S)) := by
-  rw [isGenericPoint_def, ← h.def, ← image_singleton, closure_image_closure hf]
+  rw [isGenericPoint_def, ← h.def', ← image_singleton, closure_image_closure hf]
 #align is_generic_point.image IsGenericPoint.image
 
 end IsGenericPoint
@@ -187,7 +189,7 @@ theorem ClosedEmbedding.quasiSober {f : α → β} (hf : ClosedEmbedding f) [Qua
     obtain ⟨y, -, rfl⟩ := hx.mem
     use y
     apply image_injective.mpr hf.inj
-    rw [← hx.def, ← hf.closure_image_eq, image_singleton]
+    rw [← hx.def', ← hf.closure_image_eq, image_singleton]
 #align closed_embedding.quasi_sober ClosedEmbedding.quasiSober
 
 theorem OpenEmbedding.quasiSober {f : α → β} (hf : OpenEmbedding f) [QuasiSober β] :
@@ -233,7 +235,7 @@ theorem quasiSober_of_open_cover (S : Set (Set α)) (hS : ∀ s : S, IsOpen (s :
   apply le_antisymm
   · apply h'.closure_subset_iff.mpr
     simpa using this
-  rw [← image_singleton, ← closure_image_closure continuous_subtype_val, H.genericPoint_spec.def]
+  rw [← image_singleton, ← closure_image_closure continuous_subtype_val, H.genericPoint_spec.def']
   refine' (subset_closure_inter_of_isPreirreducible_of_isOpen h.2 (hS ⟨U, hU⟩) ⟨x, hx, hU'⟩).trans
     (closure_mono _)
   rw [inter_comm t, ← Subtype.image_preimage_coe]

0a0ec350

chore: rename open_range to isOpen_range, closed_range to isClosed_range (#11438)

All these lemmas refer to the range of some function being open/range (i.e. isOpen or isClosed).

75784e0d

Diff

@@ -201,7 +201,7 @@ theorem OpenEmbedding.quasiSober {f : α → β} (hf : OpenEmbedding f) [QuasiSo
       rw [← hT.closure_eq]
       exact closure_mono (inter_subset_left _ _) hx.mem
     obtain ⟨y, rfl⟩ : x ∈ range f := by
-      rw [hx.mem_open_set_iff hf.open_range]
+      rw [hx.mem_open_set_iff hf.isOpen_range]
       refine' Nonempty.mono _ hS''.1
       simpa using subset_closure
     use y

0a0ec350

refactor: prefer s ∩ . when passing to a subset of s (#10433)

This is partial work to make s ∩ . be consistently used for passing to a subset of s. This is sort of an adjoint to (Subtype.val : s -> _) '' ., except for the fact that it does not produce a Set s.

The main API changes are to Subtype.image_preimage_val and Subtype.preimage_val_eq_preimage_val_iff in Mathlib.Data.Set.Image. Changes in other modules are all proof fixups.

Zulip discussion

3660a8f3

Diff

@@ -236,7 +236,7 @@ theorem quasiSober_of_open_cover (S : Set (Set α)) (hS : ∀ s : S, IsOpen (s :
   rw [← image_singleton, ← closure_image_closure continuous_subtype_val, H.genericPoint_spec.def]
   refine' (subset_closure_inter_of_isPreirreducible_of_isOpen h.2 (hS ⟨U, hU⟩) ⟨x, hx, hU'⟩).trans
     (closure_mono _)
-  rw [← Subtype.image_preimage_coe]
+  rw [inter_comm t, ← Subtype.image_preimage_coe]
   exact Set.image_subset _ subset_closure
 #align quasi_sober_of_open_cover quasiSober_of_open_cover

0a0ec350

refactor: decapitalize names in @[mk_iff] (#9378)

@[mk_iff] class MyPred now generates myPred_iff, not MyPred_iff
add Lean.Name.decapitalize
fix indentation and a few typos in the docs/comments.

Partially addresses issue #9129

5192777c

Diff

@@ -116,7 +116,7 @@ end genericPoint
 section Sober
 
 /-- A space is sober if every irreducible closed subset has a generic point. -/
-@[mk_iff quasiSober_iff]
+@[mk_iff]
 class QuasiSober (α : Type*) [TopologicalSpace α] : Prop where
   sober : ∀ {S : Set α}, IsIrreducible S → IsClosed S → ∃ x, IsGenericPoint x S
 #align quasi_sober QuasiSober

0a0ec350

style: cleanup by putting by on the same line as := (#8407)

Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

5e9b46ed

Diff

@@ -145,8 +145,9 @@ noncomputable def genericPoint [QuasiSober α] [IrreducibleSpace α] : α :=
   (IrreducibleSpace.isIrreducible_univ α).genericPoint
 #align generic_point genericPoint
 
-theorem genericPoint_spec [QuasiSober α] [IrreducibleSpace α] : IsGenericPoint (genericPoint α) ⊤ :=
-  by simpa using (IrreducibleSpace.isIrreducible_univ α).genericPoint_spec
+theorem genericPoint_spec [QuasiSober α] [IrreducibleSpace α] :
+    IsGenericPoint (genericPoint α) ⊤ := by
+  simpa using (IrreducibleSpace.isIrreducible_univ α).genericPoint_spec
 #align generic_point_spec genericPoint_spec
 
 @[simp]

0a0ec350

chore: banish Type _ and Sort _ (#6499)

We remove all possible occurences of Type _ and Sort _ in favor of Type* and Sort*.

This has nice performance benefits.

32de3f67

Diff

@@ -26,7 +26,7 @@ stated via `[QuasiSober α] [T0Space α]`.
 
 open Set
 
-variable {α β : Type _} [TopologicalSpace α] [TopologicalSpace β]
+variable {α β : Type*} [TopologicalSpace α] [TopologicalSpace β]
 
 section genericPoint
 
@@ -117,7 +117,7 @@ section Sober
 
 /-- A space is sober if every irreducible closed subset has a generic point. -/
 @[mk_iff quasiSober_iff]
-class QuasiSober (α : Type _) [TopologicalSpace α] : Prop where
+class QuasiSober (α : Type*) [TopologicalSpace α] : Prop where
   sober : ∀ {S : Set α}, IsIrreducible S → IsClosed S → ∃ x, IsGenericPoint x S
 #align quasi_sober QuasiSober

0a0ec350

chore: script to replace headers with #align_import statements (#5979)

depends on: #5966

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

89aa3a3b

Diff

@@ -2,14 +2,11 @@
 Copyright (c) 2021 Andrew Yang. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Andrew Yang
-
-! This file was ported from Lean 3 source module topology.sober
-! leanprover-community/mathlib commit 0a0ec35061ed9960bf0e7ffb0335f44447b58977
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Topology.Separation
 
+#align_import topology.sober from "leanprover-community/mathlib"@"0a0ec35061ed9960bf0e7ffb0335f44447b58977"
+
 /-!
 # Sober spaces

0a0ec350

chore: Rename to sSup/iSup (#3938)

As discussed on Zulip

Renames

supₛ → sSup
infₛ → sInf
supᵢ → iSup
infᵢ → iInf
bsupₛ → bsSup
binfₛ → bsInf
bsupᵢ → biSup
binfᵢ → biInf
csupₛ → csSup
cinfₛ → csInf
csupᵢ → ciSup
cinfᵢ → ciInf
unionₛ → sUnion
interₛ → sInter
unionᵢ → iUnion
interᵢ → iInter
bunionₛ → bsUnion
binterₛ → bsInter
bunionᵢ → biUnion
binterᵢ → biInter

Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

d1eb6264

Diff

@@ -110,7 +110,7 @@ end IsGenericPoint
 theorem isGenericPoint_iff_forall_closed (hS : IsClosed S) (hxS : x ∈ S) :
     IsGenericPoint x S ↔ ∀ Z : Set α, IsClosed Z → x ∈ Z → S ⊆ Z := by
   have : closure {x} ⊆ S := closure_minimal (singleton_subset_iff.2 hxS) hS
-  simp_rw [IsGenericPoint, subset_antisymm_iff, this, true_and_iff, closure, subset_interₛ_iff,
+  simp_rw [IsGenericPoint, subset_antisymm_iff, this, true_and_iff, closure, subset_sInter_iff,
     mem_setOf_eq, and_imp, singleton_subset_iff]
 #align is_generic_point_iff_forall_closed isGenericPoint_iff_forall_closed
 
@@ -250,4 +250,3 @@ instance (priority := 100) T2Space.quasiSober [T2Space α] : QuasiSober α where
 #align t2_space.quasi_sober T2Space.quasiSober
 
 end Sober
-

0a0ec350

feat: port Topology.Sober (#2134)

12ec4c91

`topology.sober` ⟷ `Mathlib.Topology.Sober`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Renames

Dependencies 8 + 303

topology.sober ⟷ Mathlib.Topology.Sober

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Renames

Dependencies 8 + 303

`topology.sober` ⟷ `Mathlib.Topology.Sober`