topology.stone_cech ⟷ Mathlib.Topology.StoneCech

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

@@ -112,7 +112,7 @@ instance : TotallyDisconnectedSpace (Ultrafilter α) :=
   intro B hB
   rw [← Ultrafilter.coe_le_coe]
   intro s hs
-  rw [connectedComponent_eq_iInter_isClopen, Set.mem_iInter] at hB 
+  rw [connectedComponent_eq_iInter_isClopen, Set.mem_iInter] at hB
   let Z := {F : Ultrafilter α | s ∈ F}
   have hZ : IsClopen Z := ⟨ultrafilter_isOpen_basic s, ultrafilter_isClosed_basic s⟩
   exact hB ⟨Z, hZ, hs⟩
@@ -137,7 +137,7 @@ theorem ultrafilter_pure_injective : Function.Injective (pure : α → Ultrafilt
   by
   intro x y h
   have : {x} ∈ (pure x : Ultrafilter α) := singleton_mem_pure
-  rw [h] at this 
+  rw [h] at this
   exact (mem_singleton_iff.mp (mem_pure.mp this)).symm
 #align ultrafilter_pure_injective ultrafilter_pure_injective
 -/
@@ -365,7 +365,7 @@ theorem continuous_stoneCechUnit : Continuous (stoneCechUnit : α → StoneCech
     have : ↑(g.map pure) ≤ 𝓝 g := by rw [ultrafilter_converges_iff] <;> exact (bind_pure _).symm
     have : (g.map stoneCechUnit : Filter (StoneCech α)) ≤ 𝓝 ⟦g⟧ :=
       continuousAt_iff_ultrafilter.mp (continuous_quotient_mk'.Tendsto g) _ this
-    rwa [show ⟦g⟧ = ⟦pure x⟧ from Quotient.sound <| convergent_eqv_pure gx] at this 
+    rwa [show ⟦g⟧ = ⟦pure x⟧ from Quotient.sound <| convergent_eqv_pure gx] at this
 #align continuous_stone_cech_unit continuous_stoneCechUnit
 -/
 

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

@@ -112,7 +112,7 @@ instance : TotallyDisconnectedSpace (Ultrafilter α) :=
   intro B hB
   rw [← Ultrafilter.coe_le_coe]
   intro s hs
-  rw [connectedComponent_eq_iInter_clopen, Set.mem_iInter] at hB 
+  rw [connectedComponent_eq_iInter_isClopen, Set.mem_iInter] at hB 
   let Z := {F : Ultrafilter α | s ∈ F}
   have hZ : IsClopen Z := ⟨ultrafilter_isOpen_basic s, ultrafilter_isClosed_basic s⟩
   exact hB ⟨Z, hZ, hs⟩

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

@@ -3,8 +3,8 @@ Copyright (c) 2018 Reid Barton. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Reid Barton
 -/
-import Mathbin.Topology.Bases
-import Mathbin.Topology.DenseEmbedding
+import Topology.Bases
+import Topology.DenseEmbedding
 
 #align_import topology.stone_cech from "leanprover-community/mathlib"@"3e32bc908f617039c74c06ea9a897e30c30803c2"
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/001ffdc42920050657fd45bd2b8bfbec8eaaeb29

@@ -223,7 +223,7 @@ theorem continuous_ultrafilter_extend (f : α → γ) : Continuous (Ultrafilter.
       isCompact_univ.ultrafilter_le_nhds (b.map f) (by rw [le_principal_iff] <;> exact univ_mem)
     ⟨c, le_trans (map_mono (ultrafilter_comap_pure_nhds _)) h⟩
   letI : TopologicalSpace α := ⊥
-  haveI : NormalSpace γ := normalOfCompactT2
+  haveI : NormalSpace γ := T4Space.of_compactSpace_t2Space
   exact dense_inducing_pure.continuous_extend this
 #align continuous_ultrafilter_extend continuous_ultrafilter_extend
 -/

mathlib commit https://github.com/leanprover-community/mathlib/commit/63721b2c3eba6c325ecf8ae8cca27155a4f6306f

@@ -159,7 +159,7 @@ theorem induced_topology_pure :
   by
   apply eq_bot_of_singletons_open
   intro x
-  use {u : Ultrafilter α | {x} ∈ u}, ultrafilter_isOpen_basic _
+  use{u : Ultrafilter α | {x} ∈ u}, ultrafilter_isOpen_basic _
   simp
 #align induced_topology_pure induced_topology_pure
 -/

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

@@ -2,15 +2,12 @@
 Copyright (c) 2018 Reid Barton. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Reid Barton
-
-! This file was ported from Lean 3 source module topology.stone_cech
-! 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.Bases
 import Mathbin.Topology.DenseEmbedding
 
+#align_import topology.stone_cech from "leanprover-community/mathlib"@"3e32bc908f617039c74c06ea9a897e30c30803c2"
+
 /-! # Stone-Čech compactification
 
 > THIS FILE IS SYNCHRONIZED WITH MATHLIB4.

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

@@ -76,6 +76,7 @@ theorem ultrafilter_isClosed_basic (s : Set α) : IsClosed {u : Ultrafilter α |
 #align ultrafilter_is_closed_basic ultrafilter_isClosed_basic
 -/
 
+#print ultrafilter_converges_iff /-
 /-- Every ultrafilter `u` on `ultrafilter α` converges to a unique
   point of `ultrafilter α`, namely `mjoin u`. -/
 theorem ultrafilter_converges_iff {u : Ultrafilter (Ultrafilter α)} {x : Ultrafilter α} :
@@ -88,6 +89,7 @@ theorem ultrafilter_converges_iff {u : Ultrafilter (Ultrafilter α)} {x : Ultraf
   · intro h a ha; exact h _ ⟨ha, a, rfl⟩
   · rintro h a ⟨xi, a, rfl⟩; exact h _ xi
 #align ultrafilter_converges_iff ultrafilter_converges_iff
+-/
 
 #print ultrafilter_compact /-
 instance ultrafilter_compact : CompactSpace (Ultrafilter α) :=
@@ -118,6 +120,7 @@ instance : TotallyDisconnectedSpace (Ultrafilter α) :=
   have hZ : IsClopen Z := ⟨ultrafilter_isOpen_basic s, ultrafilter_isClosed_basic s⟩
   exact hB ⟨Z, hZ, hs⟩
 
+#print ultrafilter_comap_pure_nhds /-
 theorem ultrafilter_comap_pure_nhds (b : Ultrafilter α) : comap pure (𝓝 b) ≤ b :=
   by
   rw [TopologicalSpace.nhds_generateFrom]
@@ -128,9 +131,11 @@ theorem ultrafilter_comap_pure_nhds (b : Ultrafilter α) : comap pure (𝓝 b) 
   refine' iInf_le_of_le ⟨hs, ⟨s, rfl⟩⟩ _
   exact principal_mono.2 fun a => id
 #align ultrafilter_comap_pure_nhds ultrafilter_comap_pure_nhds
+-/
 
 section Embedding
 
+#print ultrafilter_pure_injective /-
 theorem ultrafilter_pure_injective : Function.Injective (pure : α → Ultrafilter α) :=
   by
   intro x y h
@@ -138,15 +143,19 @@ theorem ultrafilter_pure_injective : Function.Injective (pure : α → Ultrafilt
   rw [h] at this 
   exact (mem_singleton_iff.mp (mem_pure.mp this)).symm
 #align ultrafilter_pure_injective ultrafilter_pure_injective
+-/
 
 open TopologicalSpace
 
+#print denseRange_pure /-
 /-- The range of `pure : α → ultrafilter α` is dense in `ultrafilter α`. -/
 theorem denseRange_pure : DenseRange (pure : α → Ultrafilter α) := fun x =>
   mem_closure_iff_ultrafilter.mpr
     ⟨x.map pure, range_mem_map, ultrafilter_converges_iff.mpr (bind_pure x).symm⟩
 #align dense_range_pure denseRange_pure
+-/
 
+#print induced_topology_pure /-
 /-- The map `pure : α → ultra_filter α` induces on `α` the discrete topology. -/
 theorem induced_topology_pure :
     TopologicalSpace.induced (pure : α → Ultrafilter α) Ultrafilter.topologicalSpace = ⊥ :=
@@ -156,19 +165,24 @@ theorem induced_topology_pure :
   use {u : Ultrafilter α | {x} ∈ u}, ultrafilter_isOpen_basic _
   simp
 #align induced_topology_pure induced_topology_pure
+-/
 
+#print denseInducing_pure /-
 /-- `pure : α → ultrafilter α` defines a dense inducing of `α` in `ultrafilter α`. -/
 theorem denseInducing_pure : @DenseInducing _ _ ⊥ _ (pure : α → Ultrafilter α) :=
   letI : TopologicalSpace α := ⊥
   ⟨⟨induced_topology_pure.symm⟩, denseRange_pure⟩
 #align dense_inducing_pure denseInducing_pure
+-/
 
+#print denseEmbedding_pure /-
 -- The following refined version will never be used
 /-- `pure : α → ultrafilter α` defines a dense embedding of `α` in `ultrafilter α`. -/
 theorem denseEmbedding_pure : @DenseEmbedding _ _ ⊥ _ (pure : α → Ultrafilter α) :=
   letI : TopologicalSpace α := ⊥
   { denseInducing_pure with inj := ultrafilter_pure_injective }
 #align dense_embedding_pure denseEmbedding_pure
+-/
 
 end Embedding
 
@@ -192,15 +206,18 @@ def Ultrafilter.extend (f : α → γ) : Ultrafilter α → γ :=
 
 variable [T2Space γ]
 
+#print ultrafilter_extend_extends /-
 theorem ultrafilter_extend_extends (f : α → γ) : Ultrafilter.extend f ∘ pure = f :=
   by
   letI : TopologicalSpace α := ⊥
   haveI : DiscreteTopology α := ⟨rfl⟩
   exact funext (dense_inducing_pure.extend_eq continuous_of_discreteTopology)
 #align ultrafilter_extend_extends ultrafilter_extend_extends
+-/
 
 variable [CompactSpace γ]
 
+#print continuous_ultrafilter_extend /-
 theorem continuous_ultrafilter_extend (f : α → γ) : Continuous (Ultrafilter.extend f) :=
   by
   have : ∀ b : Ultrafilter α, ∃ c, Tendsto f (comap pure (𝓝 b)) (𝓝 c) := fun b =>
@@ -212,7 +229,9 @@ theorem continuous_ultrafilter_extend (f : α → γ) : Continuous (Ultrafilter.
   haveI : NormalSpace γ := normalOfCompactT2
   exact dense_inducing_pure.continuous_extend this
 #align continuous_ultrafilter_extend continuous_ultrafilter_extend
+-/
 
+#print ultrafilter_extend_eq_iff /-
 /-- The value of `ultrafilter.extend f` on an ultrafilter `b` is the
   unique limit of the ultrafilter `b.map f` in `γ`. -/
 theorem ultrafilter_extend_eq_iff {f : α → γ} {b : Ultrafilter α} {c : γ} :
@@ -233,6 +252,7 @@ theorem ultrafilter_extend_eq_iff {f : α → γ} {b : Ultrafilter α} {c : γ}
     dense_inducing_pure.extend_eq_of_tendsto
       (le_trans (map_mono (ultrafilter_comap_pure_nhds _)) h)⟩
 #align ultrafilter_extend_eq_iff ultrafilter_extend_eq_iff
+-/
 
 end Extension
 
@@ -331,6 +351,7 @@ theorem stoneCech_hom_ext {g₁ g₂ : StoneCech α → γ'} (h₁ : Continuous
 
 end Extension
 
+#print convergent_eqv_pure /-
 theorem convergent_eqv_pure {u : Ultrafilter α} {x : α} (ux : ↑u ≤ 𝓝 x) : u ≈ pure x :=
   fun γ tγ h₁ h₂ f hf => by
   skip
@@ -338,6 +359,7 @@ theorem convergent_eqv_pure {u : Ultrafilter α} {x : α} (ux : ↑u ≤ 𝓝 x)
   all_goals refine' ultrafilter_extend_eq_iff.mpr (le_trans (map_mono _) (hf.tendsto _))
   · apply pure_le_nhds; · exact ux
 #align convergent_eqv_pure convergent_eqv_pure
+-/
 
 #print continuous_stoneCechUnit /-
 theorem continuous_stoneCechUnit : Continuous (stoneCechUnit : α → StoneCech α) :=

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

@@ -38,7 +38,7 @@ section Ultrafilter
   it the Stone-Čech compactification of α (viewed as a discrete space). -/
 /-- Basis for the topology on `ultrafilter α`. -/
 def ultrafilterBasis (α : Type u) : Set (Set (Ultrafilter α)) :=
-  range fun s : Set α => { u | s ∈ u }
+  range fun s : Set α => {u | s ∈ u}
 #align ultrafilter_basis ultrafilterBasis
 -/
 
@@ -60,14 +60,14 @@ theorem ultrafilterBasis_is_basis : TopologicalSpace.IsTopologicalBasis (ultrafi
 
 #print ultrafilter_isOpen_basic /-
 /-- The basic open sets for the topology on ultrafilters are open. -/
-theorem ultrafilter_isOpen_basic (s : Set α) : IsOpen { u : Ultrafilter α | s ∈ u } :=
+theorem ultrafilter_isOpen_basic (s : Set α) : IsOpen {u : Ultrafilter α | s ∈ u} :=
   ultrafilterBasis_is_basis.IsOpen ⟨s, rfl⟩
 #align ultrafilter_is_open_basic ultrafilter_isOpen_basic
 -/
 
 #print ultrafilter_isClosed_basic /-
 /-- The basic open sets for the topology on ultrafilters are also closed. -/
-theorem ultrafilter_isClosed_basic (s : Set α) : IsClosed { u : Ultrafilter α | s ∈ u } :=
+theorem ultrafilter_isClosed_basic (s : Set α) : IsClosed {u : Ultrafilter α | s ∈ u} :=
   by
   rw [← isOpen_compl_iff]
   convert ultrafilter_isOpen_basic (sᶜ)
@@ -81,7 +81,7 @@ theorem ultrafilter_isClosed_basic (s : Set α) : IsClosed { u : Ultrafilter α
 theorem ultrafilter_converges_iff {u : Ultrafilter (Ultrafilter α)} {x : Ultrafilter α} :
     ↑u ≤ 𝓝 x ↔ x = joinM u := by
   rw [eq_comm, ← Ultrafilter.coe_le_coe]
-  change ↑u ≤ 𝓝 x ↔ ∀ s ∈ x, { v : Ultrafilter α | s ∈ v } ∈ u
+  change ↑u ≤ 𝓝 x ↔ ∀ s ∈ x, {v : Ultrafilter α | s ∈ v} ∈ u
   simp only [TopologicalSpace.nhds_generateFrom, le_iInf_iff, ultrafilterBasis, le_principal_iff,
     mem_set_of_eq]
   constructor
@@ -114,7 +114,7 @@ instance : TotallyDisconnectedSpace (Ultrafilter α) :=
   rw [← Ultrafilter.coe_le_coe]
   intro s hs
   rw [connectedComponent_eq_iInter_clopen, Set.mem_iInter] at hB 
-  let Z := { F : Ultrafilter α | s ∈ F }
+  let Z := {F : Ultrafilter α | s ∈ F}
   have hZ : IsClopen Z := ⟨ultrafilter_isOpen_basic s, ultrafilter_isClosed_basic s⟩
   exact hB ⟨Z, hZ, hs⟩
 
@@ -124,7 +124,7 @@ theorem ultrafilter_comap_pure_nhds (b : Ultrafilter α) : comap pure (𝓝 b) 
   simp only [comap_infi, comap_principal]
   intro s hs
   rw [← le_principal_iff]
-  refine' iInf_le_of_le { u | s ∈ u } _
+  refine' iInf_le_of_le {u | s ∈ u} _
   refine' iInf_le_of_le ⟨hs, ⟨s, rfl⟩⟩ _
   exact principal_mono.2 fun a => id
 #align ultrafilter_comap_pure_nhds ultrafilter_comap_pure_nhds
@@ -153,7 +153,7 @@ theorem induced_topology_pure :
   by
   apply eq_bot_of_singletons_open
   intro x
-  use { u : Ultrafilter α | {x} ∈ u }, ultrafilter_isOpen_basic _
+  use {u : Ultrafilter α | {x} ∈ u}, ultrafilter_isOpen_basic _
   simp
 #align induced_topology_pure induced_topology_pure
 

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

@@ -113,7 +113,7 @@ instance : TotallyDisconnectedSpace (Ultrafilter α) :=
   intro B hB
   rw [← Ultrafilter.coe_le_coe]
   intro s hs
-  rw [connectedComponent_eq_iInter_clopen, Set.mem_iInter] at hB
+  rw [connectedComponent_eq_iInter_clopen, Set.mem_iInter] at hB 
   let Z := { F : Ultrafilter α | s ∈ F }
   have hZ : IsClopen Z := ⟨ultrafilter_isOpen_basic s, ultrafilter_isClosed_basic s⟩
   exact hB ⟨Z, hZ, hs⟩
@@ -135,7 +135,7 @@ theorem ultrafilter_pure_injective : Function.Injective (pure : α → Ultrafilt
   by
   intro x y h
   have : {x} ∈ (pure x : Ultrafilter α) := singleton_mem_pure
-  rw [h] at this
+  rw [h] at this 
   exact (mem_singleton_iff.mp (mem_pure.mp this)).symm
 #align ultrafilter_pure_injective ultrafilter_pure_injective
 
@@ -346,7 +346,7 @@ theorem continuous_stoneCechUnit : Continuous (stoneCechUnit : α → StoneCech
     have : ↑(g.map pure) ≤ 𝓝 g := by rw [ultrafilter_converges_iff] <;> exact (bind_pure _).symm
     have : (g.map stoneCechUnit : Filter (StoneCech α)) ≤ 𝓝 ⟦g⟧ :=
       continuousAt_iff_ultrafilter.mp (continuous_quotient_mk'.Tendsto g) _ this
-    rwa [show ⟦g⟧ = ⟦pure x⟧ from Quotient.sound <| convergent_eqv_pure gx] at this
+    rwa [show ⟦g⟧ = ⟦pure x⟧ from Quotient.sound <| convergent_eqv_pure gx] at this 
 #align continuous_stone_cech_unit continuous_stoneCechUnit
 -/
 

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

@@ -27,7 +27,7 @@ noncomputable section
 
 open Filter Set
 
-open Topology
+open scoped Topology
 
 universe u v
 

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

@@ -76,12 +76,6 @@ theorem ultrafilter_isClosed_basic (s : Set α) : IsClosed { u : Ultrafilter α
 #align ultrafilter_is_closed_basic ultrafilter_isClosed_basic
 -/
 
-/- warning: ultrafilter_converges_iff -> ultrafilter_converges_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {u : Ultrafilter.{u1} (Ultrafilter.{u1} α)} {x : Ultrafilter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} (Ultrafilter.{u1} α)) (Preorder.toHasLe.{u1} (Filter.{u1} (Ultrafilter.{u1} α)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (Ultrafilter.{u1} α)) (Filter.partialOrder.{u1} (Ultrafilter.{u1} α)))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} (Ultrafilter.{u1} α)) (Filter.{u1} (Ultrafilter.{u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} (Ultrafilter.{u1} α)) (Filter.{u1} (Ultrafilter.{u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} (Ultrafilter.{u1} α)) (Filter.{u1} (Ultrafilter.{u1} α)) (Ultrafilter.Filter.hasCoeT.{u1} (Ultrafilter.{u1} α)))) u) (nhds.{u1} (Ultrafilter.{u1} α) (Ultrafilter.topologicalSpace.{u1} α) x)) (Eq.{succ u1} (Ultrafilter.{u1} α) x (joinM.{u1} Ultrafilter.{u1} Ultrafilter.monad.{u1} α u))
-but is expected to have type
-  forall {α : Type.{u1}} {u : Ultrafilter.{u1} (Ultrafilter.{u1} α)} {x : Ultrafilter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} (Ultrafilter.{u1} α)) (Preorder.toLE.{u1} (Filter.{u1} (Ultrafilter.{u1} α)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (Ultrafilter.{u1} α)) (Filter.instPartialOrderFilter.{u1} (Ultrafilter.{u1} α)))) (Ultrafilter.toFilter.{u1} (Ultrafilter.{u1} α) u) (nhds.{u1} (Ultrafilter.{u1} α) (Ultrafilter.topologicalSpace.{u1} α) x)) (Eq.{succ u1} (Ultrafilter.{u1} α) x (joinM.{u1} Ultrafilter.{u1} Ultrafilter.monad.{u1} α u))
-Case conversion may be inaccurate. Consider using '#align ultrafilter_converges_iff ultrafilter_converges_iffₓ'. -/
 /-- Every ultrafilter `u` on `ultrafilter α` converges to a unique
   point of `ultrafilter α`, namely `mjoin u`. -/
 theorem ultrafilter_converges_iff {u : Ultrafilter (Ultrafilter α)} {x : Ultrafilter α} :
@@ -124,12 +118,6 @@ instance : TotallyDisconnectedSpace (Ultrafilter α) :=
   have hZ : IsClopen Z := ⟨ultrafilter_isOpen_basic s, ultrafilter_isClosed_basic s⟩
   exact hB ⟨Z, hZ, hs⟩
 
-/- warning: ultrafilter_comap_pure_nhds -> ultrafilter_comap_pure_nhds is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (b : Ultrafilter.{u1} α), LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Filter.comap.{u1, u1} α (Ultrafilter.{u1} α) (Pure.pure.{u1, u1} Ultrafilter.{u1} Ultrafilter.hasPure.{u1} α) (nhds.{u1} (Ultrafilter.{u1} α) (Ultrafilter.topologicalSpace.{u1} α) b)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) b)
-but is expected to have type
-  forall {α : Type.{u1}} (b : Ultrafilter.{u1} α), LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (Filter.comap.{u1, u1} α (Ultrafilter.{u1} α) (Pure.pure.{u1, u1} Ultrafilter.{u1} Ultrafilter.instPureUltrafilter.{u1} α) (nhds.{u1} (Ultrafilter.{u1} α) (Ultrafilter.topologicalSpace.{u1} α) b)) (Ultrafilter.toFilter.{u1} α b)
-Case conversion may be inaccurate. Consider using '#align ultrafilter_comap_pure_nhds ultrafilter_comap_pure_nhdsₓ'. -/
 theorem ultrafilter_comap_pure_nhds (b : Ultrafilter α) : comap pure (𝓝 b) ≤ b :=
   by
   rw [TopologicalSpace.nhds_generateFrom]
@@ -143,12 +131,6 @@ theorem ultrafilter_comap_pure_nhds (b : Ultrafilter α) : comap pure (𝓝 b) 
 
 section Embedding
 
-/- warning: ultrafilter_pure_injective -> ultrafilter_pure_injective is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}}, Function.Injective.{succ u1, succ u1} α (Ultrafilter.{u1} α) (Pure.pure.{u1, u1} (fun {α : Type.{u1}} => Ultrafilter.{u1} α) Ultrafilter.hasPure.{u1} α)
-but is expected to have type
-  forall {α : Type.{u1}}, Function.Injective.{succ u1, succ u1} α (Ultrafilter.{u1} α) (Pure.pure.{u1, u1} Ultrafilter.{u1} Ultrafilter.instPureUltrafilter.{u1} α)
-Case conversion may be inaccurate. Consider using '#align ultrafilter_pure_injective ultrafilter_pure_injectiveₓ'. -/
 theorem ultrafilter_pure_injective : Function.Injective (pure : α → Ultrafilter α) :=
   by
   intro x y h
@@ -159,24 +141,12 @@ theorem ultrafilter_pure_injective : Function.Injective (pure : α → Ultrafilt
 
 open TopologicalSpace
 
-/- warning: dense_range_pure -> denseRange_pure is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}}, DenseRange.{u1, u1} (Ultrafilter.{u1} α) (Ultrafilter.topologicalSpace.{u1} α) α (Pure.pure.{u1, u1} (fun {α : Type.{u1}} => Ultrafilter.{u1} α) Ultrafilter.hasPure.{u1} α)
-but is expected to have type
-  forall {α : Type.{u1}}, DenseRange.{u1, u1} (Ultrafilter.{u1} α) (Ultrafilter.topologicalSpace.{u1} α) α (Pure.pure.{u1, u1} Ultrafilter.{u1} Ultrafilter.instPureUltrafilter.{u1} α)
-Case conversion may be inaccurate. Consider using '#align dense_range_pure denseRange_pureₓ'. -/
 /-- The range of `pure : α → ultrafilter α` is dense in `ultrafilter α`. -/
 theorem denseRange_pure : DenseRange (pure : α → Ultrafilter α) := fun x =>
   mem_closure_iff_ultrafilter.mpr
     ⟨x.map pure, range_mem_map, ultrafilter_converges_iff.mpr (bind_pure x).symm⟩
 #align dense_range_pure denseRange_pure
 
-/- warning: induced_topology_pure -> induced_topology_pure is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}}, Eq.{succ u1} (TopologicalSpace.{u1} α) (TopologicalSpace.induced.{u1, u1} α (Ultrafilter.{u1} α) (Pure.pure.{u1, u1} (fun {α : Type.{u1}} => Ultrafilter.{u1} α) Ultrafilter.hasPure.{u1} α) (Ultrafilter.topologicalSpace.{u1} α)) (Bot.bot.{u1} (TopologicalSpace.{u1} α) (CompleteLattice.toHasBot.{u1} (TopologicalSpace.{u1} α) (TopologicalSpace.completeLattice.{u1} α)))
-but is expected to have type
-  forall {α : Type.{u1}}, Eq.{succ u1} (TopologicalSpace.{u1} α) (TopologicalSpace.induced.{u1, u1} α (Ultrafilter.{u1} α) (Pure.pure.{u1, u1} Ultrafilter.{u1} Ultrafilter.instPureUltrafilter.{u1} α) (Ultrafilter.topologicalSpace.{u1} α)) (Bot.bot.{u1} (TopologicalSpace.{u1} α) (CompleteLattice.toBot.{u1} (TopologicalSpace.{u1} α) (TopologicalSpace.instCompleteLatticeTopologicalSpace.{u1} α)))
-Case conversion may be inaccurate. Consider using '#align induced_topology_pure induced_topology_pureₓ'. -/
 /-- The map `pure : α → ultra_filter α` induces on `α` the discrete topology. -/
 theorem induced_topology_pure :
     TopologicalSpace.induced (pure : α → Ultrafilter α) Ultrafilter.topologicalSpace = ⊥ :=
@@ -187,24 +157,12 @@ theorem induced_topology_pure :
   simp
 #align induced_topology_pure induced_topology_pure
 
-/- warning: dense_inducing_pure -> denseInducing_pure is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}}, DenseInducing.{u1, u1} α (Ultrafilter.{u1} α) (Bot.bot.{u1} (TopologicalSpace.{u1} α) (CompleteLattice.toHasBot.{u1} (TopologicalSpace.{u1} α) (TopologicalSpace.completeLattice.{u1} α))) (Ultrafilter.topologicalSpace.{u1} α) (Pure.pure.{u1, u1} (fun {α : Type.{u1}} => Ultrafilter.{u1} α) Ultrafilter.hasPure.{u1} α)
-but is expected to have type
-  forall {α : Type.{u1}}, DenseInducing.{u1, u1} α (Ultrafilter.{u1} α) (Bot.bot.{u1} (TopologicalSpace.{u1} α) (CompleteLattice.toBot.{u1} (TopologicalSpace.{u1} α) (TopologicalSpace.instCompleteLatticeTopologicalSpace.{u1} α))) (Ultrafilter.topologicalSpace.{u1} α) (Pure.pure.{u1, u1} Ultrafilter.{u1} Ultrafilter.instPureUltrafilter.{u1} α)
-Case conversion may be inaccurate. Consider using '#align dense_inducing_pure denseInducing_pureₓ'. -/
 /-- `pure : α → ultrafilter α` defines a dense inducing of `α` in `ultrafilter α`. -/
 theorem denseInducing_pure : @DenseInducing _ _ ⊥ _ (pure : α → Ultrafilter α) :=
   letI : TopologicalSpace α := ⊥
   ⟨⟨induced_topology_pure.symm⟩, denseRange_pure⟩
 #align dense_inducing_pure denseInducing_pure
 
-/- warning: dense_embedding_pure -> denseEmbedding_pure is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}}, DenseEmbedding.{u1, u1} α (Ultrafilter.{u1} α) (Bot.bot.{u1} (TopologicalSpace.{u1} α) (CompleteLattice.toHasBot.{u1} (TopologicalSpace.{u1} α) (TopologicalSpace.completeLattice.{u1} α))) (Ultrafilter.topologicalSpace.{u1} α) (Pure.pure.{u1, u1} (fun {α : Type.{u1}} => Ultrafilter.{u1} α) Ultrafilter.hasPure.{u1} α)
-but is expected to have type
-  forall {α : Type.{u1}}, DenseEmbedding.{u1, u1} α (Ultrafilter.{u1} α) (Bot.bot.{u1} (TopologicalSpace.{u1} α) (CompleteLattice.toBot.{u1} (TopologicalSpace.{u1} α) (TopologicalSpace.instCompleteLatticeTopologicalSpace.{u1} α))) (Ultrafilter.topologicalSpace.{u1} α) (Pure.pure.{u1, u1} Ultrafilter.{u1} Ultrafilter.instPureUltrafilter.{u1} α)
-Case conversion may be inaccurate. Consider using '#align dense_embedding_pure denseEmbedding_pureₓ'. -/
 -- The following refined version will never be used
 /-- `pure : α → ultrafilter α` defines a dense embedding of `α` in `ultrafilter α`. -/
 theorem denseEmbedding_pure : @DenseEmbedding _ _ ⊥ _ (pure : α → Ultrafilter α) :=
@@ -234,12 +192,6 @@ def Ultrafilter.extend (f : α → γ) : Ultrafilter α → γ :=
 
 variable [T2Space γ]
 
-/- warning: ultrafilter_extend_extends -> ultrafilter_extend_extends is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {γ : Type.{u2}} [_inst_1 : TopologicalSpace.{u2} γ] [_inst_2 : T2Space.{u2} γ _inst_1] (f : α -> γ), Eq.{max (succ u1) (succ u2)} (α -> γ) (Function.comp.{succ u1, succ u1, succ u2} α (Ultrafilter.{u1} α) γ (Ultrafilter.extend.{u1, u2} α γ _inst_1 f) (Pure.pure.{u1, u1} Ultrafilter.{u1} Ultrafilter.hasPure.{u1} α)) f
-but is expected to have type
-  forall {α : Type.{u2}} {γ : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} γ] [_inst_2 : T2Space.{u1} γ _inst_1] (f : α -> γ), Eq.{max (succ u2) (succ u1)} (α -> γ) (Function.comp.{succ u2, succ u2, succ u1} α (Ultrafilter.{u2} α) γ (Ultrafilter.extend.{u2, u1} α γ _inst_1 f) (Pure.pure.{u2, u2} Ultrafilter.{u2} Ultrafilter.instPureUltrafilter.{u2} α)) f
-Case conversion may be inaccurate. Consider using '#align ultrafilter_extend_extends ultrafilter_extend_extendsₓ'. -/
 theorem ultrafilter_extend_extends (f : α → γ) : Ultrafilter.extend f ∘ pure = f :=
   by
   letI : TopologicalSpace α := ⊥
@@ -249,12 +201,6 @@ theorem ultrafilter_extend_extends (f : α → γ) : Ultrafilter.extend f ∘ pu
 
 variable [CompactSpace γ]
 
-/- warning: continuous_ultrafilter_extend -> continuous_ultrafilter_extend is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {γ : Type.{u2}} [_inst_1 : TopologicalSpace.{u2} γ] [_inst_2 : T2Space.{u2} γ _inst_1] [_inst_3 : CompactSpace.{u2} γ _inst_1] (f : α -> γ), Continuous.{u1, u2} (Ultrafilter.{u1} α) γ (Ultrafilter.topologicalSpace.{u1} α) _inst_1 (Ultrafilter.extend.{u1, u2} α γ _inst_1 f)
-but is expected to have type
-  forall {α : Type.{u2}} {γ : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} γ] [_inst_2 : T2Space.{u1} γ _inst_1] [_inst_3 : CompactSpace.{u1} γ _inst_1] (f : α -> γ), Continuous.{u2, u1} (Ultrafilter.{u2} α) γ (Ultrafilter.topologicalSpace.{u2} α) _inst_1 (Ultrafilter.extend.{u2, u1} α γ _inst_1 f)
-Case conversion may be inaccurate. Consider using '#align continuous_ultrafilter_extend continuous_ultrafilter_extendₓ'. -/
 theorem continuous_ultrafilter_extend (f : α → γ) : Continuous (Ultrafilter.extend f) :=
   by
   have : ∀ b : Ultrafilter α, ∃ c, Tendsto f (comap pure (𝓝 b)) (𝓝 c) := fun b =>
@@ -267,12 +213,6 @@ theorem continuous_ultrafilter_extend (f : α → γ) : Continuous (Ultrafilter.
   exact dense_inducing_pure.continuous_extend this
 #align continuous_ultrafilter_extend continuous_ultrafilter_extend
 
-/- warning: ultrafilter_extend_eq_iff -> ultrafilter_extend_eq_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {γ : Type.{u2}} [_inst_1 : TopologicalSpace.{u2} γ] [_inst_2 : T2Space.{u2} γ _inst_1] [_inst_3 : CompactSpace.{u2} γ _inst_1] {f : α -> γ} {b : Ultrafilter.{u1} α} {c : γ}, Iff (Eq.{succ u2} γ (Ultrafilter.extend.{u1, u2} α γ _inst_1 f b) c) (LE.le.{u2} (Filter.{u2} γ) (Preorder.toHasLe.{u2} (Filter.{u2} γ) (PartialOrder.toPreorder.{u2} (Filter.{u2} γ) (Filter.partialOrder.{u2} γ))) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Ultrafilter.{u2} γ) (Filter.{u2} γ) (HasLiftT.mk.{succ u2, succ u2} (Ultrafilter.{u2} γ) (Filter.{u2} γ) (CoeTCₓ.coe.{succ u2, succ u2} (Ultrafilter.{u2} γ) (Filter.{u2} γ) (Ultrafilter.Filter.hasCoeT.{u2} γ))) (Ultrafilter.map.{u1, u2} α γ f b)) (nhds.{u2} γ _inst_1 c))
-but is expected to have type
-  forall {α : Type.{u2}} {γ : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} γ] [_inst_2 : T2Space.{u1} γ _inst_1] [_inst_3 : CompactSpace.{u1} γ _inst_1] {f : α -> γ} {b : Ultrafilter.{u2} α} {c : γ}, Iff (Eq.{succ u1} γ (Ultrafilter.extend.{u2, u1} α γ _inst_1 f b) c) (LE.le.{u1} (Filter.{u1} γ) (Preorder.toLE.{u1} (Filter.{u1} γ) (PartialOrder.toPreorder.{u1} (Filter.{u1} γ) (Filter.instPartialOrderFilter.{u1} γ))) (Ultrafilter.toFilter.{u1} γ (Ultrafilter.map.{u2, u1} α γ f b)) (nhds.{u1} γ _inst_1 c))
-Case conversion may be inaccurate. Consider using '#align ultrafilter_extend_eq_iff ultrafilter_extend_eq_iffₓ'. -/
 /-- The value of `ultrafilter.extend f` on an ultrafilter `b` is the
   unique limit of the ultrafilter `b.map f` in `γ`. -/
 theorem ultrafilter_extend_eq_iff {f : α → γ} {b : Ultrafilter α} {c : γ} :
@@ -391,12 +331,6 @@ theorem stoneCech_hom_ext {g₁ g₂ : StoneCech α → γ'} (h₁ : Continuous
 
 end Extension
 
-/- warning: convergent_eqv_pure -> convergent_eqv_pure is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {u : Ultrafilter.{u1} α} {x : α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) u) (nhds.{u1} α _inst_1 x)) -> (HasEquivₓ.Equiv.{succ u1} (Ultrafilter.{u1} α) (setoidHasEquiv.{succ u1} (Ultrafilter.{u1} α) (stoneCechSetoid.{u1} α _inst_1)) u (Pure.pure.{u1, u1} Ultrafilter.{u1} Ultrafilter.hasPure.{u1} α x))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {u : Ultrafilter.{u1} α} {x : α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (Ultrafilter.toFilter.{u1} α u) (nhds.{u1} α _inst_1 x)) -> (HasEquiv.Equiv.{succ u1, 0} (Ultrafilter.{u1} α) (instHasEquiv.{succ u1} (Ultrafilter.{u1} α) (stoneCechSetoid.{u1} α _inst_1)) u (Pure.pure.{u1, u1} Ultrafilter.{u1} Ultrafilter.instPureUltrafilter.{u1} α x))
-Case conversion may be inaccurate. Consider using '#align convergent_eqv_pure convergent_eqv_pureₓ'. -/
 theorem convergent_eqv_pure {u : Ultrafilter α} {x : α} (ux : ↑u ≤ 𝓝 x) : u ≈ pure x :=
   fun γ tγ h₁ h₂ f hf => by
   skip

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

@@ -91,10 +91,8 @@ theorem ultrafilter_converges_iff {u : Ultrafilter (Ultrafilter α)} {x : Ultraf
   simp only [TopologicalSpace.nhds_generateFrom, le_iInf_iff, ultrafilterBasis, le_principal_iff,
     mem_set_of_eq]
   constructor
-  · intro h a ha
-    exact h _ ⟨ha, a, rfl⟩
-  · rintro h a ⟨xi, a, rfl⟩
-    exact h _ xi
+  · intro h a ha; exact h _ ⟨ha, a, rfl⟩
+  · rintro h a ⟨xi, a, rfl⟩; exact h _ xi
 #align ultrafilter_converges_iff ultrafilter_converges_iff
 
 #print ultrafilter_compact /-

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

@@ -78,7 +78,7 @@ theorem ultrafilter_isClosed_basic (s : Set α) : IsClosed { u : Ultrafilter α
 
 /- warning: ultrafilter_converges_iff -> ultrafilter_converges_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {u : Ultrafilter.{u1} (Ultrafilter.{u1} α)} {x : Ultrafilter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} (Ultrafilter.{u1} α)) (Preorder.toLE.{u1} (Filter.{u1} (Ultrafilter.{u1} α)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (Ultrafilter.{u1} α)) (Filter.partialOrder.{u1} (Ultrafilter.{u1} α)))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} (Ultrafilter.{u1} α)) (Filter.{u1} (Ultrafilter.{u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} (Ultrafilter.{u1} α)) (Filter.{u1} (Ultrafilter.{u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} (Ultrafilter.{u1} α)) (Filter.{u1} (Ultrafilter.{u1} α)) (Ultrafilter.Filter.hasCoeT.{u1} (Ultrafilter.{u1} α)))) u) (nhds.{u1} (Ultrafilter.{u1} α) (Ultrafilter.topologicalSpace.{u1} α) x)) (Eq.{succ u1} (Ultrafilter.{u1} α) x (joinM.{u1} Ultrafilter.{u1} Ultrafilter.monad.{u1} α u))
+  forall {α : Type.{u1}} {u : Ultrafilter.{u1} (Ultrafilter.{u1} α)} {x : Ultrafilter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} (Ultrafilter.{u1} α)) (Preorder.toHasLe.{u1} (Filter.{u1} (Ultrafilter.{u1} α)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (Ultrafilter.{u1} α)) (Filter.partialOrder.{u1} (Ultrafilter.{u1} α)))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} (Ultrafilter.{u1} α)) (Filter.{u1} (Ultrafilter.{u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} (Ultrafilter.{u1} α)) (Filter.{u1} (Ultrafilter.{u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} (Ultrafilter.{u1} α)) (Filter.{u1} (Ultrafilter.{u1} α)) (Ultrafilter.Filter.hasCoeT.{u1} (Ultrafilter.{u1} α)))) u) (nhds.{u1} (Ultrafilter.{u1} α) (Ultrafilter.topologicalSpace.{u1} α) x)) (Eq.{succ u1} (Ultrafilter.{u1} α) x (joinM.{u1} Ultrafilter.{u1} Ultrafilter.monad.{u1} α u))
 but is expected to have type
   forall {α : Type.{u1}} {u : Ultrafilter.{u1} (Ultrafilter.{u1} α)} {x : Ultrafilter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} (Ultrafilter.{u1} α)) (Preorder.toLE.{u1} (Filter.{u1} (Ultrafilter.{u1} α)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (Ultrafilter.{u1} α)) (Filter.instPartialOrderFilter.{u1} (Ultrafilter.{u1} α)))) (Ultrafilter.toFilter.{u1} (Ultrafilter.{u1} α) u) (nhds.{u1} (Ultrafilter.{u1} α) (Ultrafilter.topologicalSpace.{u1} α) x)) (Eq.{succ u1} (Ultrafilter.{u1} α) x (joinM.{u1} Ultrafilter.{u1} Ultrafilter.monad.{u1} α u))
 Case conversion may be inaccurate. Consider using '#align ultrafilter_converges_iff ultrafilter_converges_iffₓ'. -/
@@ -128,7 +128,7 @@ instance : TotallyDisconnectedSpace (Ultrafilter α) :=
 
 /- warning: ultrafilter_comap_pure_nhds -> ultrafilter_comap_pure_nhds is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} (b : Ultrafilter.{u1} α), LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Filter.comap.{u1, u1} α (Ultrafilter.{u1} α) (Pure.pure.{u1, u1} Ultrafilter.{u1} Ultrafilter.hasPure.{u1} α) (nhds.{u1} (Ultrafilter.{u1} α) (Ultrafilter.topologicalSpace.{u1} α) b)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) b)
+  forall {α : Type.{u1}} (b : Ultrafilter.{u1} α), LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Filter.comap.{u1, u1} α (Ultrafilter.{u1} α) (Pure.pure.{u1, u1} Ultrafilter.{u1} Ultrafilter.hasPure.{u1} α) (nhds.{u1} (Ultrafilter.{u1} α) (Ultrafilter.topologicalSpace.{u1} α) b)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) b)
 but is expected to have type
   forall {α : Type.{u1}} (b : Ultrafilter.{u1} α), LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (Filter.comap.{u1, u1} α (Ultrafilter.{u1} α) (Pure.pure.{u1, u1} Ultrafilter.{u1} Ultrafilter.instPureUltrafilter.{u1} α) (nhds.{u1} (Ultrafilter.{u1} α) (Ultrafilter.topologicalSpace.{u1} α) b)) (Ultrafilter.toFilter.{u1} α b)
 Case conversion may be inaccurate. Consider using '#align ultrafilter_comap_pure_nhds ultrafilter_comap_pure_nhdsₓ'. -/
@@ -271,7 +271,7 @@ theorem continuous_ultrafilter_extend (f : α → γ) : Continuous (Ultrafilter.
 
 /- warning: ultrafilter_extend_eq_iff -> ultrafilter_extend_eq_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {γ : Type.{u2}} [_inst_1 : TopologicalSpace.{u2} γ] [_inst_2 : T2Space.{u2} γ _inst_1] [_inst_3 : CompactSpace.{u2} γ _inst_1] {f : α -> γ} {b : Ultrafilter.{u1} α} {c : γ}, Iff (Eq.{succ u2} γ (Ultrafilter.extend.{u1, u2} α γ _inst_1 f b) c) (LE.le.{u2} (Filter.{u2} γ) (Preorder.toLE.{u2} (Filter.{u2} γ) (PartialOrder.toPreorder.{u2} (Filter.{u2} γ) (Filter.partialOrder.{u2} γ))) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Ultrafilter.{u2} γ) (Filter.{u2} γ) (HasLiftT.mk.{succ u2, succ u2} (Ultrafilter.{u2} γ) (Filter.{u2} γ) (CoeTCₓ.coe.{succ u2, succ u2} (Ultrafilter.{u2} γ) (Filter.{u2} γ) (Ultrafilter.Filter.hasCoeT.{u2} γ))) (Ultrafilter.map.{u1, u2} α γ f b)) (nhds.{u2} γ _inst_1 c))
+  forall {α : Type.{u1}} {γ : Type.{u2}} [_inst_1 : TopologicalSpace.{u2} γ] [_inst_2 : T2Space.{u2} γ _inst_1] [_inst_3 : CompactSpace.{u2} γ _inst_1] {f : α -> γ} {b : Ultrafilter.{u1} α} {c : γ}, Iff (Eq.{succ u2} γ (Ultrafilter.extend.{u1, u2} α γ _inst_1 f b) c) (LE.le.{u2} (Filter.{u2} γ) (Preorder.toHasLe.{u2} (Filter.{u2} γ) (PartialOrder.toPreorder.{u2} (Filter.{u2} γ) (Filter.partialOrder.{u2} γ))) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Ultrafilter.{u2} γ) (Filter.{u2} γ) (HasLiftT.mk.{succ u2, succ u2} (Ultrafilter.{u2} γ) (Filter.{u2} γ) (CoeTCₓ.coe.{succ u2, succ u2} (Ultrafilter.{u2} γ) (Filter.{u2} γ) (Ultrafilter.Filter.hasCoeT.{u2} γ))) (Ultrafilter.map.{u1, u2} α γ f b)) (nhds.{u2} γ _inst_1 c))
 but is expected to have type
   forall {α : Type.{u2}} {γ : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} γ] [_inst_2 : T2Space.{u1} γ _inst_1] [_inst_3 : CompactSpace.{u1} γ _inst_1] {f : α -> γ} {b : Ultrafilter.{u2} α} {c : γ}, Iff (Eq.{succ u1} γ (Ultrafilter.extend.{u2, u1} α γ _inst_1 f b) c) (LE.le.{u1} (Filter.{u1} γ) (Preorder.toLE.{u1} (Filter.{u1} γ) (PartialOrder.toPreorder.{u1} (Filter.{u1} γ) (Filter.instPartialOrderFilter.{u1} γ))) (Ultrafilter.toFilter.{u1} γ (Ultrafilter.map.{u2, u1} α γ f b)) (nhds.{u1} γ _inst_1 c))
 Case conversion may be inaccurate. Consider using '#align ultrafilter_extend_eq_iff ultrafilter_extend_eq_iffₓ'. -/
@@ -395,7 +395,7 @@ end Extension
 
 /- warning: convergent_eqv_pure -> convergent_eqv_pure is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {u : Ultrafilter.{u1} α} {x : α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) u) (nhds.{u1} α _inst_1 x)) -> (HasEquivₓ.Equiv.{succ u1} (Ultrafilter.{u1} α) (setoidHasEquiv.{succ u1} (Ultrafilter.{u1} α) (stoneCechSetoid.{u1} α _inst_1)) u (Pure.pure.{u1, u1} Ultrafilter.{u1} Ultrafilter.hasPure.{u1} α x))
+  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {u : Ultrafilter.{u1} α} {x : α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) u) (nhds.{u1} α _inst_1 x)) -> (HasEquivₓ.Equiv.{succ u1} (Ultrafilter.{u1} α) (setoidHasEquiv.{succ u1} (Ultrafilter.{u1} α) (stoneCechSetoid.{u1} α _inst_1)) u (Pure.pure.{u1, u1} Ultrafilter.{u1} Ultrafilter.hasPure.{u1} α x))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {u : Ultrafilter.{u1} α} {x : α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (Ultrafilter.toFilter.{u1} α u) (nhds.{u1} α _inst_1 x)) -> (HasEquiv.Equiv.{succ u1, 0} (Ultrafilter.{u1} α) (instHasEquiv.{succ u1} (Ultrafilter.{u1} α) (stoneCechSetoid.{u1} α _inst_1)) u (Pure.pure.{u1, u1} Ultrafilter.{u1} Ultrafilter.instPureUltrafilter.{u1} α x))
 Case conversion may be inaccurate. Consider using '#align convergent_eqv_pure convergent_eqv_pureₓ'. -/

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

@@ -53,7 +53,7 @@ theorem ultrafilterBasis_is_basis : TopologicalSpace.IsTopologicalBasis (ultrafi
     rintro _ ⟨a, rfl⟩ _ ⟨b, rfl⟩ u ⟨ua, ub⟩
     refine' ⟨_, ⟨a ∩ b, rfl⟩, inter_mem ua ub, fun v hv => ⟨_, _⟩⟩ <;> apply mem_of_superset hv <;>
       simp [inter_subset_right a b],
-    eq_univ_of_univ_subset <| subset_unionₛ_of_mem <| ⟨univ, eq_univ_of_forall fun u => univ_mem⟩,
+    eq_univ_of_univ_subset <| subset_sUnion_of_mem <| ⟨univ, eq_univ_of_forall fun u => univ_mem⟩,
     rfl⟩
 #align ultrafilter_basis_is_basis ultrafilterBasis_is_basis
 -/
@@ -88,7 +88,7 @@ theorem ultrafilter_converges_iff {u : Ultrafilter (Ultrafilter α)} {x : Ultraf
     ↑u ≤ 𝓝 x ↔ x = joinM u := by
   rw [eq_comm, ← Ultrafilter.coe_le_coe]
   change ↑u ≤ 𝓝 x ↔ ∀ s ∈ x, { v : Ultrafilter α | s ∈ v } ∈ u
-  simp only [TopologicalSpace.nhds_generateFrom, le_infᵢ_iff, ultrafilterBasis, le_principal_iff,
+  simp only [TopologicalSpace.nhds_generateFrom, le_iInf_iff, ultrafilterBasis, le_principal_iff,
     mem_set_of_eq]
   constructor
   · intro h a ha
@@ -121,7 +121,7 @@ instance : TotallyDisconnectedSpace (Ultrafilter α) :=
   intro B hB
   rw [← Ultrafilter.coe_le_coe]
   intro s hs
-  rw [connectedComponent_eq_interᵢ_clopen, Set.mem_interᵢ] at hB
+  rw [connectedComponent_eq_iInter_clopen, Set.mem_iInter] at hB
   let Z := { F : Ultrafilter α | s ∈ F }
   have hZ : IsClopen Z := ⟨ultrafilter_isOpen_basic s, ultrafilter_isClosed_basic s⟩
   exact hB ⟨Z, hZ, hs⟩
@@ -138,8 +138,8 @@ theorem ultrafilter_comap_pure_nhds (b : Ultrafilter α) : comap pure (𝓝 b) 
   simp only [comap_infi, comap_principal]
   intro s hs
   rw [← le_principal_iff]
-  refine' infᵢ_le_of_le { u | s ∈ u } _
-  refine' infᵢ_le_of_le ⟨hs, ⟨s, rfl⟩⟩ _
+  refine' iInf_le_of_le { u | s ∈ u } _
+  refine' iInf_le_of_le ⟨hs, ⟨s, rfl⟩⟩ _
   exact principal_mono.2 fun a => id
 #align ultrafilter_comap_pure_nhds ultrafilter_comap_pure_nhds
 

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

A PR analogous to #12338 and #12361: reformatting proofs following the multiple goals linter of #12339.

@@ -295,7 +295,7 @@ end Extension
 
 theorem convergent_eqv_pure {u : Ultrafilter α} {x : α} (ux : ↑u ≤ 𝓝 x) : u ≈ pure x :=
   fun γ tγ h₁ h₂ f hf => by
-  trans f x; swap; symm
+  trans f x; swap; on_goal 1 => symm
   all_goals refine' ultrafilter_extend_eq_iff.mpr (le_trans (map_mono _) (hf.tendsto _))
   · apply pure_le_nhds
   · exact ux

Empty lines were removed by executing the following Python script twice

import os
import re


# Loop through each file in the repository
for dir_path, dirs, files in os.walk('.'):
  for filename in files:
    if filename.endswith('.lean'):
      file_path = os.path.join(dir_path, filename)

      # Open the file and read its contents
      with open(file_path, 'r') as file:
        content = file.read()

      # Use a regular expression to replace sequences of "variable" lines separated by empty lines
      # with sequences without empty lines
      modified_content = re.sub(r'(variable.*\n)\n(variable(?! .* in))', r'\1\2', content)

      # Write the modified content back to the file
      with open(file_path, 'w') as file:
        file.write(modified_content)

@@ -264,9 +264,7 @@ theorem denseRange_stoneCechUnit : DenseRange (stoneCechUnit : α → StoneCech
 section Extension
 
 variable {γ : Type u} [TopologicalSpace γ] [T2Space γ] [CompactSpace γ]
-
 variable {γ' : Type u} [TopologicalSpace γ'] [T2Space γ']
-
 variable {f : α → γ} (hf : Continuous f)
 
 -- Porting note: missing attribute

The removal of some pointless tactics flagged by #11308.

@@ -297,7 +297,6 @@ end Extension
 
 theorem convergent_eqv_pure {u : Ultrafilter α} {x : α} (ux : ↑u ≤ 𝓝 x) : u ≈ pure x :=
   fun γ tγ h₁ h₂ f hf => by
-  skip
   trans f x; swap; symm
   all_goals refine' ultrafilter_extend_eq_iff.mpr (le_trans (map_mono _) (hf.tendsto _))
   · apply pure_le_nhds
@@ -319,7 +318,6 @@ instance StoneCech.t2Space : T2Space (StoneCech α) := by
   rintro ⟨x⟩ ⟨y⟩ g gx gy
   apply Quotient.sound
   intro γ tγ h₁ h₂ f hf
-  skip
   let ff := stoneCechExtend hf
   change ff ⟦x⟧ = ff ⟦y⟧
   have lim := fun (z : Ultrafilter α) (gz : (g : Filter (StoneCech α)) ≤ 𝓝 ⟦z⟧) =>

This cleans up instances of

⟨ foo, bar⟩

and

⟨foo, bar ⟩

where spaces a on the inside one side, but not on the other side. Fixing this by removing the extra space.

Co-authored-by: Moritz Firsching <firsching@google.com>

@@ -98,7 +98,7 @@ instance : TotallyDisconnectedSpace (Ultrafilter α) := by
   intro s hs
   rw [connectedComponent_eq_iInter_isClopen, Set.mem_iInter] at hB
   let Z := { F : Ultrafilter α | s ∈ F }
-  have hZ : IsClopen Z := ⟨ ultrafilter_isClosed_basic s, ultrafilter_isOpen_basic s⟩
+  have hZ : IsClopen Z := ⟨ultrafilter_isClosed_basic s, ultrafilter_isOpen_basic s⟩
   exact hB ⟨Z, hZ, hs⟩
 
 @[simp] theorem Ultrafilter.tendsto_pure_self (b : Ultrafilter α) : Tendsto pure b (𝓝 b) := by

Co-authored-by: Moritz Firsching <firsching@google.com>

@@ -98,7 +98,7 @@ instance : TotallyDisconnectedSpace (Ultrafilter α) := by
   intro s hs
   rw [connectedComponent_eq_iInter_isClopen, Set.mem_iInter] at hB
   let Z := { F : Ultrafilter α | s ∈ F }
-  have hZ : IsClopen Z := ⟨ultrafilter_isOpen_basic s, ultrafilter_isClosed_basic s⟩
+  have hZ : IsClopen Z := ⟨ ultrafilter_isClosed_basic s, ultrafilter_isOpen_basic s⟩
   exact hB ⟨Z, hZ, hs⟩
 
 @[simp] theorem Ultrafilter.tendsto_pure_self (b : Ultrafilter α) : Tendsto pure b (𝓝 b) := by

This PR renames the field Clopens.clopen' -> Clopens.isClopen', and the lemmas

• preimage_closed_of_closed -> ContinuousOn.preimage_isClosed_of_isClosed

as well as: ClopenUpperSet.clopen -> ClopenUpperSet.isClopen connectedComponent_eq_iInter_clopen -> connectedComponent_eq_iInter_isClopen connectedComponent_subset_iInter_clopen -> connectedComponent_subset_iInter_isClopen continuous_boolIndicator_iff_clopen -> continuous_boolIndicator_iff_isClopen continuousOn_boolIndicator_iff_clopen -> continuousOn_boolIndicator_iff_isClopen DiscreteQuotient.ofClopen -> DiscreteQuotient.ofIsClopen disjoint_or_subset_of_clopen -> disjoint_or_subset_of_isClopen exists_clopen_{lower,upper}of_not_le -> exists_isClopen{lower,upper}_of_not_le exists_clopen_of_cofiltered -> exists_isClopen_of_cofiltered exists_clopen_of_totally_separated -> exists_isClopen_of_totally_separated exists_clopen_upper_or_lower_of_ne -> exists_isClopen_upper_or_lower_of_ne IsPreconnected.subset_clopen -> IsPreconnected.subset_isClopen isTotallyDisconnected_of_clopen_set -> isTotallyDisconnected_of_isClopen_set LocallyConstant.ofClopen_fiber_one -> LocallyConstant.ofIsClopen_fiber_one LocallyConstant.ofClopen_fiber_zero -> LocallyConstant.ofIsClopen_fiber_zero LocallyConstant.ofClopen -> LocallyConstant.ofIsClopen preimage_clopen_of_clopen -> preimage_isClopen_of_isClopen TopologicalSpace.Clopens.clopen -> TopologicalSpace.Clopens.isClopen

@@ -96,7 +96,7 @@ instance : TotallyDisconnectedSpace (Ultrafilter α) := by
   intro B hB
   rw [← Ultrafilter.coe_le_coe]
   intro s hs
-  rw [connectedComponent_eq_iInter_clopen, Set.mem_iInter] at hB
+  rw [connectedComponent_eq_iInter_isClopen, Set.mem_iInter] at hB
   let Z := { F : Ultrafilter α | s ∈ F }
   have hZ : IsClopen Z := ⟨ultrafilter_isOpen_basic s, ultrafilter_isClosed_basic s⟩
   exact hB ⟨Z, hZ, hs⟩

• Rename NormalSpace to T4Space.
• Add NormalSpace, a version without the T1Space assumption.
• Adjust some theorems.
• Supersedes thus closes #6892.
• Add some instance cycles, see #2030

@@ -191,7 +191,6 @@ theorem continuous_ultrafilter_extend (f : α → γ) : Continuous (Ultrafilter.
       isCompact_univ.ultrafilter_le_nhds (b.map f) (by rw [le_principal_iff]; exact univ_mem)
     ⟨c, le_trans (map_mono (ultrafilter_comap_pure_nhds _)) h'⟩
   letI : TopologicalSpace α := ⊥
-  haveI : NormalSpace γ := normalOfCompactT2
   exact denseInducing_pure.continuous_extend h
 #align continuous_ultrafilter_extend continuous_ultrafilter_extend
 

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

This has nice performance benefits.

@@ -165,7 +165,7 @@ section Extension
   already know it must be unique because `α → Ultrafilter α` is a
   dense embedding and `γ` is Hausdorff. For existence, we will invoke
   `DenseInducing.continuous_extend`. -/
-variable {γ : Type _} [TopologicalSpace γ]
+variable {γ : Type*} [TopologicalSpace γ]
 
 /-- The extension of a function `α → γ` to a function `Ultrafilter α → γ`.
   When `γ` is a compact Hausdorff space it will be continuous. -/

@@ -101,6 +101,12 @@ instance : TotallyDisconnectedSpace (Ultrafilter α) := by
   have hZ : IsClopen Z := ⟨ultrafilter_isOpen_basic s, ultrafilter_isClosed_basic s⟩
   exact hB ⟨Z, hZ, hs⟩
 
+@[simp] theorem Ultrafilter.tendsto_pure_self (b : Ultrafilter α) : Tendsto pure b (𝓝 b) := by
+  rw [Tendsto, ← coe_map, ultrafilter_converges_iff]
+  ext s
+  change s ∈ b ↔ {t | s ∈ t} ∈ map pure b
+  simp_rw [mem_map, preimage_setOf_eq, mem_pure, setOf_mem_eq]
+
 theorem ultrafilter_comap_pure_nhds (b : Ultrafilter α) : comap pure (𝓝 b) ≤ b := by
   rw [TopologicalSpace.nhds_generateFrom]
   simp only [comap_iInf, comap_principal]

• depends on: #5966

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

@@ -2,15 +2,12 @@
 Copyright (c) 2018 Reid Barton. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Reid Barton
-
-! This file was ported from Lean 3 source module topology.stone_cech
-! 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.Bases
 import Mathlib.Topology.DenseEmbedding
 
+#align_import topology.stone_cech from "leanprover-community/mathlib"@"0a0ec35061ed9960bf0e7ffb0335f44447b58977"
+
 /-! # Stone-Čech compactification
 
 Construction of the Stone-Čech compactification using ultrafilters.

Co-authored-by: Yury G. Kudryashov <urkud@urkud.name>

@@ -60,7 +60,7 @@ theorem ultrafilter_isOpen_basic (s : Set α) : IsOpen { u : Ultrafilter α | s
 /-- The basic open sets for the topology on ultrafilters are also closed. -/
 theorem ultrafilter_isClosed_basic (s : Set α) : IsClosed { u : Ultrafilter α | s ∈ u } := by
   rw [← isOpen_compl_iff]
-  convert ultrafilter_isOpen_basic (sᶜ) using 1
+  convert ultrafilter_isOpen_basic sᶜ using 1
   ext u
   exact Ultrafilter.compl_mem_iff_not_mem.symm
 #align ultrafilter_is_closed_basic ultrafilter_isClosed_basic

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>

@@ -48,7 +48,7 @@ theorem ultrafilterBasis_is_basis : TopologicalSpace.IsTopologicalBasis (ultrafi
     rintro _ ⟨a, rfl⟩ _ ⟨b, rfl⟩ u ⟨ua, ub⟩
     refine' ⟨_, ⟨a ∩ b, rfl⟩, inter_mem ua ub, fun v hv => ⟨_, _⟩⟩ <;> apply mem_of_superset hv <;>
       simp [inter_subset_right a b],
-    eq_univ_of_univ_subset <| subset_unionₛ_of_mem <| ⟨univ, eq_univ_of_forall fun u => univ_mem⟩,
+    eq_univ_of_univ_subset <| subset_sUnion_of_mem <| ⟨univ, eq_univ_of_forall fun u => univ_mem⟩,
     rfl⟩
 #align ultrafilter_basis_is_basis ultrafilterBasis_is_basis
 
@@ -71,7 +71,7 @@ theorem ultrafilter_converges_iff {u : Ultrafilter (Ultrafilter α)} {x : Ultraf
     ↑u ≤ 𝓝 x ↔ x = joinM u := by
   rw [eq_comm, ← Ultrafilter.coe_le_coe]
   change ↑u ≤ 𝓝 x ↔ ∀ s ∈ x, { v : Ultrafilter α | s ∈ v } ∈ u
-  simp only [TopologicalSpace.nhds_generateFrom, le_infᵢ_iff, ultrafilterBasis, le_principal_iff,
+  simp only [TopologicalSpace.nhds_generateFrom, le_iInf_iff, ultrafilterBasis, le_principal_iff,
     mem_setOf_eq]
   constructor
   · intro h a ha
@@ -99,18 +99,18 @@ instance : TotallyDisconnectedSpace (Ultrafilter α) := by
   intro B hB
   rw [← Ultrafilter.coe_le_coe]
   intro s hs
-  rw [connectedComponent_eq_interᵢ_clopen, Set.mem_interᵢ] at hB
+  rw [connectedComponent_eq_iInter_clopen, Set.mem_iInter] at hB
   let Z := { F : Ultrafilter α | s ∈ F }
   have hZ : IsClopen Z := ⟨ultrafilter_isOpen_basic s, ultrafilter_isClosed_basic s⟩
   exact hB ⟨Z, hZ, hs⟩
 
 theorem ultrafilter_comap_pure_nhds (b : Ultrafilter α) : comap pure (𝓝 b) ≤ b := by
   rw [TopologicalSpace.nhds_generateFrom]
-  simp only [comap_infᵢ, comap_principal]
+  simp only [comap_iInf, comap_principal]
   intro s hs
   rw [← le_principal_iff]
-  refine' infᵢ_le_of_le { u | s ∈ u } _
-  refine' infᵢ_le_of_le ⟨hs, ⟨s, rfl⟩⟩ _
+  refine' iInf_le_of_le { u | s ∈ u } _
+  refine' iInf_le_of_le ⟨hs, ⟨s, rfl⟩⟩ _
   exact principal_mono.2 fun a => id
 #align ultrafilter_comap_pure_nhds ultrafilter_comap_pure_nhds
 

This PR puts, with one exception, every single remaining by that lies all by itself on its own line to the previous line, thus matching the current behaviour of start-port.sh. The exception is when the by begins the second or later argument to a tuple or anonymous constructor; see https://github.com/leanprover-community/mathlib4/pull/3825#discussion_r1186702599.

Essentially this is s/\n *by$/ by/g, but with manual editing to satisfy the linter's max-100-char-line requirement. The Python style linter is also modified to catch these "isolated bys".

@@ -196,8 +196,7 @@ theorem continuous_ultrafilter_extend (f : α → γ) : Continuous (Ultrafilter.
   unique limit of the ultrafilter `b.map f` in `γ`. -/
 theorem ultrafilter_extend_eq_iff {f : α → γ} {b : Ultrafilter α} {c : γ} :
     Ultrafilter.extend f b = c ↔ ↑(b.map f) ≤ 𝓝 c :=
-  ⟨fun h =>
-    by
+  ⟨fun h => by
     -- Write b as an ultrafilter limit of pure ultrafilters, and use
     -- the facts that ultrafilter.extend is a continuous extension of f.
     let b' : Ultrafilter (Ultrafilter α) := b.map pure
@@ -304,8 +303,7 @@ theorem convergent_eqv_pure {u : Ultrafilter α} {x : α} (ux : ↑u ≤ 𝓝 x)
 #align convergent_eqv_pure convergent_eqv_pure
 
 theorem continuous_stoneCechUnit : Continuous (stoneCechUnit : α → StoneCech α) :=
-  continuous_iff_ultrafilter.mpr fun x g gx =>
-    by
+  continuous_iff_ultrafilter.mpr fun x g gx => by
     have : (g.map pure).toFilter ≤ 𝓝 g := by
       rw [ultrafilter_converges_iff]
       exact (bind_pure _).symm

• There is now configuration for congr!, convert, and convert_to to control parts of the congruence algorithm, in particular transparency settings when applying congruence lemmas.
• congr! now applies congruence lemmas with reducible transparency by default. This prevents it from unfolding definitions when applying congruence lemmas. It also now tries both the LHS-biased and RHS-biased simp congruence lemmas, with a configuration option to set which it should try first.
• There is now a new HEq congruence lemma generator that gives each hypothesis access to the proofs of previous hypotheses. This means that if you have an equality ⊢ ⟨a, x⟩ = ⟨b, y⟩ of sigma types, congr! turns this into goals ⊢ a = b and ⊢ a = b → HEq x y (note that congr! will also auto-introduce a = b for you in the second goal). This congruence lemma generator applies to more cases than the simp congruence lemma generator does.
• congr! (and hence convert) are more careful about applying lemmas that don't force definitions to unfold. There were a number of cases in mathlib where the implementation of congr was being abused to unfold definitions.
• With set_option trace.congr! true you can see what congr! sees when it is deciding on congruence lemmas.
• There is also a bug fix in convert_to to do using 1 when there is no using clause, to match its documentation.

Note that congr! is more capable than congr at finding a way to equate left-hand sides and right-hand sides, so you will frequently need to limit its depth with a using clause. However, there is also a new heuristic to prevent considering unlikely-to-be-provable type equalities (controlled by the typeEqs option), which can help limit the depth automatically.

There is also a predefined configuration that you can invoke with, for example, convert (config := .unfoldSameFun) h, that causes it to behave more like congr, including using default transparency when unfolding.

@@ -60,7 +60,7 @@ theorem ultrafilter_isOpen_basic (s : Set α) : IsOpen { u : Ultrafilter α | s
 /-- The basic open sets for the topology on ultrafilters are also closed. -/
 theorem ultrafilter_isClosed_basic (s : Set α) : IsClosed { u : Ultrafilter α | s ∈ u } := by
   rw [← isOpen_compl_iff]
-  convert ultrafilter_isOpen_basic (sᶜ)
+  convert ultrafilter_isOpen_basic (sᶜ) using 1
   ext u
   exact Ultrafilter.compl_mem_iff_not_mem.symm
 #align ultrafilter_is_closed_basic ultrafilter_isClosed_basic