topology.locally_constant.basic ⟷ Mathlib.Topology.LocallyConstant.Basic

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

@@ -4,9 +4,9 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
 -/
 import Topology.SubsetProperties
-import Topology.Connected
+import Topology.Connected.Basic
 import Topology.ContinuousFunction.Basic
-import Algebra.IndicatorFunction
+import Algebra.Function.Indicator
 import Tactic.Tfae
 import Tactic.FinCases
 

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

@@ -222,7 +222,7 @@ theorem iff_is_const [PreconnectedSpace X] {f : X → Y} : IsLocallyConstant f 
 theorem range_finite [CompactSpace X] {f : X → Y} (hf : IsLocallyConstant f) :
     (Set.range f).Finite := by
   letI : TopologicalSpace Y := ⊥; haveI := discreteTopology_bot Y
-  rw [@iff_continuous X Y ‹_› ‹_›] at hf 
+  rw [@iff_continuous X Y ‹_› ‹_›] at hf
   exact (isCompact_range hf).finite_of_discrete
 #align is_locally_constant.range_finite IsLocallyConstant.range_finite
 -/
@@ -479,7 +479,7 @@ theorem ofIsClopen_fiber_one {X : Type _} [TopologicalSpace X] {U : Set X} [∀
 theorem locallyConstant_eq_of_fiber_zero_eq {X : Type _} [TopologicalSpace X]
     (f g : LocallyConstant X (Fin 2)) (h : f ⁻¹' ({0} : Set (Fin 2)) = g ⁻¹' {0}) : f = g :=
   by
-  simp only [Set.ext_iff, mem_singleton_iff, mem_preimage] at h 
+  simp only [Set.ext_iff, mem_singleton_iff, mem_preimage] at h
   ext1 x
   exact Fin.fin_two_eq_of_eq_zero_iff (h x)
 #align locally_constant.locally_constant_eq_of_fiber_zero_eq LocallyConstant.locallyConstant_eq_of_fiber_zero_eq
@@ -689,10 +689,10 @@ noncomputable def mulIndicator (hU : IsClopen U) : LocallyConstant X R
     obtain ⟨V, hV, hx, h'⟩ := (IsLocallyConstant.iff_exists_open _).1 f.is_locally_constant x
     by_cases x ∈ U
     · refine' ⟨U ∩ V, IsOpen.inter hU.1 hV, Set.mem_inter h hx, _⟩; rintro y hy
-      rw [Set.mem_inter_iff] at hy ; rw [Set.mulIndicator_of_mem hy.1, Set.mulIndicator_of_mem h]
+      rw [Set.mem_inter_iff] at hy; rw [Set.mulIndicator_of_mem hy.1, Set.mulIndicator_of_mem h]
       apply h' y hy.2
-    · rw [← Set.mem_compl_iff] at h ; refine' ⟨Uᶜ, (IsClopen.compl hU).1, h, _⟩
-      rintro y hy; rw [Set.mem_compl_iff] at h ; rw [Set.mem_compl_iff] at hy 
+    · rw [← Set.mem_compl_iff] at h; refine' ⟨Uᶜ, (IsClopen.compl hU).1, h, _⟩
+      rintro y hy; rw [Set.mem_compl_iff] at h; rw [Set.mem_compl_iff] at hy
       simp [h, hy]
 #align locally_constant.mul_indicator LocallyConstant.mulIndicator
 #align locally_constant.indicator LocallyConstant.indicator

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

@@ -620,7 +620,7 @@ theorem coe_comap (f : X → Y) (g : LocallyConstant Y Z) (hf : Continuous f) :
 #print LocallyConstant.comap_id /-
 @[simp]
 theorem comap_id : @comap X X Z _ _ id = id := by ext;
-  simp only [continuous_id, id.def, Function.comp.right_id, coe_comap]
+  simp only [continuous_id, id.def, Function.comp_id, coe_comap]
 #align locally_constant.comap_id LocallyConstant.comap_id
 -/
 

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

@@ -428,9 +428,9 @@ theorem coe_const (y : Y) : (const X y : X → Y) = Function.const X y :=
 #align locally_constant.coe_const LocallyConstant.coe_const
 -/
 
-#print LocallyConstant.ofClopen /-
+#print LocallyConstant.ofIsClopen /-
 /-- The locally constant function to `fin 2` associated to a clopen set. -/
-def ofClopen {X : Type _} [TopologicalSpace X] {U : Set X} [∀ x, Decidable (x ∈ U)]
+def ofIsClopen {X : Type _} [TopologicalSpace X] {U : Set X} [∀ x, Decidable (x ∈ U)]
     (hU : IsClopen U) : LocallyConstant X (Fin 2)
     where
   toFun x := if x ∈ U then 0 else 1
@@ -448,31 +448,31 @@ def ofClopen {X : Type _} [TopologicalSpace X] {U : Set X} [∀ x, Decidable (x
       convert hU.2
       ext
       simp
-#align locally_constant.of_clopen LocallyConstant.ofClopen
+#align locally_constant.of_clopen LocallyConstant.ofIsClopen
 -/
 
-#print LocallyConstant.ofClopen_fiber_zero /-
+#print LocallyConstant.ofIsClopen_fiber_zero /-
 @[simp]
-theorem ofClopen_fiber_zero {X : Type _} [TopologicalSpace X] {U : Set X} [∀ x, Decidable (x ∈ U)]
-    (hU : IsClopen U) : ofClopen hU ⁻¹' ({0} : Set (Fin 2)) = U :=
+theorem ofIsClopen_fiber_zero {X : Type _} [TopologicalSpace X] {U : Set X} [∀ x, Decidable (x ∈ U)]
+    (hU : IsClopen U) : ofIsClopen hU ⁻¹' ({0} : Set (Fin 2)) = U :=
   by
   ext
   simp only [of_clopen, mem_singleton_iff, Fin.one_eq_zero_iff, coe_mk, mem_preimage,
     ite_eq_left_iff, Nat.succ_succ_ne_one]
   tauto
-#align locally_constant.of_clopen_fiber_zero LocallyConstant.ofClopen_fiber_zero
+#align locally_constant.of_clopen_fiber_zero LocallyConstant.ofIsClopen_fiber_zero
 -/
 
-#print LocallyConstant.ofClopen_fiber_one /-
+#print LocallyConstant.ofIsClopen_fiber_one /-
 @[simp]
-theorem ofClopen_fiber_one {X : Type _} [TopologicalSpace X] {U : Set X} [∀ x, Decidable (x ∈ U)]
-    (hU : IsClopen U) : ofClopen hU ⁻¹' ({1} : Set (Fin 2)) = Uᶜ :=
+theorem ofIsClopen_fiber_one {X : Type _} [TopologicalSpace X] {U : Set X} [∀ x, Decidable (x ∈ U)]
+    (hU : IsClopen U) : ofIsClopen hU ⁻¹' ({1} : Set (Fin 2)) = Uᶜ :=
   by
   ext
   simp only [of_clopen, mem_singleton_iff, coe_mk, Fin.zero_eq_one_iff, mem_preimage,
     ite_eq_right_iff, mem_compl_iff, Nat.succ_succ_ne_one]
   tauto
-#align locally_constant.of_clopen_fiber_one LocallyConstant.ofClopen_fiber_one
+#align locally_constant.of_clopen_fiber_one LocallyConstant.ofIsClopen_fiber_one
 -/
 
 #print LocallyConstant.locallyConstant_eq_of_fiber_zero_eq /-

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

@@ -3,12 +3,12 @@ Copyright (c) 2021 Johan Commelin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
 -/
-import Mathbin.Topology.SubsetProperties
-import Mathbin.Topology.Connected
-import Mathbin.Topology.ContinuousFunction.Basic
-import Mathbin.Algebra.IndicatorFunction
-import Mathbin.Tactic.Tfae
-import Mathbin.Tactic.FinCases
+import Topology.SubsetProperties
+import Topology.Connected
+import Topology.ContinuousFunction.Basic
+import Algebra.IndicatorFunction
+import Tactic.Tfae
+import Tactic.FinCases
 
 #align_import topology.locally_constant.basic from "leanprover-community/mathlib"@"3e32bc908f617039c74c06ea9a897e30c30803c2"
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/442a83d738cb208d3600056c489be16900ba701d

@@ -568,7 +568,7 @@ def unflip {X α β : Type _} [Fintype α] [TopologicalSpace X] (f : α → Loca
     intro g
     have : (fun (x : X) (a : α) => f a x) ⁻¹' {g} = ⋂ a : α, f a ⁻¹' {g a} := by tidy
     rw [this]
-    apply isOpen_iInter
+    apply isOpen_iInter_of_finite
     intro a
     apply (f a).IsLocallyConstant
 #align locally_constant.unflip LocallyConstant.unflip

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

@@ -2,11 +2,6 @@
 Copyright (c) 2021 Johan Commelin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
-
-! This file was ported from Lean 3 source module topology.locally_constant.basic
-! 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.SubsetProperties
 import Mathbin.Topology.Connected
@@ -15,6 +10,8 @@ import Mathbin.Algebra.IndicatorFunction
 import Mathbin.Tactic.Tfae
 import Mathbin.Tactic.FinCases
 
+#align_import topology.locally_constant.basic from "leanprover-community/mathlib"@"3e32bc908f617039c74c06ea9a897e30c30803c2"
+
 /-!
 # Locally constant functions
 

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

@@ -49,6 +49,7 @@ def IsLocallyConstant (f : X → Y) : Prop :=
 
 namespace IsLocallyConstant
 
+#print IsLocallyConstant.tfae /-
 protected theorem tfae (f : X → Y) :
     TFAE
       [IsLocallyConstant f, ∀ x, ∀ᶠ x' in 𝓝 x, f x' = f x, ∀ x, IsOpen {x' | f x' = f x},
@@ -69,42 +70,59 @@ protected theorem tfae (f : X → Y) :
     exact ⟨U, fun x' hx' => mem_preimage.2 <| (Eq x' hx').symm ▸ hx, hU, hxU⟩
   tfae_finish
 #align is_locally_constant.tfae IsLocallyConstant.tfae
+-/
 
+#print IsLocallyConstant.of_discrete /-
 @[nontriviality]
 theorem of_discrete [DiscreteTopology X] (f : X → Y) : IsLocallyConstant f := fun s =>
   isOpen_discrete _
 #align is_locally_constant.of_discrete IsLocallyConstant.of_discrete
+-/
 
+#print IsLocallyConstant.isOpen_fiber /-
 theorem isOpen_fiber {f : X → Y} (hf : IsLocallyConstant f) (y : Y) : IsOpen {x | f x = y} :=
   hf {y}
 #align is_locally_constant.is_open_fiber IsLocallyConstant.isOpen_fiber
+-/
 
+#print IsLocallyConstant.isClosed_fiber /-
 theorem isClosed_fiber {f : X → Y} (hf : IsLocallyConstant f) (y : Y) : IsClosed {x | f x = y} :=
   ⟨hf ({y}ᶜ)⟩
 #align is_locally_constant.is_closed_fiber IsLocallyConstant.isClosed_fiber
+-/
 
+#print IsLocallyConstant.isClopen_fiber /-
 theorem isClopen_fiber {f : X → Y} (hf : IsLocallyConstant f) (y : Y) : IsClopen {x | f x = y} :=
   ⟨isOpen_fiber hf _, isClosed_fiber hf _⟩
 #align is_locally_constant.is_clopen_fiber IsLocallyConstant.isClopen_fiber
+-/
 
+#print IsLocallyConstant.iff_exists_open /-
 theorem iff_exists_open (f : X → Y) :
     IsLocallyConstant f ↔ ∀ x, ∃ (U : Set X) (hU : IsOpen U) (hx : x ∈ U), ∀ x' ∈ U, f x' = f x :=
   (IsLocallyConstant.tfae f).out 0 4
 #align is_locally_constant.iff_exists_open IsLocallyConstant.iff_exists_open
+-/
 
+#print IsLocallyConstant.iff_eventually_eq /-
 theorem iff_eventually_eq (f : X → Y) : IsLocallyConstant f ↔ ∀ x, ∀ᶠ y in 𝓝 x, f y = f x :=
   (IsLocallyConstant.tfae f).out 0 1
 #align is_locally_constant.iff_eventually_eq IsLocallyConstant.iff_eventually_eq
+-/
 
+#print IsLocallyConstant.exists_open /-
 theorem exists_open {f : X → Y} (hf : IsLocallyConstant f) (x : X) :
     ∃ (U : Set X) (hU : IsOpen U) (hx : x ∈ U), ∀ x' ∈ U, f x' = f x :=
   (iff_exists_open f).1 hf x
 #align is_locally_constant.exists_open IsLocallyConstant.exists_open
+-/
 
+#print IsLocallyConstant.eventually_eq /-
 protected theorem eventually_eq {f : X → Y} (hf : IsLocallyConstant f) (x : X) :
     ∀ᶠ y in 𝓝 x, f y = f x :=
   (iff_eventually_eq f).1 hf x
 #align is_locally_constant.eventually_eq IsLocallyConstant.eventually_eq
+-/
 
 #print IsLocallyConstant.continuous /-
 protected theorem continuous [TopologicalSpace Y] {f : X → Y} (hf : IsLocallyConstant f) :
@@ -126,30 +144,41 @@ theorem of_constant (f : X → Y) (h : ∀ x y, f x = f y) : IsLocallyConstant f
 #align is_locally_constant.of_constant IsLocallyConstant.of_constant
 -/
 
+#print IsLocallyConstant.const /-
 theorem const (y : Y) : IsLocallyConstant (Function.const X y) :=
   of_constant _ fun _ _ => rfl
 #align is_locally_constant.const IsLocallyConstant.const
+-/
 
+#print IsLocallyConstant.comp /-
 theorem comp {f : X → Y} (hf : IsLocallyConstant f) (g : Y → Z) : IsLocallyConstant (g ∘ f) :=
   fun s => by rw [Set.preimage_comp]; exact hf _
 #align is_locally_constant.comp IsLocallyConstant.comp
+-/
 
+#print IsLocallyConstant.prod_mk /-
 theorem prod_mk {Y'} {f : X → Y} {f' : X → Y'} (hf : IsLocallyConstant f)
     (hf' : IsLocallyConstant f') : IsLocallyConstant fun x => (f x, f' x) :=
   (iff_eventually_eq _).2 fun x =>
     (hf.EventuallyEq x).mp <| (hf'.EventuallyEq x).mono fun x' hf' hf => Prod.ext hf hf'
 #align is_locally_constant.prod_mk IsLocallyConstant.prod_mk
+-/
 
+#print IsLocallyConstant.comp₂ /-
 theorem comp₂ {Y₁ Y₂ Z : Type _} {f : X → Y₁} {g : X → Y₂} (hf : IsLocallyConstant f)
     (hg : IsLocallyConstant g) (h : Y₁ → Y₂ → Z) : IsLocallyConstant fun x => h (f x) (g x) :=
   (hf.prod_mk hg).comp fun x : Y₁ × Y₂ => h x.1 x.2
 #align is_locally_constant.comp₂ IsLocallyConstant.comp₂
+-/
 
+#print IsLocallyConstant.comp_continuous /-
 theorem comp_continuous [TopologicalSpace Y] {g : Y → Z} {f : X → Y} (hg : IsLocallyConstant g)
     (hf : Continuous f) : IsLocallyConstant (g ∘ f) := fun s => by rw [Set.preimage_comp];
   exact hf.is_open_preimage _ (hg _)
 #align is_locally_constant.comp_continuous IsLocallyConstant.comp_continuous
+-/
 
+#print IsLocallyConstant.apply_eq_of_isPreconnected /-
 /-- A locally constant function is constant on any preconnected set. -/
 theorem apply_eq_of_isPreconnected {f : X → Y} (hf : IsLocallyConstant f) {s : Set X}
     (hs : IsPreconnected s) {x y : X} (hx : x ∈ s) (hy : y ∈ s) : f x = f y :=
@@ -161,34 +190,45 @@ theorem apply_eq_of_isPreconnected {f : X → Y} (hf : IsLocallyConstant f) {s :
   · simp only [union_compl_self, subset_univ]
   · simpa only [inter_empty, not_nonempty_empty, inter_compl_self] using hs
 #align is_locally_constant.apply_eq_of_is_preconnected IsLocallyConstant.apply_eq_of_isPreconnected
+-/
 
+#print IsLocallyConstant.apply_eq_of_preconnectedSpace /-
 theorem apply_eq_of_preconnectedSpace [PreconnectedSpace X] {f : X → Y} (hf : IsLocallyConstant f)
     (x y : X) : f x = f y :=
   hf.apply_eq_of_isPreconnected isPreconnected_univ trivial trivial
 #align is_locally_constant.apply_eq_of_preconnected_space IsLocallyConstant.apply_eq_of_preconnectedSpace
+-/
 
+#print IsLocallyConstant.eq_const /-
 theorem eq_const [PreconnectedSpace X] {f : X → Y} (hf : IsLocallyConstant f) (x : X) :
     f = Function.const X (f x) :=
   funext fun y => hf.apply_eq_of_preconnectedSpace y x
 #align is_locally_constant.eq_const IsLocallyConstant.eq_const
+-/
 
+#print IsLocallyConstant.exists_eq_const /-
 theorem exists_eq_const [PreconnectedSpace X] [Nonempty Y] {f : X → Y} (hf : IsLocallyConstant f) :
     ∃ y, f = Function.const X y := by
   cases isEmpty_or_nonempty X
   · exact ⟨Classical.arbitrary Y, funext <| h.elim⟩
   · exact ⟨f (Classical.arbitrary X), hf.eq_const _⟩
 #align is_locally_constant.exists_eq_const IsLocallyConstant.exists_eq_const
+-/
 
+#print IsLocallyConstant.iff_is_const /-
 theorem iff_is_const [PreconnectedSpace X] {f : X → Y} : IsLocallyConstant f ↔ ∀ x y, f x = f y :=
   ⟨fun h x y => h.apply_eq_of_isPreconnected isPreconnected_univ trivial trivial, of_constant _⟩
 #align is_locally_constant.iff_is_const IsLocallyConstant.iff_is_const
+-/
 
+#print IsLocallyConstant.range_finite /-
 theorem range_finite [CompactSpace X] {f : X → Y} (hf : IsLocallyConstant f) :
     (Set.range f).Finite := by
   letI : TopologicalSpace Y := ⊥; haveI := discreteTopology_bot Y
   rw [@iff_continuous X Y ‹_› ‹_›] at hf 
   exact (isCompact_range hf).finite_of_discrete
 #align is_locally_constant.range_finite IsLocallyConstant.range_finite
+-/
 
 #print IsLocallyConstant.one /-
 @[to_additive]
@@ -224,6 +264,7 @@ theorem div [Div Y] ⦃f g : X → Y⦄ (hf : IsLocallyConstant f) (hg : IsLocal
 #align is_locally_constant.sub IsLocallyConstant.sub
 -/
 
+#print IsLocallyConstant.desc /-
 /-- If a composition of a function `f` followed by an injection `g` is locally
 constant, then the locally constant property descends to `f`. -/
 theorem desc {α β : Type _} (f : X → α) (g : α → β) (h : IsLocallyConstant (g ∘ f))
@@ -238,14 +279,18 @@ theorem desc {α β : Type _} (f : X → α) (g : α → β) (h : IsLocallyConst
   rw [this]
   apply h
 #align is_locally_constant.desc IsLocallyConstant.desc
+-/
 
+#print IsLocallyConstant.of_constant_on_connected_components /-
 theorem of_constant_on_connected_components [LocallyConnectedSpace X] {f : X → Y}
     (h : ∀ x, ∀ y ∈ connectedComponent x, f y = f x) : IsLocallyConstant f :=
   by
   rw [iff_exists_open]
   exact fun x => ⟨connectedComponent x, isOpen_connectedComponent, mem_connectedComponent, h x⟩
 #align is_locally_constant.of_constant_on_connected_components IsLocallyConstant.of_constant_on_connected_components
+-/
 
+#print IsLocallyConstant.of_constant_on_preconnected_clopens /-
 theorem of_constant_on_preconnected_clopens [LocallyConnectedSpace X] {f : X → Y}
     (h : ∀ U : Set X, IsPreconnected U → IsClopen U → ∀ x ∈ U, ∀ y ∈ U, f y = f x) :
     IsLocallyConstant f :=
@@ -253,6 +298,7 @@ theorem of_constant_on_preconnected_clopens [LocallyConnectedSpace X] {f : X →
     h (connectedComponent x) isPreconnected_connectedComponent isClopen_connectedComponent x
       mem_connectedComponent
 #align is_locally_constant.of_constant_on_preconnected_clopens IsLocallyConstant.of_constant_on_preconnected_clopens
+-/
 
 end IsLocallyConstant
 
@@ -275,23 +321,31 @@ instance : CoeFun (LocallyConstant X Y) fun _ => X → Y :=
 
 initialize_simps_projections LocallyConstant (toFun → apply)
 
+#print LocallyConstant.toFun_eq_coe /-
 @[simp]
 theorem toFun_eq_coe (f : LocallyConstant X Y) : f.toFun = f :=
   rfl
 #align locally_constant.to_fun_eq_coe LocallyConstant.toFun_eq_coe
+-/
 
+#print LocallyConstant.coe_mk /-
 @[simp]
 theorem coe_mk (f : X → Y) (h) : ⇑(⟨f, h⟩ : LocallyConstant X Y) = f :=
   rfl
 #align locally_constant.coe_mk LocallyConstant.coe_mk
+-/
 
+#print LocallyConstant.congr_fun /-
 theorem congr_fun {f g : LocallyConstant X Y} (h : f = g) (x : X) : f x = g x :=
   congr_arg (fun h : LocallyConstant X Y => h x) h
 #align locally_constant.congr_fun LocallyConstant.congr_fun
+-/
 
+#print LocallyConstant.congr_arg /-
 theorem congr_arg (f : LocallyConstant X Y) {x y : X} (h : x = y) : f x = f y :=
   congr_arg (fun x : X => f x) h
 #align locally_constant.congr_arg LocallyConstant.congr_arg
+-/
 
 #print LocallyConstant.coe_injective /-
 theorem coe_injective : @Function.Injective (LocallyConstant X Y) (X → Y) coeFn
@@ -301,27 +355,35 @@ theorem coe_injective : @Function.Injective (LocallyConstant X Y) (X → Y) coeF
 #align locally_constant.coe_injective LocallyConstant.coe_injective
 -/
 
+#print LocallyConstant.coe_inj /-
 @[simp, norm_cast]
 theorem coe_inj {f g : LocallyConstant X Y} : (f : X → Y) = g ↔ f = g :=
   coe_injective.eq_iff
 #align locally_constant.coe_inj LocallyConstant.coe_inj
+-/
 
+#print LocallyConstant.ext /-
 @[ext]
 theorem ext ⦃f g : LocallyConstant X Y⦄ (h : ∀ x, f x = g x) : f = g :=
   coe_injective (funext h)
 #align locally_constant.ext LocallyConstant.ext
+-/
 
+#print LocallyConstant.ext_iff /-
 theorem ext_iff {f g : LocallyConstant X Y} : f = g ↔ ∀ x, f x = g x :=
   ⟨fun h x => h ▸ rfl, fun h => ext h⟩
 #align locally_constant.ext_iff LocallyConstant.ext_iff
+-/
 
 section CodomainTopologicalSpace
 
 variable [TopologicalSpace Y] (f : LocallyConstant X Y)
 
+#print LocallyConstant.continuous /-
 protected theorem continuous : Continuous f :=
   f.IsLocallyConstant.Continuous
 #align locally_constant.continuous LocallyConstant.continuous
+-/
 
 #print LocallyConstant.toContinuousMap /-
 /-- We can turn a locally-constant function into a bundled `continuous_map`. -/
@@ -339,15 +401,19 @@ theorem toContinuousMap_eq_coe : f.toContinuousMap = f :=
   rfl
 #align locally_constant.to_continuous_map_eq_coe LocallyConstant.toContinuousMap_eq_coe
 
+#print LocallyConstant.coe_continuousMap /-
 @[simp]
 theorem coe_continuousMap : ((f : C(X, Y)) : X → Y) = (f : X → Y) :=
   rfl
 #align locally_constant.coe_continuous_map LocallyConstant.coe_continuousMap
+-/
 
+#print LocallyConstant.toContinuousMap_injective /-
 theorem toContinuousMap_injective :
     Function.Injective (toContinuousMap : LocallyConstant X Y → C(X, Y)) := fun _ _ h =>
   ext (ContinuousMap.congr_fun h)
 #align locally_constant.to_continuous_map_injective LocallyConstant.toContinuousMap_injective
+-/
 
 end CodomainTopologicalSpace
 
@@ -358,10 +424,12 @@ def const (X : Type _) {Y : Type _} [TopologicalSpace X] (y : Y) : LocallyConsta
 #align locally_constant.const LocallyConstant.const
 -/
 
+#print LocallyConstant.coe_const /-
 @[simp]
 theorem coe_const (y : Y) : (const X y : X → Y) = Function.const X y :=
   rfl
 #align locally_constant.coe_const LocallyConstant.coe_const
+-/
 
 #print LocallyConstant.ofClopen /-
 /-- The locally constant function to `fin 2` associated to a clopen set. -/
@@ -386,6 +454,7 @@ def ofClopen {X : Type _} [TopologicalSpace X] {U : Set X} [∀ x, Decidable (x
 #align locally_constant.of_clopen LocallyConstant.ofClopen
 -/
 
+#print LocallyConstant.ofClopen_fiber_zero /-
 @[simp]
 theorem ofClopen_fiber_zero {X : Type _} [TopologicalSpace X] {U : Set X} [∀ x, Decidable (x ∈ U)]
     (hU : IsClopen U) : ofClopen hU ⁻¹' ({0} : Set (Fin 2)) = U :=
@@ -395,7 +464,9 @@ theorem ofClopen_fiber_zero {X : Type _} [TopologicalSpace X] {U : Set X} [∀ x
     ite_eq_left_iff, Nat.succ_succ_ne_one]
   tauto
 #align locally_constant.of_clopen_fiber_zero LocallyConstant.ofClopen_fiber_zero
+-/
 
+#print LocallyConstant.ofClopen_fiber_one /-
 @[simp]
 theorem ofClopen_fiber_one {X : Type _} [TopologicalSpace X] {U : Set X} [∀ x, Decidable (x ∈ U)]
     (hU : IsClopen U) : ofClopen hU ⁻¹' ({1} : Set (Fin 2)) = Uᶜ :=
@@ -405,7 +476,9 @@ theorem ofClopen_fiber_one {X : Type _} [TopologicalSpace X] {U : Set X} [∀ x,
     ite_eq_right_iff, mem_compl_iff, Nat.succ_succ_ne_one]
   tauto
 #align locally_constant.of_clopen_fiber_one LocallyConstant.ofClopen_fiber_one
+-/
 
+#print LocallyConstant.locallyConstant_eq_of_fiber_zero_eq /-
 theorem locallyConstant_eq_of_fiber_zero_eq {X : Type _} [TopologicalSpace X]
     (f g : LocallyConstant X (Fin 2)) (h : f ⁻¹' ({0} : Set (Fin 2)) = g ⁻¹' {0}) : f = g :=
   by
@@ -413,25 +486,35 @@ theorem locallyConstant_eq_of_fiber_zero_eq {X : Type _} [TopologicalSpace X]
   ext1 x
   exact Fin.fin_two_eq_of_eq_zero_iff (h x)
 #align locally_constant.locally_constant_eq_of_fiber_zero_eq LocallyConstant.locallyConstant_eq_of_fiber_zero_eq
+-/
 
+#print LocallyConstant.range_finite /-
 theorem range_finite [CompactSpace X] (f : LocallyConstant X Y) : (Set.range f).Finite :=
   f.IsLocallyConstant.range_finite
 #align locally_constant.range_finite LocallyConstant.range_finite
+-/
 
+#print LocallyConstant.apply_eq_of_isPreconnected /-
 theorem apply_eq_of_isPreconnected (f : LocallyConstant X Y) {s : Set X} (hs : IsPreconnected s)
     {x y : X} (hx : x ∈ s) (hy : y ∈ s) : f x = f y :=
   f.IsLocallyConstant.apply_eq_of_isPreconnected hs hx hy
 #align locally_constant.apply_eq_of_is_preconnected LocallyConstant.apply_eq_of_isPreconnected
+-/
 
+#print LocallyConstant.apply_eq_of_preconnectedSpace /-
 theorem apply_eq_of_preconnectedSpace [PreconnectedSpace X] (f : LocallyConstant X Y) (x y : X) :
     f x = f y :=
   f.IsLocallyConstant.apply_eq_of_isPreconnected isPreconnected_univ trivial trivial
 #align locally_constant.apply_eq_of_preconnected_space LocallyConstant.apply_eq_of_preconnectedSpace
+-/
 
+#print LocallyConstant.eq_const /-
 theorem eq_const [PreconnectedSpace X] (f : LocallyConstant X Y) (x : X) : f = const X (f x) :=
   ext fun y => apply_eq_of_preconnectedSpace f _ _
 #align locally_constant.eq_const LocallyConstant.eq_const
+-/
 
+#print LocallyConstant.exists_eq_const /-
 theorem exists_eq_const [PreconnectedSpace X] [Nonempty Y] (f : LocallyConstant X Y) :
     ∃ y, f = const X y :=
   by
@@ -439,6 +522,7 @@ theorem exists_eq_const [PreconnectedSpace X] [Nonempty Y] (f : LocallyConstant
   · exact ⟨f x, f.eq_const x⟩
   · exact ⟨Classical.arbitrary Y, ext fun x => (hX ⟨x⟩).elim⟩
 #align locally_constant.exists_eq_const LocallyConstant.exists_eq_const
+-/
 
 #print LocallyConstant.map /-
 /-- Push forward of locally constant maps under any map, by post-composition. -/
@@ -447,19 +531,25 @@ def map (f : Y → Z) : LocallyConstant X Y → LocallyConstant X Z := fun g =>
 #align locally_constant.map LocallyConstant.map
 -/
 
+#print LocallyConstant.map_apply /-
 @[simp]
 theorem map_apply (f : Y → Z) (g : LocallyConstant X Y) : ⇑(map f g) = f ∘ g :=
   rfl
 #align locally_constant.map_apply LocallyConstant.map_apply
+-/
 
+#print LocallyConstant.map_id /-
 @[simp]
 theorem map_id : @map X Y Y _ id = id := by ext; rfl
 #align locally_constant.map_id LocallyConstant.map_id
+-/
 
+#print LocallyConstant.map_comp /-
 @[simp]
 theorem map_comp {Y₁ Y₂ Y₃ : Type _} (g : Y₂ → Y₃) (f : Y₁ → Y₂) :
     @map X _ _ _ g ∘ map f = map (g ∘ f) := by ext; rfl
 #align locally_constant.map_comp LocallyConstant.map_comp
+-/
 
 #print LocallyConstant.flip /-
 /-- Given a locally constant function to `α → β`, construct a family of locally constant
@@ -470,6 +560,7 @@ def flip {X α β : Type _} [TopologicalSpace X] (f : LocallyConstant X (α →
 #align locally_constant.flip LocallyConstant.flip
 -/
 
+#print LocallyConstant.unflip /-
 /-- If α is finite, this constructs a locally constant function to `α → β` given a
 family of locally constant functions with values in β indexed by α. -/
 def unflip {X α β : Type _} [Fintype α] [TopologicalSpace X] (f : α → LocallyConstant X β) :
@@ -484,16 +575,21 @@ def unflip {X α β : Type _} [Fintype α] [TopologicalSpace X] (f : α → Loca
     intro a
     apply (f a).IsLocallyConstant
 #align locally_constant.unflip LocallyConstant.unflip
+-/
 
+#print LocallyConstant.unflip_flip /-
 @[simp]
 theorem unflip_flip {X α β : Type _} [Fintype α] [TopologicalSpace X]
     (f : LocallyConstant X (α → β)) : unflip f.flip = f := by ext; rfl
 #align locally_constant.unflip_flip LocallyConstant.unflip_flip
+-/
 
+#print LocallyConstant.flip_unflip /-
 @[simp]
 theorem flip_unflip {X α β : Type _} [Fintype α] [TopologicalSpace X]
     (f : α → LocallyConstant X β) : (unflip f).flip = f := by ext; rfl
 #align locally_constant.flip_unflip LocallyConstant.flip_unflip
+-/
 
 section Comap
 
@@ -517,21 +613,28 @@ noncomputable def comap (f : X → Y) : LocallyConstant Y Z → LocallyConstant
 #align locally_constant.comap LocallyConstant.comap
 -/
 
+#print LocallyConstant.coe_comap /-
 @[simp]
 theorem coe_comap (f : X → Y) (g : LocallyConstant Y Z) (hf : Continuous f) :
     ⇑(comap f g) = g ∘ f := by rw [comap, dif_pos hf]; rfl
 #align locally_constant.coe_comap LocallyConstant.coe_comap
+-/
 
+#print LocallyConstant.comap_id /-
 @[simp]
 theorem comap_id : @comap X X Z _ _ id = id := by ext;
   simp only [continuous_id, id.def, Function.comp.right_id, coe_comap]
 #align locally_constant.comap_id LocallyConstant.comap_id
+-/
 
+#print LocallyConstant.comap_comp /-
 theorem comap_comp [TopologicalSpace Z] (f : X → Y) (g : Y → Z) (hf : Continuous f)
     (hg : Continuous g) : @comap _ _ α _ _ f ∘ comap g = comap (g ∘ f) := by ext;
   simp only [hf, hg, hg.comp hf, coe_comap]
 #align locally_constant.comap_comp LocallyConstant.comap_comp
+-/
 
+#print LocallyConstant.comap_const /-
 theorem comap_const (f : X → Y) (y : Y) (h : ∀ x, f x = y) :
     (comap f : LocallyConstant Y Z → LocallyConstant X Z) = fun g =>
       ⟨fun x => g y, IsLocallyConstant.const _⟩ :=
@@ -541,6 +644,7 @@ theorem comap_const (f : X → Y) (y : Y) (h : ∀ x, f x = y) :
   · rw [show f = fun x => y by ext <;> apply h]
     exact continuous_const
 #align locally_constant.comap_const LocallyConstant.comap_const
+-/
 
 end Comap
 
@@ -557,12 +661,14 @@ def desc {X α β : Type _} [TopologicalSpace X] {g : α → β} (f : X → α)
 #align locally_constant.desc LocallyConstant.desc
 -/
 
+#print LocallyConstant.coe_desc /-
 @[simp]
 theorem coe_desc {X α β : Type _} [TopologicalSpace X] (f : X → α) (g : α → β)
     (h : LocallyConstant X β) (cond : g ∘ f = h) (inj : Function.Injective g) :
     ⇑(desc f h cond inj) = f :=
   rfl
 #align locally_constant.coe_desc LocallyConstant.coe_desc
+-/
 
 end Desc
 
@@ -597,26 +703,32 @@ noncomputable def mulIndicator (hU : IsClopen U) : LocallyConstant X R
 
 variable (a : X)
 
+#print LocallyConstant.mulIndicator_apply_eq_if /-
 @[to_additive]
 theorem mulIndicator_apply_eq_if (hU : IsClopen U) :
     mulIndicator f hU a = if a ∈ U then f a else 1 :=
   Set.mulIndicator_apply U f a
 #align locally_constant.mul_indicator_apply_eq_if LocallyConstant.mulIndicator_apply_eq_if
 #align locally_constant.indicator_apply_eq_if LocallyConstant.indicator_apply_eq_if
+-/
 
 variable {a}
 
+#print LocallyConstant.mulIndicator_of_mem /-
 @[to_additive]
 theorem mulIndicator_of_mem (hU : IsClopen U) (h : a ∈ U) : f.mulIndicator hU a = f a := by
   rw [mul_indicator_apply]; apply Set.mulIndicator_of_mem h
 #align locally_constant.mul_indicator_of_mem LocallyConstant.mulIndicator_of_mem
 #align locally_constant.indicator_of_mem LocallyConstant.indicator_of_mem
+-/
 
+#print LocallyConstant.mulIndicator_of_not_mem /-
 @[to_additive]
 theorem mulIndicator_of_not_mem (hU : IsClopen U) (h : a ∉ U) : f.mulIndicator hU a = 1 := by
   rw [mul_indicator_apply]; apply Set.mulIndicator_of_not_mem h
 #align locally_constant.mul_indicator_of_not_mem LocallyConstant.mulIndicator_of_not_mem
 #align locally_constant.indicator_of_not_mem LocallyConstant.indicator_of_not_mem
+-/
 
 end Indicator
 

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

@@ -51,7 +51,7 @@ namespace IsLocallyConstant
 
 protected theorem tfae (f : X → Y) :
     TFAE
-      [IsLocallyConstant f, ∀ x, ∀ᶠ x' in 𝓝 x, f x' = f x, ∀ x, IsOpen { x' | f x' = f x },
+      [IsLocallyConstant f, ∀ x, ∀ᶠ x' in 𝓝 x, f x' = f x, ∀ x, IsOpen {x' | f x' = f x},
         ∀ y, IsOpen (f ⁻¹' {y}),
         ∀ x, ∃ (U : Set X) (hU : IsOpen U) (hx : x ∈ U), ∀ x' ∈ U, f x' = f x] :=
   by
@@ -75,15 +75,15 @@ theorem of_discrete [DiscreteTopology X] (f : X → Y) : IsLocallyConstant f :=
   isOpen_discrete _
 #align is_locally_constant.of_discrete IsLocallyConstant.of_discrete
 
-theorem isOpen_fiber {f : X → Y} (hf : IsLocallyConstant f) (y : Y) : IsOpen { x | f x = y } :=
+theorem isOpen_fiber {f : X → Y} (hf : IsLocallyConstant f) (y : Y) : IsOpen {x | f x = y} :=
   hf {y}
 #align is_locally_constant.is_open_fiber IsLocallyConstant.isOpen_fiber
 
-theorem isClosed_fiber {f : X → Y} (hf : IsLocallyConstant f) (y : Y) : IsClosed { x | f x = y } :=
+theorem isClosed_fiber {f : X → Y} (hf : IsLocallyConstant f) (y : Y) : IsClosed {x | f x = y} :=
   ⟨hf ({y}ᶜ)⟩
 #align is_locally_constant.is_closed_fiber IsLocallyConstant.isClosed_fiber
 
-theorem isClopen_fiber {f : X → Y} (hf : IsLocallyConstant f) (y : Y) : IsClopen { x | f x = y } :=
+theorem isClopen_fiber {f : X → Y} (hf : IsLocallyConstant f) (y : Y) : IsClopen {x | f x = y} :=
   ⟨isOpen_fiber hf _, isClosed_fiber hf _⟩
 #align is_locally_constant.is_clopen_fiber IsLocallyConstant.isClopen_fiber
 

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

@@ -53,7 +53,7 @@ protected theorem tfae (f : X → Y) :
     TFAE
       [IsLocallyConstant f, ∀ x, ∀ᶠ x' in 𝓝 x, f x' = f x, ∀ x, IsOpen { x' | f x' = f x },
         ∀ y, IsOpen (f ⁻¹' {y}),
-        ∀ x, ∃ (U : Set X)(hU : IsOpen U)(hx : x ∈ U), ∀ x' ∈ U, f x' = f x] :=
+        ∀ x, ∃ (U : Set X) (hU : IsOpen U) (hx : x ∈ U), ∀ x' ∈ U, f x' = f x] :=
   by
   tfae_have 1 → 4; exact fun h y => h {y}
   tfae_have 4 → 3; exact fun h x => h (f x)
@@ -88,7 +88,7 @@ theorem isClopen_fiber {f : X → Y} (hf : IsLocallyConstant f) (y : Y) : IsClop
 #align is_locally_constant.is_clopen_fiber IsLocallyConstant.isClopen_fiber
 
 theorem iff_exists_open (f : X → Y) :
-    IsLocallyConstant f ↔ ∀ x, ∃ (U : Set X)(hU : IsOpen U)(hx : x ∈ U), ∀ x' ∈ U, f x' = f x :=
+    IsLocallyConstant f ↔ ∀ x, ∃ (U : Set X) (hU : IsOpen U) (hx : x ∈ U), ∀ x' ∈ U, f x' = f x :=
   (IsLocallyConstant.tfae f).out 0 4
 #align is_locally_constant.iff_exists_open IsLocallyConstant.iff_exists_open
 
@@ -97,7 +97,7 @@ theorem iff_eventually_eq (f : X → Y) : IsLocallyConstant f ↔ ∀ x, ∀ᶠ
 #align is_locally_constant.iff_eventually_eq IsLocallyConstant.iff_eventually_eq
 
 theorem exists_open {f : X → Y} (hf : IsLocallyConstant f) (x : X) :
-    ∃ (U : Set X)(hU : IsOpen U)(hx : x ∈ U), ∀ x' ∈ U, f x' = f x :=
+    ∃ (U : Set X) (hU : IsOpen U) (hx : x ∈ U), ∀ x' ∈ U, f x' = f x :=
   (iff_exists_open f).1 hf x
 #align is_locally_constant.exists_open IsLocallyConstant.exists_open
 
@@ -186,7 +186,7 @@ theorem iff_is_const [PreconnectedSpace X] {f : X → Y} : IsLocallyConstant f 
 theorem range_finite [CompactSpace X] {f : X → Y} (hf : IsLocallyConstant f) :
     (Set.range f).Finite := by
   letI : TopologicalSpace Y := ⊥; haveI := discreteTopology_bot Y
-  rw [@iff_continuous X Y ‹_› ‹_›] at hf
+  rw [@iff_continuous X Y ‹_› ‹_›] at hf 
   exact (isCompact_range hf).finite_of_discrete
 #align is_locally_constant.range_finite IsLocallyConstant.range_finite
 
@@ -409,7 +409,7 @@ theorem ofClopen_fiber_one {X : Type _} [TopologicalSpace X] {U : Set X} [∀ x,
 theorem locallyConstant_eq_of_fiber_zero_eq {X : Type _} [TopologicalSpace X]
     (f g : LocallyConstant X (Fin 2)) (h : f ⁻¹' ({0} : Set (Fin 2)) = g ⁻¹' {0}) : f = g :=
   by
-  simp only [Set.ext_iff, mem_singleton_iff, mem_preimage] at h
+  simp only [Set.ext_iff, mem_singleton_iff, mem_preimage] at h 
   ext1 x
   exact Fin.fin_two_eq_of_eq_zero_iff (h x)
 #align locally_constant.locally_constant_eq_of_fiber_zero_eq LocallyConstant.locallyConstant_eq_of_fiber_zero_eq
@@ -586,10 +586,10 @@ noncomputable def mulIndicator (hU : IsClopen U) : LocallyConstant X R
     obtain ⟨V, hV, hx, h'⟩ := (IsLocallyConstant.iff_exists_open _).1 f.is_locally_constant x
     by_cases x ∈ U
     · refine' ⟨U ∩ V, IsOpen.inter hU.1 hV, Set.mem_inter h hx, _⟩; rintro y hy
-      rw [Set.mem_inter_iff] at hy; rw [Set.mulIndicator_of_mem hy.1, Set.mulIndicator_of_mem h]
+      rw [Set.mem_inter_iff] at hy ; rw [Set.mulIndicator_of_mem hy.1, Set.mulIndicator_of_mem h]
       apply h' y hy.2
-    · rw [← Set.mem_compl_iff] at h; refine' ⟨Uᶜ, (IsClopen.compl hU).1, h, _⟩
-      rintro y hy; rw [Set.mem_compl_iff] at h; rw [Set.mem_compl_iff] at hy
+    · rw [← Set.mem_compl_iff] at h ; refine' ⟨Uᶜ, (IsClopen.compl hU).1, h, _⟩
+      rintro y hy; rw [Set.mem_compl_iff] at h ; rw [Set.mem_compl_iff] at hy 
       simp [h, hy]
 #align locally_constant.mul_indicator LocallyConstant.mulIndicator
 #align locally_constant.indicator LocallyConstant.indicator

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

@@ -334,12 +334,10 @@ def toContinuousMap : C(X, Y) :=
 instance : Coe (LocallyConstant X Y) C(X, Y) :=
   ⟨toContinuousMap⟩
 
-/- warning: locally_constant.to_continuous_map_eq_coe clashes with [anonymous] -> [anonymous]
-Case conversion may be inaccurate. Consider using '#align locally_constant.to_continuous_map_eq_coe [anonymous]ₓ'. -/
 @[simp]
-theorem [anonymous] : f.toContinuousMap = f :=
+theorem toContinuousMap_eq_coe : f.toContinuousMap = f :=
   rfl
-#align locally_constant.to_continuous_map_eq_coe [anonymous]
+#align locally_constant.to_continuous_map_eq_coe LocallyConstant.toContinuousMap_eq_coe
 
 @[simp]
 theorem coe_continuousMap : ((f : C(X, Y)) : X → Y) = (f : X → Y) :=

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

@@ -38,7 +38,7 @@ variable {X Y Z α : Type _} [TopologicalSpace X]
 
 open Set Filter
 
-open Topology
+open scoped Topology
 
 #print IsLocallyConstant /-
 /-- A function between topological spaces is locally constant if the preimage of any set is open. -/
@@ -499,7 +499,7 @@ theorem flip_unflip {X α β : Type _} [Fintype α] [TopologicalSpace X]
 
 section Comap
 
-open Classical
+open scoped Classical
 
 variable [TopologicalSpace Y]
 
@@ -572,7 +572,7 @@ section Indicator
 
 variable {R : Type _} [One R] {U : Set X} (f : LocallyConstant X R)
 
-open Classical
+open scoped Classical
 
 #print LocallyConstant.mulIndicator /-
 /-- Given a clopen set `U` and a locally constant function `f`, `locally_constant.mul_indicator`

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

@@ -49,12 +49,6 @@ def IsLocallyConstant (f : X → Y) : Prop :=
 
 namespace IsLocallyConstant
 
-/- warning: is_locally_constant.tfae -> IsLocallyConstant.tfae is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] (f : X -> Y), List.TFAE (List.cons.{0} Prop (IsLocallyConstant.{u1, u2} X Y _inst_1 f) (List.cons.{0} Prop (forall (x : X), Filter.Eventually.{u1} X (fun (x' : X) => Eq.{succ u2} Y (f x') (f x)) (nhds.{u1} X _inst_1 x)) (List.cons.{0} Prop (forall (x : X), IsOpen.{u1} X _inst_1 (setOf.{u1} X (fun (x' : X) => Eq.{succ u2} Y (f x') (f x)))) (List.cons.{0} Prop (forall (y : Y), IsOpen.{u1} X _inst_1 (Set.preimage.{u1, u2} X Y f (Singleton.singleton.{u2, u2} Y (Set.{u2} Y) (Set.hasSingleton.{u2} Y) y))) (List.cons.{0} Prop (forall (x : X), Exists.{succ u1} (Set.{u1} X) (fun (U : Set.{u1} X) => Exists.{0} (IsOpen.{u1} X _inst_1 U) (fun (hU : IsOpen.{u1} X _inst_1 U) => Exists.{0} (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) x U) (fun (hx : Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) x U) => forall (x' : X), (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) x' U) -> (Eq.{succ u2} Y (f x') (f x)))))) (List.nil.{0} Prop))))))
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] (f : X -> Y), List.TFAE (List.cons.{0} Prop (IsLocallyConstant.{u2, u1} X Y _inst_1 f) (List.cons.{0} Prop (forall (x : X), Filter.Eventually.{u2} X (fun (x' : X) => Eq.{succ u1} Y (f x') (f x)) (nhds.{u2} X _inst_1 x)) (List.cons.{0} Prop (forall (x : X), IsOpen.{u2} X _inst_1 (setOf.{u2} X (fun (x' : X) => Eq.{succ u1} Y (f x') (f x)))) (List.cons.{0} Prop (forall (y : Y), IsOpen.{u2} X _inst_1 (Set.preimage.{u2, u1} X Y f (Singleton.singleton.{u1, u1} Y (Set.{u1} Y) (Set.instSingletonSet.{u1} Y) y))) (List.cons.{0} Prop (forall (x : X), Exists.{succ u2} (Set.{u2} X) (fun (U : Set.{u2} X) => And (IsOpen.{u2} X _inst_1 U) (And (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) x U) (forall (x' : X), (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) x' U) -> (Eq.{succ u1} Y (f x') (f x)))))) (List.nil.{0} Prop))))))
-Case conversion may be inaccurate. Consider using '#align is_locally_constant.tfae IsLocallyConstant.tfaeₓ'. -/
 protected theorem tfae (f : X → Y) :
     TFAE
       [IsLocallyConstant f, ∀ x, ∀ᶠ x' in 𝓝 x, f x' = f x, ∀ x, IsOpen { x' | f x' = f x },
@@ -76,85 +70,37 @@ protected theorem tfae (f : X → Y) :
   tfae_finish
 #align is_locally_constant.tfae IsLocallyConstant.tfae
 
-/- warning: is_locally_constant.of_discrete -> IsLocallyConstant.of_discrete is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : DiscreteTopology.{u1} X _inst_1] (f : X -> Y), IsLocallyConstant.{u1, u2} X Y _inst_1 f
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : DiscreteTopology.{u2} X _inst_1] (f : X -> Y), IsLocallyConstant.{u2, u1} X Y _inst_1 f
-Case conversion may be inaccurate. Consider using '#align is_locally_constant.of_discrete IsLocallyConstant.of_discreteₓ'. -/
 @[nontriviality]
 theorem of_discrete [DiscreteTopology X] (f : X → Y) : IsLocallyConstant f := fun s =>
   isOpen_discrete _
 #align is_locally_constant.of_discrete IsLocallyConstant.of_discrete
 
-/- warning: is_locally_constant.is_open_fiber -> IsLocallyConstant.isOpen_fiber is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] {f : X -> Y}, (IsLocallyConstant.{u1, u2} X Y _inst_1 f) -> (forall (y : Y), IsOpen.{u1} X _inst_1 (setOf.{u1} X (fun (x : X) => Eq.{succ u2} Y (f x) y)))
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] {f : X -> Y}, (IsLocallyConstant.{u2, u1} X Y _inst_1 f) -> (forall (y : Y), IsOpen.{u2} X _inst_1 (setOf.{u2} X (fun (x : X) => Eq.{succ u1} Y (f x) y)))
-Case conversion may be inaccurate. Consider using '#align is_locally_constant.is_open_fiber IsLocallyConstant.isOpen_fiberₓ'. -/
 theorem isOpen_fiber {f : X → Y} (hf : IsLocallyConstant f) (y : Y) : IsOpen { x | f x = y } :=
   hf {y}
 #align is_locally_constant.is_open_fiber IsLocallyConstant.isOpen_fiber
 
-/- warning: is_locally_constant.is_closed_fiber -> IsLocallyConstant.isClosed_fiber is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] {f : X -> Y}, (IsLocallyConstant.{u1, u2} X Y _inst_1 f) -> (forall (y : Y), IsClosed.{u1} X _inst_1 (setOf.{u1} X (fun (x : X) => Eq.{succ u2} Y (f x) y)))
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] {f : X -> Y}, (IsLocallyConstant.{u2, u1} X Y _inst_1 f) -> (forall (y : Y), IsClosed.{u2} X _inst_1 (setOf.{u2} X (fun (x : X) => Eq.{succ u1} Y (f x) y)))
-Case conversion may be inaccurate. Consider using '#align is_locally_constant.is_closed_fiber IsLocallyConstant.isClosed_fiberₓ'. -/
 theorem isClosed_fiber {f : X → Y} (hf : IsLocallyConstant f) (y : Y) : IsClosed { x | f x = y } :=
   ⟨hf ({y}ᶜ)⟩
 #align is_locally_constant.is_closed_fiber IsLocallyConstant.isClosed_fiber
 
-/- warning: is_locally_constant.is_clopen_fiber -> IsLocallyConstant.isClopen_fiber is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] {f : X -> Y}, (IsLocallyConstant.{u1, u2} X Y _inst_1 f) -> (forall (y : Y), IsClopen.{u1} X _inst_1 (setOf.{u1} X (fun (x : X) => Eq.{succ u2} Y (f x) y)))
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] {f : X -> Y}, (IsLocallyConstant.{u2, u1} X Y _inst_1 f) -> (forall (y : Y), IsClopen.{u2} X _inst_1 (setOf.{u2} X (fun (x : X) => Eq.{succ u1} Y (f x) y)))
-Case conversion may be inaccurate. Consider using '#align is_locally_constant.is_clopen_fiber IsLocallyConstant.isClopen_fiberₓ'. -/
 theorem isClopen_fiber {f : X → Y} (hf : IsLocallyConstant f) (y : Y) : IsClopen { x | f x = y } :=
   ⟨isOpen_fiber hf _, isClosed_fiber hf _⟩
 #align is_locally_constant.is_clopen_fiber IsLocallyConstant.isClopen_fiber
 
-/- warning: is_locally_constant.iff_exists_open -> IsLocallyConstant.iff_exists_open is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] (f : X -> Y), Iff (IsLocallyConstant.{u1, u2} X Y _inst_1 f) (forall (x : X), Exists.{succ u1} (Set.{u1} X) (fun (U : Set.{u1} X) => Exists.{0} (IsOpen.{u1} X _inst_1 U) (fun (hU : IsOpen.{u1} X _inst_1 U) => Exists.{0} (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) x U) (fun (hx : Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) x U) => forall (x' : X), (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) x' U) -> (Eq.{succ u2} Y (f x') (f x))))))
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] (f : X -> Y), Iff (IsLocallyConstant.{u2, u1} X Y _inst_1 f) (forall (x : X), Exists.{succ u2} (Set.{u2} X) (fun (U : Set.{u2} X) => And (IsOpen.{u2} X _inst_1 U) (And (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) x U) (forall (x' : X), (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) x' U) -> (Eq.{succ u1} Y (f x') (f x))))))
-Case conversion may be inaccurate. Consider using '#align is_locally_constant.iff_exists_open IsLocallyConstant.iff_exists_openₓ'. -/
 theorem iff_exists_open (f : X → Y) :
     IsLocallyConstant f ↔ ∀ x, ∃ (U : Set X)(hU : IsOpen U)(hx : x ∈ U), ∀ x' ∈ U, f x' = f x :=
   (IsLocallyConstant.tfae f).out 0 4
 #align is_locally_constant.iff_exists_open IsLocallyConstant.iff_exists_open
 
-/- warning: is_locally_constant.iff_eventually_eq -> IsLocallyConstant.iff_eventually_eq is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] (f : X -> Y), Iff (IsLocallyConstant.{u1, u2} X Y _inst_1 f) (forall (x : X), Filter.Eventually.{u1} X (fun (y : X) => Eq.{succ u2} Y (f y) (f x)) (nhds.{u1} X _inst_1 x))
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] (f : X -> Y), Iff (IsLocallyConstant.{u2, u1} X Y _inst_1 f) (forall (x : X), Filter.Eventually.{u2} X (fun (y : X) => Eq.{succ u1} Y (f y) (f x)) (nhds.{u2} X _inst_1 x))
-Case conversion may be inaccurate. Consider using '#align is_locally_constant.iff_eventually_eq IsLocallyConstant.iff_eventually_eqₓ'. -/
 theorem iff_eventually_eq (f : X → Y) : IsLocallyConstant f ↔ ∀ x, ∀ᶠ y in 𝓝 x, f y = f x :=
   (IsLocallyConstant.tfae f).out 0 1
 #align is_locally_constant.iff_eventually_eq IsLocallyConstant.iff_eventually_eq
 
-/- warning: is_locally_constant.exists_open -> IsLocallyConstant.exists_open is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] {f : X -> Y}, (IsLocallyConstant.{u1, u2} X Y _inst_1 f) -> (forall (x : X), Exists.{succ u1} (Set.{u1} X) (fun (U : Set.{u1} X) => Exists.{0} (IsOpen.{u1} X _inst_1 U) (fun (hU : IsOpen.{u1} X _inst_1 U) => Exists.{0} (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) x U) (fun (hx : Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) x U) => forall (x' : X), (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) x' U) -> (Eq.{succ u2} Y (f x') (f x))))))
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] {f : X -> Y}, (IsLocallyConstant.{u2, u1} X Y _inst_1 f) -> (forall (x : X), Exists.{succ u2} (Set.{u2} X) (fun (U : Set.{u2} X) => And (IsOpen.{u2} X _inst_1 U) (And (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) x U) (forall (x' : X), (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) x' U) -> (Eq.{succ u1} Y (f x') (f x))))))
-Case conversion may be inaccurate. Consider using '#align is_locally_constant.exists_open IsLocallyConstant.exists_openₓ'. -/
 theorem exists_open {f : X → Y} (hf : IsLocallyConstant f) (x : X) :
     ∃ (U : Set X)(hU : IsOpen U)(hx : x ∈ U), ∀ x' ∈ U, f x' = f x :=
   (iff_exists_open f).1 hf x
 #align is_locally_constant.exists_open IsLocallyConstant.exists_open
 
-/- warning: is_locally_constant.eventually_eq -> IsLocallyConstant.eventually_eq is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] {f : X -> Y}, (IsLocallyConstant.{u1, u2} X Y _inst_1 f) -> (forall (x : X), Filter.Eventually.{u1} X (fun (y : X) => Eq.{succ u2} Y (f y) (f x)) (nhds.{u1} X _inst_1 x))
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] {f : X -> Y}, (IsLocallyConstant.{u2, u1} X Y _inst_1 f) -> (forall (x : X), Filter.Eventually.{u2} X (fun (y : X) => Eq.{succ u1} Y (f y) (f x)) (nhds.{u2} X _inst_1 x))
-Case conversion may be inaccurate. Consider using '#align is_locally_constant.eventually_eq IsLocallyConstant.eventually_eqₓ'. -/
 protected theorem eventually_eq {f : X → Y} (hf : IsLocallyConstant f) (x : X) :
     ∀ᶠ y in 𝓝 x, f y = f x :=
   (iff_eventually_eq f).1 hf x
@@ -180,66 +126,30 @@ theorem of_constant (f : X → Y) (h : ∀ x y, f x = f y) : IsLocallyConstant f
 #align is_locally_constant.of_constant IsLocallyConstant.of_constant
 -/
 
-/- warning: is_locally_constant.const -> IsLocallyConstant.const is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] (y : Y), IsLocallyConstant.{u1, u2} X Y _inst_1 (Function.const.{succ u2, succ u1} Y X y)
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] (y : Y), IsLocallyConstant.{u2, u1} X Y _inst_1 (Function.const.{succ u1, succ u2} Y X y)
-Case conversion may be inaccurate. Consider using '#align is_locally_constant.const IsLocallyConstant.constₓ'. -/
 theorem const (y : Y) : IsLocallyConstant (Function.const X y) :=
   of_constant _ fun _ _ => rfl
 #align is_locally_constant.const IsLocallyConstant.const
 
-/- warning: is_locally_constant.comp -> IsLocallyConstant.comp is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} {Z : Type.{u3}} [_inst_1 : TopologicalSpace.{u1} X] {f : X -> Y}, (IsLocallyConstant.{u1, u2} X Y _inst_1 f) -> (forall (g : Y -> Z), IsLocallyConstant.{u1, u3} X Z _inst_1 (Function.comp.{succ u1, succ u2, succ u3} X Y Z g f))
-but is expected to have type
-  forall {X : Type.{u3}} {Y : Type.{u2}} {Z : Type.{u1}} [_inst_1 : TopologicalSpace.{u3} X] {f : X -> Y}, (IsLocallyConstant.{u3, u2} X Y _inst_1 f) -> (forall (g : Y -> Z), IsLocallyConstant.{u3, u1} X Z _inst_1 (Function.comp.{succ u3, succ u2, succ u1} X Y Z g f))
-Case conversion may be inaccurate. Consider using '#align is_locally_constant.comp IsLocallyConstant.compₓ'. -/
 theorem comp {f : X → Y} (hf : IsLocallyConstant f) (g : Y → Z) : IsLocallyConstant (g ∘ f) :=
   fun s => by rw [Set.preimage_comp]; exact hf _
 #align is_locally_constant.comp IsLocallyConstant.comp
 
-/- warning: is_locally_constant.prod_mk -> IsLocallyConstant.prod_mk is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] {Y' : Type.{u3}} {f : X -> Y} {f' : X -> Y'}, (IsLocallyConstant.{u1, u2} X Y _inst_1 f) -> (IsLocallyConstant.{u1, u3} X Y' _inst_1 f') -> (IsLocallyConstant.{u1, max u2 u3} X (Prod.{u2, u3} Y Y') _inst_1 (fun (x : X) => Prod.mk.{u2, u3} Y Y' (f x) (f' x)))
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] {Y' : Type.{u3}} {f : X -> Y} {f' : X -> Y'}, (IsLocallyConstant.{u2, u1} X Y _inst_1 f) -> (IsLocallyConstant.{u2, u3} X Y' _inst_1 f') -> (IsLocallyConstant.{u2, max u3 u1} X (Prod.{u1, u3} Y Y') _inst_1 (fun (x : X) => Prod.mk.{u1, u3} Y Y' (f x) (f' x)))
-Case conversion may be inaccurate. Consider using '#align is_locally_constant.prod_mk IsLocallyConstant.prod_mkₓ'. -/
 theorem prod_mk {Y'} {f : X → Y} {f' : X → Y'} (hf : IsLocallyConstant f)
     (hf' : IsLocallyConstant f') : IsLocallyConstant fun x => (f x, f' x) :=
   (iff_eventually_eq _).2 fun x =>
     (hf.EventuallyEq x).mp <| (hf'.EventuallyEq x).mono fun x' hf' hf => Prod.ext hf hf'
 #align is_locally_constant.prod_mk IsLocallyConstant.prod_mk
 
-/- warning: is_locally_constant.comp₂ -> IsLocallyConstant.comp₂ is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} X] {Y₁ : Type.{u2}} {Y₂ : Type.{u3}} {Z : Type.{u4}} {f : X -> Y₁} {g : X -> Y₂}, (IsLocallyConstant.{u1, u2} X Y₁ _inst_1 f) -> (IsLocallyConstant.{u1, u3} X Y₂ _inst_1 g) -> (forall (h : Y₁ -> Y₂ -> Z), IsLocallyConstant.{u1, u4} X Z _inst_1 (fun (x : X) => h (f x) (g x)))
-but is expected to have type
-  forall {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} X] {Y₁ : Type.{u4}} {Y₂ : Type.{u3}} {Z : Type.{u2}} {f : X -> Y₁} {g : X -> Y₂}, (IsLocallyConstant.{u1, u4} X Y₁ _inst_1 f) -> (IsLocallyConstant.{u1, u3} X Y₂ _inst_1 g) -> (forall (h : Y₁ -> Y₂ -> Z), IsLocallyConstant.{u1, u2} X Z _inst_1 (fun (x : X) => h (f x) (g x)))
-Case conversion may be inaccurate. Consider using '#align is_locally_constant.comp₂ IsLocallyConstant.comp₂ₓ'. -/
 theorem comp₂ {Y₁ Y₂ Z : Type _} {f : X → Y₁} {g : X → Y₂} (hf : IsLocallyConstant f)
     (hg : IsLocallyConstant g) (h : Y₁ → Y₂ → Z) : IsLocallyConstant fun x => h (f x) (g x) :=
   (hf.prod_mk hg).comp fun x : Y₁ × Y₂ => h x.1 x.2
 #align is_locally_constant.comp₂ IsLocallyConstant.comp₂
 
-/- warning: is_locally_constant.comp_continuous -> IsLocallyConstant.comp_continuous is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} {Z : Type.{u3}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : TopologicalSpace.{u2} Y] {g : Y -> Z} {f : X -> Y}, (IsLocallyConstant.{u2, u3} Y Z _inst_2 g) -> (Continuous.{u1, u2} X Y _inst_1 _inst_2 f) -> (IsLocallyConstant.{u1, u3} X Z _inst_1 (Function.comp.{succ u1, succ u2, succ u3} X Y Z g f))
-but is expected to have type
-  forall {X : Type.{u1}} {Y : Type.{u3}} {Z : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : TopologicalSpace.{u3} Y] {g : Y -> Z} {f : X -> Y}, (IsLocallyConstant.{u3, u2} Y Z _inst_2 g) -> (Continuous.{u1, u3} X Y _inst_1 _inst_2 f) -> (IsLocallyConstant.{u1, u2} X Z _inst_1 (Function.comp.{succ u1, succ u3, succ u2} X Y Z g f))
-Case conversion may be inaccurate. Consider using '#align is_locally_constant.comp_continuous IsLocallyConstant.comp_continuousₓ'. -/
 theorem comp_continuous [TopologicalSpace Y] {g : Y → Z} {f : X → Y} (hg : IsLocallyConstant g)
     (hf : Continuous f) : IsLocallyConstant (g ∘ f) := fun s => by rw [Set.preimage_comp];
   exact hf.is_open_preimage _ (hg _)
 #align is_locally_constant.comp_continuous IsLocallyConstant.comp_continuous
 
-/- warning: is_locally_constant.apply_eq_of_is_preconnected -> IsLocallyConstant.apply_eq_of_isPreconnected is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] {f : X -> Y}, (IsLocallyConstant.{u1, u2} X Y _inst_1 f) -> (forall {s : Set.{u1} X}, (IsPreconnected.{u1} X _inst_1 s) -> (forall {x : X} {y : X}, (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) x s) -> (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) y s) -> (Eq.{succ u2} Y (f x) (f y))))
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] {f : X -> Y}, (IsLocallyConstant.{u2, u1} X Y _inst_1 f) -> (forall {s : Set.{u2} X}, (IsPreconnected.{u2} X _inst_1 s) -> (forall {x : X} {y : X}, (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) x s) -> (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) y s) -> (Eq.{succ u1} Y (f x) (f y))))
-Case conversion may be inaccurate. Consider using '#align is_locally_constant.apply_eq_of_is_preconnected IsLocallyConstant.apply_eq_of_isPreconnectedₓ'. -/
 /-- A locally constant function is constant on any preconnected set. -/
 theorem apply_eq_of_isPreconnected {f : X → Y} (hf : IsLocallyConstant f) {s : Set X}
     (hs : IsPreconnected s) {x y : X} (hx : x ∈ s) (hy : y ∈ s) : f x = f y :=
@@ -252,34 +162,16 @@ theorem apply_eq_of_isPreconnected {f : X → Y} (hf : IsLocallyConstant f) {s :
   · simpa only [inter_empty, not_nonempty_empty, inter_compl_self] using hs
 #align is_locally_constant.apply_eq_of_is_preconnected IsLocallyConstant.apply_eq_of_isPreconnected
 
-/- warning: is_locally_constant.apply_eq_of_preconnected_space -> IsLocallyConstant.apply_eq_of_preconnectedSpace is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : PreconnectedSpace.{u1} X _inst_1] {f : X -> Y}, (IsLocallyConstant.{u1, u2} X Y _inst_1 f) -> (forall (x : X) (y : X), Eq.{succ u2} Y (f x) (f y))
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : PreconnectedSpace.{u2} X _inst_1] {f : X -> Y}, (IsLocallyConstant.{u2, u1} X Y _inst_1 f) -> (forall (x : X) (y : X), Eq.{succ u1} Y (f x) (f y))
-Case conversion may be inaccurate. Consider using '#align is_locally_constant.apply_eq_of_preconnected_space IsLocallyConstant.apply_eq_of_preconnectedSpaceₓ'. -/
 theorem apply_eq_of_preconnectedSpace [PreconnectedSpace X] {f : X → Y} (hf : IsLocallyConstant f)
     (x y : X) : f x = f y :=
   hf.apply_eq_of_isPreconnected isPreconnected_univ trivial trivial
 #align is_locally_constant.apply_eq_of_preconnected_space IsLocallyConstant.apply_eq_of_preconnectedSpace
 
-/- warning: is_locally_constant.eq_const -> IsLocallyConstant.eq_const is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : PreconnectedSpace.{u1} X _inst_1] {f : X -> Y}, (IsLocallyConstant.{u1, u2} X Y _inst_1 f) -> (forall (x : X), Eq.{max (succ u1) (succ u2)} (X -> Y) f (Function.const.{succ u2, succ u1} Y X (f x)))
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : PreconnectedSpace.{u2} X _inst_1] {f : X -> Y}, (IsLocallyConstant.{u2, u1} X Y _inst_1 f) -> (forall (x : X), Eq.{max (succ u2) (succ u1)} (X -> Y) f (Function.const.{succ u1, succ u2} Y X (f x)))
-Case conversion may be inaccurate. Consider using '#align is_locally_constant.eq_const IsLocallyConstant.eq_constₓ'. -/
 theorem eq_const [PreconnectedSpace X] {f : X → Y} (hf : IsLocallyConstant f) (x : X) :
     f = Function.const X (f x) :=
   funext fun y => hf.apply_eq_of_preconnectedSpace y x
 #align is_locally_constant.eq_const IsLocallyConstant.eq_const
 
-/- warning: is_locally_constant.exists_eq_const -> IsLocallyConstant.exists_eq_const is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : PreconnectedSpace.{u1} X _inst_1] [_inst_3 : Nonempty.{succ u2} Y] {f : X -> Y}, (IsLocallyConstant.{u1, u2} X Y _inst_1 f) -> (Exists.{succ u2} Y (fun (y : Y) => Eq.{max (succ u1) (succ u2)} (X -> Y) f (Function.const.{succ u2, succ u1} Y X y)))
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : PreconnectedSpace.{u2} X _inst_1] [_inst_3 : Nonempty.{succ u1} Y] {f : X -> Y}, (IsLocallyConstant.{u2, u1} X Y _inst_1 f) -> (Exists.{succ u1} Y (fun (y : Y) => Eq.{max (succ u2) (succ u1)} (X -> Y) f (Function.const.{succ u1, succ u2} Y X y)))
-Case conversion may be inaccurate. Consider using '#align is_locally_constant.exists_eq_const IsLocallyConstant.exists_eq_constₓ'. -/
 theorem exists_eq_const [PreconnectedSpace X] [Nonempty Y] {f : X → Y} (hf : IsLocallyConstant f) :
     ∃ y, f = Function.const X y := by
   cases isEmpty_or_nonempty X
@@ -287,22 +179,10 @@ theorem exists_eq_const [PreconnectedSpace X] [Nonempty Y] {f : X → Y} (hf : I
   · exact ⟨f (Classical.arbitrary X), hf.eq_const _⟩
 #align is_locally_constant.exists_eq_const IsLocallyConstant.exists_eq_const
 
-/- warning: is_locally_constant.iff_is_const -> IsLocallyConstant.iff_is_const is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : PreconnectedSpace.{u1} X _inst_1] {f : X -> Y}, Iff (IsLocallyConstant.{u1, u2} X Y _inst_1 f) (forall (x : X) (y : X), Eq.{succ u2} Y (f x) (f y))
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : PreconnectedSpace.{u2} X _inst_1] {f : X -> Y}, Iff (IsLocallyConstant.{u2, u1} X Y _inst_1 f) (forall (x : X) (y : X), Eq.{succ u1} Y (f x) (f y))
-Case conversion may be inaccurate. Consider using '#align is_locally_constant.iff_is_const IsLocallyConstant.iff_is_constₓ'. -/
 theorem iff_is_const [PreconnectedSpace X] {f : X → Y} : IsLocallyConstant f ↔ ∀ x y, f x = f y :=
   ⟨fun h x y => h.apply_eq_of_isPreconnected isPreconnected_univ trivial trivial, of_constant _⟩
 #align is_locally_constant.iff_is_const IsLocallyConstant.iff_is_const
 
-/- warning: is_locally_constant.range_finite -> IsLocallyConstant.range_finite is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : CompactSpace.{u1} X _inst_1] {f : X -> Y}, (IsLocallyConstant.{u1, u2} X Y _inst_1 f) -> (Set.Finite.{u2} Y (Set.range.{u2, succ u1} Y X f))
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : CompactSpace.{u2} X _inst_1] {f : X -> Y}, (IsLocallyConstant.{u2, u1} X Y _inst_1 f) -> (Set.Finite.{u1} Y (Set.range.{u1, succ u2} Y X f))
-Case conversion may be inaccurate. Consider using '#align is_locally_constant.range_finite IsLocallyConstant.range_finiteₓ'. -/
 theorem range_finite [CompactSpace X] {f : X → Y} (hf : IsLocallyConstant f) :
     (Set.range f).Finite := by
   letI : TopologicalSpace Y := ⊥; haveI := discreteTopology_bot Y
@@ -344,12 +224,6 @@ theorem div [Div Y] ⦃f g : X → Y⦄ (hf : IsLocallyConstant f) (hg : IsLocal
 #align is_locally_constant.sub IsLocallyConstant.sub
 -/
 
-/- warning: is_locally_constant.desc -> IsLocallyConstant.desc is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} X] {α : Type.{u2}} {β : Type.{u3}} (f : X -> α) (g : α -> β), (IsLocallyConstant.{u1, u3} X β _inst_1 (Function.comp.{succ u1, succ u2, succ u3} X α β g f)) -> (Function.Injective.{succ u2, succ u3} α β g) -> (IsLocallyConstant.{u1, u2} X α _inst_1 f)
-but is expected to have type
-  forall {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} X] {α : Type.{u3}} {β : Type.{u2}} (f : X -> α) (g : α -> β), (IsLocallyConstant.{u1, u2} X β _inst_1 (Function.comp.{succ u1, succ u3, succ u2} X α β g f)) -> (Function.Injective.{succ u3, succ u2} α β g) -> (IsLocallyConstant.{u1, u3} X α _inst_1 f)
-Case conversion may be inaccurate. Consider using '#align is_locally_constant.desc IsLocallyConstant.descₓ'. -/
 /-- If a composition of a function `f` followed by an injection `g` is locally
 constant, then the locally constant property descends to `f`. -/
 theorem desc {α β : Type _} (f : X → α) (g : α → β) (h : IsLocallyConstant (g ∘ f))
@@ -365,12 +239,6 @@ theorem desc {α β : Type _} (f : X → α) (g : α → β) (h : IsLocallyConst
   apply h
 #align is_locally_constant.desc IsLocallyConstant.desc
 
-/- warning: is_locally_constant.of_constant_on_connected_components -> IsLocallyConstant.of_constant_on_connected_components is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : LocallyConnectedSpace.{u1} X _inst_1] {f : X -> Y}, (forall (x : X) (y : X), (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) y (connectedComponent.{u1} X _inst_1 x)) -> (Eq.{succ u2} Y (f y) (f x))) -> (IsLocallyConstant.{u1, u2} X Y _inst_1 f)
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : LocallyConnectedSpace.{u2} X _inst_1] {f : X -> Y}, (forall (x : X) (y : X), (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) y (connectedComponent.{u2} X _inst_1 x)) -> (Eq.{succ u1} Y (f y) (f x))) -> (IsLocallyConstant.{u2, u1} X Y _inst_1 f)
-Case conversion may be inaccurate. Consider using '#align is_locally_constant.of_constant_on_connected_components IsLocallyConstant.of_constant_on_connected_componentsₓ'. -/
 theorem of_constant_on_connected_components [LocallyConnectedSpace X] {f : X → Y}
     (h : ∀ x, ∀ y ∈ connectedComponent x, f y = f x) : IsLocallyConstant f :=
   by
@@ -378,12 +246,6 @@ theorem of_constant_on_connected_components [LocallyConnectedSpace X] {f : X →
   exact fun x => ⟨connectedComponent x, isOpen_connectedComponent, mem_connectedComponent, h x⟩
 #align is_locally_constant.of_constant_on_connected_components IsLocallyConstant.of_constant_on_connected_components
 
-/- warning: is_locally_constant.of_constant_on_preconnected_clopens -> IsLocallyConstant.of_constant_on_preconnected_clopens is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : LocallyConnectedSpace.{u1} X _inst_1] {f : X -> Y}, (forall (U : Set.{u1} X), (IsPreconnected.{u1} X _inst_1 U) -> (IsClopen.{u1} X _inst_1 U) -> (forall (x : X), (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) x U) -> (forall (y : X), (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) y U) -> (Eq.{succ u2} Y (f y) (f x))))) -> (IsLocallyConstant.{u1, u2} X Y _inst_1 f)
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : LocallyConnectedSpace.{u2} X _inst_1] {f : X -> Y}, (forall (U : Set.{u2} X), (IsPreconnected.{u2} X _inst_1 U) -> (IsClopen.{u2} X _inst_1 U) -> (forall (x : X), (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) x U) -> (forall (y : X), (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) y U) -> (Eq.{succ u1} Y (f y) (f x))))) -> (IsLocallyConstant.{u2, u1} X Y _inst_1 f)
-Case conversion may be inaccurate. Consider using '#align is_locally_constant.of_constant_on_preconnected_clopens IsLocallyConstant.of_constant_on_preconnected_clopensₓ'. -/
 theorem of_constant_on_preconnected_clopens [LocallyConnectedSpace X] {f : X → Y}
     (h : ∀ U : Set X, IsPreconnected U → IsClopen U → ∀ x ∈ U, ∀ y ∈ U, f y = f x) :
     IsLocallyConstant f :=
@@ -413,44 +275,20 @@ instance : CoeFun (LocallyConstant X Y) fun _ => X → Y :=
 
 initialize_simps_projections LocallyConstant (toFun → apply)
 
-/- warning: locally_constant.to_fun_eq_coe -> LocallyConstant.toFun_eq_coe is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] (f : LocallyConstant.{u1, u2} X Y _inst_1), Eq.{max (succ u1) (succ u2)} (X -> Y) (LocallyConstant.toFun.{u1, u2} X Y _inst_1 f) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) f)
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] (f : LocallyConstant.{u2, u1} X Y _inst_1), Eq.{max (succ u2) (succ u1)} (X -> Y) (LocallyConstant.toFun.{u2, u1} X Y _inst_1 f) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f)
-Case conversion may be inaccurate. Consider using '#align locally_constant.to_fun_eq_coe LocallyConstant.toFun_eq_coeₓ'. -/
 @[simp]
 theorem toFun_eq_coe (f : LocallyConstant X Y) : f.toFun = f :=
   rfl
 #align locally_constant.to_fun_eq_coe LocallyConstant.toFun_eq_coe
 
-/- warning: locally_constant.coe_mk -> LocallyConstant.coe_mk is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] (f : X -> Y) (h : IsLocallyConstant.{u1, u2} X Y _inst_1 f), Eq.{max (succ u1) (succ u2)} (X -> Y) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) (LocallyConstant.mk.{u1, u2} X Y _inst_1 f h)) f
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] (f : X -> Y) (h : IsLocallyConstant.{u2, u1} X Y _inst_1 f), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : X), (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) (LocallyConstant.mk.{u2, u1} X Y _inst_1 f h)) f
-Case conversion may be inaccurate. Consider using '#align locally_constant.coe_mk LocallyConstant.coe_mkₓ'. -/
 @[simp]
 theorem coe_mk (f : X → Y) (h) : ⇑(⟨f, h⟩ : LocallyConstant X Y) = f :=
   rfl
 #align locally_constant.coe_mk LocallyConstant.coe_mk
 
-/- warning: locally_constant.congr_fun -> LocallyConstant.congr_fun is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] {f : LocallyConstant.{u1, u2} X Y _inst_1} {g : LocallyConstant.{u1, u2} X Y _inst_1}, (Eq.{max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) f g) -> (forall (x : X), Eq.{succ u2} Y (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) f x) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) g x))
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] {f : LocallyConstant.{u2, u1} X Y _inst_1} {g : LocallyConstant.{u2, u1} X Y _inst_1}, (Eq.{max (succ u2) (succ u1)} (LocallyConstant.{u2, u1} X Y _inst_1) f g) -> (forall (x : X), Eq.{succ u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) g x))
-Case conversion may be inaccurate. Consider using '#align locally_constant.congr_fun LocallyConstant.congr_funₓ'. -/
 theorem congr_fun {f g : LocallyConstant X Y} (h : f = g) (x : X) : f x = g x :=
   congr_arg (fun h : LocallyConstant X Y => h x) h
 #align locally_constant.congr_fun LocallyConstant.congr_fun
 
-/- warning: locally_constant.congr_arg -> LocallyConstant.congr_arg is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] (f : LocallyConstant.{u1, u2} X Y _inst_1) {x : X} {y : X}, (Eq.{succ u1} X x y) -> (Eq.{succ u2} Y (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) f x) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) f y))
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] (f : LocallyConstant.{u2, u1} X Y _inst_1) {x : X} {y : X}, (Eq.{succ u2} X x y) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f y))
-Case conversion may be inaccurate. Consider using '#align locally_constant.congr_arg LocallyConstant.congr_argₓ'. -/
 theorem congr_arg (f : LocallyConstant X Y) {x y : X} (h : x = y) : f x = f y :=
   congr_arg (fun x : X => f x) h
 #align locally_constant.congr_arg LocallyConstant.congr_arg
@@ -463,34 +301,16 @@ theorem coe_injective : @Function.Injective (LocallyConstant X Y) (X → Y) coeF
 #align locally_constant.coe_injective LocallyConstant.coe_injective
 -/
 
-/- warning: locally_constant.coe_inj -> LocallyConstant.coe_inj is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] {f : LocallyConstant.{u1, u2} X Y _inst_1} {g : LocallyConstant.{u1, u2} X Y _inst_1}, Iff (Eq.{max (succ u1) (succ u2)} ((fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) f) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) f) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) g)) (Eq.{max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) f g)
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] {f : LocallyConstant.{u2, u1} X Y _inst_1} {g : LocallyConstant.{u2, u1} X Y _inst_1}, Iff (Eq.{max (succ u2) (succ u1)} (forall (a : X), (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) g)) (Eq.{max (succ u2) (succ u1)} (LocallyConstant.{u2, u1} X Y _inst_1) f g)
-Case conversion may be inaccurate. Consider using '#align locally_constant.coe_inj LocallyConstant.coe_injₓ'. -/
 @[simp, norm_cast]
 theorem coe_inj {f g : LocallyConstant X Y} : (f : X → Y) = g ↔ f = g :=
   coe_injective.eq_iff
 #align locally_constant.coe_inj LocallyConstant.coe_inj
 
-/- warning: locally_constant.ext -> LocallyConstant.ext is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] {{f : LocallyConstant.{u1, u2} X Y _inst_1}} {{g : LocallyConstant.{u1, u2} X Y _inst_1}}, (forall (x : X), Eq.{succ u2} Y (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) f x) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) g x)) -> (Eq.{max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) f g)
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] {{f : LocallyConstant.{u2, u1} X Y _inst_1}} {{g : LocallyConstant.{u2, u1} X Y _inst_1}}, (forall (x : X), Eq.{succ u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) g x)) -> (Eq.{max (succ u2) (succ u1)} (LocallyConstant.{u2, u1} X Y _inst_1) f g)
-Case conversion may be inaccurate. Consider using '#align locally_constant.ext LocallyConstant.extₓ'. -/
 @[ext]
 theorem ext ⦃f g : LocallyConstant X Y⦄ (h : ∀ x, f x = g x) : f = g :=
   coe_injective (funext h)
 #align locally_constant.ext LocallyConstant.ext
 
-/- warning: locally_constant.ext_iff -> LocallyConstant.ext_iff is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] {f : LocallyConstant.{u1, u2} X Y _inst_1} {g : LocallyConstant.{u1, u2} X Y _inst_1}, Iff (Eq.{max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) f g) (forall (x : X), Eq.{succ u2} Y (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) f x) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) g x))
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] {f : LocallyConstant.{u2, u1} X Y _inst_1} {g : LocallyConstant.{u2, u1} X Y _inst_1}, Iff (Eq.{max (succ u2) (succ u1)} (LocallyConstant.{u2, u1} X Y _inst_1) f g) (forall (x : X), Eq.{succ u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) g x))
-Case conversion may be inaccurate. Consider using '#align locally_constant.ext_iff LocallyConstant.ext_iffₓ'. -/
 theorem ext_iff {f g : LocallyConstant X Y} : f = g ↔ ∀ x, f x = g x :=
   ⟨fun h x => h ▸ rfl, fun h => ext h⟩
 #align locally_constant.ext_iff LocallyConstant.ext_iff
@@ -499,12 +319,6 @@ section CodomainTopologicalSpace
 
 variable [TopologicalSpace Y] (f : LocallyConstant X Y)
 
-/- warning: locally_constant.continuous -> LocallyConstant.continuous is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : TopologicalSpace.{u2} Y] (f : LocallyConstant.{u1, u2} X Y _inst_1), Continuous.{u1, u2} X Y _inst_1 _inst_2 (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) f)
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : TopologicalSpace.{u1} Y] (f : LocallyConstant.{u2, u1} X Y _inst_1), Continuous.{u2, u1} X Y _inst_1 _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f)
-Case conversion may be inaccurate. Consider using '#align locally_constant.continuous LocallyConstant.continuousₓ'. -/
 protected theorem continuous : Continuous f :=
   f.IsLocallyConstant.Continuous
 #align locally_constant.continuous LocallyConstant.continuous
@@ -521,34 +335,17 @@ instance : Coe (LocallyConstant X Y) C(X, Y) :=
   ⟨toContinuousMap⟩
 
 /- warning: locally_constant.to_continuous_map_eq_coe clashes with [anonymous] -> [anonymous]
-warning: locally_constant.to_continuous_map_eq_coe -> [anonymous] is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : TopologicalSpace.{u2} Y] (f : LocallyConstant.{u1, u2} X Y _inst_1), Eq.{max (succ u1) (succ u2)} (ContinuousMap.{u1, u2} X Y _inst_1 _inst_2) (LocallyConstant.toContinuousMap.{u1, u2} X Y _inst_1 _inst_2 f) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Sort.{max (succ u1) (succ u2)}) [self : HasLiftT.{max (succ u1) (succ u2), max (succ u1) (succ u2)} a b] => self.0) (LocallyConstant.{u1, u2} X Y _inst_1) (ContinuousMap.{u1, u2} X Y _inst_1 _inst_2) (HasLiftT.mk.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (ContinuousMap.{u1, u2} X Y _inst_1 _inst_2) (CoeTCₓ.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (ContinuousMap.{u1, u2} X Y _inst_1 _inst_2) (coeBase.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (ContinuousMap.{u1, u2} X Y _inst_1 _inst_2) (LocallyConstant.ContinuousMap.hasCoe.{u1, u2} X Y _inst_1 _inst_2)))) f)
-but is expected to have type
-  forall {X : Type.{u1}} {Y : Type.{u2}}, (Nat -> X -> Y) -> Nat -> (List.{u1} X) -> (List.{u2} Y)
 Case conversion may be inaccurate. Consider using '#align locally_constant.to_continuous_map_eq_coe [anonymous]ₓ'. -/
 @[simp]
 theorem [anonymous] : f.toContinuousMap = f :=
   rfl
 #align locally_constant.to_continuous_map_eq_coe [anonymous]
 
-/- warning: locally_constant.coe_continuous_map -> LocallyConstant.coe_continuousMap is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : TopologicalSpace.{u2} Y] (f : LocallyConstant.{u1, u2} X Y _inst_1), Eq.{max (succ u1) (succ u2)} ((fun (_x : ContinuousMap.{u1, u2} X Y _inst_1 _inst_2) => X -> Y) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Sort.{max (succ u1) (succ u2)}) [self : HasLiftT.{max (succ u1) (succ u2), max (succ u1) (succ u2)} a b] => self.0) (LocallyConstant.{u1, u2} X Y _inst_1) (ContinuousMap.{u1, u2} X Y _inst_1 _inst_2) (HasLiftT.mk.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (ContinuousMap.{u1, u2} X Y _inst_1 _inst_2) (CoeTCₓ.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (ContinuousMap.{u1, u2} X Y _inst_1 _inst_2) (coeBase.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (ContinuousMap.{u1, u2} X Y _inst_1 _inst_2) (LocallyConstant.ContinuousMap.hasCoe.{u1, u2} X Y _inst_1 _inst_2)))) f)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (ContinuousMap.{u1, u2} X Y _inst_1 _inst_2) (fun (_x : ContinuousMap.{u1, u2} X Y _inst_1 _inst_2) => X -> Y) (ContinuousMap.hasCoeToFun.{u1, u2} X Y _inst_1 _inst_2) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Sort.{max (succ u1) (succ u2)}) [self : HasLiftT.{max (succ u1) (succ u2), max (succ u1) (succ u2)} a b] => self.0) (LocallyConstant.{u1, u2} X Y _inst_1) (ContinuousMap.{u1, u2} X Y _inst_1 _inst_2) (HasLiftT.mk.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (ContinuousMap.{u1, u2} X Y _inst_1 _inst_2) (CoeTCₓ.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (ContinuousMap.{u1, u2} X Y _inst_1 _inst_2) (coeBase.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (ContinuousMap.{u1, u2} X Y _inst_1 _inst_2) (LocallyConstant.ContinuousMap.hasCoe.{u1, u2} X Y _inst_1 _inst_2)))) f)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) f)
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : TopologicalSpace.{u1} Y] (f : LocallyConstant.{u2, u1} X Y _inst_1), Eq.{max (succ u2) (succ u1)} (forall (a : X), (fun (x._@.Mathlib.Topology.ContinuousFunction.Basic._hyg.699 : X) => Y) a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (ContinuousMap.{u2, u1} X Y _inst_1 _inst_2) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.ContinuousFunction.Basic._hyg.699 : X) => Y) _x) (ContinuousMapClass.toFunLike.{max u2 u1, u2, u1} (ContinuousMap.{u2, u1} X Y _inst_1 _inst_2) X Y _inst_1 _inst_2 (ContinuousMap.instContinuousMapClassContinuousMap.{u2, u1} X Y _inst_1 _inst_2)) (LocallyConstant.toContinuousMap.{u2, u1} X Y _inst_1 _inst_2 f)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f)
-Case conversion may be inaccurate. Consider using '#align locally_constant.coe_continuous_map LocallyConstant.coe_continuousMapₓ'. -/
 @[simp]
 theorem coe_continuousMap : ((f : C(X, Y)) : X → Y) = (f : X → Y) :=
   rfl
 #align locally_constant.coe_continuous_map LocallyConstant.coe_continuousMap
 
-/- warning: locally_constant.to_continuous_map_injective -> LocallyConstant.toContinuousMap_injective is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : TopologicalSpace.{u2} Y], Function.Injective.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (ContinuousMap.{u1, u2} X Y _inst_1 _inst_2) (LocallyConstant.toContinuousMap.{u1, u2} X Y _inst_1 _inst_2)
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : TopologicalSpace.{u1} Y], Function.Injective.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (LocallyConstant.{u2, u1} X Y _inst_1) (ContinuousMap.{u2, u1} X Y _inst_1 _inst_2) (LocallyConstant.toContinuousMap.{u2, u1} X Y _inst_1 _inst_2)
-Case conversion may be inaccurate. Consider using '#align locally_constant.to_continuous_map_injective LocallyConstant.toContinuousMap_injectiveₓ'. -/
 theorem toContinuousMap_injective :
     Function.Injective (toContinuousMap : LocallyConstant X Y → C(X, Y)) := fun _ _ h =>
   ext (ContinuousMap.congr_fun h)
@@ -563,12 +360,6 @@ def const (X : Type _) {Y : Type _} [TopologicalSpace X] (y : Y) : LocallyConsta
 #align locally_constant.const LocallyConstant.const
 -/
 
-/- warning: locally_constant.coe_const -> LocallyConstant.coe_const is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] (y : Y), Eq.{max (succ u1) (succ u2)} ((fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.const.{u1, u2} X Y _inst_1 y)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) (LocallyConstant.const.{u1, u2} X Y _inst_1 y)) (Function.const.{succ u2, succ u1} Y X y)
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] (y : Y), Eq.{max (succ u2) (succ u1)} (forall (a : X), (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) (LocallyConstant.const.{u2, u1} X Y _inst_1 y)) (Function.const.{succ u1, succ u2} Y X y)
-Case conversion may be inaccurate. Consider using '#align locally_constant.coe_const LocallyConstant.coe_constₓ'. -/
 @[simp]
 theorem coe_const (y : Y) : (const X y : X → Y) = Function.const X y :=
   rfl
@@ -597,12 +388,6 @@ def ofClopen {X : Type _} [TopologicalSpace X] {U : Set X} [∀ x, Decidable (x
 #align locally_constant.of_clopen LocallyConstant.ofClopen
 -/
 
-/- warning: locally_constant.of_clopen_fiber_zero -> LocallyConstant.ofClopen_fiber_zero is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} [_inst_2 : TopologicalSpace.{u1} X] {U : Set.{u1} X} [_inst_3 : forall (x : X), Decidable (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) x U)] (hU : IsClopen.{u1} X _inst_2 U), Eq.{succ u1} (Set.{u1} X) (Set.preimage.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) (coeFn.{succ u1, succ u1} (LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) _inst_2) (fun (_x : LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) _inst_2) => X -> (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))))) (LocallyConstant.hasCoeToFun.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) _inst_2) (LocallyConstant.ofClopen.{u1} X _inst_2 U (fun (x : X) => _inst_3 x) hU)) (Singleton.singleton.{0, 0} (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) (Set.{0} (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))))) (Set.hasSingleton.{0} (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))))) (OfNat.ofNat.{0} (Fin (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))) 0 (OfNat.mk.{0} (Fin (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))) 0 (Zero.zero.{0} (Fin (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))) (Fin.hasZeroOfNeZero (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)) (CharZero.NeZero.two.{0} Nat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} Nat (NonAssocSemiring.toAddCommMonoidWithOne.{0} Nat (Semiring.toNonAssocSemiring.{0} Nat Nat.semiring))) (StrictOrderedSemiring.to_charZero.{0} Nat Nat.strictOrderedSemiring)))))))) U
-but is expected to have type
-  forall {X : Type.{u1}} [_inst_2 : TopologicalSpace.{u1} X] {U : Set.{u1} X} [_inst_3 : forall (x : X), Decidable (Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) x U)] (hU : IsClopen.{u1} X _inst_2 U), Eq.{succ u1} (Set.{u1} X) (Set.preimage.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) (FunLike.coe.{succ u1, succ u1, 1} (LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _inst_2) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _x) (LocallyConstant.instFunLikeLocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _inst_2) (LocallyConstant.ofClopen.{u1} X _inst_2 U (fun (x : X) => _inst_3 x) hU)) (Singleton.singleton.{0, 0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) (Set.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))) (Set.instSingletonSet.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))) (OfNat.ofNat.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) 0 (Fin.instOfNatFin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) 0 (NeZero.succ (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))))))) U
-Case conversion may be inaccurate. Consider using '#align locally_constant.of_clopen_fiber_zero LocallyConstant.ofClopen_fiber_zeroₓ'. -/
 @[simp]
 theorem ofClopen_fiber_zero {X : Type _} [TopologicalSpace X] {U : Set X} [∀ x, Decidable (x ∈ U)]
     (hU : IsClopen U) : ofClopen hU ⁻¹' ({0} : Set (Fin 2)) = U :=
@@ -613,12 +398,6 @@ theorem ofClopen_fiber_zero {X : Type _} [TopologicalSpace X] {U : Set X} [∀ x
   tauto
 #align locally_constant.of_clopen_fiber_zero LocallyConstant.ofClopen_fiber_zero
 
-/- warning: locally_constant.of_clopen_fiber_one -> LocallyConstant.ofClopen_fiber_one is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} [_inst_2 : TopologicalSpace.{u1} X] {U : Set.{u1} X} [_inst_3 : forall (x : X), Decidable (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) x U)] (hU : IsClopen.{u1} X _inst_2 U), Eq.{succ u1} (Set.{u1} X) (Set.preimage.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) (coeFn.{succ u1, succ u1} (LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) _inst_2) (fun (_x : LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) _inst_2) => X -> (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))))) (LocallyConstant.hasCoeToFun.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) _inst_2) (LocallyConstant.ofClopen.{u1} X _inst_2 U (fun (x : X) => _inst_3 x) hU)) (Singleton.singleton.{0, 0} (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) (Set.{0} (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))))) (Set.hasSingleton.{0} (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))))) (OfNat.ofNat.{0} (Fin (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))) 1 (OfNat.mk.{0} (Fin (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))) 1 (One.one.{0} (Fin (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))) (Fin.hasOneOfNeZero (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)) (CharZero.NeZero.two.{0} Nat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} Nat (NonAssocSemiring.toAddCommMonoidWithOne.{0} Nat (Semiring.toNonAssocSemiring.{0} Nat Nat.semiring))) (StrictOrderedSemiring.to_charZero.{0} Nat Nat.strictOrderedSemiring)))))))) (HasCompl.compl.{u1} (Set.{u1} X) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} X) (Set.booleanAlgebra.{u1} X)) U)
-but is expected to have type
-  forall {X : Type.{u1}} [_inst_2 : TopologicalSpace.{u1} X] {U : Set.{u1} X} [_inst_3 : forall (x : X), Decidable (Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) x U)] (hU : IsClopen.{u1} X _inst_2 U), Eq.{succ u1} (Set.{u1} X) (Set.preimage.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) (FunLike.coe.{succ u1, succ u1, 1} (LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _inst_2) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _x) (LocallyConstant.instFunLikeLocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _inst_2) (LocallyConstant.ofClopen.{u1} X _inst_2 U (fun (x : X) => _inst_3 x) hU)) (Singleton.singleton.{0, 0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) (Set.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))) (Set.instSingletonSet.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))) (OfNat.ofNat.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) 1 (Fin.instOfNatFin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) 1 (NeZero.succ (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))))))) (HasCompl.compl.{u1} (Set.{u1} X) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} X) (Set.instBooleanAlgebraSet.{u1} X)) U)
-Case conversion may be inaccurate. Consider using '#align locally_constant.of_clopen_fiber_one LocallyConstant.ofClopen_fiber_oneₓ'. -/
 @[simp]
 theorem ofClopen_fiber_one {X : Type _} [TopologicalSpace X] {U : Set X} [∀ x, Decidable (x ∈ U)]
     (hU : IsClopen U) : ofClopen hU ⁻¹' ({1} : Set (Fin 2)) = Uᶜ :=
@@ -629,12 +408,6 @@ theorem ofClopen_fiber_one {X : Type _} [TopologicalSpace X] {U : Set X} [∀ x,
   tauto
 #align locally_constant.of_clopen_fiber_one LocallyConstant.ofClopen_fiber_one
 
-/- warning: locally_constant.locally_constant_eq_of_fiber_zero_eq -> LocallyConstant.locallyConstant_eq_of_fiber_zero_eq is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} [_inst_2 : TopologicalSpace.{u1} X] (f : LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) _inst_2) (g : LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) _inst_2), (Eq.{succ u1} (Set.{u1} X) (Set.preimage.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) (coeFn.{succ u1, succ u1} (LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) _inst_2) (fun (_x : LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) _inst_2) => X -> (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))))) (LocallyConstant.hasCoeToFun.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) _inst_2) f) (Singleton.singleton.{0, 0} (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) (Set.{0} (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))))) (Set.hasSingleton.{0} (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))))) (OfNat.ofNat.{0} (Fin (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))) 0 (OfNat.mk.{0} (Fin (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))) 0 (Zero.zero.{0} (Fin (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))) (Fin.hasZeroOfNeZero (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)) (CharZero.NeZero.two.{0} Nat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} Nat (NonAssocSemiring.toAddCommMonoidWithOne.{0} Nat (Semiring.toNonAssocSemiring.{0} Nat Nat.semiring))) (StrictOrderedSemiring.to_charZero.{0} Nat Nat.strictOrderedSemiring)))))))) (Set.preimage.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) (coeFn.{succ u1, succ u1} (LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) _inst_2) (fun (_x : LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) _inst_2) => X -> (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))))) (LocallyConstant.hasCoeToFun.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) _inst_2) g) (Singleton.singleton.{0, 0} (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) (Set.{0} (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))))) (Set.hasSingleton.{0} (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))))) (OfNat.ofNat.{0} (Fin (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))) 0 (OfNat.mk.{0} (Fin (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))) 0 (Zero.zero.{0} (Fin (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))) (Fin.hasZeroOfNeZero (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)) (CharZero.NeZero.two.{0} Nat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} Nat (NonAssocSemiring.toAddCommMonoidWithOne.{0} Nat (Semiring.toNonAssocSemiring.{0} Nat Nat.semiring))) (StrictOrderedSemiring.to_charZero.{0} Nat Nat.strictOrderedSemiring))))))))) -> (Eq.{succ u1} (LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) _inst_2) f g)
-but is expected to have type
-  forall {X : Type.{u1}} [_inst_2 : TopologicalSpace.{u1} X] (f : LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _inst_2) (g : LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _inst_2), (Eq.{succ u1} (Set.{u1} X) (Set.preimage.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) (FunLike.coe.{succ u1, succ u1, 1} (LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _inst_2) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _x) (LocallyConstant.instFunLikeLocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _inst_2) f) (Singleton.singleton.{0, 0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) (Set.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))) (Set.instSingletonSet.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))) (OfNat.ofNat.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) 0 (Fin.instOfNatFin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) 0 (NeZero.succ (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))))))) (Set.preimage.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) (FunLike.coe.{succ u1, succ u1, 1} (LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _inst_2) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _x) (LocallyConstant.instFunLikeLocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _inst_2) g) (Singleton.singleton.{0, 0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) (Set.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))) (Set.instSingletonSet.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))) (OfNat.ofNat.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) 0 (Fin.instOfNatFin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) 0 (NeZero.succ (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))))))) -> (Eq.{succ u1} (LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _inst_2) f g)
-Case conversion may be inaccurate. Consider using '#align locally_constant.locally_constant_eq_of_fiber_zero_eq LocallyConstant.locallyConstant_eq_of_fiber_zero_eqₓ'. -/
 theorem locallyConstant_eq_of_fiber_zero_eq {X : Type _} [TopologicalSpace X]
     (f g : LocallyConstant X (Fin 2)) (h : f ⁻¹' ({0} : Set (Fin 2)) = g ⁻¹' {0}) : f = g :=
   by
@@ -643,54 +416,24 @@ theorem locallyConstant_eq_of_fiber_zero_eq {X : Type _} [TopologicalSpace X]
   exact Fin.fin_two_eq_of_eq_zero_iff (h x)
 #align locally_constant.locally_constant_eq_of_fiber_zero_eq LocallyConstant.locallyConstant_eq_of_fiber_zero_eq
 
-/- warning: locally_constant.range_finite -> LocallyConstant.range_finite is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : CompactSpace.{u1} X _inst_1] (f : LocallyConstant.{u1, u2} X Y _inst_1), Set.Finite.{u2} Y (Set.range.{u2, succ u1} Y X (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) f))
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : CompactSpace.{u2} X _inst_1] (f : LocallyConstant.{u2, u1} X Y _inst_1), Set.Finite.{u1} Y (Set.range.{u1, succ u2} Y X (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f))
-Case conversion may be inaccurate. Consider using '#align locally_constant.range_finite LocallyConstant.range_finiteₓ'. -/
 theorem range_finite [CompactSpace X] (f : LocallyConstant X Y) : (Set.range f).Finite :=
   f.IsLocallyConstant.range_finite
 #align locally_constant.range_finite LocallyConstant.range_finite
 
-/- warning: locally_constant.apply_eq_of_is_preconnected -> LocallyConstant.apply_eq_of_isPreconnected is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] (f : LocallyConstant.{u1, u2} X Y _inst_1) {s : Set.{u1} X}, (IsPreconnected.{u1} X _inst_1 s) -> (forall {x : X} {y : X}, (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) x s) -> (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) y s) -> (Eq.{succ u2} Y (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) f x) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) f y)))
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] (f : LocallyConstant.{u2, u1} X Y _inst_1) {s : Set.{u2} X}, (IsPreconnected.{u2} X _inst_1 s) -> (forall {x : X} {y : X}, (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) x s) -> (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) y s) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f y)))
-Case conversion may be inaccurate. Consider using '#align locally_constant.apply_eq_of_is_preconnected LocallyConstant.apply_eq_of_isPreconnectedₓ'. -/
 theorem apply_eq_of_isPreconnected (f : LocallyConstant X Y) {s : Set X} (hs : IsPreconnected s)
     {x y : X} (hx : x ∈ s) (hy : y ∈ s) : f x = f y :=
   f.IsLocallyConstant.apply_eq_of_isPreconnected hs hx hy
 #align locally_constant.apply_eq_of_is_preconnected LocallyConstant.apply_eq_of_isPreconnected
 
-/- warning: locally_constant.apply_eq_of_preconnected_space -> LocallyConstant.apply_eq_of_preconnectedSpace is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : PreconnectedSpace.{u1} X _inst_1] (f : LocallyConstant.{u1, u2} X Y _inst_1) (x : X) (y : X), Eq.{succ u2} Y (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) f x) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) f y)
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : PreconnectedSpace.{u2} X _inst_1] (f : LocallyConstant.{u2, u1} X Y _inst_1) (x : X) (y : X), Eq.{succ u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f y)
-Case conversion may be inaccurate. Consider using '#align locally_constant.apply_eq_of_preconnected_space LocallyConstant.apply_eq_of_preconnectedSpaceₓ'. -/
 theorem apply_eq_of_preconnectedSpace [PreconnectedSpace X] (f : LocallyConstant X Y) (x y : X) :
     f x = f y :=
   f.IsLocallyConstant.apply_eq_of_isPreconnected isPreconnected_univ trivial trivial
 #align locally_constant.apply_eq_of_preconnected_space LocallyConstant.apply_eq_of_preconnectedSpace
 
-/- warning: locally_constant.eq_const -> LocallyConstant.eq_const is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : PreconnectedSpace.{u1} X _inst_1] (f : LocallyConstant.{u1, u2} X Y _inst_1) (x : X), Eq.{max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) f (LocallyConstant.const.{u1, u2} X Y _inst_1 (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) f x))
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : PreconnectedSpace.{u2} X _inst_1] (f : LocallyConstant.{u2, u1} X Y _inst_1) (x : X), Eq.{max (succ u2) (succ u1)} (LocallyConstant.{u2, u1} X Y _inst_1) f (LocallyConstant.const.{u2, u1} X ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) x) _inst_1 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f x))
-Case conversion may be inaccurate. Consider using '#align locally_constant.eq_const LocallyConstant.eq_constₓ'. -/
 theorem eq_const [PreconnectedSpace X] (f : LocallyConstant X Y) (x : X) : f = const X (f x) :=
   ext fun y => apply_eq_of_preconnectedSpace f _ _
 #align locally_constant.eq_const LocallyConstant.eq_const
 
-/- warning: locally_constant.exists_eq_const -> LocallyConstant.exists_eq_const is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : PreconnectedSpace.{u1} X _inst_1] [_inst_3 : Nonempty.{succ u2} Y] (f : LocallyConstant.{u1, u2} X Y _inst_1), Exists.{succ u2} Y (fun (y : Y) => Eq.{max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) f (LocallyConstant.const.{u1, u2} X Y _inst_1 y))
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : PreconnectedSpace.{u2} X _inst_1] [_inst_3 : Nonempty.{succ u1} Y] (f : LocallyConstant.{u2, u1} X Y _inst_1), Exists.{succ u1} Y (fun (y : Y) => Eq.{max (succ u2) (succ u1)} (LocallyConstant.{u2, u1} X Y _inst_1) f (LocallyConstant.const.{u2, u1} X Y _inst_1 y))
-Case conversion may be inaccurate. Consider using '#align locally_constant.exists_eq_const LocallyConstant.exists_eq_constₓ'. -/
 theorem exists_eq_const [PreconnectedSpace X] [Nonempty Y] (f : LocallyConstant X Y) :
     ∃ y, f = const X y :=
   by
@@ -706,33 +449,15 @@ def map (f : Y → Z) : LocallyConstant X Y → LocallyConstant X Z := fun g =>
 #align locally_constant.map LocallyConstant.map
 -/
 
-/- warning: locally_constant.map_apply -> LocallyConstant.map_apply is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} {Z : Type.{u3}} [_inst_1 : TopologicalSpace.{u1} X] (f : Y -> Z) (g : LocallyConstant.{u1, u2} X Y _inst_1), Eq.{max (succ u1) (succ u3)} (X -> Z) (coeFn.{max (succ u1) (succ u3), max (succ u1) (succ u3)} (LocallyConstant.{u1, u3} X Z _inst_1) (fun (_x : LocallyConstant.{u1, u3} X Z _inst_1) => X -> Z) (LocallyConstant.hasCoeToFun.{u1, u3} X Z _inst_1) (LocallyConstant.map.{u1, u2, u3} X Y Z _inst_1 f g)) (Function.comp.{succ u1, succ u2, succ u3} X Y Z f (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) g))
-but is expected to have type
-  forall {X : Type.{u3}} {Y : Type.{u2}} {Z : Type.{u1}} [_inst_1 : TopologicalSpace.{u3} X] (f : Y -> Z) (g : LocallyConstant.{u3, u2} X Y _inst_1), Eq.{max (succ u3) (succ u1)} (forall (ᾰ : X), (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Z) ᾰ) (FunLike.coe.{max (succ u3) (succ u1), succ u3, succ u1} (LocallyConstant.{u3, u1} X Z _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Z) _x) (LocallyConstant.instFunLikeLocallyConstant.{u3, u1} X Z _inst_1) (LocallyConstant.map.{u3, u2, u1} X Y Z _inst_1 f g)) (Function.comp.{succ u3, succ u2, succ u1} X Y Z f (FunLike.coe.{max (succ u3) (succ u2), succ u3, succ u2} (LocallyConstant.{u3, u2} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u3, u2} X Y _inst_1) g))
-Case conversion may be inaccurate. Consider using '#align locally_constant.map_apply LocallyConstant.map_applyₓ'. -/
 @[simp]
 theorem map_apply (f : Y → Z) (g : LocallyConstant X Y) : ⇑(map f g) = f ∘ g :=
   rfl
 #align locally_constant.map_apply LocallyConstant.map_apply
 
-/- warning: locally_constant.map_id -> LocallyConstant.map_id is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X], Eq.{max (succ u1) (succ u2)} ((LocallyConstant.{u1, u2} X Y _inst_1) -> (LocallyConstant.{u1, u2} X Y _inst_1)) (LocallyConstant.map.{u1, u2, u2} X Y Y _inst_1 (id.{succ u2} Y)) (id.{max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1))
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X], Eq.{max (succ u2) (succ u1)} ((LocallyConstant.{u2, u1} X Y _inst_1) -> (LocallyConstant.{u2, u1} X Y _inst_1)) (LocallyConstant.map.{u2, u1, u1} X Y Y _inst_1 (id.{succ u1} Y)) (id.{max (succ u2) (succ u1)} (LocallyConstant.{u2, u1} X Y _inst_1))
-Case conversion may be inaccurate. Consider using '#align locally_constant.map_id LocallyConstant.map_idₓ'. -/
 @[simp]
 theorem map_id : @map X Y Y _ id = id := by ext; rfl
 #align locally_constant.map_id LocallyConstant.map_id
 
-/- warning: locally_constant.map_comp -> LocallyConstant.map_comp is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} X] {Y₁ : Type.{u2}} {Y₂ : Type.{u3}} {Y₃ : Type.{u4}} (g : Y₂ -> Y₃) (f : Y₁ -> Y₂), Eq.{max (max (succ u1) (succ u2)) (succ u1) (succ u4)} ((LocallyConstant.{u1, u2} X Y₁ _inst_1) -> (LocallyConstant.{u1, u4} X Y₃ _inst_1)) (Function.comp.{max (succ u1) (succ u2), max (succ u1) (succ u3), max (succ u1) (succ u4)} (LocallyConstant.{u1, u2} X Y₁ _inst_1) (LocallyConstant.{u1, u3} X Y₂ _inst_1) (LocallyConstant.{u1, u4} X Y₃ _inst_1) (LocallyConstant.map.{u1, u3, u4} X Y₂ Y₃ _inst_1 g) (LocallyConstant.map.{u1, u2, u3} X Y₁ Y₂ _inst_1 f)) (LocallyConstant.map.{u1, u2, u4} X Y₁ Y₃ _inst_1 (Function.comp.{succ u2, succ u3, succ u4} Y₁ Y₂ Y₃ g f))
-but is expected to have type
-  forall {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} X] {Y₁ : Type.{u4}} {Y₂ : Type.{u3}} {Y₃ : Type.{u2}} (g : Y₂ -> Y₃) (f : Y₁ -> Y₂), Eq.{max (max (succ u1) (succ u4)) (succ u2)} ((LocallyConstant.{u1, u4} X Y₁ _inst_1) -> (LocallyConstant.{u1, u2} X Y₃ _inst_1)) (Function.comp.{max (succ u4) (succ u1), max (succ u1) (succ u3), max (succ u1) (succ u2)} (LocallyConstant.{u1, u4} X Y₁ _inst_1) (LocallyConstant.{u1, u3} X Y₂ _inst_1) (LocallyConstant.{u1, u2} X Y₃ _inst_1) (LocallyConstant.map.{u1, u3, u2} X Y₂ Y₃ _inst_1 g) (LocallyConstant.map.{u1, u4, u3} X Y₁ Y₂ _inst_1 f)) (LocallyConstant.map.{u1, u4, u2} X Y₁ Y₃ _inst_1 (Function.comp.{succ u4, succ u3, succ u2} Y₁ Y₂ Y₃ g f))
-Case conversion may be inaccurate. Consider using '#align locally_constant.map_comp LocallyConstant.map_compₓ'. -/
 @[simp]
 theorem map_comp {Y₁ Y₂ Y₃ : Type _} (g : Y₂ → Y₃) (f : Y₁ → Y₂) :
     @map X _ _ _ g ∘ map f = map (g ∘ f) := by ext; rfl
@@ -747,12 +472,6 @@ def flip {X α β : Type _} [TopologicalSpace X] (f : LocallyConstant X (α →
 #align locally_constant.flip LocallyConstant.flip
 -/
 
-/- warning: locally_constant.unflip -> LocallyConstant.unflip is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_2 : Fintype.{u2} α] [_inst_3 : TopologicalSpace.{u1} X], (α -> (LocallyConstant.{u1, u3} X β _inst_3)) -> (LocallyConstant.{u1, max u2 u3} X (α -> β) _inst_3)
-but is expected to have type
-  forall {X : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_2 : Finite.{succ u2} α] [_inst_3 : TopologicalSpace.{u1} X], (α -> (LocallyConstant.{u1, u3} X β _inst_3)) -> (LocallyConstant.{u1, max u2 u3} X (α -> β) _inst_3)
-Case conversion may be inaccurate. Consider using '#align locally_constant.unflip LocallyConstant.unflipₓ'. -/
 /-- If α is finite, this constructs a locally constant function to `α → β` given a
 family of locally constant functions with values in β indexed by α. -/
 def unflip {X α β : Type _} [Fintype α] [TopologicalSpace X] (f : α → LocallyConstant X β) :
@@ -768,23 +487,11 @@ def unflip {X α β : Type _} [Fintype α] [TopologicalSpace X] (f : α → Loca
     apply (f a).IsLocallyConstant
 #align locally_constant.unflip LocallyConstant.unflip
 
-/- warning: locally_constant.unflip_flip -> LocallyConstant.unflip_flip is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_2 : Fintype.{u2} α] [_inst_3 : TopologicalSpace.{u1} X] (f : LocallyConstant.{u1, max u2 u3} X (α -> β) _inst_3), Eq.{max (succ u1) (succ (max u2 u3))} (LocallyConstant.{u1, max u2 u3} X (α -> β) _inst_3) (LocallyConstant.unflip.{u1, u2, u3} X α β _inst_2 _inst_3 (LocallyConstant.flip.{u1, u2, u3} X α β _inst_3 f)) f
-but is expected to have type
-  forall {X : Type.{u3}} {α : Type.{u2}} {β : Type.{u1}} [_inst_2 : Finite.{succ u2} α] [_inst_3 : TopologicalSpace.{u3} X] (f : LocallyConstant.{u3, max u2 u1} X (α -> β) _inst_3), Eq.{max (max (succ u3) (succ u2)) (succ u1)} (LocallyConstant.{u3, max u2 u1} X (α -> β) _inst_3) (LocallyConstant.unflip.{u3, u2, u1} X α β _inst_2 _inst_3 (LocallyConstant.flip.{u3, u2, u1} X α β _inst_3 f)) f
-Case conversion may be inaccurate. Consider using '#align locally_constant.unflip_flip LocallyConstant.unflip_flipₓ'. -/
 @[simp]
 theorem unflip_flip {X α β : Type _} [Fintype α] [TopologicalSpace X]
     (f : LocallyConstant X (α → β)) : unflip f.flip = f := by ext; rfl
 #align locally_constant.unflip_flip LocallyConstant.unflip_flip
 
-/- warning: locally_constant.flip_unflip -> LocallyConstant.flip_unflip is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_2 : Fintype.{u2} α] [_inst_3 : TopologicalSpace.{u1} X] (f : α -> (LocallyConstant.{u1, u3} X β _inst_3)), Eq.{max (succ u2) (succ u1) (succ u3)} (α -> (LocallyConstant.{u1, u3} X β _inst_3)) (LocallyConstant.flip.{u1, u2, u3} X α β _inst_3 (LocallyConstant.unflip.{u1, u2, u3} X α β _inst_2 _inst_3 f)) f
-but is expected to have type
-  forall {X : Type.{u3}} {α : Type.{u2}} {β : Type.{u1}} [_inst_2 : Finite.{succ u2} α] [_inst_3 : TopologicalSpace.{u3} X] (f : α -> (LocallyConstant.{u3, u1} X β _inst_3)), Eq.{max (max (succ u3) (succ u2)) (succ u1)} (α -> (LocallyConstant.{u3, u1} X β _inst_3)) (LocallyConstant.flip.{u3, u2, u1} X α β _inst_3 (LocallyConstant.unflip.{u3, u2, u1} X α β _inst_2 _inst_3 f)) f
-Case conversion may be inaccurate. Consider using '#align locally_constant.flip_unflip LocallyConstant.flip_unflipₓ'. -/
 @[simp]
 theorem flip_unflip {X α β : Type _} [Fintype α] [TopologicalSpace X]
     (f : α → LocallyConstant X β) : (unflip f).flip = f := by ext; rfl
@@ -812,45 +519,21 @@ noncomputable def comap (f : X → Y) : LocallyConstant Y Z → LocallyConstant
 #align locally_constant.comap LocallyConstant.comap
 -/
 
-/- warning: locally_constant.coe_comap -> LocallyConstant.coe_comap is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} {Z : Type.{u3}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : TopologicalSpace.{u2} Y] (f : X -> Y) (g : LocallyConstant.{u2, u3} Y Z _inst_2), (Continuous.{u1, u2} X Y _inst_1 _inst_2 f) -> (Eq.{max (succ u1) (succ u3)} (X -> Z) (coeFn.{max (succ u1) (succ u3), max (succ u1) (succ u3)} (LocallyConstant.{u1, u3} X Z _inst_1) (fun (_x : LocallyConstant.{u1, u3} X Z _inst_1) => X -> Z) (LocallyConstant.hasCoeToFun.{u1, u3} X Z _inst_1) (LocallyConstant.comap.{u1, u2, u3} X Y Z _inst_1 _inst_2 f g)) (Function.comp.{succ u1, succ u2, succ u3} X Y Z (coeFn.{max (succ u2) (succ u3), max (succ u2) (succ u3)} (LocallyConstant.{u2, u3} Y Z _inst_2) (fun (_x : LocallyConstant.{u2, u3} Y Z _inst_2) => Y -> Z) (LocallyConstant.hasCoeToFun.{u2, u3} Y Z _inst_2) g) f))
-but is expected to have type
-  forall {X : Type.{u1}} {Y : Type.{u3}} {Z : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : TopologicalSpace.{u3} Y] (f : X -> Y) (g : LocallyConstant.{u3, u2} Y Z _inst_2), (Continuous.{u1, u3} X Y _inst_1 _inst_2 f) -> (Eq.{max (succ u1) (succ u2)} (forall (ᾰ : X), (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Z) ᾰ) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (LocallyConstant.{u1, u2} X Z _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Z) _x) (LocallyConstant.instFunLikeLocallyConstant.{u1, u2} X Z _inst_1) (LocallyConstant.comap.{u1, u3, u2} X Y Z _inst_1 _inst_2 f g)) (Function.comp.{succ u1, succ u3, succ u2} X Y Z (FunLike.coe.{max (succ u3) (succ u2), succ u3, succ u2} (LocallyConstant.{u3, u2} Y Z _inst_2) Y (fun (_x : Y) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : Y) => Z) _x) (LocallyConstant.instFunLikeLocallyConstant.{u3, u2} Y Z _inst_2) g) f))
-Case conversion may be inaccurate. Consider using '#align locally_constant.coe_comap LocallyConstant.coe_comapₓ'. -/
 @[simp]
 theorem coe_comap (f : X → Y) (g : LocallyConstant Y Z) (hf : Continuous f) :
     ⇑(comap f g) = g ∘ f := by rw [comap, dif_pos hf]; rfl
 #align locally_constant.coe_comap LocallyConstant.coe_comap
 
-/- warning: locally_constant.comap_id -> LocallyConstant.comap_id is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Z : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X], Eq.{max (succ u1) (succ u2)} ((LocallyConstant.{u1, u2} X Z _inst_1) -> (LocallyConstant.{u1, u2} X Z _inst_1)) (LocallyConstant.comap.{u1, u1, u2} X X Z _inst_1 _inst_1 (id.{succ u1} X)) (id.{max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Z _inst_1))
-but is expected to have type
-  forall {X : Type.{u2}} {Z : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X], Eq.{max (succ u2) (succ u1)} ((LocallyConstant.{u2, u1} X Z _inst_1) -> (LocallyConstant.{u2, u1} X Z _inst_1)) (LocallyConstant.comap.{u2, u2, u1} X X Z _inst_1 _inst_1 (id.{succ u2} X)) (id.{max (succ u2) (succ u1)} (LocallyConstant.{u2, u1} X Z _inst_1))
-Case conversion may be inaccurate. Consider using '#align locally_constant.comap_id LocallyConstant.comap_idₓ'. -/
 @[simp]
 theorem comap_id : @comap X X Z _ _ id = id := by ext;
   simp only [continuous_id, id.def, Function.comp.right_id, coe_comap]
 #align locally_constant.comap_id LocallyConstant.comap_id
 
-/- warning: locally_constant.comap_comp -> LocallyConstant.comap_comp is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} {Z : Type.{u3}} {α : Type.{u4}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : TopologicalSpace.{u2} Y] [_inst_3 : TopologicalSpace.{u3} Z] (f : X -> Y) (g : Y -> Z), (Continuous.{u1, u2} X Y _inst_1 _inst_2 f) -> (Continuous.{u2, u3} Y Z _inst_2 _inst_3 g) -> (Eq.{max (max (succ u3) (succ u4)) (succ u1) (succ u4)} ((LocallyConstant.{u3, u4} Z α _inst_3) -> (LocallyConstant.{u1, u4} X α _inst_1)) (Function.comp.{max (succ u3) (succ u4), max (succ u2) (succ u4), max (succ u1) (succ u4)} (LocallyConstant.{u3, u4} Z α _inst_3) (LocallyConstant.{u2, u4} Y α _inst_2) (LocallyConstant.{u1, u4} X α _inst_1) (LocallyConstant.comap.{u1, u2, u4} X Y α _inst_1 _inst_2 f) (LocallyConstant.comap.{u2, u3, u4} Y Z α _inst_2 _inst_3 g)) (LocallyConstant.comap.{u1, u3, u4} X Z α _inst_1 _inst_3 (Function.comp.{succ u1, succ u2, succ u3} X Y Z g f)))
-but is expected to have type
-  forall {X : Type.{u3}} {Y : Type.{u2}} {Z : Type.{u4}} {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u3} X] [_inst_2 : TopologicalSpace.{u2} Y] [_inst_3 : TopologicalSpace.{u4} Z] (f : X -> Y) (g : Y -> Z), (Continuous.{u3, u2} X Y _inst_1 _inst_2 f) -> (Continuous.{u2, u4} Y Z _inst_2 _inst_3 g) -> (Eq.{max (max (succ u3) (succ u4)) (succ u1)} ((LocallyConstant.{u4, u1} Z α _inst_3) -> (LocallyConstant.{u3, u1} X α _inst_1)) (Function.comp.{max (succ u1) (succ u4), max (succ u1) (succ u2), max (succ u1) (succ u3)} (LocallyConstant.{u4, u1} Z α _inst_3) (LocallyConstant.{u2, u1} Y α _inst_2) (LocallyConstant.{u3, u1} X α _inst_1) (LocallyConstant.comap.{u3, u2, u1} X Y α _inst_1 _inst_2 f) (LocallyConstant.comap.{u2, u4, u1} Y Z α _inst_2 _inst_3 g)) (LocallyConstant.comap.{u3, u4, u1} X Z α _inst_1 _inst_3 (Function.comp.{succ u3, succ u2, succ u4} X Y Z g f)))
-Case conversion may be inaccurate. Consider using '#align locally_constant.comap_comp LocallyConstant.comap_compₓ'. -/
 theorem comap_comp [TopologicalSpace Z] (f : X → Y) (g : Y → Z) (hf : Continuous f)
     (hg : Continuous g) : @comap _ _ α _ _ f ∘ comap g = comap (g ∘ f) := by ext;
   simp only [hf, hg, hg.comp hf, coe_comap]
 #align locally_constant.comap_comp LocallyConstant.comap_comp
 
-/- warning: locally_constant.comap_const -> LocallyConstant.comap_const is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u2}} {Z : Type.{u3}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : TopologicalSpace.{u2} Y] (f : X -> Y) (y : Y), (forall (x : X), Eq.{succ u2} Y (f x) y) -> (Eq.{max (max (succ u2) (succ u3)) (succ u1) (succ u3)} ((LocallyConstant.{u2, u3} Y Z _inst_2) -> (LocallyConstant.{u1, u3} X Z _inst_1)) (LocallyConstant.comap.{u1, u2, u3} X Y Z _inst_1 _inst_2 f) (fun (g : LocallyConstant.{u2, u3} Y Z _inst_2) => LocallyConstant.mk.{u1, u3} X Z _inst_1 (fun (x : X) => coeFn.{max (succ u2) (succ u3), max (succ u2) (succ u3)} (LocallyConstant.{u2, u3} Y Z _inst_2) (fun (_x : LocallyConstant.{u2, u3} Y Z _inst_2) => Y -> Z) (LocallyConstant.hasCoeToFun.{u2, u3} Y Z _inst_2) g y) (IsLocallyConstant.const.{u1, u3} X Z _inst_1 (coeFn.{max (succ u2) (succ u3), max (succ u2) (succ u3)} (LocallyConstant.{u2, u3} Y Z _inst_2) (fun (_x : LocallyConstant.{u2, u3} Y Z _inst_2) => Y -> Z) (LocallyConstant.hasCoeToFun.{u2, u3} Y Z _inst_2) g y))))
-but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u3}} {Z : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : TopologicalSpace.{u3} Y] (f : X -> Y) (y : Y), (forall (x : X), Eq.{succ u3} Y (f x) y) -> (Eq.{max (max (succ u2) (succ u3)) (succ u1)} ((LocallyConstant.{u3, u1} Y Z _inst_2) -> (LocallyConstant.{u2, u1} X Z _inst_1)) (LocallyConstant.comap.{u2, u3, u1} X Y Z _inst_1 _inst_2 f) (fun (g : LocallyConstant.{u3, u1} Y Z _inst_2) => LocallyConstant.mk.{u2, u1} X Z _inst_1 (fun (x : X) => FunLike.coe.{max (succ u3) (succ u1), succ u3, succ u1} (LocallyConstant.{u3, u1} Y Z _inst_2) Y (fun (_x : Y) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : Y) => Z) _x) (LocallyConstant.instFunLikeLocallyConstant.{u3, u1} Y Z _inst_2) g y) (IsLocallyConstant.const.{u1, u2} X Z _inst_1 (FunLike.coe.{max (succ u3) (succ u1), succ u3, succ u1} (LocallyConstant.{u3, u1} Y Z _inst_2) Y (fun (_x : Y) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : Y) => Z) _x) (LocallyConstant.instFunLikeLocallyConstant.{u3, u1} Y Z _inst_2) g y))))
-Case conversion may be inaccurate. Consider using '#align locally_constant.comap_const LocallyConstant.comap_constₓ'. -/
 theorem comap_const (f : X → Y) (y : Y) (h : ∀ x, f x = y) :
     (comap f : LocallyConstant Y Z → LocallyConstant X Z) = fun g =>
       ⟨fun x => g y, IsLocallyConstant.const _⟩ :=
@@ -876,12 +559,6 @@ def desc {X α β : Type _} [TopologicalSpace X] {g : α → β} (f : X → α)
 #align locally_constant.desc LocallyConstant.desc
 -/
 
-/- warning: locally_constant.coe_desc -> LocallyConstant.coe_desc is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_2 : TopologicalSpace.{u1} X] (f : X -> α) (g : α -> β) (h : LocallyConstant.{u1, u3} X β _inst_2) (cond : Eq.{max (succ u1) (succ u3)} (X -> β) (Function.comp.{succ u1, succ u2, succ u3} X α β g f) (coeFn.{max (succ u1) (succ u3), max (succ u1) (succ u3)} (LocallyConstant.{u1, u3} X β _inst_2) (fun (_x : LocallyConstant.{u1, u3} X β _inst_2) => X -> β) (LocallyConstant.hasCoeToFun.{u1, u3} X β _inst_2) h)) (inj : Function.Injective.{succ u2, succ u3} α β g), Eq.{max (succ u1) (succ u2)} (X -> α) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X α _inst_2) (fun (_x : LocallyConstant.{u1, u2} X α _inst_2) => X -> α) (LocallyConstant.hasCoeToFun.{u1, u2} X α _inst_2) (LocallyConstant.desc.{u1, u2, u3} X α β _inst_2 g f h cond inj)) f
-but is expected to have type
-  forall {X : Type.{u3}} {α : Type.{u2}} {β : Type.{u1}} [_inst_2 : TopologicalSpace.{u3} X] (f : X -> α) (g : α -> β) (h : LocallyConstant.{u3, u1} X β _inst_2) (cond : Eq.{max (succ u3) (succ u1)} (X -> β) (Function.comp.{succ u3, succ u2, succ u1} X α β g f) (FunLike.coe.{max (succ u3) (succ u1), succ u3, succ u1} (LocallyConstant.{u3, u1} X β _inst_2) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => β) _x) (LocallyConstant.instFunLikeLocallyConstant.{u3, u1} X β _inst_2) h)) (inj : Function.Injective.{succ u2, succ u1} α β g), Eq.{max (succ u3) (succ u2)} (forall (ᾰ : X), (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => α) ᾰ) (FunLike.coe.{max (succ u3) (succ u2), succ u3, succ u2} (LocallyConstant.{u3, u2} X α _inst_2) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => α) _x) (LocallyConstant.instFunLikeLocallyConstant.{u3, u2} X α _inst_2) (LocallyConstant.desc.{u3, u2, u1} X α β _inst_2 g f h cond inj)) f
-Case conversion may be inaccurate. Consider using '#align locally_constant.coe_desc LocallyConstant.coe_descₓ'. -/
 @[simp]
 theorem coe_desc {X α β : Type _} [TopologicalSpace X] (f : X → α) (g : α → β)
     (h : LocallyConstant X β) (cond : g ∘ f = h) (inj : Function.Injective g) :
@@ -922,12 +599,6 @@ noncomputable def mulIndicator (hU : IsClopen U) : LocallyConstant X R
 
 variable (a : X)
 
-/- warning: locally_constant.mul_indicator_apply_eq_if -> LocallyConstant.mulIndicator_apply_eq_if is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} X] {R : Type.{u2}} [_inst_2 : One.{u2} R] {U : Set.{u1} X} (f : LocallyConstant.{u1, u2} X R _inst_1) (a : X) (hU : IsClopen.{u1} X _inst_1 U), Eq.{succ u2} R (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X R _inst_1) (fun (_x : LocallyConstant.{u1, u2} X R _inst_1) => X -> R) (LocallyConstant.hasCoeToFun.{u1, u2} X R _inst_1) (LocallyConstant.mulIndicator.{u1, u2} X _inst_1 R _inst_2 U f hU) a) (ite.{succ u2} R (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) a U) (Classical.propDecidable (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) a U)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X R _inst_1) (fun (_x : LocallyConstant.{u1, u2} X R _inst_1) => X -> R) (LocallyConstant.hasCoeToFun.{u1, u2} X R _inst_1) f a) (OfNat.ofNat.{u2} R 1 (OfNat.mk.{u2} R 1 (One.one.{u2} R _inst_2))))
-but is expected to have type
-  forall {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u2} X] {R : Type.{u1}} [_inst_2 : One.{u1} R] {U : Set.{u2} X} (f : LocallyConstant.{u2, u1} X R _inst_1) (a : X) (hU : IsClopen.{u2} X _inst_1 U), Eq.{succ u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => R) a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X R _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => R) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X R _inst_1) (LocallyConstant.mulIndicator.{u2, u1} X _inst_1 R _inst_2 U f hU) a) (ite.{succ u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => R) a) (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) a U) (Classical.propDecidable (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) a U)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X R _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => R) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X R _inst_1) f a) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => R) a) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => R) a) _inst_2)))
-Case conversion may be inaccurate. Consider using '#align locally_constant.mul_indicator_apply_eq_if LocallyConstant.mulIndicator_apply_eq_ifₓ'. -/
 @[to_additive]
 theorem mulIndicator_apply_eq_if (hU : IsClopen U) :
     mulIndicator f hU a = if a ∈ U then f a else 1 :=
@@ -937,24 +608,12 @@ theorem mulIndicator_apply_eq_if (hU : IsClopen U) :
 
 variable {a}
 
-/- warning: locally_constant.mul_indicator_of_mem -> LocallyConstant.mulIndicator_of_mem is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} X] {R : Type.{u2}} [_inst_2 : One.{u2} R] {U : Set.{u1} X} (f : LocallyConstant.{u1, u2} X R _inst_1) {a : X} (hU : IsClopen.{u1} X _inst_1 U), (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) a U) -> (Eq.{succ u2} R (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X R _inst_1) (fun (_x : LocallyConstant.{u1, u2} X R _inst_1) => X -> R) (LocallyConstant.hasCoeToFun.{u1, u2} X R _inst_1) (LocallyConstant.mulIndicator.{u1, u2} X _inst_1 R _inst_2 U f hU) a) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X R _inst_1) (fun (_x : LocallyConstant.{u1, u2} X R _inst_1) => X -> R) (LocallyConstant.hasCoeToFun.{u1, u2} X R _inst_1) f a))
-but is expected to have type
-  forall {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u2} X] {R : Type.{u1}} [_inst_2 : One.{u1} R] {U : Set.{u2} X} (f : LocallyConstant.{u2, u1} X R _inst_1) {a : X} (hU : IsClopen.{u2} X _inst_1 U), (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) a U) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => R) a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X R _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => R) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X R _inst_1) (LocallyConstant.mulIndicator.{u2, u1} X _inst_1 R _inst_2 U f hU) a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X R _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => R) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X R _inst_1) f a))
-Case conversion may be inaccurate. Consider using '#align locally_constant.mul_indicator_of_mem LocallyConstant.mulIndicator_of_memₓ'. -/
 @[to_additive]
 theorem mulIndicator_of_mem (hU : IsClopen U) (h : a ∈ U) : f.mulIndicator hU a = f a := by
   rw [mul_indicator_apply]; apply Set.mulIndicator_of_mem h
 #align locally_constant.mul_indicator_of_mem LocallyConstant.mulIndicator_of_mem
 #align locally_constant.indicator_of_mem LocallyConstant.indicator_of_mem
 
-/- warning: locally_constant.mul_indicator_of_not_mem -> LocallyConstant.mulIndicator_of_not_mem is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} X] {R : Type.{u2}} [_inst_2 : One.{u2} R] {U : Set.{u1} X} (f : LocallyConstant.{u1, u2} X R _inst_1) {a : X} (hU : IsClopen.{u1} X _inst_1 U), (Not (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) a U)) -> (Eq.{succ u2} R (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X R _inst_1) (fun (_x : LocallyConstant.{u1, u2} X R _inst_1) => X -> R) (LocallyConstant.hasCoeToFun.{u1, u2} X R _inst_1) (LocallyConstant.mulIndicator.{u1, u2} X _inst_1 R _inst_2 U f hU) a) (OfNat.ofNat.{u2} R 1 (OfNat.mk.{u2} R 1 (One.one.{u2} R _inst_2))))
-but is expected to have type
-  forall {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u2} X] {R : Type.{u1}} [_inst_2 : One.{u1} R] {U : Set.{u2} X} (f : LocallyConstant.{u2, u1} X R _inst_1) {a : X} (hU : IsClopen.{u2} X _inst_1 U), (Not (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) a U)) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => R) a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X R _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => R) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X R _inst_1) (LocallyConstant.mulIndicator.{u2, u1} X _inst_1 R _inst_2 U f hU) a) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => R) a) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => R) a) _inst_2)))
-Case conversion may be inaccurate. Consider using '#align locally_constant.mul_indicator_of_not_mem LocallyConstant.mulIndicator_of_not_memₓ'. -/
 @[to_additive]
 theorem mulIndicator_of_not_mem (hU : IsClopen U) (h : a ∉ U) : f.mulIndicator hU a = 1 := by
   rw [mul_indicator_apply]; apply Set.mulIndicator_of_not_mem h

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

@@ -197,9 +197,7 @@ but is expected to have type
   forall {X : Type.{u3}} {Y : Type.{u2}} {Z : Type.{u1}} [_inst_1 : TopologicalSpace.{u3} X] {f : X -> Y}, (IsLocallyConstant.{u3, u2} X Y _inst_1 f) -> (forall (g : Y -> Z), IsLocallyConstant.{u3, u1} X Z _inst_1 (Function.comp.{succ u3, succ u2, succ u1} X Y Z g f))
 Case conversion may be inaccurate. Consider using '#align is_locally_constant.comp IsLocallyConstant.compₓ'. -/
 theorem comp {f : X → Y} (hf : IsLocallyConstant f) (g : Y → Z) : IsLocallyConstant (g ∘ f) :=
-  fun s => by
-  rw [Set.preimage_comp]
-  exact hf _
+  fun s => by rw [Set.preimage_comp]; exact hf _
 #align is_locally_constant.comp IsLocallyConstant.comp
 
 /- warning: is_locally_constant.prod_mk -> IsLocallyConstant.prod_mk is a dubious translation:
@@ -232,9 +230,7 @@ but is expected to have type
   forall {X : Type.{u1}} {Y : Type.{u3}} {Z : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : TopologicalSpace.{u3} Y] {g : Y -> Z} {f : X -> Y}, (IsLocallyConstant.{u3, u2} Y Z _inst_2 g) -> (Continuous.{u1, u3} X Y _inst_1 _inst_2 f) -> (IsLocallyConstant.{u1, u2} X Z _inst_1 (Function.comp.{succ u1, succ u3, succ u2} X Y Z g f))
 Case conversion may be inaccurate. Consider using '#align is_locally_constant.comp_continuous IsLocallyConstant.comp_continuousₓ'. -/
 theorem comp_continuous [TopologicalSpace Y] {g : Y → Z} {f : X → Y} (hg : IsLocallyConstant g)
-    (hf : Continuous f) : IsLocallyConstant (g ∘ f) := fun s =>
-  by
-  rw [Set.preimage_comp]
+    (hf : Continuous f) : IsLocallyConstant (g ∘ f) := fun s => by rw [Set.preimage_comp];
   exact hf.is_open_preimage _ (hg _)
 #align is_locally_constant.comp_continuous IsLocallyConstant.comp_continuous
 
@@ -706,9 +702,7 @@ theorem exists_eq_const [PreconnectedSpace X] [Nonempty Y] (f : LocallyConstant
 #print LocallyConstant.map /-
 /-- Push forward of locally constant maps under any map, by post-composition. -/
 def map (f : Y → Z) : LocallyConstant X Y → LocallyConstant X Z := fun g =>
-  ⟨f ∘ g, fun s => by
-    rw [Set.preimage_comp]
-    apply g.is_locally_constant⟩
+  ⟨f ∘ g, fun s => by rw [Set.preimage_comp]; apply g.is_locally_constant⟩
 #align locally_constant.map LocallyConstant.map
 -/
 
@@ -730,9 +724,7 @@ but is expected to have type
   forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X], Eq.{max (succ u2) (succ u1)} ((LocallyConstant.{u2, u1} X Y _inst_1) -> (LocallyConstant.{u2, u1} X Y _inst_1)) (LocallyConstant.map.{u2, u1, u1} X Y Y _inst_1 (id.{succ u1} Y)) (id.{max (succ u2) (succ u1)} (LocallyConstant.{u2, u1} X Y _inst_1))
 Case conversion may be inaccurate. Consider using '#align locally_constant.map_id LocallyConstant.map_idₓ'. -/
 @[simp]
-theorem map_id : @map X Y Y _ id = id := by
-  ext
-  rfl
+theorem map_id : @map X Y Y _ id = id := by ext; rfl
 #align locally_constant.map_id LocallyConstant.map_id
 
 /- warning: locally_constant.map_comp -> LocallyConstant.map_comp is a dubious translation:
@@ -743,9 +735,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align locally_constant.map_comp LocallyConstant.map_compₓ'. -/
 @[simp]
 theorem map_comp {Y₁ Y₂ Y₃ : Type _} (g : Y₂ → Y₃) (f : Y₁ → Y₂) :
-    @map X _ _ _ g ∘ map f = map (g ∘ f) := by
-  ext
-  rfl
+    @map X _ _ _ g ∘ map f = map (g ∘ f) := by ext; rfl
 #align locally_constant.map_comp LocallyConstant.map_comp
 
 #print LocallyConstant.flip /-
@@ -786,10 +776,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align locally_constant.unflip_flip LocallyConstant.unflip_flipₓ'. -/
 @[simp]
 theorem unflip_flip {X α β : Type _} [Fintype α] [TopologicalSpace X]
-    (f : LocallyConstant X (α → β)) : unflip f.flip = f :=
-  by
-  ext
-  rfl
+    (f : LocallyConstant X (α → β)) : unflip f.flip = f := by ext; rfl
 #align locally_constant.unflip_flip LocallyConstant.unflip_flip
 
 /- warning: locally_constant.flip_unflip -> LocallyConstant.flip_unflip is a dubious translation:
@@ -800,10 +787,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align locally_constant.flip_unflip LocallyConstant.flip_unflipₓ'. -/
 @[simp]
 theorem flip_unflip {X α β : Type _} [Fintype α] [TopologicalSpace X]
-    (f : α → LocallyConstant X β) : (unflip f).flip = f :=
-  by
-  ext
-  rfl
+    (f : α → LocallyConstant X β) : (unflip f).flip = f := by ext; rfl
 #align locally_constant.flip_unflip LocallyConstant.flip_unflip
 
 section Comap
@@ -822,14 +806,9 @@ noncomputable def comap (f : X → Y) : LocallyConstant Y Z → LocallyConstant
   if hf : Continuous f then fun g => ⟨g ∘ f, g.IsLocallyConstant.comp_continuous hf⟩
   else by
     by_cases H : Nonempty X
-    · intro g
-      exact const X (g <| f <| Classical.arbitrary X)
-    · intro g
-      refine' ⟨fun x => (H ⟨x⟩).elim, _⟩
-      intro s
-      rw [isOpen_iff_nhds]
-      intro x
-      exact (H ⟨x⟩).elim
+    · intro g; exact const X (g <| f <| Classical.arbitrary X)
+    · intro g; refine' ⟨fun x => (H ⟨x⟩).elim, _⟩
+      intro s; rw [isOpen_iff_nhds]; intro x; exact (H ⟨x⟩).elim
 #align locally_constant.comap LocallyConstant.comap
 -/
 
@@ -841,9 +820,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align locally_constant.coe_comap LocallyConstant.coe_comapₓ'. -/
 @[simp]
 theorem coe_comap (f : X → Y) (g : LocallyConstant Y Z) (hf : Continuous f) :
-    ⇑(comap f g) = g ∘ f := by
-  rw [comap, dif_pos hf]
-  rfl
+    ⇑(comap f g) = g ∘ f := by rw [comap, dif_pos hf]; rfl
 #align locally_constant.coe_comap LocallyConstant.coe_comap
 
 /- warning: locally_constant.comap_id -> LocallyConstant.comap_id is a dubious translation:
@@ -853,8 +830,7 @@ but is expected to have type
   forall {X : Type.{u2}} {Z : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X], Eq.{max (succ u2) (succ u1)} ((LocallyConstant.{u2, u1} X Z _inst_1) -> (LocallyConstant.{u2, u1} X Z _inst_1)) (LocallyConstant.comap.{u2, u2, u1} X X Z _inst_1 _inst_1 (id.{succ u2} X)) (id.{max (succ u2) (succ u1)} (LocallyConstant.{u2, u1} X Z _inst_1))
 Case conversion may be inaccurate. Consider using '#align locally_constant.comap_id LocallyConstant.comap_idₓ'. -/
 @[simp]
-theorem comap_id : @comap X X Z _ _ id = id := by
-  ext
+theorem comap_id : @comap X X Z _ _ id = id := by ext;
   simp only [continuous_id, id.def, Function.comp.right_id, coe_comap]
 #align locally_constant.comap_id LocallyConstant.comap_id
 
@@ -865,9 +841,7 @@ but is expected to have type
   forall {X : Type.{u3}} {Y : Type.{u2}} {Z : Type.{u4}} {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u3} X] [_inst_2 : TopologicalSpace.{u2} Y] [_inst_3 : TopologicalSpace.{u4} Z] (f : X -> Y) (g : Y -> Z), (Continuous.{u3, u2} X Y _inst_1 _inst_2 f) -> (Continuous.{u2, u4} Y Z _inst_2 _inst_3 g) -> (Eq.{max (max (succ u3) (succ u4)) (succ u1)} ((LocallyConstant.{u4, u1} Z α _inst_3) -> (LocallyConstant.{u3, u1} X α _inst_1)) (Function.comp.{max (succ u1) (succ u4), max (succ u1) (succ u2), max (succ u1) (succ u3)} (LocallyConstant.{u4, u1} Z α _inst_3) (LocallyConstant.{u2, u1} Y α _inst_2) (LocallyConstant.{u3, u1} X α _inst_1) (LocallyConstant.comap.{u3, u2, u1} X Y α _inst_1 _inst_2 f) (LocallyConstant.comap.{u2, u4, u1} Y Z α _inst_2 _inst_3 g)) (LocallyConstant.comap.{u3, u4, u1} X Z α _inst_1 _inst_3 (Function.comp.{succ u3, succ u2, succ u4} X Y Z g f)))
 Case conversion may be inaccurate. Consider using '#align locally_constant.comap_comp LocallyConstant.comap_compₓ'. -/
 theorem comap_comp [TopologicalSpace Z] (f : X → Y) (g : Y → Z) (hf : Continuous f)
-    (hg : Continuous g) : @comap _ _ α _ _ f ∘ comap g = comap (g ∘ f) :=
-  by
-  ext
+    (hg : Continuous g) : @comap _ _ α _ _ f ∘ comap g = comap (g ∘ f) := by ext;
   simp only [hf, hg, hg.comp hf, coe_comap]
 #align locally_constant.comap_comp LocallyConstant.comap_comp
 
@@ -898,12 +872,7 @@ def desc {X α β : Type _} [TopologicalSpace X] {g : α → β} (f : X → α)
     (cond : g ∘ f = h) (inj : Function.Injective g) : LocallyConstant X α
     where
   toFun := f
-  IsLocallyConstant :=
-    IsLocallyConstant.desc _ g
-      (by
-        rw [cond]
-        exact h.2)
-      inj
+  IsLocallyConstant := IsLocallyConstant.desc _ g (by rw [cond]; exact h.2) inj
 #align locally_constant.desc LocallyConstant.desc
 -/
 
@@ -941,16 +910,11 @@ noncomputable def mulIndicator (hU : IsClopen U) : LocallyConstant X R
     rw [IsLocallyConstant.iff_exists_open]; rintro x
     obtain ⟨V, hV, hx, h'⟩ := (IsLocallyConstant.iff_exists_open _).1 f.is_locally_constant x
     by_cases x ∈ U
-    · refine' ⟨U ∩ V, IsOpen.inter hU.1 hV, Set.mem_inter h hx, _⟩
-      rintro y hy
-      rw [Set.mem_inter_iff] at hy
-      rw [Set.mulIndicator_of_mem hy.1, Set.mulIndicator_of_mem h]
+    · refine' ⟨U ∩ V, IsOpen.inter hU.1 hV, Set.mem_inter h hx, _⟩; rintro y hy
+      rw [Set.mem_inter_iff] at hy; rw [Set.mulIndicator_of_mem hy.1, Set.mulIndicator_of_mem h]
       apply h' y hy.2
-    · rw [← Set.mem_compl_iff] at h
-      refine' ⟨Uᶜ, (IsClopen.compl hU).1, h, _⟩
-      rintro y hy
-      rw [Set.mem_compl_iff] at h
-      rw [Set.mem_compl_iff] at hy
+    · rw [← Set.mem_compl_iff] at h; refine' ⟨Uᶜ, (IsClopen.compl hU).1, h, _⟩
+      rintro y hy; rw [Set.mem_compl_iff] at h; rw [Set.mem_compl_iff] at hy
       simp [h, hy]
 #align locally_constant.mul_indicator LocallyConstant.mulIndicator
 #align locally_constant.indicator LocallyConstant.indicator
@@ -980,10 +944,8 @@ but is expected to have type
   forall {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u2} X] {R : Type.{u1}} [_inst_2 : One.{u1} R] {U : Set.{u2} X} (f : LocallyConstant.{u2, u1} X R _inst_1) {a : X} (hU : IsClopen.{u2} X _inst_1 U), (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) a U) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => R) a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X R _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => R) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X R _inst_1) (LocallyConstant.mulIndicator.{u2, u1} X _inst_1 R _inst_2 U f hU) a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X R _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => R) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X R _inst_1) f a))
 Case conversion may be inaccurate. Consider using '#align locally_constant.mul_indicator_of_mem LocallyConstant.mulIndicator_of_memₓ'. -/
 @[to_additive]
-theorem mulIndicator_of_mem (hU : IsClopen U) (h : a ∈ U) : f.mulIndicator hU a = f a :=
-  by
-  rw [mul_indicator_apply]
-  apply Set.mulIndicator_of_mem h
+theorem mulIndicator_of_mem (hU : IsClopen U) (h : a ∈ U) : f.mulIndicator hU a = f a := by
+  rw [mul_indicator_apply]; apply Set.mulIndicator_of_mem h
 #align locally_constant.mul_indicator_of_mem LocallyConstant.mulIndicator_of_mem
 #align locally_constant.indicator_of_mem LocallyConstant.indicator_of_mem
 
@@ -994,10 +956,8 @@ but is expected to have type
   forall {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u2} X] {R : Type.{u1}} [_inst_2 : One.{u1} R] {U : Set.{u2} X} (f : LocallyConstant.{u2, u1} X R _inst_1) {a : X} (hU : IsClopen.{u2} X _inst_1 U), (Not (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) a U)) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => R) a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X R _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => R) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X R _inst_1) (LocallyConstant.mulIndicator.{u2, u1} X _inst_1 R _inst_2 U f hU) a) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => R) a) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => R) a) _inst_2)))
 Case conversion may be inaccurate. Consider using '#align locally_constant.mul_indicator_of_not_mem LocallyConstant.mulIndicator_of_not_memₓ'. -/
 @[to_additive]
-theorem mulIndicator_of_not_mem (hU : IsClopen U) (h : a ∉ U) : f.mulIndicator hU a = 1 :=
-  by
-  rw [mul_indicator_apply]
-  apply Set.mulIndicator_of_not_mem h
+theorem mulIndicator_of_not_mem (hU : IsClopen U) (h : a ∉ U) : f.mulIndicator hU a = 1 := by
+  rw [mul_indicator_apply]; apply Set.mulIndicator_of_not_mem h
 #align locally_constant.mul_indicator_of_not_mem LocallyConstant.mulIndicator_of_not_mem
 #align locally_constant.indicator_of_not_mem LocallyConstant.indicator_of_not_mem
 

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

@@ -773,7 +773,7 @@ def unflip {X α β : Type _} [Fintype α] [TopologicalSpace X] (f : α → Loca
     intro g
     have : (fun (x : X) (a : α) => f a x) ⁻¹' {g} = ⋂ a : α, f a ⁻¹' {g a} := by tidy
     rw [this]
-    apply isOpen_interᵢ
+    apply isOpen_iInter
     intro a
     apply (f a).IsLocallyConstant
 #align locally_constant.unflip LocallyConstant.unflip

mathlib commit https://github.com/leanprover-community/mathlib/commit/02ba8949f486ebecf93fe7460f1ed0564b5e442c

@@ -421,7 +421,7 @@ initialize_simps_projections LocallyConstant (toFun → apply)
 lean 3 declaration is
   forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] (f : LocallyConstant.{u1, u2} X Y _inst_1), Eq.{max (succ u1) (succ u2)} (X -> Y) (LocallyConstant.toFun.{u1, u2} X Y _inst_1 f) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) f)
 but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] (f : LocallyConstant.{u2, u1} X Y _inst_1), Eq.{max (succ u2) (succ u1)} (X -> Y) (LocallyConstant.toFun.{u2, u1} X Y _inst_1 f) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f)
+  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] (f : LocallyConstant.{u2, u1} X Y _inst_1), Eq.{max (succ u2) (succ u1)} (X -> Y) (LocallyConstant.toFun.{u2, u1} X Y _inst_1 f) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f)
 Case conversion may be inaccurate. Consider using '#align locally_constant.to_fun_eq_coe LocallyConstant.toFun_eq_coeₓ'. -/
 @[simp]
 theorem toFun_eq_coe (f : LocallyConstant X Y) : f.toFun = f :=
@@ -432,7 +432,7 @@ theorem toFun_eq_coe (f : LocallyConstant X Y) : f.toFun = f :=
 lean 3 declaration is
   forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] (f : X -> Y) (h : IsLocallyConstant.{u1, u2} X Y _inst_1 f), Eq.{max (succ u1) (succ u2)} (X -> Y) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) (LocallyConstant.mk.{u1, u2} X Y _inst_1 f h)) f
 but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] (f : X -> Y) (h : IsLocallyConstant.{u2, u1} X Y _inst_1 f), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : X), (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Y) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) (LocallyConstant.mk.{u2, u1} X Y _inst_1 f h)) f
+  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] (f : X -> Y) (h : IsLocallyConstant.{u2, u1} X Y _inst_1 f), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : X), (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) (LocallyConstant.mk.{u2, u1} X Y _inst_1 f h)) f
 Case conversion may be inaccurate. Consider using '#align locally_constant.coe_mk LocallyConstant.coe_mkₓ'. -/
 @[simp]
 theorem coe_mk (f : X → Y) (h) : ⇑(⟨f, h⟩ : LocallyConstant X Y) = f :=
@@ -443,7 +443,7 @@ theorem coe_mk (f : X → Y) (h) : ⇑(⟨f, h⟩ : LocallyConstant X Y) = f :=
 lean 3 declaration is
   forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] {f : LocallyConstant.{u1, u2} X Y _inst_1} {g : LocallyConstant.{u1, u2} X Y _inst_1}, (Eq.{max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) f g) -> (forall (x : X), Eq.{succ u2} Y (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) f x) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) g x))
 but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] {f : LocallyConstant.{u2, u1} X Y _inst_1} {g : LocallyConstant.{u2, u1} X Y _inst_1}, (Eq.{max (succ u2) (succ u1)} (LocallyConstant.{u2, u1} X Y _inst_1) f g) -> (forall (x : X), Eq.{succ u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Y) x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) g x))
+  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] {f : LocallyConstant.{u2, u1} X Y _inst_1} {g : LocallyConstant.{u2, u1} X Y _inst_1}, (Eq.{max (succ u2) (succ u1)} (LocallyConstant.{u2, u1} X Y _inst_1) f g) -> (forall (x : X), Eq.{succ u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) g x))
 Case conversion may be inaccurate. Consider using '#align locally_constant.congr_fun LocallyConstant.congr_funₓ'. -/
 theorem congr_fun {f g : LocallyConstant X Y} (h : f = g) (x : X) : f x = g x :=
   congr_arg (fun h : LocallyConstant X Y => h x) h
@@ -453,7 +453,7 @@ theorem congr_fun {f g : LocallyConstant X Y} (h : f = g) (x : X) : f x = g x :=
 lean 3 declaration is
   forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] (f : LocallyConstant.{u1, u2} X Y _inst_1) {x : X} {y : X}, (Eq.{succ u1} X x y) -> (Eq.{succ u2} Y (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) f x) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) f y))
 but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] (f : LocallyConstant.{u2, u1} X Y _inst_1) {x : X} {y : X}, (Eq.{succ u2} X x y) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Y) x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f y))
+  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] (f : LocallyConstant.{u2, u1} X Y _inst_1) {x : X} {y : X}, (Eq.{succ u2} X x y) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f y))
 Case conversion may be inaccurate. Consider using '#align locally_constant.congr_arg LocallyConstant.congr_argₓ'. -/
 theorem congr_arg (f : LocallyConstant X Y) {x y : X} (h : x = y) : f x = f y :=
   congr_arg (fun x : X => f x) h
@@ -471,7 +471,7 @@ theorem coe_injective : @Function.Injective (LocallyConstant X Y) (X → Y) coeF
 lean 3 declaration is
   forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] {f : LocallyConstant.{u1, u2} X Y _inst_1} {g : LocallyConstant.{u1, u2} X Y _inst_1}, Iff (Eq.{max (succ u1) (succ u2)} ((fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) f) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) f) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) g)) (Eq.{max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) f g)
 but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] {f : LocallyConstant.{u2, u1} X Y _inst_1} {g : LocallyConstant.{u2, u1} X Y _inst_1}, Iff (Eq.{max (succ u2) (succ u1)} (forall (a : X), (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Y) a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) g)) (Eq.{max (succ u2) (succ u1)} (LocallyConstant.{u2, u1} X Y _inst_1) f g)
+  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] {f : LocallyConstant.{u2, u1} X Y _inst_1} {g : LocallyConstant.{u2, u1} X Y _inst_1}, Iff (Eq.{max (succ u2) (succ u1)} (forall (a : X), (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) g)) (Eq.{max (succ u2) (succ u1)} (LocallyConstant.{u2, u1} X Y _inst_1) f g)
 Case conversion may be inaccurate. Consider using '#align locally_constant.coe_inj LocallyConstant.coe_injₓ'. -/
 @[simp, norm_cast]
 theorem coe_inj {f g : LocallyConstant X Y} : (f : X → Y) = g ↔ f = g :=
@@ -482,7 +482,7 @@ theorem coe_inj {f g : LocallyConstant X Y} : (f : X → Y) = g ↔ f = g :=
 lean 3 declaration is
   forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] {{f : LocallyConstant.{u1, u2} X Y _inst_1}} {{g : LocallyConstant.{u1, u2} X Y _inst_1}}, (forall (x : X), Eq.{succ u2} Y (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) f x) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) g x)) -> (Eq.{max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) f g)
 but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] {{f : LocallyConstant.{u2, u1} X Y _inst_1}} {{g : LocallyConstant.{u2, u1} X Y _inst_1}}, (forall (x : X), Eq.{succ u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Y) x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) g x)) -> (Eq.{max (succ u2) (succ u1)} (LocallyConstant.{u2, u1} X Y _inst_1) f g)
+  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] {{f : LocallyConstant.{u2, u1} X Y _inst_1}} {{g : LocallyConstant.{u2, u1} X Y _inst_1}}, (forall (x : X), Eq.{succ u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) g x)) -> (Eq.{max (succ u2) (succ u1)} (LocallyConstant.{u2, u1} X Y _inst_1) f g)
 Case conversion may be inaccurate. Consider using '#align locally_constant.ext LocallyConstant.extₓ'. -/
 @[ext]
 theorem ext ⦃f g : LocallyConstant X Y⦄ (h : ∀ x, f x = g x) : f = g :=
@@ -493,7 +493,7 @@ theorem ext ⦃f g : LocallyConstant X Y⦄ (h : ∀ x, f x = g x) : f = g :=
 lean 3 declaration is
   forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] {f : LocallyConstant.{u1, u2} X Y _inst_1} {g : LocallyConstant.{u1, u2} X Y _inst_1}, Iff (Eq.{max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) f g) (forall (x : X), Eq.{succ u2} Y (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) f x) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) g x))
 but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] {f : LocallyConstant.{u2, u1} X Y _inst_1} {g : LocallyConstant.{u2, u1} X Y _inst_1}, Iff (Eq.{max (succ u2) (succ u1)} (LocallyConstant.{u2, u1} X Y _inst_1) f g) (forall (x : X), Eq.{succ u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Y) x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) g x))
+  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] {f : LocallyConstant.{u2, u1} X Y _inst_1} {g : LocallyConstant.{u2, u1} X Y _inst_1}, Iff (Eq.{max (succ u2) (succ u1)} (LocallyConstant.{u2, u1} X Y _inst_1) f g) (forall (x : X), Eq.{succ u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) g x))
 Case conversion may be inaccurate. Consider using '#align locally_constant.ext_iff LocallyConstant.ext_iffₓ'. -/
 theorem ext_iff {f g : LocallyConstant X Y} : f = g ↔ ∀ x, f x = g x :=
   ⟨fun h x => h ▸ rfl, fun h => ext h⟩
@@ -507,7 +507,7 @@ variable [TopologicalSpace Y] (f : LocallyConstant X Y)
 lean 3 declaration is
   forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : TopologicalSpace.{u2} Y] (f : LocallyConstant.{u1, u2} X Y _inst_1), Continuous.{u1, u2} X Y _inst_1 _inst_2 (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) f)
 but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : TopologicalSpace.{u1} Y] (f : LocallyConstant.{u2, u1} X Y _inst_1), Continuous.{u2, u1} X Y _inst_1 _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f)
+  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : TopologicalSpace.{u1} Y] (f : LocallyConstant.{u2, u1} X Y _inst_1), Continuous.{u2, u1} X Y _inst_1 _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f)
 Case conversion may be inaccurate. Consider using '#align locally_constant.continuous LocallyConstant.continuousₓ'. -/
 protected theorem continuous : Continuous f :=
   f.IsLocallyConstant.Continuous
@@ -540,7 +540,7 @@ theorem [anonymous] : f.toContinuousMap = f :=
 lean 3 declaration is
   forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : TopologicalSpace.{u2} Y] (f : LocallyConstant.{u1, u2} X Y _inst_1), Eq.{max (succ u1) (succ u2)} ((fun (_x : ContinuousMap.{u1, u2} X Y _inst_1 _inst_2) => X -> Y) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Sort.{max (succ u1) (succ u2)}) [self : HasLiftT.{max (succ u1) (succ u2), max (succ u1) (succ u2)} a b] => self.0) (LocallyConstant.{u1, u2} X Y _inst_1) (ContinuousMap.{u1, u2} X Y _inst_1 _inst_2) (HasLiftT.mk.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (ContinuousMap.{u1, u2} X Y _inst_1 _inst_2) (CoeTCₓ.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (ContinuousMap.{u1, u2} X Y _inst_1 _inst_2) (coeBase.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (ContinuousMap.{u1, u2} X Y _inst_1 _inst_2) (LocallyConstant.ContinuousMap.hasCoe.{u1, u2} X Y _inst_1 _inst_2)))) f)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (ContinuousMap.{u1, u2} X Y _inst_1 _inst_2) (fun (_x : ContinuousMap.{u1, u2} X Y _inst_1 _inst_2) => X -> Y) (ContinuousMap.hasCoeToFun.{u1, u2} X Y _inst_1 _inst_2) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Sort.{max (succ u1) (succ u2)}) [self : HasLiftT.{max (succ u1) (succ u2), max (succ u1) (succ u2)} a b] => self.0) (LocallyConstant.{u1, u2} X Y _inst_1) (ContinuousMap.{u1, u2} X Y _inst_1 _inst_2) (HasLiftT.mk.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (ContinuousMap.{u1, u2} X Y _inst_1 _inst_2) (CoeTCₓ.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (ContinuousMap.{u1, u2} X Y _inst_1 _inst_2) (coeBase.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (ContinuousMap.{u1, u2} X Y _inst_1 _inst_2) (LocallyConstant.ContinuousMap.hasCoe.{u1, u2} X Y _inst_1 _inst_2)))) f)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) f)
 but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : TopologicalSpace.{u1} Y] (f : LocallyConstant.{u2, u1} X Y _inst_1), Eq.{max (succ u2) (succ u1)} (forall (a : X), (fun (x._@.Mathlib.Topology.ContinuousFunction.Basic._hyg.699 : X) => Y) a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (ContinuousMap.{u2, u1} X Y _inst_1 _inst_2) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.ContinuousFunction.Basic._hyg.699 : X) => Y) _x) (ContinuousMapClass.toFunLike.{max u2 u1, u2, u1} (ContinuousMap.{u2, u1} X Y _inst_1 _inst_2) X Y _inst_1 _inst_2 (ContinuousMap.instContinuousMapClassContinuousMap.{u2, u1} X Y _inst_1 _inst_2)) (LocallyConstant.toContinuousMap.{u2, u1} X Y _inst_1 _inst_2 f)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f)
+  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : TopologicalSpace.{u1} Y] (f : LocallyConstant.{u2, u1} X Y _inst_1), Eq.{max (succ u2) (succ u1)} (forall (a : X), (fun (x._@.Mathlib.Topology.ContinuousFunction.Basic._hyg.699 : X) => Y) a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (ContinuousMap.{u2, u1} X Y _inst_1 _inst_2) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.ContinuousFunction.Basic._hyg.699 : X) => Y) _x) (ContinuousMapClass.toFunLike.{max u2 u1, u2, u1} (ContinuousMap.{u2, u1} X Y _inst_1 _inst_2) X Y _inst_1 _inst_2 (ContinuousMap.instContinuousMapClassContinuousMap.{u2, u1} X Y _inst_1 _inst_2)) (LocallyConstant.toContinuousMap.{u2, u1} X Y _inst_1 _inst_2 f)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f)
 Case conversion may be inaccurate. Consider using '#align locally_constant.coe_continuous_map LocallyConstant.coe_continuousMapₓ'. -/
 @[simp]
 theorem coe_continuousMap : ((f : C(X, Y)) : X → Y) = (f : X → Y) :=
@@ -571,7 +571,7 @@ def const (X : Type _) {Y : Type _} [TopologicalSpace X] (y : Y) : LocallyConsta
 lean 3 declaration is
   forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] (y : Y), Eq.{max (succ u1) (succ u2)} ((fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.const.{u1, u2} X Y _inst_1 y)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) (LocallyConstant.const.{u1, u2} X Y _inst_1 y)) (Function.const.{succ u2, succ u1} Y X y)
 but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] (y : Y), Eq.{max (succ u2) (succ u1)} (forall (a : X), (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Y) a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) (LocallyConstant.const.{u2, u1} X Y _inst_1 y)) (Function.const.{succ u1, succ u2} Y X y)
+  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] (y : Y), Eq.{max (succ u2) (succ u1)} (forall (a : X), (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) (LocallyConstant.const.{u2, u1} X Y _inst_1 y)) (Function.const.{succ u1, succ u2} Y X y)
 Case conversion may be inaccurate. Consider using '#align locally_constant.coe_const LocallyConstant.coe_constₓ'. -/
 @[simp]
 theorem coe_const (y : Y) : (const X y : X → Y) = Function.const X y :=
@@ -605,7 +605,7 @@ def ofClopen {X : Type _} [TopologicalSpace X] {U : Set X} [∀ x, Decidable (x
 lean 3 declaration is
   forall {X : Type.{u1}} [_inst_2 : TopologicalSpace.{u1} X] {U : Set.{u1} X} [_inst_3 : forall (x : X), Decidable (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) x U)] (hU : IsClopen.{u1} X _inst_2 U), Eq.{succ u1} (Set.{u1} X) (Set.preimage.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) (coeFn.{succ u1, succ u1} (LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) _inst_2) (fun (_x : LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) _inst_2) => X -> (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))))) (LocallyConstant.hasCoeToFun.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) _inst_2) (LocallyConstant.ofClopen.{u1} X _inst_2 U (fun (x : X) => _inst_3 x) hU)) (Singleton.singleton.{0, 0} (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) (Set.{0} (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))))) (Set.hasSingleton.{0} (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))))) (OfNat.ofNat.{0} (Fin (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))) 0 (OfNat.mk.{0} (Fin (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))) 0 (Zero.zero.{0} (Fin (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))) (Fin.hasZeroOfNeZero (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)) (CharZero.NeZero.two.{0} Nat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} Nat (NonAssocSemiring.toAddCommMonoidWithOne.{0} Nat (Semiring.toNonAssocSemiring.{0} Nat Nat.semiring))) (StrictOrderedSemiring.to_charZero.{0} Nat Nat.strictOrderedSemiring)))))))) U
 but is expected to have type
-  forall {X : Type.{u1}} [_inst_2 : TopologicalSpace.{u1} X] {U : Set.{u1} X} [_inst_3 : forall (x : X), Decidable (Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) x U)] (hU : IsClopen.{u1} X _inst_2 U), Eq.{succ u1} (Set.{u1} X) (Set.preimage.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) (FunLike.coe.{succ u1, succ u1, 1} (LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _inst_2) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _x) (LocallyConstant.instFunLikeLocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _inst_2) (LocallyConstant.ofClopen.{u1} X _inst_2 U (fun (x : X) => _inst_3 x) hU)) (Singleton.singleton.{0, 0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) (Set.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))) (Set.instSingletonSet.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))) (OfNat.ofNat.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) 0 (Fin.instOfNatFin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) 0 (NeZero.succ (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))))))) U
+  forall {X : Type.{u1}} [_inst_2 : TopologicalSpace.{u1} X] {U : Set.{u1} X} [_inst_3 : forall (x : X), Decidable (Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) x U)] (hU : IsClopen.{u1} X _inst_2 U), Eq.{succ u1} (Set.{u1} X) (Set.preimage.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) (FunLike.coe.{succ u1, succ u1, 1} (LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _inst_2) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _x) (LocallyConstant.instFunLikeLocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _inst_2) (LocallyConstant.ofClopen.{u1} X _inst_2 U (fun (x : X) => _inst_3 x) hU)) (Singleton.singleton.{0, 0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) (Set.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))) (Set.instSingletonSet.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))) (OfNat.ofNat.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) 0 (Fin.instOfNatFin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) 0 (NeZero.succ (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))))))) U
 Case conversion may be inaccurate. Consider using '#align locally_constant.of_clopen_fiber_zero LocallyConstant.ofClopen_fiber_zeroₓ'. -/
 @[simp]
 theorem ofClopen_fiber_zero {X : Type _} [TopologicalSpace X] {U : Set X} [∀ x, Decidable (x ∈ U)]
@@ -621,7 +621,7 @@ theorem ofClopen_fiber_zero {X : Type _} [TopologicalSpace X] {U : Set X} [∀ x
 lean 3 declaration is
   forall {X : Type.{u1}} [_inst_2 : TopologicalSpace.{u1} X] {U : Set.{u1} X} [_inst_3 : forall (x : X), Decidable (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) x U)] (hU : IsClopen.{u1} X _inst_2 U), Eq.{succ u1} (Set.{u1} X) (Set.preimage.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) (coeFn.{succ u1, succ u1} (LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) _inst_2) (fun (_x : LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) _inst_2) => X -> (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))))) (LocallyConstant.hasCoeToFun.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) _inst_2) (LocallyConstant.ofClopen.{u1} X _inst_2 U (fun (x : X) => _inst_3 x) hU)) (Singleton.singleton.{0, 0} (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) (Set.{0} (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))))) (Set.hasSingleton.{0} (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))))) (OfNat.ofNat.{0} (Fin (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))) 1 (OfNat.mk.{0} (Fin (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))) 1 (One.one.{0} (Fin (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))) (Fin.hasOneOfNeZero (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)) (CharZero.NeZero.two.{0} Nat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} Nat (NonAssocSemiring.toAddCommMonoidWithOne.{0} Nat (Semiring.toNonAssocSemiring.{0} Nat Nat.semiring))) (StrictOrderedSemiring.to_charZero.{0} Nat Nat.strictOrderedSemiring)))))))) (HasCompl.compl.{u1} (Set.{u1} X) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} X) (Set.booleanAlgebra.{u1} X)) U)
 but is expected to have type
-  forall {X : Type.{u1}} [_inst_2 : TopologicalSpace.{u1} X] {U : Set.{u1} X} [_inst_3 : forall (x : X), Decidable (Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) x U)] (hU : IsClopen.{u1} X _inst_2 U), Eq.{succ u1} (Set.{u1} X) (Set.preimage.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) (FunLike.coe.{succ u1, succ u1, 1} (LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _inst_2) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _x) (LocallyConstant.instFunLikeLocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _inst_2) (LocallyConstant.ofClopen.{u1} X _inst_2 U (fun (x : X) => _inst_3 x) hU)) (Singleton.singleton.{0, 0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) (Set.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))) (Set.instSingletonSet.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))) (OfNat.ofNat.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) 1 (Fin.instOfNatFin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) 1 (NeZero.succ (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))))))) (HasCompl.compl.{u1} (Set.{u1} X) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} X) (Set.instBooleanAlgebraSet.{u1} X)) U)
+  forall {X : Type.{u1}} [_inst_2 : TopologicalSpace.{u1} X] {U : Set.{u1} X} [_inst_3 : forall (x : X), Decidable (Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) x U)] (hU : IsClopen.{u1} X _inst_2 U), Eq.{succ u1} (Set.{u1} X) (Set.preimage.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) (FunLike.coe.{succ u1, succ u1, 1} (LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _inst_2) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _x) (LocallyConstant.instFunLikeLocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _inst_2) (LocallyConstant.ofClopen.{u1} X _inst_2 U (fun (x : X) => _inst_3 x) hU)) (Singleton.singleton.{0, 0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) (Set.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))) (Set.instSingletonSet.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))) (OfNat.ofNat.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) 1 (Fin.instOfNatFin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) 1 (NeZero.succ (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))))))) (HasCompl.compl.{u1} (Set.{u1} X) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} X) (Set.instBooleanAlgebraSet.{u1} X)) U)
 Case conversion may be inaccurate. Consider using '#align locally_constant.of_clopen_fiber_one LocallyConstant.ofClopen_fiber_oneₓ'. -/
 @[simp]
 theorem ofClopen_fiber_one {X : Type _} [TopologicalSpace X] {U : Set X} [∀ x, Decidable (x ∈ U)]
@@ -637,7 +637,7 @@ theorem ofClopen_fiber_one {X : Type _} [TopologicalSpace X] {U : Set X} [∀ x,
 lean 3 declaration is
   forall {X : Type.{u1}} [_inst_2 : TopologicalSpace.{u1} X] (f : LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) _inst_2) (g : LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) _inst_2), (Eq.{succ u1} (Set.{u1} X) (Set.preimage.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) (coeFn.{succ u1, succ u1} (LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) _inst_2) (fun (_x : LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) _inst_2) => X -> (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))))) (LocallyConstant.hasCoeToFun.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) _inst_2) f) (Singleton.singleton.{0, 0} (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) (Set.{0} (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))))) (Set.hasSingleton.{0} (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))))) (OfNat.ofNat.{0} (Fin (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))) 0 (OfNat.mk.{0} (Fin (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))) 0 (Zero.zero.{0} (Fin (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))) (Fin.hasZeroOfNeZero (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)) (CharZero.NeZero.two.{0} Nat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} Nat (NonAssocSemiring.toAddCommMonoidWithOne.{0} Nat (Semiring.toNonAssocSemiring.{0} Nat Nat.semiring))) (StrictOrderedSemiring.to_charZero.{0} Nat Nat.strictOrderedSemiring)))))))) (Set.preimage.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) (coeFn.{succ u1, succ u1} (LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) _inst_2) (fun (_x : LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) _inst_2) => X -> (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))))) (LocallyConstant.hasCoeToFun.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) _inst_2) g) (Singleton.singleton.{0, 0} (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) (Set.{0} (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))))) (Set.hasSingleton.{0} (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))))) (OfNat.ofNat.{0} (Fin (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))) 0 (OfNat.mk.{0} (Fin (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))) 0 (Zero.zero.{0} (Fin (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))) (Fin.hasZeroOfNeZero (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)) (CharZero.NeZero.two.{0} Nat (AddCommMonoidWithOne.toAddMonoidWithOne.{0} Nat (NonAssocSemiring.toAddCommMonoidWithOne.{0} Nat (Semiring.toNonAssocSemiring.{0} Nat Nat.semiring))) (StrictOrderedSemiring.to_charZero.{0} Nat Nat.strictOrderedSemiring))))))))) -> (Eq.{succ u1} (LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) _inst_2) f g)
 but is expected to have type
-  forall {X : Type.{u1}} [_inst_2 : TopologicalSpace.{u1} X] (f : LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _inst_2) (g : LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _inst_2), (Eq.{succ u1} (Set.{u1} X) (Set.preimage.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) (FunLike.coe.{succ u1, succ u1, 1} (LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _inst_2) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _x) (LocallyConstant.instFunLikeLocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _inst_2) f) (Singleton.singleton.{0, 0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) (Set.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))) (Set.instSingletonSet.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))) (OfNat.ofNat.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) 0 (Fin.instOfNatFin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) 0 (NeZero.succ (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))))))) (Set.preimage.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) (FunLike.coe.{succ u1, succ u1, 1} (LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _inst_2) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _x) (LocallyConstant.instFunLikeLocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _inst_2) g) (Singleton.singleton.{0, 0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) (Set.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))) (Set.instSingletonSet.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))) (OfNat.ofNat.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) 0 (Fin.instOfNatFin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) 0 (NeZero.succ (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))))))) -> (Eq.{succ u1} (LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _inst_2) f g)
+  forall {X : Type.{u1}} [_inst_2 : TopologicalSpace.{u1} X] (f : LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _inst_2) (g : LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _inst_2), (Eq.{succ u1} (Set.{u1} X) (Set.preimage.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) (FunLike.coe.{succ u1, succ u1, 1} (LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _inst_2) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _x) (LocallyConstant.instFunLikeLocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _inst_2) f) (Singleton.singleton.{0, 0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) (Set.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))) (Set.instSingletonSet.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))) (OfNat.ofNat.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) 0 (Fin.instOfNatFin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) 0 (NeZero.succ (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))))))) (Set.preimage.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) (FunLike.coe.{succ u1, succ u1, 1} (LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _inst_2) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _x) (LocallyConstant.instFunLikeLocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _inst_2) g) (Singleton.singleton.{0, 0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) (Set.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))) (Set.instSingletonSet.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))) (OfNat.ofNat.{0} (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) 0 (Fin.instOfNatFin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) 0 (NeZero.succ (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))))))) -> (Eq.{succ u1} (LocallyConstant.{u1, 0} X (Fin (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) _inst_2) f g)
 Case conversion may be inaccurate. Consider using '#align locally_constant.locally_constant_eq_of_fiber_zero_eq LocallyConstant.locallyConstant_eq_of_fiber_zero_eqₓ'. -/
 theorem locallyConstant_eq_of_fiber_zero_eq {X : Type _} [TopologicalSpace X]
     (f g : LocallyConstant X (Fin 2)) (h : f ⁻¹' ({0} : Set (Fin 2)) = g ⁻¹' {0}) : f = g :=
@@ -651,7 +651,7 @@ theorem locallyConstant_eq_of_fiber_zero_eq {X : Type _} [TopologicalSpace X]
 lean 3 declaration is
   forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : CompactSpace.{u1} X _inst_1] (f : LocallyConstant.{u1, u2} X Y _inst_1), Set.Finite.{u2} Y (Set.range.{u2, succ u1} Y X (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) f))
 but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : CompactSpace.{u2} X _inst_1] (f : LocallyConstant.{u2, u1} X Y _inst_1), Set.Finite.{u1} Y (Set.range.{u1, succ u2} Y X (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f))
+  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : CompactSpace.{u2} X _inst_1] (f : LocallyConstant.{u2, u1} X Y _inst_1), Set.Finite.{u1} Y (Set.range.{u1, succ u2} Y X (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f))
 Case conversion may be inaccurate. Consider using '#align locally_constant.range_finite LocallyConstant.range_finiteₓ'. -/
 theorem range_finite [CompactSpace X] (f : LocallyConstant X Y) : (Set.range f).Finite :=
   f.IsLocallyConstant.range_finite
@@ -661,7 +661,7 @@ theorem range_finite [CompactSpace X] (f : LocallyConstant X Y) : (Set.range f).
 lean 3 declaration is
   forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] (f : LocallyConstant.{u1, u2} X Y _inst_1) {s : Set.{u1} X}, (IsPreconnected.{u1} X _inst_1 s) -> (forall {x : X} {y : X}, (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) x s) -> (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) y s) -> (Eq.{succ u2} Y (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) f x) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) f y)))
 but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] (f : LocallyConstant.{u2, u1} X Y _inst_1) {s : Set.{u2} X}, (IsPreconnected.{u2} X _inst_1 s) -> (forall {x : X} {y : X}, (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) x s) -> (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) y s) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Y) x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f y)))
+  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] (f : LocallyConstant.{u2, u1} X Y _inst_1) {s : Set.{u2} X}, (IsPreconnected.{u2} X _inst_1 s) -> (forall {x : X} {y : X}, (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) x s) -> (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) y s) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f y)))
 Case conversion may be inaccurate. Consider using '#align locally_constant.apply_eq_of_is_preconnected LocallyConstant.apply_eq_of_isPreconnectedₓ'. -/
 theorem apply_eq_of_isPreconnected (f : LocallyConstant X Y) {s : Set X} (hs : IsPreconnected s)
     {x y : X} (hx : x ∈ s) (hy : y ∈ s) : f x = f y :=
@@ -672,7 +672,7 @@ theorem apply_eq_of_isPreconnected (f : LocallyConstant X Y) {s : Set X} (hs : I
 lean 3 declaration is
   forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : PreconnectedSpace.{u1} X _inst_1] (f : LocallyConstant.{u1, u2} X Y _inst_1) (x : X) (y : X), Eq.{succ u2} Y (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) f x) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) f y)
 but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : PreconnectedSpace.{u2} X _inst_1] (f : LocallyConstant.{u2, u1} X Y _inst_1) (x : X) (y : X), Eq.{succ u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Y) x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f y)
+  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : PreconnectedSpace.{u2} X _inst_1] (f : LocallyConstant.{u2, u1} X Y _inst_1) (x : X) (y : X), Eq.{succ u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f y)
 Case conversion may be inaccurate. Consider using '#align locally_constant.apply_eq_of_preconnected_space LocallyConstant.apply_eq_of_preconnectedSpaceₓ'. -/
 theorem apply_eq_of_preconnectedSpace [PreconnectedSpace X] (f : LocallyConstant X Y) (x y : X) :
     f x = f y :=
@@ -683,7 +683,7 @@ theorem apply_eq_of_preconnectedSpace [PreconnectedSpace X] (f : LocallyConstant
 lean 3 declaration is
   forall {X : Type.{u1}} {Y : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : PreconnectedSpace.{u1} X _inst_1] (f : LocallyConstant.{u1, u2} X Y _inst_1) (x : X), Eq.{max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) f (LocallyConstant.const.{u1, u2} X Y _inst_1 (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) f x))
 but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : PreconnectedSpace.{u2} X _inst_1] (f : LocallyConstant.{u2, u1} X Y _inst_1) (x : X), Eq.{max (succ u2) (succ u1)} (LocallyConstant.{u2, u1} X Y _inst_1) f (LocallyConstant.const.{u2, u1} X ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Y) x) _inst_1 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f x))
+  forall {X : Type.{u2}} {Y : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : PreconnectedSpace.{u2} X _inst_1] (f : LocallyConstant.{u2, u1} X Y _inst_1) (x : X), Eq.{max (succ u2) (succ u1)} (LocallyConstant.{u2, u1} X Y _inst_1) f (LocallyConstant.const.{u2, u1} X ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) x) _inst_1 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X Y _inst_1) f x))
 Case conversion may be inaccurate. Consider using '#align locally_constant.eq_const LocallyConstant.eq_constₓ'. -/
 theorem eq_const [PreconnectedSpace X] (f : LocallyConstant X Y) (x : X) : f = const X (f x) :=
   ext fun y => apply_eq_of_preconnectedSpace f _ _
@@ -716,7 +716,7 @@ def map (f : Y → Z) : LocallyConstant X Y → LocallyConstant X Z := fun g =>
 lean 3 declaration is
   forall {X : Type.{u1}} {Y : Type.{u2}} {Z : Type.{u3}} [_inst_1 : TopologicalSpace.{u1} X] (f : Y -> Z) (g : LocallyConstant.{u1, u2} X Y _inst_1), Eq.{max (succ u1) (succ u3)} (X -> Z) (coeFn.{max (succ u1) (succ u3), max (succ u1) (succ u3)} (LocallyConstant.{u1, u3} X Z _inst_1) (fun (_x : LocallyConstant.{u1, u3} X Z _inst_1) => X -> Z) (LocallyConstant.hasCoeToFun.{u1, u3} X Z _inst_1) (LocallyConstant.map.{u1, u2, u3} X Y Z _inst_1 f g)) (Function.comp.{succ u1, succ u2, succ u3} X Y Z f (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X Y _inst_1) (fun (_x : LocallyConstant.{u1, u2} X Y _inst_1) => X -> Y) (LocallyConstant.hasCoeToFun.{u1, u2} X Y _inst_1) g))
 but is expected to have type
-  forall {X : Type.{u3}} {Y : Type.{u2}} {Z : Type.{u1}} [_inst_1 : TopologicalSpace.{u3} X] (f : Y -> Z) (g : LocallyConstant.{u3, u2} X Y _inst_1), Eq.{max (succ u3) (succ u1)} (forall (ᾰ : X), (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Z) ᾰ) (FunLike.coe.{max (succ u3) (succ u1), succ u3, succ u1} (LocallyConstant.{u3, u1} X Z _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Z) _x) (LocallyConstant.instFunLikeLocallyConstant.{u3, u1} X Z _inst_1) (LocallyConstant.map.{u3, u2, u1} X Y Z _inst_1 f g)) (Function.comp.{succ u3, succ u2, succ u1} X Y Z f (FunLike.coe.{max (succ u3) (succ u2), succ u3, succ u2} (LocallyConstant.{u3, u2} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u3, u2} X Y _inst_1) g))
+  forall {X : Type.{u3}} {Y : Type.{u2}} {Z : Type.{u1}} [_inst_1 : TopologicalSpace.{u3} X] (f : Y -> Z) (g : LocallyConstant.{u3, u2} X Y _inst_1), Eq.{max (succ u3) (succ u1)} (forall (ᾰ : X), (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Z) ᾰ) (FunLike.coe.{max (succ u3) (succ u1), succ u3, succ u1} (LocallyConstant.{u3, u1} X Z _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Z) _x) (LocallyConstant.instFunLikeLocallyConstant.{u3, u1} X Z _inst_1) (LocallyConstant.map.{u3, u2, u1} X Y Z _inst_1 f g)) (Function.comp.{succ u3, succ u2, succ u1} X Y Z f (FunLike.coe.{max (succ u3) (succ u2), succ u3, succ u2} (LocallyConstant.{u3, u2} X Y _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Y) _x) (LocallyConstant.instFunLikeLocallyConstant.{u3, u2} X Y _inst_1) g))
 Case conversion may be inaccurate. Consider using '#align locally_constant.map_apply LocallyConstant.map_applyₓ'. -/
 @[simp]
 theorem map_apply (f : Y → Z) (g : LocallyConstant X Y) : ⇑(map f g) = f ∘ g :=
@@ -837,7 +837,7 @@ noncomputable def comap (f : X → Y) : LocallyConstant Y Z → LocallyConstant
 lean 3 declaration is
   forall {X : Type.{u1}} {Y : Type.{u2}} {Z : Type.{u3}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : TopologicalSpace.{u2} Y] (f : X -> Y) (g : LocallyConstant.{u2, u3} Y Z _inst_2), (Continuous.{u1, u2} X Y _inst_1 _inst_2 f) -> (Eq.{max (succ u1) (succ u3)} (X -> Z) (coeFn.{max (succ u1) (succ u3), max (succ u1) (succ u3)} (LocallyConstant.{u1, u3} X Z _inst_1) (fun (_x : LocallyConstant.{u1, u3} X Z _inst_1) => X -> Z) (LocallyConstant.hasCoeToFun.{u1, u3} X Z _inst_1) (LocallyConstant.comap.{u1, u2, u3} X Y Z _inst_1 _inst_2 f g)) (Function.comp.{succ u1, succ u2, succ u3} X Y Z (coeFn.{max (succ u2) (succ u3), max (succ u2) (succ u3)} (LocallyConstant.{u2, u3} Y Z _inst_2) (fun (_x : LocallyConstant.{u2, u3} Y Z _inst_2) => Y -> Z) (LocallyConstant.hasCoeToFun.{u2, u3} Y Z _inst_2) g) f))
 but is expected to have type
-  forall {X : Type.{u1}} {Y : Type.{u3}} {Z : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : TopologicalSpace.{u3} Y] (f : X -> Y) (g : LocallyConstant.{u3, u2} Y Z _inst_2), (Continuous.{u1, u3} X Y _inst_1 _inst_2 f) -> (Eq.{max (succ u1) (succ u2)} (forall (ᾰ : X), (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Z) ᾰ) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (LocallyConstant.{u1, u2} X Z _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => Z) _x) (LocallyConstant.instFunLikeLocallyConstant.{u1, u2} X Z _inst_1) (LocallyConstant.comap.{u1, u3, u2} X Y Z _inst_1 _inst_2 f g)) (Function.comp.{succ u1, succ u3, succ u2} X Y Z (FunLike.coe.{max (succ u3) (succ u2), succ u3, succ u2} (LocallyConstant.{u3, u2} Y Z _inst_2) Y (fun (_x : Y) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : Y) => Z) _x) (LocallyConstant.instFunLikeLocallyConstant.{u3, u2} Y Z _inst_2) g) f))
+  forall {X : Type.{u1}} {Y : Type.{u3}} {Z : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : TopologicalSpace.{u3} Y] (f : X -> Y) (g : LocallyConstant.{u3, u2} Y Z _inst_2), (Continuous.{u1, u3} X Y _inst_1 _inst_2 f) -> (Eq.{max (succ u1) (succ u2)} (forall (ᾰ : X), (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Z) ᾰ) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (LocallyConstant.{u1, u2} X Z _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => Z) _x) (LocallyConstant.instFunLikeLocallyConstant.{u1, u2} X Z _inst_1) (LocallyConstant.comap.{u1, u3, u2} X Y Z _inst_1 _inst_2 f g)) (Function.comp.{succ u1, succ u3, succ u2} X Y Z (FunLike.coe.{max (succ u3) (succ u2), succ u3, succ u2} (LocallyConstant.{u3, u2} Y Z _inst_2) Y (fun (_x : Y) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : Y) => Z) _x) (LocallyConstant.instFunLikeLocallyConstant.{u3, u2} Y Z _inst_2) g) f))
 Case conversion may be inaccurate. Consider using '#align locally_constant.coe_comap LocallyConstant.coe_comapₓ'. -/
 @[simp]
 theorem coe_comap (f : X → Y) (g : LocallyConstant Y Z) (hf : Continuous f) :
@@ -875,7 +875,7 @@ theorem comap_comp [TopologicalSpace Z] (f : X → Y) (g : Y → Z) (hf : Contin
 lean 3 declaration is
   forall {X : Type.{u1}} {Y : Type.{u2}} {Z : Type.{u3}} [_inst_1 : TopologicalSpace.{u1} X] [_inst_2 : TopologicalSpace.{u2} Y] (f : X -> Y) (y : Y), (forall (x : X), Eq.{succ u2} Y (f x) y) -> (Eq.{max (max (succ u2) (succ u3)) (succ u1) (succ u3)} ((LocallyConstant.{u2, u3} Y Z _inst_2) -> (LocallyConstant.{u1, u3} X Z _inst_1)) (LocallyConstant.comap.{u1, u2, u3} X Y Z _inst_1 _inst_2 f) (fun (g : LocallyConstant.{u2, u3} Y Z _inst_2) => LocallyConstant.mk.{u1, u3} X Z _inst_1 (fun (x : X) => coeFn.{max (succ u2) (succ u3), max (succ u2) (succ u3)} (LocallyConstant.{u2, u3} Y Z _inst_2) (fun (_x : LocallyConstant.{u2, u3} Y Z _inst_2) => Y -> Z) (LocallyConstant.hasCoeToFun.{u2, u3} Y Z _inst_2) g y) (IsLocallyConstant.const.{u1, u3} X Z _inst_1 (coeFn.{max (succ u2) (succ u3), max (succ u2) (succ u3)} (LocallyConstant.{u2, u3} Y Z _inst_2) (fun (_x : LocallyConstant.{u2, u3} Y Z _inst_2) => Y -> Z) (LocallyConstant.hasCoeToFun.{u2, u3} Y Z _inst_2) g y))))
 but is expected to have type
-  forall {X : Type.{u2}} {Y : Type.{u3}} {Z : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : TopologicalSpace.{u3} Y] (f : X -> Y) (y : Y), (forall (x : X), Eq.{succ u3} Y (f x) y) -> (Eq.{max (max (succ u2) (succ u3)) (succ u1)} ((LocallyConstant.{u3, u1} Y Z _inst_2) -> (LocallyConstant.{u2, u1} X Z _inst_1)) (LocallyConstant.comap.{u2, u3, u1} X Y Z _inst_1 _inst_2 f) (fun (g : LocallyConstant.{u3, u1} Y Z _inst_2) => LocallyConstant.mk.{u2, u1} X Z _inst_1 (fun (x : X) => FunLike.coe.{max (succ u3) (succ u1), succ u3, succ u1} (LocallyConstant.{u3, u1} Y Z _inst_2) Y (fun (_x : Y) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : Y) => Z) _x) (LocallyConstant.instFunLikeLocallyConstant.{u3, u1} Y Z _inst_2) g y) (IsLocallyConstant.const.{u1, u2} X Z _inst_1 (FunLike.coe.{max (succ u3) (succ u1), succ u3, succ u1} (LocallyConstant.{u3, u1} Y Z _inst_2) Y (fun (_x : Y) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : Y) => Z) _x) (LocallyConstant.instFunLikeLocallyConstant.{u3, u1} Y Z _inst_2) g y))))
+  forall {X : Type.{u2}} {Y : Type.{u3}} {Z : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} X] [_inst_2 : TopologicalSpace.{u3} Y] (f : X -> Y) (y : Y), (forall (x : X), Eq.{succ u3} Y (f x) y) -> (Eq.{max (max (succ u2) (succ u3)) (succ u1)} ((LocallyConstant.{u3, u1} Y Z _inst_2) -> (LocallyConstant.{u2, u1} X Z _inst_1)) (LocallyConstant.comap.{u2, u3, u1} X Y Z _inst_1 _inst_2 f) (fun (g : LocallyConstant.{u3, u1} Y Z _inst_2) => LocallyConstant.mk.{u2, u1} X Z _inst_1 (fun (x : X) => FunLike.coe.{max (succ u3) (succ u1), succ u3, succ u1} (LocallyConstant.{u3, u1} Y Z _inst_2) Y (fun (_x : Y) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : Y) => Z) _x) (LocallyConstant.instFunLikeLocallyConstant.{u3, u1} Y Z _inst_2) g y) (IsLocallyConstant.const.{u1, u2} X Z _inst_1 (FunLike.coe.{max (succ u3) (succ u1), succ u3, succ u1} (LocallyConstant.{u3, u1} Y Z _inst_2) Y (fun (_x : Y) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : Y) => Z) _x) (LocallyConstant.instFunLikeLocallyConstant.{u3, u1} Y Z _inst_2) g y))))
 Case conversion may be inaccurate. Consider using '#align locally_constant.comap_const LocallyConstant.comap_constₓ'. -/
 theorem comap_const (f : X → Y) (y : Y) (h : ∀ x, f x = y) :
     (comap f : LocallyConstant Y Z → LocallyConstant X Z) = fun g =>
@@ -911,7 +911,7 @@ def desc {X α β : Type _} [TopologicalSpace X] {g : α → β} (f : X → α)
 lean 3 declaration is
   forall {X : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_2 : TopologicalSpace.{u1} X] (f : X -> α) (g : α -> β) (h : LocallyConstant.{u1, u3} X β _inst_2) (cond : Eq.{max (succ u1) (succ u3)} (X -> β) (Function.comp.{succ u1, succ u2, succ u3} X α β g f) (coeFn.{max (succ u1) (succ u3), max (succ u1) (succ u3)} (LocallyConstant.{u1, u3} X β _inst_2) (fun (_x : LocallyConstant.{u1, u3} X β _inst_2) => X -> β) (LocallyConstant.hasCoeToFun.{u1, u3} X β _inst_2) h)) (inj : Function.Injective.{succ u2, succ u3} α β g), Eq.{max (succ u1) (succ u2)} (X -> α) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X α _inst_2) (fun (_x : LocallyConstant.{u1, u2} X α _inst_2) => X -> α) (LocallyConstant.hasCoeToFun.{u1, u2} X α _inst_2) (LocallyConstant.desc.{u1, u2, u3} X α β _inst_2 g f h cond inj)) f
 but is expected to have type
-  forall {X : Type.{u3}} {α : Type.{u2}} {β : Type.{u1}} [_inst_2 : TopologicalSpace.{u3} X] (f : X -> α) (g : α -> β) (h : LocallyConstant.{u3, u1} X β _inst_2) (cond : Eq.{max (succ u3) (succ u1)} (X -> β) (Function.comp.{succ u3, succ u2, succ u1} X α β g f) (FunLike.coe.{max (succ u3) (succ u1), succ u3, succ u1} (LocallyConstant.{u3, u1} X β _inst_2) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => β) _x) (LocallyConstant.instFunLikeLocallyConstant.{u3, u1} X β _inst_2) h)) (inj : Function.Injective.{succ u2, succ u1} α β g), Eq.{max (succ u3) (succ u2)} (forall (ᾰ : X), (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => α) ᾰ) (FunLike.coe.{max (succ u3) (succ u2), succ u3, succ u2} (LocallyConstant.{u3, u2} X α _inst_2) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => α) _x) (LocallyConstant.instFunLikeLocallyConstant.{u3, u2} X α _inst_2) (LocallyConstant.desc.{u3, u2, u1} X α β _inst_2 g f h cond inj)) f
+  forall {X : Type.{u3}} {α : Type.{u2}} {β : Type.{u1}} [_inst_2 : TopologicalSpace.{u3} X] (f : X -> α) (g : α -> β) (h : LocallyConstant.{u3, u1} X β _inst_2) (cond : Eq.{max (succ u3) (succ u1)} (X -> β) (Function.comp.{succ u3, succ u2, succ u1} X α β g f) (FunLike.coe.{max (succ u3) (succ u1), succ u3, succ u1} (LocallyConstant.{u3, u1} X β _inst_2) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => β) _x) (LocallyConstant.instFunLikeLocallyConstant.{u3, u1} X β _inst_2) h)) (inj : Function.Injective.{succ u2, succ u1} α β g), Eq.{max (succ u3) (succ u2)} (forall (ᾰ : X), (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => α) ᾰ) (FunLike.coe.{max (succ u3) (succ u2), succ u3, succ u2} (LocallyConstant.{u3, u2} X α _inst_2) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => α) _x) (LocallyConstant.instFunLikeLocallyConstant.{u3, u2} X α _inst_2) (LocallyConstant.desc.{u3, u2, u1} X α β _inst_2 g f h cond inj)) f
 Case conversion may be inaccurate. Consider using '#align locally_constant.coe_desc LocallyConstant.coe_descₓ'. -/
 @[simp]
 theorem coe_desc {X α β : Type _} [TopologicalSpace X] (f : X → α) (g : α → β)
@@ -962,7 +962,7 @@ variable (a : X)
 lean 3 declaration is
   forall {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} X] {R : Type.{u2}} [_inst_2 : One.{u2} R] {U : Set.{u1} X} (f : LocallyConstant.{u1, u2} X R _inst_1) (a : X) (hU : IsClopen.{u1} X _inst_1 U), Eq.{succ u2} R (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X R _inst_1) (fun (_x : LocallyConstant.{u1, u2} X R _inst_1) => X -> R) (LocallyConstant.hasCoeToFun.{u1, u2} X R _inst_1) (LocallyConstant.mulIndicator.{u1, u2} X _inst_1 R _inst_2 U f hU) a) (ite.{succ u2} R (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) a U) (Classical.propDecidable (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) a U)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X R _inst_1) (fun (_x : LocallyConstant.{u1, u2} X R _inst_1) => X -> R) (LocallyConstant.hasCoeToFun.{u1, u2} X R _inst_1) f a) (OfNat.ofNat.{u2} R 1 (OfNat.mk.{u2} R 1 (One.one.{u2} R _inst_2))))
 but is expected to have type
-  forall {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u2} X] {R : Type.{u1}} [_inst_2 : One.{u1} R] {U : Set.{u2} X} (f : LocallyConstant.{u2, u1} X R _inst_1) (a : X) (hU : IsClopen.{u2} X _inst_1 U), Eq.{succ u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => R) a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X R _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => R) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X R _inst_1) (LocallyConstant.mulIndicator.{u2, u1} X _inst_1 R _inst_2 U f hU) a) (ite.{succ u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => R) a) (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) a U) (Classical.propDecidable (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) a U)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X R _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => R) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X R _inst_1) f a) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => R) a) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => R) a) _inst_2)))
+  forall {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u2} X] {R : Type.{u1}} [_inst_2 : One.{u1} R] {U : Set.{u2} X} (f : LocallyConstant.{u2, u1} X R _inst_1) (a : X) (hU : IsClopen.{u2} X _inst_1 U), Eq.{succ u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => R) a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X R _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => R) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X R _inst_1) (LocallyConstant.mulIndicator.{u2, u1} X _inst_1 R _inst_2 U f hU) a) (ite.{succ u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => R) a) (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) a U) (Classical.propDecidable (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) a U)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X R _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => R) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X R _inst_1) f a) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => R) a) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => R) a) _inst_2)))
 Case conversion may be inaccurate. Consider using '#align locally_constant.mul_indicator_apply_eq_if LocallyConstant.mulIndicator_apply_eq_ifₓ'. -/
 @[to_additive]
 theorem mulIndicator_apply_eq_if (hU : IsClopen U) :
@@ -977,7 +977,7 @@ variable {a}
 lean 3 declaration is
   forall {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} X] {R : Type.{u2}} [_inst_2 : One.{u2} R] {U : Set.{u1} X} (f : LocallyConstant.{u1, u2} X R _inst_1) {a : X} (hU : IsClopen.{u1} X _inst_1 U), (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) a U) -> (Eq.{succ u2} R (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X R _inst_1) (fun (_x : LocallyConstant.{u1, u2} X R _inst_1) => X -> R) (LocallyConstant.hasCoeToFun.{u1, u2} X R _inst_1) (LocallyConstant.mulIndicator.{u1, u2} X _inst_1 R _inst_2 U f hU) a) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X R _inst_1) (fun (_x : LocallyConstant.{u1, u2} X R _inst_1) => X -> R) (LocallyConstant.hasCoeToFun.{u1, u2} X R _inst_1) f a))
 but is expected to have type
-  forall {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u2} X] {R : Type.{u1}} [_inst_2 : One.{u1} R] {U : Set.{u2} X} (f : LocallyConstant.{u2, u1} X R _inst_1) {a : X} (hU : IsClopen.{u2} X _inst_1 U), (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) a U) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => R) a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X R _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => R) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X R _inst_1) (LocallyConstant.mulIndicator.{u2, u1} X _inst_1 R _inst_2 U f hU) a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X R _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => R) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X R _inst_1) f a))
+  forall {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u2} X] {R : Type.{u1}} [_inst_2 : One.{u1} R] {U : Set.{u2} X} (f : LocallyConstant.{u2, u1} X R _inst_1) {a : X} (hU : IsClopen.{u2} X _inst_1 U), (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) a U) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => R) a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X R _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => R) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X R _inst_1) (LocallyConstant.mulIndicator.{u2, u1} X _inst_1 R _inst_2 U f hU) a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X R _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => R) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X R _inst_1) f a))
 Case conversion may be inaccurate. Consider using '#align locally_constant.mul_indicator_of_mem LocallyConstant.mulIndicator_of_memₓ'. -/
 @[to_additive]
 theorem mulIndicator_of_mem (hU : IsClopen U) (h : a ∈ U) : f.mulIndicator hU a = f a :=
@@ -991,7 +991,7 @@ theorem mulIndicator_of_mem (hU : IsClopen U) (h : a ∈ U) : f.mulIndicator hU
 lean 3 declaration is
   forall {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} X] {R : Type.{u2}} [_inst_2 : One.{u2} R] {U : Set.{u1} X} (f : LocallyConstant.{u1, u2} X R _inst_1) {a : X} (hU : IsClopen.{u1} X _inst_1 U), (Not (Membership.Mem.{u1, u1} X (Set.{u1} X) (Set.hasMem.{u1} X) a U)) -> (Eq.{succ u2} R (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (LocallyConstant.{u1, u2} X R _inst_1) (fun (_x : LocallyConstant.{u1, u2} X R _inst_1) => X -> R) (LocallyConstant.hasCoeToFun.{u1, u2} X R _inst_1) (LocallyConstant.mulIndicator.{u1, u2} X _inst_1 R _inst_2 U f hU) a) (OfNat.ofNat.{u2} R 1 (OfNat.mk.{u2} R 1 (One.one.{u2} R _inst_2))))
 but is expected to have type
-  forall {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u2} X] {R : Type.{u1}} [_inst_2 : One.{u1} R] {U : Set.{u2} X} (f : LocallyConstant.{u2, u1} X R _inst_1) {a : X} (hU : IsClopen.{u2} X _inst_1 U), (Not (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) a U)) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => R) a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X R _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => R) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X R _inst_1) (LocallyConstant.mulIndicator.{u2, u1} X _inst_1 R _inst_2 U f hU) a) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => R) a) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.2185 : X) => R) a) _inst_2)))
+  forall {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u2} X] {R : Type.{u1}} [_inst_2 : One.{u1} R] {U : Set.{u2} X} (f : LocallyConstant.{u2, u1} X R _inst_1) {a : X} (hU : IsClopen.{u2} X _inst_1 U), (Not (Membership.mem.{u2, u2} X (Set.{u2} X) (Set.instMembershipSet.{u2} X) a U)) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => R) a) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (LocallyConstant.{u2, u1} X R _inst_1) X (fun (_x : X) => (fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => R) _x) (LocallyConstant.instFunLikeLocallyConstant.{u2, u1} X R _inst_1) (LocallyConstant.mulIndicator.{u2, u1} X _inst_1 R _inst_2 U f hU) a) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => R) a) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Topology.LocallyConstant.Basic._hyg.5691 : X) => R) a) _inst_2)))
 Case conversion may be inaccurate. Consider using '#align locally_constant.mul_indicator_of_not_mem LocallyConstant.mulIndicator_of_not_memₓ'. -/
 @[to_additive]
 theorem mulIndicator_of_not_mem (hU : IsClopen U) (h : a ∉ U) : f.mulIndicator hU a = 1 :=

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.

@@ -45,9 +45,12 @@ protected theorem tfae (f : X → Y) :
       ∀ x, IsOpen { x' | f x' = f x },
       ∀ y, IsOpen (f ⁻¹' {y}),
       ∀ x, ∃ U : Set X, IsOpen U ∧ x ∈ U ∧ ∀ x' ∈ U, f x' = f x] := by
-  tfae_have 1 → 4; exact fun h y => h {y}
-  tfae_have 4 → 3; exact fun h x => h (f x)
-  tfae_have 3 → 2; exact fun h x => IsOpen.mem_nhds (h x) rfl
+  tfae_have 1 → 4
+  · exact fun h y => h {y}
+  tfae_have 4 → 3
+  · exact fun h x => h (f x)
+  tfae_have 3 → 2
+  · exact fun h x => IsOpen.mem_nhds (h x) rfl
   tfae_have 2 → 5
   · intro h x
     rcases mem_nhds_iff.1 (h x) with ⟨U, eq, hU, hx⟩

After the recent refactor (#12136), the noncomputable modifier is unnecessary, and the docstring needed modification.

@@ -449,16 +449,10 @@ theorem flip_unflip {X α β : Type*} [Finite α] [TopologicalSpace X]
 
 section Comap
 
-open scoped Classical
-
 variable [TopologicalSpace Y]
 
-/-- Pull back of locally constant maps under any map, by pre-composition.
-
-This definition only makes sense if `f` is continuous,
-in which case it sends locally constant functions to their precomposition with `f`.
-See also `LocallyConstant.coe_comap`. -/
-noncomputable def comap (f : C(X, Y)) (g : LocallyConstant Y Z) : LocallyConstant X Z :=
+/-- Pull back of locally constant maps under a continuous map, by pre-composition. -/
+def comap (f : C(X, Y)) (g : LocallyConstant Y Z) : LocallyConstant X Z :=
   ⟨g ∘ f, g.isLocallyConstant.comp_continuous f.continuous⟩
 #align locally_constant.comap LocallyConstant.comap
 

Changes the definition of LocallyConstant.comap so that it takes an argument of the form C(X, Y) instead of X → Y. There was no example of a non-continuous argument in mathlib, and this definition generally makes proofs easier.

@@ -457,66 +457,41 @@ variable [TopologicalSpace Y]
 
 This definition only makes sense if `f` is continuous,
 in which case it sends locally constant functions to their precomposition with `f`.
-See also `LocallyConstant.coe_comap`.
-
-TODO: take `f : C(X, Y)` as an argument? Or we actually use it for discontinuous `f`? -/
-noncomputable def comap (f : X → Y) : LocallyConstant Y Z → LocallyConstant X Z :=
-  if hf : Continuous f then fun g => ⟨g ∘ f, g.isLocallyConstant.comp_continuous hf⟩
-  else by
-    by_cases H : Nonempty X
-    · intro g
-      exact const X (g <| f <| Classical.arbitrary X)
-    · refine fun _ => ⟨fun x => (H ⟨x⟩).elim, fun s => ?_⟩
-      rw [isOpen_iff_nhds]
-      intro x
-      exact (H ⟨x⟩).elim
+See also `LocallyConstant.coe_comap`. -/
+noncomputable def comap (f : C(X, Y)) (g : LocallyConstant Y Z) : LocallyConstant X Z :=
+  ⟨g ∘ f, g.isLocallyConstant.comp_continuous f.continuous⟩
 #align locally_constant.comap LocallyConstant.comap
 
 @[simp]
-theorem coe_comap (f : X → Y) (g : LocallyConstant Y Z) (hf : Continuous f) :
-    (comap f g) = g ∘ f := by
-  rw [comap, dif_pos hf]
-  rfl
+theorem coe_comap (f : C(X, Y)) (g : LocallyConstant Y Z) :
+    (comap f g) = g ∘ f := rfl
 #align locally_constant.coe_comap LocallyConstant.coe_comap
 
-theorem coe_comap_apply (f : X → Y) (g : LocallyConstant Y Z) (hf : Continuous f) (x : X) :
-    comap f g x = g (f x) := by
-  simp only [hf, coe_comap, Function.comp_apply]
+theorem coe_comap_apply (f : C(X, Y)) (g : LocallyConstant Y Z) (x : X) :
+    comap f g x = g (f x) := rfl
 
 @[simp]
-theorem comap_id : comap (@id X) = @id (LocallyConstant X Z) := by
-  ext
-  simp only [continuous_id, id.def, Function.comp_id, coe_comap]
+theorem comap_id : comap (@ContinuousMap.id X _) = @id (LocallyConstant X Z) := rfl
 #align locally_constant.comap_id LocallyConstant.comap_id
 
-theorem comap_comp [TopologicalSpace Z] (f : X → Y) (g : Y → Z) (hf : Continuous f)
-    (hg : Continuous g) : @comap _ _ α _ _ f ∘ comap g = comap (g ∘ f) := by
-  ext
-  rw [Function.comp_apply]
-  simp only [hf, hg, hg.comp hf, coe_comap]; rfl
+theorem comap_comp {W : Type*} [TopologicalSpace W] (f : C(W, X)) (g : C(X, Y)) :
+    comap (Z := Z) (g.comp f) = comap f ∘ comap g := rfl
 #align locally_constant.comap_comp LocallyConstant.comap_comp
 
-theorem comap_comap [TopologicalSpace Z] (f : X → Y) (g : Y → Z)
-    (hf : Continuous f) (hg : Continuous g) (x : LocallyConstant Z α) :
-    comap f (comap g x) = comap (g ∘ f) x := by
-  rw [← comap_comp f g hf hg]; rfl
+theorem comap_comap {W : Type*} [TopologicalSpace W] (f : C(W, X)) (g : C(X, Y))
+    (x : LocallyConstant Y Z) : comap f (comap g x) = comap (g.comp f) x := rfl
 
-theorem comap_const (f : X → Y) (y : Y) (h : ∀ x, f x = y) :
+theorem comap_const (f : C(X, Y)) (y : Y) (h : ∀ x, f x = y) :
     (comap f : LocallyConstant Y Z → LocallyConstant X Z) = fun g => const X (g y) := by
-  ext; rw [coe_comap]
-  · simp only [Function.comp_apply, h, coe_const, Function.const_apply]
-  · rw [show f = fun _ => y by ext; apply h]
-    exact continuous_const
+  ext; simp [h]
 #align locally_constant.comap_const LocallyConstant.comap_const
 
-lemma comap_injective (f : X → Y) (hf: Continuous f) (hfs : f.Surjective) :
+lemma comap_injective (f : C(X, Y)) (hfs : f.1.Surjective) :
     (comap (Z := Z) f).Injective := by
   intro a b h
-  rw [LocallyConstant.ext_iff] at h
   ext y
   obtain ⟨x, hx⟩ := hfs y
-  specialize h x
-  rwa [coe_comap_apply _ _ hf, coe_comap_apply _ _ hf, hx] at h
+  simpa [← hx] using LocallyConstant.congr_fun h x
 
 end Comap
 
@@ -594,12 +569,10 @@ def congrLeft [TopologicalSpace Y] (e : X ≃ₜ Y) : LocallyConstant X Z ≃ Lo
   invFun := comap e
   left_inv := by
     intro
-    rw [comap_comap _ _ e.continuous e.symm.continuous]
-    simp
+    simp [comap_comap]
   right_inv := by
     intro
-    rw [comap_comap _ _ e.symm.continuous e.continuous]
-    simp
+    simp [comap_comap]
 
 variable (X) in
 /--
@@ -677,11 +650,10 @@ noncomputable def piecewise' {C₀ C₁ C₂ : Set X} (h₀ : C₀ ⊆ C₁ ∪
   letI : ∀ j : C₀, Decidable (j ∈ Subtype.val ⁻¹' C₁) := fun j ↦ decidable_of_iff (↑j ∈ C₁) Iff.rfl
   piecewise (h₁.preimage continuous_subtype_val) (h₂.preimage continuous_subtype_val)
     (by simpa [eq_univ_iff_forall] using h₀)
-    (f₁.comap (restrictPreimage C₁ ((↑) : C₀ → X)))
-    (f₂.comap (restrictPreimage C₂ ((↑) : C₀ → X))) <| by
+    (f₁.comap ⟨(restrictPreimage C₁ ((↑) : C₀ → X)), continuous_subtype_val.restrictPreimage⟩)
+    (f₂.comap ⟨(restrictPreimage C₂ ((↑) : C₀ → X)), continuous_subtype_val.restrictPreimage⟩) <| by
       rintro ⟨x, hx₀⟩ ⟨hx₁ : x ∈ C₁, hx₂ : x ∈ C₂⟩
-      simp_rw [coe_comap_apply _ _ continuous_subtype_val.restrictPreimage]
-      exact hf x ⟨hx₁, hx₂⟩
+      simpa using hf x ⟨hx₁, hx₂⟩
 
 @[simp]
 lemma piecewise'_apply_left {C₀ C₁ C₂ : Set X} (h₀ : C₀ ⊆ C₁ ∪ C₂) (h₁ : IsClosed C₁)
@@ -690,8 +662,9 @@ lemma piecewise'_apply_left {C₀ C₁ C₂ : Set X} (h₀ : C₀ ⊆ C₁ ∪ C
     (x : C₀) (hx : x.val ∈ C₁) :
     piecewise' h₀ h₁ h₂ f₁ f₂ hf x = f₁ ⟨x.val, hx⟩ := by
   letI : ∀ j : C₀, Decidable (j ∈ Subtype.val ⁻¹' C₁) := fun j ↦ decidable_of_iff (↑j ∈ C₁) Iff.rfl
-  rw [piecewise', piecewise_apply_left (f := (f₁.comap (restrictPreimage C₁ ((↑) : C₀ → X))))
-    (hx := hx), coe_comap (hf := continuous_subtype_val.restrictPreimage)]
+  rw [piecewise', piecewise_apply_left (f := (f₁.comap
+    ⟨(restrictPreimage C₁ ((↑) : C₀ → X)), continuous_subtype_val.restrictPreimage⟩))
+    (hx := hx)]
   rfl
 
 @[simp]
@@ -701,8 +674,9 @@ lemma piecewise'_apply_right {C₀ C₁ C₂ : Set X} (h₀ : C₀ ⊆ C₁ ∪
     (x : C₀) (hx : x.val ∈ C₂) :
     piecewise' h₀ h₁ h₂ f₁ f₂ hf x = f₂ ⟨x.val, hx⟩ := by
   letI : ∀ j : C₀, Decidable (j ∈ Subtype.val ⁻¹' C₁) := fun j ↦ decidable_of_iff (↑j ∈ C₁) Iff.rfl
-  rw [piecewise', piecewise_apply_right (f := (f₁.comap (restrictPreimage C₁ ((↑) : C₀ → X))))
-    (hx := hx), coe_comap (hf := continuous_subtype_val.restrictPreimage)]
+  rw [piecewise', piecewise_apply_right (f := (f₁.comap
+    ⟨(restrictPreimage C₁ ((↑) : C₀ → X)), continuous_subtype_val.restrictPreimage⟩))
+    (hx := hx)]
   rfl
 
 end Piecewise

Classifies by adding issue number #10756 to porting notes claiming anything semantically equivalent to:

• "new lemma"
• "added lemma"

@@ -96,11 +96,11 @@ protected theorem eventually_eq {f : X → Y} (hf : IsLocallyConstant f) (x : X)
   (iff_eventually_eq f).1 hf x
 #align is_locally_constant.eventually_eq IsLocallyConstant.eventually_eq
 
--- Porting note: new lemma
+-- Porting note (#10756): new lemma
 theorem iff_isOpen_fiber_apply {f : X → Y} : IsLocallyConstant f ↔ ∀ x, IsOpen (f ⁻¹' {f x}) :=
   (IsLocallyConstant.tfae f).out 0 2
 
--- Porting note: new lemma
+-- Porting note (#10756): new lemma
 theorem iff_isOpen_fiber {f : X → Y} : IsLocallyConstant f ↔ ∀ y, IsOpen (f ⁻¹' {y}) :=
   (IsLocallyConstant.tfae f).out 0 3
 

We remove all but one open Classicals, instead preferring to use open scoped Classical. The only real side-effect this led to is moving a couple declarations to use Exists.choose instead of Classical.choose.

The first few commits are explicitly labelled regex replaces for ease of review.

@@ -449,7 +449,7 @@ theorem flip_unflip {X α β : Type*} [Finite α] [TopologicalSpace X]
 
 section Comap
 
-open Classical
+open scoped Classical
 
 variable [TopologicalSpace Y]
 
@@ -543,7 +543,7 @@ section Indicator
 
 variable {R : Type*} [One R] {U : Set X} (f : LocallyConstant X R)
 
-open Classical
+open scoped Classical
 
 /-- Given a clopen set `U` and a locally constant function `f`, `LocallyConstant.mulIndicator`
   returns the locally constant function that is `f` on `U` and `1` otherwise. -/

Homogenises porting notes via capitalisation and addition of whitespace.

It makes the following changes:

• converts "--porting note" into "-- Porting note";
• converts "porting note" into "Porting note".

@@ -96,11 +96,11 @@ protected theorem eventually_eq {f : X → Y} (hf : IsLocallyConstant f) (x : X)
   (iff_eventually_eq f).1 hf x
 #align is_locally_constant.eventually_eq IsLocallyConstant.eventually_eq
 
--- porting note: new lemma
+-- Porting note: new lemma
 theorem iff_isOpen_fiber_apply {f : X → Y} : IsLocallyConstant f ↔ ∀ x, IsOpen (f ⁻¹' {f x}) :=
   (IsLocallyConstant.tfae f).out 0 2
 
--- porting note: new lemma
+-- Porting note: new lemma
 theorem iff_isOpen_fiber {f : X → Y} : IsLocallyConstant f ↔ ∀ y, IsOpen (f ⁻¹' {y}) :=
   (IsLocallyConstant.tfae f).out 0 3
 
@@ -310,7 +310,7 @@ protected theorem continuous : Continuous f :=
 /-- As a shorthand, `LocallyConstant.toContinuousMap` is available as a coercion -/
 instance : Coe (LocallyConstant X Y) C(X, Y) := ⟨toContinuousMap⟩
 
--- porting note: became a syntactic `rfl`
+-- Porting note: became a syntactic `rfl`
 #noalign locally_constant.to_continuous_map_eq_coe
 
 @[simp] theorem coe_continuousMap : ((f : C(X, Y)) : X → Y) = (f : X → Y) := rfl

No changes to tactic file, it's just boring fixes throughout the library.

This follows on from #6964.

Co-authored-by: sgouezel <sebastien.gouezel@univ-rennes1.fr> Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

@@ -149,7 +149,7 @@ theorem comp_continuous [TopologicalSpace Y] {g : Y → Z} {f : X → Y} (hg : I
 theorem apply_eq_of_isPreconnected {f : X → Y} (hf : IsLocallyConstant f) {s : Set X}
     (hs : IsPreconnected s) {x y : X} (hx : x ∈ s) (hy : y ∈ s) : f x = f y := by
   let U := f ⁻¹' {f y}
-  suffices : x ∉ Uᶜ; exact Classical.not_not.1 this
+  suffices x ∉ Uᶜ from Classical.not_not.1 this
   intro hxV
   specialize hs U Uᶜ (hf {f y}) (hf {f y}ᶜ) _ ⟨y, ⟨hy, rfl⟩⟩ ⟨x, ⟨hx, hxV⟩⟩
   · simp only [union_compl_self, subset_univ]

This is needed for the construction of limits and colimits in LightProfinite.

@@ -5,7 +5,7 @@ Authors: Johan Commelin
 -/
 import Mathlib.Algebra.Function.Indicator
 import Mathlib.Tactic.FinCases
-import Mathlib.Topology.ContinuousFunction.Basic
+import Mathlib.Topology.Sets.Closeds
 
 #align_import topology.locally_constant.basic from "leanprover-community/mathlib"@"0a0ec35061ed9960bf0e7ffb0335f44447b58977"
 
@@ -601,6 +601,18 @@ def congrLeft [TopologicalSpace Y] (e : X ≃ₜ Y) : LocallyConstant X Z ≃ Lo
     rw [comap_comap _ _ e.symm.continuous e.continuous]
     simp
 
+variable (X) in
+/--
+The set of clopen subsets of a topological space is equivalent to the locally constant maps to
+a two-element set
+-/
+def equivClopens [∀ (s : Set X) x, Decidable (x ∈ s)] :
+    LocallyConstant X (Fin 2) ≃ TopologicalSpace.Clopens X where
+  toFun f := ⟨f ⁻¹' {0}, f.2.isClopen_fiber _⟩
+  invFun s := ofIsClopen s.2
+  left_inv _ := locallyConstant_eq_of_fiber_zero_eq _ _ (by simp)
+  right_inv _ := by simp
+
 end Equiv
 
 section Piecewise

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

@@ -74,7 +74,7 @@ theorem isClosed_fiber {f : X → Y} (hf : IsLocallyConstant f) (y : Y) : IsClos
 #align is_locally_constant.is_closed_fiber IsLocallyConstant.isClosed_fiber
 
 theorem isClopen_fiber {f : X → Y} (hf : IsLocallyConstant f) (y : Y) : IsClopen { x | f x = y } :=
-  ⟨isOpen_fiber hf _, isClosed_fiber hf _⟩
+  ⟨isClosed_fiber hf _,  isOpen_fiber hf _⟩
 #align is_locally_constant.is_clopen_fiber IsLocallyConstant.isClopen_fiber
 
 theorem iff_exists_open (f : X → Y) :
@@ -339,13 +339,13 @@ def ofIsClopen {X : Type*} [TopologicalSpace X] {U : Set X} [∀ x, Decidable (x
   toFun x := if x ∈ U then 0 else 1
   isLocallyConstant := by
     refine IsLocallyConstant.iff_isOpen_fiber.2 <| Fin.forall_fin_two.2 ⟨?_, ?_⟩
-    · convert hU.1 using 1
+    · convert hU.2 using 1
       ext
       simp only [mem_singleton_iff, Fin.one_eq_zero_iff, mem_preimage, ite_eq_left_iff,
         Nat.succ_succ_ne_one]
       tauto
     · rw [← isClosed_compl_iff]
-      convert hU.2
+      convert hU.1
       ext
       simp
 #align locally_constant.of_clopen LocallyConstant.ofIsClopen

This follows up from #9785, which renamed FunLike to DFunLike, by introducing a new abbreviation FunLike F α β := DFunLike F α (fun _ => β), to make the non-dependent use of FunLike easier.

I searched for the pattern DFunLike.*fun and DFunLike.*λ in all files to replace expressions of the form DFunLike F α (fun _ => β) with FunLike F α β. I did this everywhere except for extends clauses for two reasons: it would conflict with #8386, and more importantly extends must directly refer to a structure with no unfolding of defs or abbrevs.

@@ -250,7 +250,7 @@ namespace LocallyConstant
 instance [Inhabited Y] : Inhabited (LocallyConstant X Y) :=
   ⟨⟨_, IsLocallyConstant.const default⟩⟩
 
-instance : DFunLike (LocallyConstant X Y) X (fun _ => Y) where
+instance : FunLike (LocallyConstant X Y) X Y where
   coe := LocallyConstant.toFun
   coe_injective' := by rintro ⟨_, _⟩ ⟨_, _⟩ _; congr
 

This prepares for the introduction of a non-dependent synonym of FunLike, which helps a lot with keeping #8386 readable.

This is entirely search-and-replace in 680197f combined with manual fixes in 4145626, e900597 and b8428f8. The commands that generated this change:

sed -i 's/\bFunLike\b/DFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/\btoFunLike\b/toDFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/import Mathlib.Data.DFunLike/import Mathlib.Data.FunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/\bHom_FunLike\b/Hom_DFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean     
sed -i 's/\binstFunLike\b/instDFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/\bfunLike\b/instDFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/\btoo many metavariables to apply `fun_like.has_coe_to_fun`/too many metavariables to apply `DFunLike.hasCoeToFun`/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean

Co-authored-by: Anne Baanen <Vierkantor@users.noreply.github.com>

@@ -250,7 +250,7 @@ namespace LocallyConstant
 instance [Inhabited Y] : Inhabited (LocallyConstant X Y) :=
   ⟨⟨_, IsLocallyConstant.const default⟩⟩
 
-instance : FunLike (LocallyConstant X Y) X (fun _ => Y) where
+instance : DFunLike (LocallyConstant X Y) X (fun _ => Y) where
   coe := LocallyConstant.toFun
   coe_injective' := by rintro ⟨_, _⟩ ⟨_, _⟩ _; congr
 
@@ -270,15 +270,15 @@ theorem coe_mk (f : X → Y) (h) : ⇑(⟨f, h⟩ : LocallyConstant X Y) = f :=
 #align locally_constant.coe_mk LocallyConstant.coe_mk
 
 theorem congr_fun {f g : LocallyConstant X Y} (h : f = g) (x : X) : f x = g x :=
-  FunLike.congr_fun h x
+  DFunLike.congr_fun h x
 #align locally_constant.congr_fun LocallyConstant.congr_fun
 
 theorem congr_arg (f : LocallyConstant X Y) {x y : X} (h : x = y) : f x = f y :=
-  FunLike.congr_arg f h
+  DFunLike.congr_arg f h
 #align locally_constant.congr_arg LocallyConstant.congr_arg
 
 theorem coe_injective : @Function.Injective (LocallyConstant X Y) (X → Y) (↑) := fun _ _ =>
-  FunLike.ext'
+  DFunLike.ext'
 #align locally_constant.coe_injective LocallyConstant.coe_injective
 
 @[norm_cast]
@@ -288,10 +288,10 @@ theorem coe_inj {f g : LocallyConstant X Y} : (f : X → Y) = g ↔ f = g :=
 
 @[ext]
 theorem ext ⦃f g : LocallyConstant X Y⦄ (h : ∀ x, f x = g x) : f = g :=
-  FunLike.ext _ _ h
+  DFunLike.ext _ _ h
 #align locally_constant.ext LocallyConstant.ext
 
-theorem ext_iff {f g : LocallyConstant X Y} : f = g ↔ ∀ x, f x = g x := FunLike.ext_iff
+theorem ext_iff {f g : LocallyConstant X Y} : f = g ↔ ∀ x, f x = g x := DFunLike.ext_iff
 #align locally_constant.ext_iff LocallyConstant.ext_iff
 
 section CodomainTopologicalSpace

• Merge Function.left_id and Function.comp.left_id into Function.id_comp.
• Merge Function.right_id and Function.comp.right_id into Function.comp_id.
• Merge Function.comp_const_right and Function.comp_const into Function.comp_const, use explicit arguments.
• Move Function.const_comp to Mathlib.Init.Function, use explicit arguments.

@@ -486,7 +486,7 @@ theorem coe_comap_apply (f : X → Y) (g : LocallyConstant Y Z) (hf : Continuous
 @[simp]
 theorem comap_id : comap (@id X) = @id (LocallyConstant X Z) := by
   ext
-  simp only [continuous_id, id.def, Function.comp.right_id, coe_comap]
+  simp only [continuous_id, id.def, Function.comp_id, coe_comap]
 #align locally_constant.comap_id LocallyConstant.comap_id
 
 theorem comap_comp [TopologicalSpace Z] (f : X → Y) (g : Y → Z) (hf : Continuous f)

Subset of #9319

@@ -430,7 +430,7 @@ family of locally constant functions with values in β indexed by α. -/
 def unflip {X α β : Type*} [Finite α] [TopologicalSpace X] (f : α → LocallyConstant X β) :
     LocallyConstant X (α → β) where
   toFun x a := f a x
-  isLocallyConstant := IsLocallyConstant.iff_isOpen_fiber.2 <| fun g => by
+  isLocallyConstant := IsLocallyConstant.iff_isOpen_fiber.2 fun g => by
     have : (fun (x : X) (a : α) => f a x) ⁻¹' {g} = ⋂ a : α, f a ⁻¹' {g a} := by
       ext; simp [Function.funext_iff]
     rw [this]

Function.support is a very basic definition. Nevertheless, it is a pretty heavy import because it imports most objects a support lemma can be written about.

This PR reverses the dependencies between those objects and Function.support, so that the latter can become a much more lightweight import.

Only two import could not easily be reversed, namely the ones to Data.Set.Finite and Order.ConditionallyCompleteLattice.Basic, so I created two new files instead.

I credit:

• Yury for https://github.com/leanprover-community/mathlib/pull/6791
• Oliver for https://github.com/leanprover-community/mathlib/pull/7439

@@ -3,9 +3,9 @@ Copyright (c) 2021 Johan Commelin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
 -/
-import Mathlib.Topology.ContinuousFunction.Basic
-import Mathlib.Algebra.IndicatorFunction
+import Mathlib.Algebra.Function.Indicator
 import Mathlib.Tactic.FinCases
+import Mathlib.Topology.ContinuousFunction.Basic
 
 #align_import topology.locally_constant.basic from "leanprover-community/mathlib"@"0a0ec35061ed9960bf0e7ffb0335f44447b58977"
 

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

@@ -334,7 +334,7 @@ theorem coe_const (y : Y) : (const X y : X → Y) = Function.const X y :=
 #align locally_constant.coe_const LocallyConstant.coe_const
 
 /-- The locally constant function to `Fin 2` associated to a clopen set. -/
-def ofClopen {X : Type*} [TopologicalSpace X] {U : Set X} [∀ x, Decidable (x ∈ U)]
+def ofIsClopen {X : Type*} [TopologicalSpace X] {U : Set X} [∀ x, Decidable (x ∈ U)]
     (hU : IsClopen U) : LocallyConstant X (Fin 2) where
   toFun x := if x ∈ U then 0 else 1
   isLocallyConstant := by
@@ -348,24 +348,24 @@ def ofClopen {X : Type*} [TopologicalSpace X] {U : Set X} [∀ x, Decidable (x 
       convert hU.2
       ext
       simp
-#align locally_constant.of_clopen LocallyConstant.ofClopen
+#align locally_constant.of_clopen LocallyConstant.ofIsClopen
 
 @[simp]
-theorem ofClopen_fiber_zero {X : Type*} [TopologicalSpace X] {U : Set X} [∀ x, Decidable (x ∈ U)]
-    (hU : IsClopen U) : ofClopen hU ⁻¹' ({0} : Set (Fin 2)) = U := by
+theorem ofIsClopen_fiber_zero {X : Type*} [TopologicalSpace X] {U : Set X} [∀ x, Decidable (x ∈ U)]
+    (hU : IsClopen U) : ofIsClopen hU ⁻¹' ({0} : Set (Fin 2)) = U := by
   ext
-  simp only [ofClopen, mem_singleton_iff, Fin.one_eq_zero_iff, coe_mk, mem_preimage,
+  simp only [ofIsClopen, mem_singleton_iff, Fin.one_eq_zero_iff, coe_mk, mem_preimage,
     ite_eq_left_iff, Nat.succ_succ_ne_one]
   tauto
-#align locally_constant.of_clopen_fiber_zero LocallyConstant.ofClopen_fiber_zero
+#align locally_constant.of_clopen_fiber_zero LocallyConstant.ofIsClopen_fiber_zero
 
 @[simp]
-theorem ofClopen_fiber_one {X : Type*} [TopologicalSpace X] {U : Set X} [∀ x, Decidable (x ∈ U)]
-    (hU : IsClopen U) : ofClopen hU ⁻¹' ({1} : Set (Fin 2)) = Uᶜ := by
+theorem ofIsClopen_fiber_one {X : Type*} [TopologicalSpace X] {U : Set X} [∀ x, Decidable (x ∈ U)]
+    (hU : IsClopen U) : ofIsClopen hU ⁻¹' ({1} : Set (Fin 2)) = Uᶜ := by
   ext
-  simp only [ofClopen, mem_singleton_iff, coe_mk, Fin.zero_eq_one_iff, mem_preimage,
+  simp only [ofIsClopen, mem_singleton_iff, coe_mk, Fin.zero_eq_one_iff, mem_preimage,
     ite_eq_right_iff, mem_compl_iff, Nat.succ_succ_ne_one]
-#align locally_constant.of_clopen_fiber_one LocallyConstant.ofClopen_fiber_one
+#align locally_constant.of_clopen_fiber_one LocallyConstant.ofIsClopen_fiber_one
 
 theorem locallyConstant_eq_of_fiber_zero_eq {X : Type*} [TopologicalSpace X]
     (f g : LocallyConstant X (Fin 2)) (h : f ⁻¹' ({0} : Set (Fin 2)) = g ⁻¹' {0}) : f = g := by

In the last step, I have removed redundant imports: those which are implied by the other imports. I can revert those changes if desired/if this seems too brittle.

@@ -3,11 +3,9 @@ Copyright (c) 2021 Johan Commelin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
 -/
-import Mathlib.Topology.Connected
 import Mathlib.Topology.ContinuousFunction.Basic
 import Mathlib.Algebra.IndicatorFunction
 import Mathlib.Tactic.FinCases
-import Mathlib.Tactic.TFAE
 
 #align_import topology.locally_constant.basic from "leanprover-community/mathlib"@"0a0ec35061ed9960bf0e7ffb0335f44447b58977"
 

Split up the 2000-line Topology/SubsetProperties.lean into several smaller files. Not only is it too huge, but the name is very unhelpful, since actually about 90% of the file is about compactness; I've moved this material into various files inside a new subdirectory Topology/Compactness/.

@@ -3,7 +3,6 @@ Copyright (c) 2021 Johan Commelin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
 -/
-import Mathlib.Topology.SubsetProperties
 import Mathlib.Topology.Connected
 import Mathlib.Topology.ContinuousFunction.Basic
 import Mathlib.Algebra.IndicatorFunction

And fix some names in comments where this revealed issues

@@ -551,7 +551,7 @@ open Classical
 /-- Given a clopen set `U` and a locally constant function `f`, `LocallyConstant.mulIndicator`
   returns the locally constant function that is `f` on `U` and `1` otherwise. -/
 @[to_additive (attr := simps) "Given a clopen set `U` and a locally constant function `f`,
-  `locally_constant.indicator` returns the locally constant function that is `f` on `U` and `0`
+  `LocallyConstant.indicator` returns the locally constant function that is `f` on `U` and `0`
   otherwise. "]
 noncomputable def mulIndicator (hU : IsClopen U) : LocallyConstant X R where
   toFun := Set.mulIndicator U f

We define a variant of LocallyConstant.piecewise which defines a locally constant map on a subset given locally constant maps on two closed subsets covering it, that agree on the intersection.

• depends on: #6616

Co-authored-by: Anatole Dedecker @ADedecker

@@ -610,11 +610,13 @@ section Piecewise
 
 /-- Given two closed sets covering a topological space, and locally constant maps on these two sets,
     then if these two locally constant maps agree on the intersection, we get a piecewise defined
-    locally constant map on the whole space. -/
+    locally constant map on the whole space.
+
+TODO: Generalise this construction to `ContinuousMap`. -/
 def piecewise {C₁ C₂ : Set X} (h₁ : IsClosed C₁) (h₂ : IsClosed C₂) (h : C₁ ∪ C₂ = Set.univ)
     (f : LocallyConstant C₁ Z) (g : LocallyConstant C₂ Z)
-    (hfg : ∀ (x : X) (hx : x ∈ C₁ ∩ C₂), f.toFun ⟨x, hx.1⟩ = g.toFun ⟨x, hx.2⟩)
-    [∀ j, Decidable (j ∈ C₁)] : LocallyConstant X Z where
+    (hfg : ∀ (x : X) (hx : x ∈ C₁ ∩ C₂), f ⟨x, hx.1⟩ = g ⟨x, hx.2⟩)
+    [DecidablePred (· ∈ C₁)] : LocallyConstant X Z where
   toFun i := if hi : i ∈ C₁ then f ⟨i, hi⟩ else g ⟨i, (Set.compl_subset_iff_union.mpr h) hi⟩
   isLocallyConstant := by
     let dZ : TopologicalSpace Z := ⊥
@@ -634,6 +636,66 @@ def piecewise {C₁ C₂ : Set X} (h₁ : IsClosed C₁) (h₂ : IsClosed C₂)
       · simp only [cond_true, restrict_dite, Subtype.coe_eta]
         exact hf
 
+@[simp]
+lemma piecewise_apply_left {C₁ C₂ : Set X} (h₁ : IsClosed C₁) (h₂ : IsClosed C₂)
+    (h : C₁ ∪ C₂ = Set.univ) (f : LocallyConstant C₁ Z) (g : LocallyConstant C₂ Z)
+    (hfg : ∀ (x : X) (hx : x ∈ C₁ ∩ C₂), f ⟨x, hx.1⟩ = g ⟨x, hx.2⟩)
+    [DecidablePred (· ∈ C₁)] (x : X) (hx : x ∈ C₁) :
+    piecewise h₁ h₂ h f g hfg x = f ⟨x, hx⟩ := by
+  simp only [piecewise, Set.mem_preimage, continuous_subtype_val.restrictPreimage,
+    coe_comap, Function.comp_apply, coe_mk]
+  rw [dif_pos hx]
+
+@[simp]
+lemma piecewise_apply_right {C₁ C₂ : Set X} (h₁ : IsClosed C₁) (h₂ : IsClosed C₂)
+    (h : C₁ ∪ C₂ = Set.univ) (f : LocallyConstant C₁ Z) (g : LocallyConstant C₂ Z)
+    (hfg : ∀ (x : X) (hx : x ∈ C₁ ∩ C₂), f ⟨x, hx.1⟩ = g ⟨x, hx.2⟩)
+    [DecidablePred (· ∈ C₁)] (x : X) (hx : x ∈ C₂) :
+    piecewise h₁ h₂ h f g hfg x = g ⟨x, hx⟩ := by
+  simp only [piecewise, Set.mem_preimage, continuous_subtype_val.restrictPreimage,
+    coe_comap, Function.comp_apply, coe_mk]
+  split_ifs with h
+  · exact hfg x ⟨h, hx⟩
+  · rfl
+
+/-- A variant of `LocallyConstant.piecewise` where the two closed sets cover a subset.
+
+TODO: Generalise this construction to `ContinuousMap`. -/
+noncomputable def piecewise' {C₀ C₁ C₂ : Set X} (h₀ : C₀ ⊆ C₁ ∪ C₂) (h₁ : IsClosed C₁)
+    (h₂ : IsClosed C₂) (f₁ : LocallyConstant C₁ Z) (f₂ : LocallyConstant C₂ Z)
+    [DecidablePred (· ∈ C₁)] (hf : ∀ x (hx : x ∈ C₁ ∩ C₂), f₁ ⟨x, hx.1⟩ = f₂ ⟨x, hx.2⟩) :
+    LocallyConstant C₀ Z :=
+  letI : ∀ j : C₀, Decidable (j ∈ Subtype.val ⁻¹' C₁) := fun j ↦ decidable_of_iff (↑j ∈ C₁) Iff.rfl
+  piecewise (h₁.preimage continuous_subtype_val) (h₂.preimage continuous_subtype_val)
+    (by simpa [eq_univ_iff_forall] using h₀)
+    (f₁.comap (restrictPreimage C₁ ((↑) : C₀ → X)))
+    (f₂.comap (restrictPreimage C₂ ((↑) : C₀ → X))) <| by
+      rintro ⟨x, hx₀⟩ ⟨hx₁ : x ∈ C₁, hx₂ : x ∈ C₂⟩
+      simp_rw [coe_comap_apply _ _ continuous_subtype_val.restrictPreimage]
+      exact hf x ⟨hx₁, hx₂⟩
+
+@[simp]
+lemma piecewise'_apply_left {C₀ C₁ C₂ : Set X} (h₀ : C₀ ⊆ C₁ ∪ C₂) (h₁ : IsClosed C₁)
+    (h₂ : IsClosed C₂) (f₁ : LocallyConstant C₁ Z) (f₂ : LocallyConstant C₂ Z)
+    [DecidablePred (· ∈ C₁)] (hf : ∀ x (hx : x ∈ C₁ ∩ C₂), f₁ ⟨x, hx.1⟩ = f₂ ⟨x, hx.2⟩)
+    (x : C₀) (hx : x.val ∈ C₁) :
+    piecewise' h₀ h₁ h₂ f₁ f₂ hf x = f₁ ⟨x.val, hx⟩ := by
+  letI : ∀ j : C₀, Decidable (j ∈ Subtype.val ⁻¹' C₁) := fun j ↦ decidable_of_iff (↑j ∈ C₁) Iff.rfl
+  rw [piecewise', piecewise_apply_left (f := (f₁.comap (restrictPreimage C₁ ((↑) : C₀ → X))))
+    (hx := hx), coe_comap (hf := continuous_subtype_val.restrictPreimage)]
+  rfl
+
+@[simp]
+lemma piecewise'_apply_right {C₀ C₁ C₂ : Set X} (h₀ : C₀ ⊆ C₁ ∪ C₂) (h₁ : IsClosed C₁)
+    (h₂ : IsClosed C₂) (f₁ : LocallyConstant C₁ Z) (f₂ : LocallyConstant C₂ Z)
+    [DecidablePred (· ∈ C₁)] (hf : ∀ x (hx : x ∈ C₁ ∩ C₂), f₁ ⟨x, hx.1⟩ = f₂ ⟨x, hx.2⟩)
+    (x : C₀) (hx : x.val ∈ C₂) :
+    piecewise' h₀ h₁ h₂ f₁ f₂ hf x = f₂ ⟨x.val, hx⟩ := by
+  letI : ∀ j : C₀, Decidable (j ∈ Subtype.val ⁻¹' C₁) := fun j ↦ decidable_of_iff (↑j ∈ C₁) Iff.rfl
+  rw [piecewise', piecewise_apply_right (f := (f₁.comap (restrictPreimage C₁ ((↑) : C₀ → X))))
+    (hx := hx), coe_comap (hf := continuous_subtype_val.restrictPreimage)]
+  rfl
+
 end Piecewise
 
 end LocallyConstant

We define Alexandrov-discrete spaces as topological spaces where the intersection of a family of open sets is open.

This PR only gives a minimal API because the goal is to ensure that lemma names like isOpen_sInter are free to use for AlexandrovDiscrete. The existing lemmas are getting prefixed by Set.Finite or suffixed by _of_finite.

@@ -437,7 +437,7 @@ def unflip {X α β : Type*} [Finite α] [TopologicalSpace X] (f : α → Locall
     have : (fun (x : X) (a : α) => f a x) ⁻¹' {g} = ⋂ a : α, f a ⁻¹' {g a} := by
       ext; simp [Function.funext_iff]
     rw [this]
-    exact isOpen_iInter fun a => (f a).isLocallyConstant _
+    exact isOpen_iInter_of_finite fun a => (f a).isLocallyConstant _
 #align locally_constant.unflip LocallyConstant.unflip
 
 @[simp]

We define more algebraic versions of LocallyConstant.comap and evaluation of locally constant maps, continuing the work of #6396.

@@ -590,17 +590,18 @@ section Equiv
 
 /-- The equivalence between `LocallyConstant X Z` and `LocallyConstant Y Z` given a
     homeomorphism `X ≃ₜ Y` -/
+@[simps]
 noncomputable
 def congrLeft [TopologicalSpace Y] (e : X ≃ₜ Y) : LocallyConstant X Z ≃ LocallyConstant Y Z where
-  toFun := comap e.invFun
-  invFun := comap e.toFun
+  toFun := comap e.symm
+  invFun := comap e
   left_inv := by
-    intro x
-    rw [comap_comap _ _ e.continuous_toFun e.continuous_invFun x]
+    intro
+    rw [comap_comap _ _ e.continuous e.symm.continuous]
     simp
   right_inv := by
-    intro x
-    rw [comap_comap _ _ e.continuous_invFun e.continuous_toFun]
+    intro
+    rw [comap_comap _ _ e.symm.continuous e.continuous]
     simp
 
 end Equiv

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

This has nice performance benefits.

@@ -28,7 +28,7 @@ This file sets up the theory of locally constant function from a topological spa
 -/
 
 
-variable {X Y Z α : Type _} [TopologicalSpace X]
+variable {X Y Z α : Type*} [TopologicalSpace X]
 
 open Set Filter
 
@@ -137,7 +137,7 @@ theorem prod_mk {Y'} {f : X → Y} {f' : X → Y'} (hf : IsLocallyConstant f)
     (hf.eventually_eq x).mp <| (hf'.eventually_eq x).mono fun _ hf' hf => Prod.ext hf hf'
 #align is_locally_constant.prod_mk IsLocallyConstant.prod_mk
 
-theorem comp₂ {Y₁ Y₂ Z : Type _} {f : X → Y₁} {g : X → Y₂} (hf : IsLocallyConstant f)
+theorem comp₂ {Y₁ Y₂ Z : Type*} {f : X → Y₁} {g : X → Y₂} (hf : IsLocallyConstant f)
     (hg : IsLocallyConstant g) (h : Y₁ → Y₂ → Z) : IsLocallyConstant fun x => h (f x) (g x) :=
   (hf.prod_mk hg).comp fun x : Y₁ × Y₂ => h x.1 x.2
 #align is_locally_constant.comp₂ IsLocallyConstant.comp₂
@@ -213,7 +213,7 @@ theorem div [Div Y] ⦃f g : X → Y⦄ (hf : IsLocallyConstant f) (hg : IsLocal
 
 /-- If a composition of a function `f` followed by an injection `g` is locally
 constant, then the locally constant property descends to `f`. -/
-theorem desc {α β : Type _} (f : X → α) (g : α → β) (h : IsLocallyConstant (g ∘ f))
+theorem desc {α β : Type*} (f : X → α) (g : α → β) (h : IsLocallyConstant (g ∘ f))
     (inj : Function.Injective g) : IsLocallyConstant f := fun s => by
   rw [← preimage_image_eq s inj, preimage_preimage]
   exact h (g '' s)
@@ -241,7 +241,7 @@ theorem of_constant_on_preconnected_clopens [LocallyConnectedSpace X] {f : X →
 end IsLocallyConstant
 
 /-- A (bundled) locally constant function from a topological space `X` to a type `Y`. -/
-structure LocallyConstant (X Y : Type _) [TopologicalSpace X] where
+structure LocallyConstant (X Y : Type*) [TopologicalSpace X] where
   /-- The underlying function. -/
   protected toFun : X → Y
   /-- The map is locally constant. -/
@@ -327,7 +327,7 @@ theorem toContinuousMap_injective :
 end CodomainTopologicalSpace
 
 /-- The constant locally constant function on `X` with value `y : Y`. -/
-def const (X : Type _) {Y : Type _} [TopologicalSpace X] (y : Y) : LocallyConstant X Y :=
+def const (X : Type*) {Y : Type*} [TopologicalSpace X] (y : Y) : LocallyConstant X Y :=
   ⟨Function.const X y, IsLocallyConstant.const _⟩
 #align locally_constant.const LocallyConstant.const
 
@@ -337,7 +337,7 @@ theorem coe_const (y : Y) : (const X y : X → Y) = Function.const X y :=
 #align locally_constant.coe_const LocallyConstant.coe_const
 
 /-- The locally constant function to `Fin 2` associated to a clopen set. -/
-def ofClopen {X : Type _} [TopologicalSpace X] {U : Set X} [∀ x, Decidable (x ∈ U)]
+def ofClopen {X : Type*} [TopologicalSpace X] {U : Set X} [∀ x, Decidable (x ∈ U)]
     (hU : IsClopen U) : LocallyConstant X (Fin 2) where
   toFun x := if x ∈ U then 0 else 1
   isLocallyConstant := by
@@ -354,7 +354,7 @@ def ofClopen {X : Type _} [TopologicalSpace X] {U : Set X} [∀ x, Decidable (x
 #align locally_constant.of_clopen LocallyConstant.ofClopen
 
 @[simp]
-theorem ofClopen_fiber_zero {X : Type _} [TopologicalSpace X] {U : Set X} [∀ x, Decidable (x ∈ U)]
+theorem ofClopen_fiber_zero {X : Type*} [TopologicalSpace X] {U : Set X} [∀ x, Decidable (x ∈ U)]
     (hU : IsClopen U) : ofClopen hU ⁻¹' ({0} : Set (Fin 2)) = U := by
   ext
   simp only [ofClopen, mem_singleton_iff, Fin.one_eq_zero_iff, coe_mk, mem_preimage,
@@ -363,14 +363,14 @@ theorem ofClopen_fiber_zero {X : Type _} [TopologicalSpace X] {U : Set X} [∀ x
 #align locally_constant.of_clopen_fiber_zero LocallyConstant.ofClopen_fiber_zero
 
 @[simp]
-theorem ofClopen_fiber_one {X : Type _} [TopologicalSpace X] {U : Set X} [∀ x, Decidable (x ∈ U)]
+theorem ofClopen_fiber_one {X : Type*} [TopologicalSpace X] {U : Set X} [∀ x, Decidable (x ∈ U)]
     (hU : IsClopen U) : ofClopen hU ⁻¹' ({1} : Set (Fin 2)) = Uᶜ := by
   ext
   simp only [ofClopen, mem_singleton_iff, coe_mk, Fin.zero_eq_one_iff, mem_preimage,
     ite_eq_right_iff, mem_compl_iff, Nat.succ_succ_ne_one]
 #align locally_constant.of_clopen_fiber_one LocallyConstant.ofClopen_fiber_one
 
-theorem locallyConstant_eq_of_fiber_zero_eq {X : Type _} [TopologicalSpace X]
+theorem locallyConstant_eq_of_fiber_zero_eq {X : Type*} [TopologicalSpace X]
     (f g : LocallyConstant X (Fin 2)) (h : f ⁻¹' ({0} : Set (Fin 2)) = g ⁻¹' {0}) : f = g := by
   simp only [Set.ext_iff, mem_singleton_iff, mem_preimage] at h
   ext1 x
@@ -417,20 +417,20 @@ theorem map_id : @map X Y Y _ id = id := rfl
 #align locally_constant.map_id LocallyConstant.map_id
 
 @[simp]
-theorem map_comp {Y₁ Y₂ Y₃ : Type _} (g : Y₂ → Y₃) (f : Y₁ → Y₂) :
+theorem map_comp {Y₁ Y₂ Y₃ : Type*} (g : Y₂ → Y₃) (f : Y₁ → Y₂) :
     @map X _ _ _ g ∘ map f = map (g ∘ f) := rfl
 #align locally_constant.map_comp LocallyConstant.map_comp
 
 /-- Given a locally constant function to `α → β`, construct a family of locally constant
 functions with values in β indexed by α. -/
-def flip {X α β : Type _} [TopologicalSpace X] (f : LocallyConstant X (α → β)) (a : α) :
+def flip {X α β : Type*} [TopologicalSpace X] (f : LocallyConstant X (α → β)) (a : α) :
     LocallyConstant X β :=
   f.map fun f => f a
 #align locally_constant.flip LocallyConstant.flip
 
 /-- If α is finite, this constructs a locally constant function to `α → β` given a
 family of locally constant functions with values in β indexed by α. -/
-def unflip {X α β : Type _} [Finite α] [TopologicalSpace X] (f : α → LocallyConstant X β) :
+def unflip {X α β : Type*} [Finite α] [TopologicalSpace X] (f : α → LocallyConstant X β) :
     LocallyConstant X (α → β) where
   toFun x a := f a x
   isLocallyConstant := IsLocallyConstant.iff_isOpen_fiber.2 <| fun g => by
@@ -441,12 +441,12 @@ def unflip {X α β : Type _} [Finite α] [TopologicalSpace X] (f : α → Local
 #align locally_constant.unflip LocallyConstant.unflip
 
 @[simp]
-theorem unflip_flip {X α β : Type _} [Finite α] [TopologicalSpace X]
+theorem unflip_flip {X α β : Type*} [Finite α] [TopologicalSpace X]
     (f : LocallyConstant X (α → β)) : unflip f.flip = f := rfl
 #align locally_constant.unflip_flip LocallyConstant.unflip_flip
 
 @[simp]
-theorem flip_unflip {X α β : Type _} [Finite α] [TopologicalSpace X]
+theorem flip_unflip {X α β : Type*} [Finite α] [TopologicalSpace X]
     (f : α → LocallyConstant X β) : (unflip f).flip = f := rfl
 #align locally_constant.flip_unflip LocallyConstant.flip_unflip
 
@@ -527,14 +527,14 @@ section Desc
 
 /-- If a locally constant function factors through an injection, then it factors through a locally
 constant function. -/
-def desc {X α β : Type _} [TopologicalSpace X] {g : α → β} (f : X → α) (h : LocallyConstant X β)
+def desc {X α β : Type*} [TopologicalSpace X] {g : α → β} (f : X → α) (h : LocallyConstant X β)
     (cond : g ∘ f = h) (inj : Function.Injective g) : LocallyConstant X α where
   toFun := f
   isLocallyConstant := IsLocallyConstant.desc _ g (cond.symm ▸ h.isLocallyConstant) inj
 #align locally_constant.desc LocallyConstant.desc
 
 @[simp]
-theorem coe_desc {X α β : Type _} [TopologicalSpace X] (f : X → α) (g : α → β)
+theorem coe_desc {X α β : Type*} [TopologicalSpace X] (f : X → α) (g : α → β)
     (h : LocallyConstant X β) (cond : g ∘ f = h) (inj : Function.Injective g) :
     ⇑(desc f h cond inj) = f :=
   rfl
@@ -544,7 +544,7 @@ end Desc
 
 section Indicator
 
-variable {R : Type _} [One R] {U : Set X} (f : LocallyConstant X R)
+variable {R : Type*} [One R] {U : Set X} (f : LocallyConstant X R)
 
 open Classical
 

We give algebraic versions of LocallyConstant.comap given the relevant algebraic structure on the target.

@@ -477,13 +477,17 @@ noncomputable def comap (f : X → Y) : LocallyConstant Y Z → LocallyConstant
 
 @[simp]
 theorem coe_comap (f : X → Y) (g : LocallyConstant Y Z) (hf : Continuous f) :
-    ⇑(comap f g) = g ∘ f := by
+    (comap f g) = g ∘ f := by
   rw [comap, dif_pos hf]
   rfl
 #align locally_constant.coe_comap LocallyConstant.coe_comap
 
+theorem coe_comap_apply (f : X → Y) (g : LocallyConstant Y Z) (hf : Continuous f) (x : X) :
+    comap f g x = g (f x) := by
+  simp only [hf, coe_comap, Function.comp_apply]
+
 @[simp]
-theorem comap_id : @comap X X Z _ _ id = id := by
+theorem comap_id : comap (@id X) = @id (LocallyConstant X Z) := by
   ext
   simp only [continuous_id, id.def, Function.comp.right_id, coe_comap]
 #align locally_constant.comap_id LocallyConstant.comap_id
@@ -495,15 +499,28 @@ theorem comap_comp [TopologicalSpace Z] (f : X → Y) (g : Y → Z) (hf : Contin
   simp only [hf, hg, hg.comp hf, coe_comap]; rfl
 #align locally_constant.comap_comp LocallyConstant.comap_comp
 
+theorem comap_comap [TopologicalSpace Z] (f : X → Y) (g : Y → Z)
+    (hf : Continuous f) (hg : Continuous g) (x : LocallyConstant Z α) :
+    comap f (comap g x) = comap (g ∘ f) x := by
+  rw [← comap_comp f g hf hg]; rfl
+
 theorem comap_const (f : X → Y) (y : Y) (h : ∀ x, f x = y) :
-    (comap f : LocallyConstant Y Z → LocallyConstant X Z) = fun g =>
-      ⟨fun _ => g y, IsLocallyConstant.const _⟩ := by
+    (comap f : LocallyConstant Y Z → LocallyConstant X Z) = fun g => const X (g y) := by
   ext; rw [coe_comap]
-  · simp only [h, coe_mk, Function.comp_apply]
+  · simp only [Function.comp_apply, h, coe_const, Function.const_apply]
   · rw [show f = fun _ => y by ext; apply h]
     exact continuous_const
 #align locally_constant.comap_const LocallyConstant.comap_const
 
+lemma comap_injective (f : X → Y) (hf: Continuous f) (hfs : f.Surjective) :
+    (comap (Z := Z) f).Injective := by
+  intro a b h
+  rw [LocallyConstant.ext_iff] at h
+  ext y
+  obtain ⟨x, hx⟩ := hfs y
+  specialize h x
+  rwa [coe_comap_apply _ _ hf, coe_comap_apply _ _ hf, hx] at h
+
 end Comap
 
 section Desc
@@ -569,6 +586,25 @@ theorem mulIndicator_of_not_mem (hU : IsClopen U) (h : a ∉ U) : f.mulIndicator
 
 end Indicator
 
+section Equiv
+
+/-- The equivalence between `LocallyConstant X Z` and `LocallyConstant Y Z` given a
+    homeomorphism `X ≃ₜ Y` -/
+noncomputable
+def congrLeft [TopologicalSpace Y] (e : X ≃ₜ Y) : LocallyConstant X Z ≃ LocallyConstant Y Z where
+  toFun := comap e.invFun
+  invFun := comap e.toFun
+  left_inv := by
+    intro x
+    rw [comap_comap _ _ e.continuous_toFun e.continuous_invFun x]
+    simp
+  right_inv := by
+    intro x
+    rw [comap_comap _ _ e.continuous_invFun e.continuous_toFun]
+    simp
+
+end Equiv
+
 section Piecewise
 
 /-- Given two closed sets covering a topological space, and locally constant maps on these two sets,

We define the locally constant map on a topological space covered by two closed sets, defined piecewise on those two closed sets by two maps, that are equal on the intersection.

@@ -569,4 +569,34 @@ theorem mulIndicator_of_not_mem (hU : IsClopen U) (h : a ∉ U) : f.mulIndicator
 
 end Indicator
 
+section Piecewise
+
+/-- Given two closed sets covering a topological space, and locally constant maps on these two sets,
+    then if these two locally constant maps agree on the intersection, we get a piecewise defined
+    locally constant map on the whole space. -/
+def piecewise {C₁ C₂ : Set X} (h₁ : IsClosed C₁) (h₂ : IsClosed C₂) (h : C₁ ∪ C₂ = Set.univ)
+    (f : LocallyConstant C₁ Z) (g : LocallyConstant C₂ Z)
+    (hfg : ∀ (x : X) (hx : x ∈ C₁ ∩ C₂), f.toFun ⟨x, hx.1⟩ = g.toFun ⟨x, hx.2⟩)
+    [∀ j, Decidable (j ∈ C₁)] : LocallyConstant X Z where
+  toFun i := if hi : i ∈ C₁ then f ⟨i, hi⟩ else g ⟨i, (Set.compl_subset_iff_union.mpr h) hi⟩
+  isLocallyConstant := by
+    let dZ : TopologicalSpace Z := ⊥
+    haveI : DiscreteTopology Z := discreteTopology_bot Z
+    obtain ⟨f, hf⟩ := f
+    obtain ⟨g, hg⟩ := g
+    rw [IsLocallyConstant.iff_continuous] at hf hg ⊢
+    dsimp only [coe_mk]
+    rw [Set.union_eq_iUnion] at h
+    refine' (locallyFinite_of_finite _).continuous h (fun i ↦ _) (fun i ↦ _)
+    · cases i <;> [exact h₂; exact h₁]
+    · cases i <;> rw [continuousOn_iff_continuous_restrict]
+      · convert hg
+        ext x
+        simp only [cond_false, restrict_apply, Subtype.coe_eta, dite_eq_right_iff]
+        exact fun hx ↦ hfg x ⟨hx, x.prop⟩
+      · simp only [cond_true, restrict_dite, Subtype.coe_eta]
+        exact hf
+
+end Piecewise
+
 end LocallyConstant

• depends on: #5966

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

@@ -2,11 +2,6 @@
 Copyright (c) 2021 Johan Commelin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
-
-! This file was ported from Lean 3 source module topology.locally_constant.basic
-! 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.SubsetProperties
 import Mathlib.Topology.Connected
@@ -15,6 +10,8 @@ import Mathlib.Algebra.IndicatorFunction
 import Mathlib.Tactic.FinCases
 import Mathlib.Tactic.TFAE
 
+#align_import topology.locally_constant.basic from "leanprover-community/mathlib"@"0a0ec35061ed9960bf0e7ffb0335f44447b58977"
+
 /-!
 # Locally constant functions
 

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

@@ -76,7 +76,7 @@ theorem isOpen_fiber {f : X → Y} (hf : IsLocallyConstant f) (y : Y) : IsOpen {
 #align is_locally_constant.is_open_fiber IsLocallyConstant.isOpen_fiber
 
 theorem isClosed_fiber {f : X → Y} (hf : IsLocallyConstant f) (y : Y) : IsClosed { x | f x = y } :=
-  ⟨hf ({y}ᶜ)⟩
+  ⟨hf {y}ᶜ⟩
 #align is_locally_constant.is_closed_fiber IsLocallyConstant.isClosed_fiber
 
 theorem isClopen_fiber {f : X → Y} (hf : IsLocallyConstant f) (y : Y) : IsClopen { x | f x = y } :=
@@ -157,7 +157,7 @@ theorem apply_eq_of_isPreconnected {f : X → Y} (hf : IsLocallyConstant f) {s :
   let U := f ⁻¹' {f y}
   suffices : x ∉ Uᶜ; exact Classical.not_not.1 this
   intro hxV
-  specialize hs U (Uᶜ) (hf {f y}) (hf ({f y}ᶜ)) _ ⟨y, ⟨hy, rfl⟩⟩ ⟨x, ⟨hx, hxV⟩⟩
+  specialize hs U Uᶜ (hf {f y}) (hf {f y}ᶜ) _ ⟨y, ⟨hy, rfl⟩⟩ ⟨x, ⟨hx, hxV⟩⟩
   · simp only [union_compl_self, subset_univ]
   · simp only [inter_empty, Set.not_nonempty_empty, inter_compl_self] at hs
 #align is_locally_constant.apply_eq_of_is_preconnected IsLocallyConstant.apply_eq_of_isPreconnected

@@ -228,12 +228,17 @@ theorem of_constant_on_connected_components [LocallyConnectedSpace X] {f : X →
     ⟨connectedComponent x, isOpen_connectedComponent, mem_connectedComponent, h x⟩
 #align is_locally_constant.of_constant_on_connected_components IsLocallyConstant.of_constant_on_connected_components
 
-theorem of_constant_on_preconnected_clopens [LocallyConnectedSpace X] {f : X → Y}
-    (h : ∀ U : Set X, IsPreconnected U → IsClopen U → ∀ x ∈ U, ∀ y ∈ U, f y = f x) :
+theorem of_constant_on_connected_clopens [LocallyConnectedSpace X] {f : X → Y}
+    (h : ∀ U : Set X, IsConnected U → IsClopen U → ∀ x ∈ U, ∀ y ∈ U, f y = f x) :
     IsLocallyConstant f :=
   of_constant_on_connected_components fun x =>
-    h (connectedComponent x) isPreconnected_connectedComponent isClopen_connectedComponent x
+    h (connectedComponent x) isConnected_connectedComponent isClopen_connectedComponent x
       mem_connectedComponent
+
+theorem of_constant_on_preconnected_clopens [LocallyConnectedSpace X] {f : X → Y}
+    (h : ∀ U : Set X, IsPreconnected U → IsClopen U → ∀ x ∈ U, ∀ y ∈ U, f y = f x) :
+    IsLocallyConstant f :=
+  of_constant_on_connected_clopens fun U hU ↦ h U hU.isPreconnected
 #align is_locally_constant.of_constant_on_preconnected_clopens IsLocallyConstant.of_constant_on_preconnected_clopens
 
 end IsLocallyConstant

Run codespell Mathlib and keep some suggestions.

@@ -311,7 +311,7 @@ protected theorem continuous : Continuous f :=
 /-- As a shorthand, `LocallyConstant.toContinuousMap` is available as a coercion -/
 instance : Coe (LocallyConstant X Y) C(X, Y) := ⟨toContinuousMap⟩
 
--- porting note: became a syntatic `rfl`
+-- porting note: became a syntactic `rfl`
 #noalign locally_constant.to_continuous_map_eq_coe
 
 @[simp] theorem coe_continuousMap : ((f : C(X, Y)) : X → Y) = (f : X → Y) := rfl

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>

@@ -435,7 +435,7 @@ def unflip {X α β : Type _} [Finite α] [TopologicalSpace X] (f : α → Local
     have : (fun (x : X) (a : α) => f a x) ⁻¹' {g} = ⋂ a : α, f a ⁻¹' {g a} := by
       ext; simp [Function.funext_iff]
     rw [this]
-    exact isOpen_interᵢ fun a => (f a).isLocallyConstant _
+    exact isOpen_iInter fun a => (f a).isLocallyConstant _
 #align locally_constant.unflip LocallyConstant.unflip
 
 @[simp]

@@ -13,6 +13,7 @@ import Mathlib.Topology.Connected
 import Mathlib.Topology.ContinuousFunction.Basic
 import Mathlib.Algebra.IndicatorFunction
 import Mathlib.Tactic.FinCases
+import Mathlib.Tactic.TFAE
 
 /-!
 # Locally constant functions
@@ -50,33 +51,19 @@ protected theorem tfae (f : X → Y) :
       ∀ x, IsOpen { x' | f x' = f x },
       ∀ y, IsOpen (f ⁻¹' {y}),
       ∀ x, ∃ U : Set X, IsOpen U ∧ x ∈ U ∧ ∀ x' ∈ U, f x' = f x] := by
-  apply_rules [tfae_of_cycle, Chain.cons, Chain.nil]
-  · exact fun h x => (h {f x}).mem_nhds rfl
-  · exact fun h x => isOpen_iff_mem_nhds.2 fun y (hy : f y = f x) => hy ▸ h _
-  · intro h y
-    rcases em (y ∈ range f) with (⟨x, rfl⟩ | hy)
-    · exact h x
-    · simp only [preimage_eq_empty (disjoint_singleton_left.2 hy), isOpen_empty]
+  tfae_have 1 → 4; exact fun h y => h {y}
+  tfae_have 4 → 3; exact fun h x => h (f x)
+  tfae_have 3 → 2; exact fun h x => IsOpen.mem_nhds (h x) rfl
+  tfae_have 2 → 5
   · intro h x
-    rcases mem_nhds_iff.1 ((h (f x)).mem_nhds rfl) with ⟨U, hUf, hU, hx⟩
-    exact ⟨U, hU, hx, hUf⟩
-  · refine fun h s => isOpen_iff_forall_mem_open.2 fun x hx => ?_
-    rcases h x with ⟨U, hUo, hxU, hUf⟩
-    exact ⟨U, fun z hz => mem_preimage.2 <| (hUf z hz).symm ▸ hx, hUo, hxU⟩
-  -- porting note: todo: use `tfae_have`/`tfae_finish`; auto translated code below
-  -- tfae_have 1 → 4; exact fun h y => h {y}
-  -- tfae_have 4 → 3; exact fun h x => h (f x)
-  -- tfae_have 3 → 2; exact fun h x => IsOpen.mem_nhds (h x) rfl
-  -- tfae_have 2 → 5
-  -- · intro h x
-  --   rcases mem_nhds_iff.1 (h x) with ⟨U, eq, hU, hx⟩
-  --   exact ⟨U, hU, hx, Eq⟩
-  -- tfae_have 5 → 1
-  -- · intro h s
-  --   refine' isOpen_iff_forall_mem_open.2 fun x hx => _
-  --   rcases h x with ⟨U, hU, hxU, eq⟩
-  --   exact ⟨U, fun x' hx' => mem_preimage.2 <| (Eq x' hx').symm ▸ hx, hU, hxU⟩
-  -- tfae_finish
+    rcases mem_nhds_iff.1 (h x) with ⟨U, eq, hU, hx⟩
+    exact ⟨U, hU, hx, eq⟩
+  tfae_have 5 → 1
+  · intro h s
+    refine' isOpen_iff_forall_mem_open.2 fun x hx => _
+    rcases h x with ⟨U, hU, hxU, eq⟩
+    exact ⟨U, fun x' hx' => mem_preimage.2 <| (eq x' hx').symm ▸ hx, hU, hxU⟩
+  tfae_finish
 #align is_locally_constant.tfae IsLocallyConstant.tfae
 
 @[nontriviality]

vscode is already configured by .vscode/settings.json to trim these on save. It's not clear how they've managed to stick around.

By doing this all in one PR now, it avoids getting random whitespace diffs in PRs later.

This was done with a regex search in vscode,

@@ -288,7 +288,7 @@ theorem congr_fun {f g : LocallyConstant X Y} (h : f = g) (x : X) : f x = g x :=
 #align locally_constant.congr_fun LocallyConstant.congr_fun
 
 theorem congr_arg (f : LocallyConstant X Y) {x y : X} (h : x = y) : f x = f y :=
-  FunLike.congr_arg f h 
+  FunLike.congr_arg f h
 #align locally_constant.congr_arg LocallyConstant.congr_arg
 
 theorem coe_injective : @Function.Injective (LocallyConstant X Y) (X → Y) (↑) := fun _ _ =>
@@ -567,7 +567,7 @@ theorem mulIndicator_apply_eq_if (hU : IsClopen U) :
 variable {a}
 
 @[to_additive]
-theorem mulIndicator_of_mem (hU : IsClopen U) (h : a ∈ U) : f.mulIndicator hU a = f a := 
+theorem mulIndicator_of_mem (hU : IsClopen U) (h : a ∈ U) : f.mulIndicator hU a = f a :=
   Set.mulIndicator_of_mem h _
 #align locally_constant.mul_indicator_of_mem LocallyConstant.mulIndicator_of_mem
 #align locally_constant.indicator_of_mem LocallyConstant.indicator_of_mem