topology.covering | Mathlib porting status

(last sync)

refactor: redefine bundle.total_space (#19221)

Use a custom structure for bundle.total_space.
- Use bundle.total_space.mk instead of bundle.total_space_mk.
- Use bundle.total_space.to_prod instead of equiv.sigma_equiv_prod.
- Use bundle.total_space.mk' (scoped notation) to specify F.
- Rename bundle.trivial.proj_snd to bundle.total_space.trivial_snd to allow dot notation. Should we just use bundle.total_space.snd since bundle.trivial is now reducible?
Add an unused argument to bundle.total_space.
Make bundle.trivial and bundle.continuous_linear_map reducible.
Drop instances that are no longer needed.

Diff

@@ -161,7 +161,7 @@ protected lemma is_fiber_bundle.is_covering_map {F : Type*} [topological_space F
 is_covering_map.mk f (λ x, F) (λ x, classical.some (hf x)) (λ x, classical.some_spec (hf x))
 
 protected lemma fiber_bundle.is_covering_map {F : Type*} {E : X → Type*} [topological_space F]
-  [discrete_topology F] [topological_space (bundle.total_space E)] [Π x, topological_space (E x)]
-  [hf : fiber_bundle F E] : is_covering_map (π E) :=
+  [discrete_topology F] [topological_space (bundle.total_space F E)] [Π x, topological_space (E x)]
+  [hf : fiber_bundle F E] : is_covering_map (π F E) :=
 is_fiber_bundle.is_covering_map
   (λ x, ⟨trivialization_at F E x, mem_base_set_trivialization_at F E x ⟩)

(first ported)

Changes in mathlib3port

mathlib3

mathlib3port

bump to nightly-2024-04-06-08

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

e34029c9

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2022 Thomas Browning. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Thomas Browning
 -/
-import Topology.IsLocallyHomeomorph
+import Topology.IsLocalHomeomorph
 import Topology.FiberBundle.Basic
 
 #align_import topology.covering from "leanprover-community/mathlib"@"e473c3198bb41f68560cab68a0529c854b618833"

bump to nightly-2023-12-14-06

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

a154f5e6

Diff

@@ -65,7 +65,7 @@ theorem toTrivialization_apply {x : E} {I : Type _} [TopologicalSpace I]
   let h := Classical.choose_spec h.2
   let he := e.mk_proj_snd' h
   Subtype.ext
-    ((e.toLocalEquiv.eq_symm_apply (e.mem_source.mpr h)
+    ((e.toPartialEquiv.eq_symm_apply (e.mem_source.mpr h)
             (by rwa [he, e.mem_target, e.coe_fst (e.mem_source.mpr h)])).mpr
         he.symm).symm
 #align is_evenly_covered.to_trivialization_apply IsEvenlyCovered.toTrivialization_apply

bump to nightly-2023-12-13-12

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

19154cfe

Diff

@@ -125,11 +125,11 @@ protected theorem continuousOn (hf : IsCoveringMapOn f s) : ContinuousOn f (f 
 -/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
-#print IsCoveringMapOn.isLocallyHomeomorphOn /-
-protected theorem isLocallyHomeomorphOn (hf : IsCoveringMapOn f s) :
-    IsLocallyHomeomorphOn f (f ⁻¹' s) :=
+#print IsCoveringMapOn.isLocalHomeomorphOn /-
+protected theorem isLocalHomeomorphOn (hf : IsCoveringMapOn f s) :
+    IsLocalHomeomorphOn f (f ⁻¹' s) :=
   by
-  refine' IsLocallyHomeomorphOn.mk f (f ⁻¹' s) fun x hx => _
+  refine' IsLocalHomeomorphOn.mk f (f ⁻¹' s) fun x hx => _
   let e := (hf (f x) hx).toTrivialization
   have h := (hf (f x) hx).mem_toTrivialization_baseSet
   let he := e.mem_source.2 h
@@ -151,7 +151,7 @@ protected theorem isLocallyHomeomorphOn (hf : IsCoveringMapOn f s) :
       ⟨he, by rwa [e.to_local_homeomorph.symm_symm, e.proj_to_fun x he],
         (hf (f x) hx).toTrivialization_apply⟩,
       fun p h => (e.proj_to_fun p h.1).symm⟩
-#align is_covering_map_on.is_locally_homeomorph_on IsCoveringMapOn.isLocallyHomeomorphOn
+#align is_covering_map_on.is_locally_homeomorph_on IsCoveringMapOn.isLocalHomeomorphOn
 -/
 
 end IsCoveringMapOn
@@ -199,15 +199,15 @@ protected theorem continuous (hf : IsCoveringMap f) : Continuous f :=
 #align is_covering_map.continuous IsCoveringMap.continuous
 -/
 
-#print IsCoveringMap.isLocallyHomeomorph /-
-protected theorem isLocallyHomeomorph (hf : IsCoveringMap f) : IsLocallyHomeomorph f :=
-  isLocallyHomeomorph_iff_isLocallyHomeomorphOn_univ.mpr hf.IsCoveringMapOn.IsLocallyHomeomorphOn
-#align is_covering_map.is_locally_homeomorph IsCoveringMap.isLocallyHomeomorph
+#print IsCoveringMap.isLocalHomeomorph /-
+protected theorem isLocalHomeomorph (hf : IsCoveringMap f) : IsLocalHomeomorph f :=
+  isLocalHomeomorph_iff_isLocalHomeomorphOn_univ.mpr hf.IsCoveringMapOn.IsLocalHomeomorphOn
+#align is_covering_map.is_locally_homeomorph IsCoveringMap.isLocalHomeomorph
 -/
 
 #print IsCoveringMap.isOpenMap /-
 protected theorem isOpenMap (hf : IsCoveringMap f) : IsOpenMap f :=
-  hf.IsLocallyHomeomorph.IsOpenMap
+  hf.IsLocalHomeomorph.IsOpenMap
 #align is_covering_map.is_open_map IsCoveringMap.isOpenMap
 -/

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,8 +3,8 @@ Copyright (c) 2022 Thomas Browning. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Thomas Browning
 -/
-import Mathbin.Topology.IsLocallyHomeomorph
-import Mathbin.Topology.FiberBundle.Basic
+import Topology.IsLocallyHomeomorph
+import Topology.FiberBundle.Basic
 
 #align_import topology.covering from "leanprover-community/mathlib"@"e473c3198bb41f68560cab68a0529c854b618833"

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2022 Thomas Browning. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Thomas Browning
-
-! This file was ported from Lean 3 source module topology.covering
-! leanprover-community/mathlib commit e473c3198bb41f68560cab68a0529c854b618833
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Topology.IsLocallyHomeomorph
 import Mathbin.Topology.FiberBundle.Basic
 
+#align_import topology.covering from "leanprover-community/mathlib"@"e473c3198bb41f68560cab68a0529c854b618833"
+
 /-!
 # Covering Maps

bump to nightly-2023-07-04-01

mathlib commit https://github.com/leanprover-community/mathlib/commit/728ef9dbb281241906f25cbeb30f90d83e0bb451

05318d71

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Thomas Browning
 
 ! This file was ported from Lean 3 source module topology.covering
-! leanprover-community/mathlib commit 8ef6f08ff8c781c5c07a8b12843710e1a0d8a688
+! leanprover-community/mathlib commit e473c3198bb41f68560cab68a0529c854b618833
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -235,8 +235,8 @@ protected theorem IsFiberBundle.isCoveringMap {F : Type _} [TopologicalSpace F]
 
 #print FiberBundle.isCoveringMap /-
 protected theorem FiberBundle.isCoveringMap {F : Type _} {E : X → Type _} [TopologicalSpace F]
-    [DiscreteTopology F] [TopologicalSpace (Bundle.TotalSpace E)] [∀ x, TopologicalSpace (E x)]
-    [hf : FiberBundle F E] : IsCoveringMap (π E) :=
+    [DiscreteTopology F] [TopologicalSpace (Bundle.TotalSpace F E)] [∀ x, TopologicalSpace (E x)]
+    [hf : FiberBundle F E] : IsCoveringMap (π F E) :=
   IsFiberBundle.isCoveringMap fun x => ⟨trivializationAt F E x, mem_baseSet_trivializationAt F E x⟩
 #align fiber_bundle.is_covering_map FiberBundle.isCoveringMap
 -/

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -45,18 +45,23 @@ namespace IsEvenlyCovered
 
 variable {f}
 
+#print IsEvenlyCovered.toTrivialization /-
 /-- If `x` is evenly covered by `f`, then we can construct a trivialization of `f` at `x`. -/
 noncomputable def toTrivialization {x : X} {I : Type _} [TopologicalSpace I]
     (h : IsEvenlyCovered f x I) : Trivialization (f ⁻¹' {x}) f :=
   (Classical.choose h.2).transFiberHomeomorph
     ((Classical.choose h.2).preimageSingletonHomeomorph (Classical.choose_spec h.2)).symm
 #align is_evenly_covered.to_trivialization IsEvenlyCovered.toTrivialization
+-/
 
+#print IsEvenlyCovered.mem_toTrivialization_baseSet /-
 theorem mem_toTrivialization_baseSet {x : X} {I : Type _} [TopologicalSpace I]
     (h : IsEvenlyCovered f x I) : x ∈ h.toTrivialization.baseSet :=
   Classical.choose_spec h.2
 #align is_evenly_covered.mem_to_trivialization_base_set IsEvenlyCovered.mem_toTrivialization_baseSet
+-/
 
+#print IsEvenlyCovered.toTrivialization_apply /-
 theorem toTrivialization_apply {x : E} {I : Type _} [TopologicalSpace I]
     (h : IsEvenlyCovered f (f x) I) : (h.toTrivialization x).2 = ⟨x, rfl⟩ :=
   let e := Classical.choose h.2
@@ -67,13 +72,17 @@ theorem toTrivialization_apply {x : E} {I : Type _} [TopologicalSpace I]
             (by rwa [he, e.mem_target, e.coe_fst (e.mem_source.mpr h)])).mpr
         he.symm).symm
 #align is_evenly_covered.to_trivialization_apply IsEvenlyCovered.toTrivialization_apply
+-/
 
+#print IsEvenlyCovered.continuousAt /-
 protected theorem continuousAt {x : E} {I : Type _} [TopologicalSpace I]
     (h : IsEvenlyCovered f (f x) I) : ContinuousAt f x :=
   let e := h.toTrivialization
   e.continuousAt_proj (e.mem_source.mpr (mem_toTrivialization_baseSet h))
 #align is_evenly_covered.continuous_at IsEvenlyCovered.continuousAt
+-/
 
+#print IsEvenlyCovered.to_isEvenlyCovered_preimage /-
 theorem to_isEvenlyCovered_preimage {x : X} {I : Type _} [TopologicalSpace I]
     (h : IsEvenlyCovered f x I) : IsEvenlyCovered f x (f ⁻¹' {x}) :=
   let ⟨h1, h2⟩ := h
@@ -81,6 +90,7 @@ theorem to_isEvenlyCovered_preimage {x : X} {I : Type _} [TopologicalSpace I]
           (Classical.choose_spec h2)).Embedding.DiscreteTopology,
     _, h.mem_to_trivialization_base_set⟩
 #align is_evenly_covered.to_is_evenly_covered_preimage IsEvenlyCovered.to_isEvenlyCovered_preimage
+-/
 
 end IsEvenlyCovered
 
@@ -104,16 +114,21 @@ theorem mk (F : X → Type _) [∀ x, TopologicalSpace (F x)] [hF : ∀ x, Discr
 
 variable {f} {s}
 
+#print IsCoveringMapOn.continuousAt /-
 protected theorem continuousAt (hf : IsCoveringMapOn f s) {x : E} (hx : f x ∈ s) :
     ContinuousAt f x :=
   (hf (f x) hx).ContinuousAt
 #align is_covering_map_on.continuous_at IsCoveringMapOn.continuousAt
+-/
 
+#print IsCoveringMapOn.continuousOn /-
 protected theorem continuousOn (hf : IsCoveringMapOn f s) : ContinuousOn f (f ⁻¹' s) :=
   ContinuousAt.continuousOn fun x => hf.ContinuousAt
 #align is_covering_map_on.continuous_on IsCoveringMapOn.continuousOn
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print IsCoveringMapOn.isLocallyHomeomorphOn /-
 protected theorem isLocallyHomeomorphOn (hf : IsCoveringMapOn f s) :
     IsLocallyHomeomorphOn f (f ⁻¹' s) :=
   by
@@ -140,6 +155,7 @@ protected theorem isLocallyHomeomorphOn (hf : IsCoveringMapOn f s) :
         (hf (f x) hx).toTrivialization_apply⟩,
       fun p h => (e.proj_to_fun p h.1).symm⟩
 #align is_covering_map_on.is_locally_homeomorph_on IsCoveringMapOn.isLocallyHomeomorphOn
+-/
 
 end IsCoveringMapOn
 
@@ -153,14 +169,18 @@ def IsCoveringMap :=
 
 variable {f}
 
+#print isCoveringMap_iff_isCoveringMapOn_univ /-
 theorem isCoveringMap_iff_isCoveringMapOn_univ : IsCoveringMap f ↔ IsCoveringMapOn f Set.univ := by
   simp only [IsCoveringMap, IsCoveringMapOn, Set.mem_univ, forall_true_left]
 #align is_covering_map_iff_is_covering_map_on_univ isCoveringMap_iff_isCoveringMapOn_univ
+-/
 
+#print IsCoveringMap.isCoveringMapOn /-
 protected theorem IsCoveringMap.isCoveringMapOn (hf : IsCoveringMap f) :
     IsCoveringMapOn f Set.univ :=
   isCoveringMap_iff_isCoveringMapOn_univ.mp hf
 #align is_covering_map.is_covering_map_on IsCoveringMap.isCoveringMapOn
+-/
 
 variable (f)
 
@@ -176,36 +196,48 @@ theorem mk (F : X → Type _) [∀ x, TopologicalSpace (F x)] [hF : ∀ x, Discr
 
 variable {f}
 
+#print IsCoveringMap.continuous /-
 protected theorem continuous (hf : IsCoveringMap f) : Continuous f :=
   continuous_iff_continuousOn_univ.mpr hf.IsCoveringMapOn.ContinuousOn
 #align is_covering_map.continuous IsCoveringMap.continuous
+-/
 
+#print IsCoveringMap.isLocallyHomeomorph /-
 protected theorem isLocallyHomeomorph (hf : IsCoveringMap f) : IsLocallyHomeomorph f :=
   isLocallyHomeomorph_iff_isLocallyHomeomorphOn_univ.mpr hf.IsCoveringMapOn.IsLocallyHomeomorphOn
 #align is_covering_map.is_locally_homeomorph IsCoveringMap.isLocallyHomeomorph
+-/
 
+#print IsCoveringMap.isOpenMap /-
 protected theorem isOpenMap (hf : IsCoveringMap f) : IsOpenMap f :=
   hf.IsLocallyHomeomorph.IsOpenMap
 #align is_covering_map.is_open_map IsCoveringMap.isOpenMap
+-/
 
+#print IsCoveringMap.quotientMap /-
 protected theorem quotientMap (hf : IsCoveringMap f) (hf' : Function.Surjective f) :
     QuotientMap f :=
   hf.IsOpenMap.to_quotientMap hf.Continuous hf'
 #align is_covering_map.quotient_map IsCoveringMap.quotientMap
+-/
 
 end IsCoveringMap
 
 variable {f}
 
+#print IsFiberBundle.isCoveringMap /-
 protected theorem IsFiberBundle.isCoveringMap {F : Type _} [TopologicalSpace F] [DiscreteTopology F]
     (hf : ∀ x : X, ∃ e : Trivialization F f, x ∈ e.baseSet) : IsCoveringMap f :=
   IsCoveringMap.mk f (fun x => F) (fun x => Classical.choose (hf x)) fun x =>
     Classical.choose_spec (hf x)
 #align is_fiber_bundle.is_covering_map IsFiberBundle.isCoveringMap
+-/
 
+#print FiberBundle.isCoveringMap /-
 protected theorem FiberBundle.isCoveringMap {F : Type _} {E : X → Type _} [TopologicalSpace F]
     [DiscreteTopology F] [TopologicalSpace (Bundle.TotalSpace E)] [∀ x, TopologicalSpace (E x)]
     [hf : FiberBundle F E] : IsCoveringMap (π E) :=
   IsFiberBundle.isCoveringMap fun x => ⟨trivializationAt F E x, mem_baseSet_trivializationAt F E x⟩
 #align fiber_bundle.is_covering_map FiberBundle.isCoveringMap
+-/

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -30,7 +30,7 @@ This file defines covering maps.
 -/
 
 
-open Bundle
+open scoped Bundle
 
 variable {E X : Type _} [TopologicalSpace E] [TopologicalSpace X] (f : E → X) (s : Set X)

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -45,12 +45,6 @@ namespace IsEvenlyCovered
 
 variable {f}
 
-/- warning: is_evenly_covered.to_trivialization -> IsEvenlyCovered.toTrivialization is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u_1}} {X : Type.{u_2}} [_inst_1 : TopologicalSpace.{u_1} E] [_inst_2 : TopologicalSpace.{u_2} X] {f : E -> X} {x : X} {I : Type.{u_3}} [_inst_3 : TopologicalSpace.{u_3} I], (IsEvenlyCovered.{u_1, u_2, u_3} E X _inst_1 _inst_2 f x I _inst_3) -> (Trivialization.{u_2, u_1, u_1} X (coeSort.{max (succ u_1) 1, succ (succ u_1)} (Set.{u_1} E) Type.{u_1} (Set.hasCoeToSort.{u_1} E) (Set.preimage.{u_1, u_2} E X f (Singleton.singleton.{u_2, u_2} X (Set.{u_2} X) (Set.hasSingleton.{u_2} X) x))) E _inst_2 (Subtype.topologicalSpace.{u_1} E (fun (x_1 : E) => Membership.Mem.{u_1, u_1} E (Set.{u_1} E) (Set.hasMem.{u_1} E) x_1 (Set.preimage.{u_1, u_2} E X f (Singleton.singleton.{u_2, u_2} X (Set.{u_2} X) (Set.hasSingleton.{u_2} X) x))) _inst_1) _inst_1 f)
-but is expected to have type
-  forall {E : Type.{u_1}} {X : Type.{u_2}} [_inst_1 : TopologicalSpace.{u_1} E] [_inst_2 : TopologicalSpace.{u_2} X] {f : E -> X} {x : X} {I : Type.{u_3}} [_inst_3 : TopologicalSpace.{u_3} I], (IsEvenlyCovered.{u_1, u_2, u_3} E X _inst_1 _inst_2 f x I _inst_3) -> (Trivialization.{u_2, u_1, u_1} X (Set.Elem.{u_1} E (Set.preimage.{u_1, u_2} E X f (Singleton.singleton.{u_2, u_2} X (Set.{u_2} X) (Set.instSingletonSet.{u_2} X) x))) E _inst_2 (instTopologicalSpaceSubtype.{u_1} E (fun (x_1 : E) => Membership.mem.{u_1, u_1} E (Set.{u_1} E) (Set.instMembershipSet.{u_1} E) x_1 (Set.preimage.{u_1, u_2} E X f (Singleton.singleton.{u_2, u_2} X (Set.{u_2} X) (Set.instSingletonSet.{u_2} X) x))) _inst_1) _inst_1 f)
-Case conversion may be inaccurate. Consider using '#align is_evenly_covered.to_trivialization IsEvenlyCovered.toTrivializationₓ'. -/
 /-- If `x` is evenly covered by `f`, then we can construct a trivialization of `f` at `x`. -/
 noncomputable def toTrivialization {x : X} {I : Type _} [TopologicalSpace I]
     (h : IsEvenlyCovered f x I) : Trivialization (f ⁻¹' {x}) f :=
@@ -58,23 +52,11 @@ noncomputable def toTrivialization {x : X} {I : Type _} [TopologicalSpace I]
     ((Classical.choose h.2).preimageSingletonHomeomorph (Classical.choose_spec h.2)).symm
 #align is_evenly_covered.to_trivialization IsEvenlyCovered.toTrivialization
 
-/- warning: is_evenly_covered.mem_to_trivialization_base_set -> IsEvenlyCovered.mem_toTrivialization_baseSet is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u_1}} {X : Type.{u_2}} [_inst_1 : TopologicalSpace.{u_1} E] [_inst_2 : TopologicalSpace.{u_2} X] {f : E -> X} {x : X} {I : Type.{u_3}} [_inst_3 : TopologicalSpace.{u_3} I] (h : IsEvenlyCovered.{u_1, u_2, u_3} E X _inst_1 _inst_2 f x I _inst_3), Membership.Mem.{u_2, u_2} X (Set.{u_2} X) (Set.hasMem.{u_2} X) x (Trivialization.baseSet.{u_2, u_1, u_1} X (coeSort.{max (succ u_1) 1, succ (succ u_1)} (Set.{u_1} E) Type.{u_1} (Set.hasCoeToSort.{u_1} E) (Set.preimage.{u_1, u_2} E X f (Singleton.singleton.{u_2, u_2} X (Set.{u_2} X) (Set.hasSingleton.{u_2} X) x))) E _inst_2 (Subtype.topologicalSpace.{u_1} E (fun (x_1 : E) => Membership.Mem.{u_1, u_1} E (Set.{u_1} E) (Set.hasMem.{u_1} E) x_1 (Set.preimage.{u_1, u_2} E X f (Singleton.singleton.{u_2, u_2} X (Set.{u_2} X) (Set.hasSingleton.{u_2} X) x))) _inst_1) _inst_1 f (IsEvenlyCovered.toTrivialization.{u_1, u_2, u_3, u_4} E X _inst_1 _inst_2 f x I _inst_3 h))
-but is expected to have type
-  forall {E : Type.{u_2}} {X : Type.{u_3}} [_inst_1 : TopologicalSpace.{u_2} E] [_inst_2 : TopologicalSpace.{u_3} X] {f : E -> X} {x : X} {I : Type.{u_1}} [_inst_3 : TopologicalSpace.{u_1} I] (h : IsEvenlyCovered.{u_2, u_3, u_1} E X _inst_1 _inst_2 f x I _inst_3), Membership.mem.{u_3, u_3} X (Set.{u_3} X) (Set.instMembershipSet.{u_3} X) x (Trivialization.baseSet.{u_3, u_2, u_2} X (Set.Elem.{u_2} E (Set.preimage.{u_2, u_3} E X f (Singleton.singleton.{u_3, u_3} X (Set.{u_3} X) (Set.instSingletonSet.{u_3} X) x))) E _inst_2 (instTopologicalSpaceSubtype.{u_2} E (fun (x_1 : E) => Membership.mem.{u_2, u_2} E (Set.{u_2} E) (Set.instMembershipSet.{u_2} E) x_1 (Set.preimage.{u_2, u_3} E X f (Singleton.singleton.{u_3, u_3} X (Set.{u_3} X) (Set.instSingletonSet.{u_3} X) x))) _inst_1) _inst_1 f (IsEvenlyCovered.toTrivialization.{u_2, u_3, u_1} E X _inst_1 _inst_2 f x I _inst_3 h))
-Case conversion may be inaccurate. Consider using '#align is_evenly_covered.mem_to_trivialization_base_set IsEvenlyCovered.mem_toTrivialization_baseSetₓ'. -/
 theorem mem_toTrivialization_baseSet {x : X} {I : Type _} [TopologicalSpace I]
     (h : IsEvenlyCovered f x I) : x ∈ h.toTrivialization.baseSet :=
   Classical.choose_spec h.2
 #align is_evenly_covered.mem_to_trivialization_base_set IsEvenlyCovered.mem_toTrivialization_baseSet
 
-/- warning: is_evenly_covered.to_trivialization_apply -> IsEvenlyCovered.toTrivialization_apply is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u_1}} {X : Type.{u_2}} [_inst_1 : TopologicalSpace.{u_1} E] [_inst_2 : TopologicalSpace.{u_2} X] {f : E -> X} {x : E} {I : Type.{u_3}} [_inst_3 : TopologicalSpace.{u_3} I] (h : IsEvenlyCovered.{u_1, u_2, u_3} E X _inst_1 _inst_2 f (f x) I _inst_3), Eq.{succ u_1} (coeSort.{max (succ u_1) 1, succ (succ u_1)} (Set.{u_1} E) Type.{u_1} (Set.hasCoeToSort.{u_1} E) (Set.preimage.{u_1, u_2} E X f (Singleton.singleton.{u_2, u_2} X (Set.{u_2} X) (Set.hasSingleton.{u_2} X) (f x)))) (Prod.snd.{u_2, u_1} X (coeSort.{max (succ u_1) 1, succ (succ u_1)} (Set.{u_1} E) Type.{u_1} (Set.hasCoeToSort.{u_1} E) (Set.preimage.{u_1, u_2} E X f (Singleton.singleton.{u_2, u_2} X (Set.{u_2} X) (Set.hasSingleton.{u_2} X) (f x)))) (coeFn.{max (succ u_2) (succ u_1), max (succ u_2) (succ u_1)} (Trivialization.{u_2, u_1, u_1} X (coeSort.{max (succ u_1) 1, succ (succ u_1)} (Set.{u_1} E) Type.{u_1} (Set.hasCoeToSort.{u_1} E) (Set.preimage.{u_1, u_2} E X f (Singleton.singleton.{u_2, u_2} X (Set.{u_2} X) (Set.hasSingleton.{u_2} X) (f x)))) E _inst_2 (Subtype.topologicalSpace.{u_1} E (fun (x_1 : E) => Membership.Mem.{u_1, u_1} E (Set.{u_1} E) (Set.hasMem.{u_1} E) x_1 (Set.preimage.{u_1, u_2} E X f (Singleton.singleton.{u_2, u_2} X (Set.{u_2} X) (Set.hasSingleton.{u_2} X) (f x)))) _inst_1) _inst_1 f) (fun (_x : Trivialization.{u_2, u_1, u_1} X (coeSort.{max (succ u_1) 1, succ (succ u_1)} (Set.{u_1} E) Type.{u_1} (Set.hasCoeToSort.{u_1} E) (Set.preimage.{u_1, u_2} E X f (Singleton.singleton.{u_2, u_2} X (Set.{u_2} X) (Set.hasSingleton.{u_2} X) (f x)))) E _inst_2 (Subtype.topologicalSpace.{u_1} E (fun (x_1 : E) => Membership.Mem.{u_1, u_1} E (Set.{u_1} E) (Set.hasMem.{u_1} E) x_1 (Set.preimage.{u_1, u_2} E X f (Singleton.singleton.{u_2, u_2} X (Set.{u_2} X) (Set.hasSingleton.{u_2} X) (f x)))) _inst_1) _inst_1 f) => E -> (Prod.{u_2, u_1} X (coeSort.{max (succ u_1) 1, succ (succ u_1)} (Set.{u_1} E) Type.{u_1} (Set.hasCoeToSort.{u_1} E) (Set.preimage.{u_1, u_2} E X f (Singleton.singleton.{u_2, u_2} X (Set.{u_2} X) (Set.hasSingleton.{u_2} X) (f x)))))) (Trivialization.hasCoeToFun.{u_2, u_1, u_1} X (coeSort.{max (succ u_1) 1, succ (succ u_1)} (Set.{u_1} E) Type.{u_1} (Set.hasCoeToSort.{u_1} E) (Set.preimage.{u_1, u_2} E X f (Singleton.singleton.{u_2, u_2} X (Set.{u_2} X) (Set.hasSingleton.{u_2} X) (f x)))) E _inst_2 (Subtype.topologicalSpace.{u_1} E (fun (x_1 : E) => Membership.Mem.{u_1, u_1} E (Set.{u_1} E) (Set.hasMem.{u_1} E) x_1 (Set.preimage.{u_1, u_2} E X f (Singleton.singleton.{u_2, u_2} X (Set.{u_2} X) (Set.hasSingleton.{u_2} X) (f x)))) _inst_1) f _inst_1) (IsEvenlyCovered.toTrivialization.{u_1, u_2, u_3, u_4} E X _inst_1 _inst_2 f (f x) I _inst_3 h) x)) (Subtype.mk.{succ u_1} E (fun (x_1 : E) => Membership.Mem.{u_1, u_1} E (Set.{u_1} E) (Set.hasMem.{u_1} E) x_1 (Set.preimage.{u_1, u_2} E X f (Singleton.singleton.{u_2, u_2} X (Set.{u_2} X) (Set.hasSingleton.{u_2} X) (f x)))) x (rfl.{succ u_2} X (f x)))
-but is expected to have type
-  forall {E : Type.{u_2}} {X : Type.{u_3}} [_inst_1 : TopologicalSpace.{u_2} E] [_inst_2 : TopologicalSpace.{u_3} X] {f : E -> X} {x : E} {I : Type.{u_1}} [_inst_3 : TopologicalSpace.{u_1} I] (h : IsEvenlyCovered.{u_2, u_3, u_1} E X _inst_1 _inst_2 f (f x) I _inst_3), Eq.{succ u_2} (Set.Elem.{u_2} E (Set.preimage.{u_2, u_3} E X f (Singleton.singleton.{u_3, u_3} X (Set.{u_3} X) (Set.instSingletonSet.{u_3} X) (f x)))) (Prod.snd.{u_3, u_2} X (Set.Elem.{u_2} E (Set.preimage.{u_2, u_3} E X f (Singleton.singleton.{u_3, u_3} X (Set.{u_3} X) (Set.instSingletonSet.{u_3} X) (f x)))) (Trivialization.toFun'.{u_3, u_2, u_2} X (Set.Elem.{u_2} E (Set.preimage.{u_2, u_3} E X f (Singleton.singleton.{u_3, u_3} X (Set.{u_3} X) (Set.instSingletonSet.{u_3} X) (f x)))) E _inst_2 (instTopologicalSpaceSubtype.{u_2} E (fun (x_1 : E) => Membership.mem.{u_2, u_2} E (Set.{u_2} E) (Set.instMembershipSet.{u_2} E) x_1 (Set.preimage.{u_2, u_3} E X f (Singleton.singleton.{u_3, u_3} X (Set.{u_3} X) (Set.instSingletonSet.{u_3} X) (f x)))) _inst_1) f _inst_1 (IsEvenlyCovered.toTrivialization.{u_2, u_3, u_1} E X _inst_1 _inst_2 f (f x) I _inst_3 h) x)) (Subtype.mk.{succ u_2} E (fun (x_1 : E) => Membership.mem.{u_2, u_2} E (Set.{u_2} E) (Set.instMembershipSet.{u_2} E) x_1 (Set.preimage.{u_2, u_3} E X f (Singleton.singleton.{u_3, u_3} X (Set.{u_3} X) (Set.instSingletonSet.{u_3} X) (f x)))) x (rfl.{succ u_3} X (f x)))
-Case conversion may be inaccurate. Consider using '#align is_evenly_covered.to_trivialization_apply IsEvenlyCovered.toTrivialization_applyₓ'. -/
 theorem toTrivialization_apply {x : E} {I : Type _} [TopologicalSpace I]
     (h : IsEvenlyCovered f (f x) I) : (h.toTrivialization x).2 = ⟨x, rfl⟩ :=
   let e := Classical.choose h.2
@@ -86,24 +68,12 @@ theorem toTrivialization_apply {x : E} {I : Type _} [TopologicalSpace I]
         he.symm).symm
 #align is_evenly_covered.to_trivialization_apply IsEvenlyCovered.toTrivialization_apply
 
-/- warning: is_evenly_covered.continuous_at -> IsEvenlyCovered.continuousAt is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} E] [_inst_2 : TopologicalSpace.{u2} X] {f : E -> X} {x : E} {I : Type.{u3}} [_inst_3 : TopologicalSpace.{u3} I], (IsEvenlyCovered.{u1, u2, u3} E X _inst_1 _inst_2 f (f x) I _inst_3) -> (ContinuousAt.{u1, u2} E X _inst_1 _inst_2 f x)
-but is expected to have type
-  forall {E : Type.{u2}} {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} E] [_inst_2 : TopologicalSpace.{u1} X] {f : E -> X} {x : E} {I : Type.{u3}} [_inst_3 : TopologicalSpace.{u3} I], (IsEvenlyCovered.{u2, u1, u3} E X _inst_1 _inst_2 f (f x) I _inst_3) -> (ContinuousAt.{u2, u1} E X _inst_1 _inst_2 f x)
-Case conversion may be inaccurate. Consider using '#align is_evenly_covered.continuous_at IsEvenlyCovered.continuousAtₓ'. -/
 protected theorem continuousAt {x : E} {I : Type _} [TopologicalSpace I]
     (h : IsEvenlyCovered f (f x) I) : ContinuousAt f x :=
   let e := h.toTrivialization
   e.continuousAt_proj (e.mem_source.mpr (mem_toTrivialization_baseSet h))
 #align is_evenly_covered.continuous_at IsEvenlyCovered.continuousAt
 
-/- warning: is_evenly_covered.to_is_evenly_covered_preimage -> IsEvenlyCovered.to_isEvenlyCovered_preimage is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} E] [_inst_2 : TopologicalSpace.{u2} X] {f : E -> X} {x : X} {I : Type.{u3}} [_inst_3 : TopologicalSpace.{u3} I], (IsEvenlyCovered.{u1, u2, u3} E X _inst_1 _inst_2 f x I _inst_3) -> (IsEvenlyCovered.{u1, u2, u1} E X _inst_1 _inst_2 f x (coeSort.{succ u1, succ (succ u1)} (Set.{u1} E) Type.{u1} (Set.hasCoeToSort.{u1} E) (Set.preimage.{u1, u2} E X f (Singleton.singleton.{u2, u2} X (Set.{u2} X) (Set.hasSingleton.{u2} X) x))) (Subtype.topologicalSpace.{u1} E (fun (x_1 : E) => Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) x_1 (Set.preimage.{u1, u2} E X f (Singleton.singleton.{u2, u2} X (Set.{u2} X) (Set.hasSingleton.{u2} X) x))) _inst_1))
-but is expected to have type
-  forall {E : Type.{u2}} {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} E] [_inst_2 : TopologicalSpace.{u1} X] {f : E -> X} {x : X} {I : Type.{u3}} [_inst_3 : TopologicalSpace.{u3} I], (IsEvenlyCovered.{u2, u1, u3} E X _inst_1 _inst_2 f x I _inst_3) -> (IsEvenlyCovered.{u2, u1, u2} E X _inst_1 _inst_2 f x (Set.Elem.{u2} E (Set.preimage.{u2, u1} E X f (Singleton.singleton.{u1, u1} X (Set.{u1} X) (Set.instSingletonSet.{u1} X) x))) (instTopologicalSpaceSubtype.{u2} E (fun (x_1 : E) => Membership.mem.{u2, u2} E (Set.{u2} E) (Set.instMembershipSet.{u2} E) x_1 (Set.preimage.{u2, u1} E X f (Singleton.singleton.{u1, u1} X (Set.{u1} X) (Set.instSingletonSet.{u1} X) x))) _inst_1))
-Case conversion may be inaccurate. Consider using '#align is_evenly_covered.to_is_evenly_covered_preimage IsEvenlyCovered.to_isEvenlyCovered_preimageₓ'. -/
 theorem to_isEvenlyCovered_preimage {x : X} {I : Type _} [TopologicalSpace I]
     (h : IsEvenlyCovered f x I) : IsEvenlyCovered f x (f ⁻¹' {x}) :=
   let ⟨h1, h2⟩ := h
@@ -134,33 +104,15 @@ theorem mk (F : X → Type _) [∀ x, TopologicalSpace (F x)] [hF : ∀ x, Discr
 
 variable {f} {s}
 
-/- warning: is_covering_map_on.continuous_at -> IsCoveringMapOn.continuousAt is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} E] [_inst_2 : TopologicalSpace.{u2} X] {f : E -> X} {s : Set.{u2} X}, (IsCoveringMapOn.{u1, u2} E X _inst_1 _inst_2 f s) -> (forall {x : E}, (Membership.Mem.{u2, u2} X (Set.{u2} X) (Set.hasMem.{u2} X) (f x) s) -> (ContinuousAt.{u1, u2} E X _inst_1 _inst_2 f x))
-but is expected to have type
-  forall {E : Type.{u2}} {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} E] [_inst_2 : TopologicalSpace.{u1} X] {f : E -> X} {s : Set.{u1} X}, (IsCoveringMapOn.{u2, u1} E X _inst_1 _inst_2 f s) -> (forall {x : E}, (Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) (f x) s) -> (ContinuousAt.{u2, u1} E X _inst_1 _inst_2 f x))
-Case conversion may be inaccurate. Consider using '#align is_covering_map_on.continuous_at IsCoveringMapOn.continuousAtₓ'. -/
 protected theorem continuousAt (hf : IsCoveringMapOn f s) {x : E} (hx : f x ∈ s) :
     ContinuousAt f x :=
   (hf (f x) hx).ContinuousAt
 #align is_covering_map_on.continuous_at IsCoveringMapOn.continuousAt
 
-/- warning: is_covering_map_on.continuous_on -> IsCoveringMapOn.continuousOn is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} E] [_inst_2 : TopologicalSpace.{u2} X] {f : E -> X} {s : Set.{u2} X}, (IsCoveringMapOn.{u1, u2} E X _inst_1 _inst_2 f s) -> (ContinuousOn.{u1, u2} E X _inst_1 _inst_2 f (Set.preimage.{u1, u2} E X f s))
-but is expected to have type
-  forall {E : Type.{u2}} {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} E] [_inst_2 : TopologicalSpace.{u1} X] {f : E -> X} {s : Set.{u1} X}, (IsCoveringMapOn.{u2, u1} E X _inst_1 _inst_2 f s) -> (ContinuousOn.{u2, u1} E X _inst_1 _inst_2 f (Set.preimage.{u2, u1} E X f s))
-Case conversion may be inaccurate. Consider using '#align is_covering_map_on.continuous_on IsCoveringMapOn.continuousOnₓ'. -/
 protected theorem continuousOn (hf : IsCoveringMapOn f s) : ContinuousOn f (f ⁻¹' s) :=
   ContinuousAt.continuousOn fun x => hf.ContinuousAt
 #align is_covering_map_on.continuous_on IsCoveringMapOn.continuousOn
 
-/- warning: is_covering_map_on.is_locally_homeomorph_on -> IsCoveringMapOn.isLocallyHomeomorphOn is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} E] [_inst_2 : TopologicalSpace.{u2} X] {f : E -> X} {s : Set.{u2} X}, (IsCoveringMapOn.{u1, u2} E X _inst_1 _inst_2 f s) -> (IsLocallyHomeomorphOn.{u1, u2} E X _inst_1 _inst_2 f (Set.preimage.{u1, u2} E X f s))
-but is expected to have type
-  forall {E : Type.{u2}} {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} E] [_inst_2 : TopologicalSpace.{u1} X] {f : E -> X} {s : Set.{u1} X}, (IsCoveringMapOn.{u2, u1} E X _inst_1 _inst_2 f s) -> (IsLocallyHomeomorphOn.{u2, u1} E X _inst_1 _inst_2 f (Set.preimage.{u2, u1} E X f s))
-Case conversion may be inaccurate. Consider using '#align is_covering_map_on.is_locally_homeomorph_on IsCoveringMapOn.isLocallyHomeomorphOnₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 protected theorem isLocallyHomeomorphOn (hf : IsCoveringMapOn f s) :
     IsLocallyHomeomorphOn f (f ⁻¹' s) :=
@@ -201,22 +153,10 @@ def IsCoveringMap :=
 
 variable {f}
 
-/- warning: is_covering_map_iff_is_covering_map_on_univ -> isCoveringMap_iff_isCoveringMapOn_univ is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} E] [_inst_2 : TopologicalSpace.{u2} X] {f : E -> X}, Iff (IsCoveringMap.{u1, u2} E X _inst_1 _inst_2 f) (IsCoveringMapOn.{u1, u2} E X _inst_1 _inst_2 f (Set.univ.{u2} X))
-but is expected to have type
-  forall {E : Type.{u2}} {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} E] [_inst_2 : TopologicalSpace.{u1} X] {f : E -> X}, Iff (IsCoveringMap.{u2, u1} E X _inst_1 _inst_2 f) (IsCoveringMapOn.{u2, u1} E X _inst_1 _inst_2 f (Set.univ.{u1} X))
-Case conversion may be inaccurate. Consider using '#align is_covering_map_iff_is_covering_map_on_univ isCoveringMap_iff_isCoveringMapOn_univₓ'. -/
 theorem isCoveringMap_iff_isCoveringMapOn_univ : IsCoveringMap f ↔ IsCoveringMapOn f Set.univ := by
   simp only [IsCoveringMap, IsCoveringMapOn, Set.mem_univ, forall_true_left]
 #align is_covering_map_iff_is_covering_map_on_univ isCoveringMap_iff_isCoveringMapOn_univ
 
-/- warning: is_covering_map.is_covering_map_on -> IsCoveringMap.isCoveringMapOn is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} E] [_inst_2 : TopologicalSpace.{u2} X] {f : E -> X}, (IsCoveringMap.{u1, u2} E X _inst_1 _inst_2 f) -> (IsCoveringMapOn.{u1, u2} E X _inst_1 _inst_2 f (Set.univ.{u2} X))
-but is expected to have type
-  forall {E : Type.{u2}} {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} E] [_inst_2 : TopologicalSpace.{u1} X] {f : E -> X}, (IsCoveringMap.{u2, u1} E X _inst_1 _inst_2 f) -> (IsCoveringMapOn.{u2, u1} E X _inst_1 _inst_2 f (Set.univ.{u1} X))
-Case conversion may be inaccurate. Consider using '#align is_covering_map.is_covering_map_on IsCoveringMap.isCoveringMapOnₓ'. -/
 protected theorem IsCoveringMap.isCoveringMapOn (hf : IsCoveringMap f) :
     IsCoveringMapOn f Set.univ :=
   isCoveringMap_iff_isCoveringMapOn_univ.mp hf
@@ -236,42 +176,18 @@ theorem mk (F : X → Type _) [∀ x, TopologicalSpace (F x)] [hF : ∀ x, Discr
 
 variable {f}
 
-/- warning: is_covering_map.continuous -> IsCoveringMap.continuous is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} E] [_inst_2 : TopologicalSpace.{u2} X] {f : E -> X}, (IsCoveringMap.{u1, u2} E X _inst_1 _inst_2 f) -> (Continuous.{u1, u2} E X _inst_1 _inst_2 f)
-but is expected to have type
-  forall {E : Type.{u2}} {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} E] [_inst_2 : TopologicalSpace.{u1} X] {f : E -> X}, (IsCoveringMap.{u2, u1} E X _inst_1 _inst_2 f) -> (Continuous.{u2, u1} E X _inst_1 _inst_2 f)
-Case conversion may be inaccurate. Consider using '#align is_covering_map.continuous IsCoveringMap.continuousₓ'. -/
 protected theorem continuous (hf : IsCoveringMap f) : Continuous f :=
   continuous_iff_continuousOn_univ.mpr hf.IsCoveringMapOn.ContinuousOn
 #align is_covering_map.continuous IsCoveringMap.continuous
 
-/- warning: is_covering_map.is_locally_homeomorph -> IsCoveringMap.isLocallyHomeomorph is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} E] [_inst_2 : TopologicalSpace.{u2} X] {f : E -> X}, (IsCoveringMap.{u1, u2} E X _inst_1 _inst_2 f) -> (IsLocallyHomeomorph.{u1, u2} E X _inst_1 _inst_2 f)
-but is expected to have type
-  forall {E : Type.{u2}} {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} E] [_inst_2 : TopologicalSpace.{u1} X] {f : E -> X}, (IsCoveringMap.{u2, u1} E X _inst_1 _inst_2 f) -> (IsLocallyHomeomorph.{u2, u1} E X _inst_1 _inst_2 f)
-Case conversion may be inaccurate. Consider using '#align is_covering_map.is_locally_homeomorph IsCoveringMap.isLocallyHomeomorphₓ'. -/
 protected theorem isLocallyHomeomorph (hf : IsCoveringMap f) : IsLocallyHomeomorph f :=
   isLocallyHomeomorph_iff_isLocallyHomeomorphOn_univ.mpr hf.IsCoveringMapOn.IsLocallyHomeomorphOn
 #align is_covering_map.is_locally_homeomorph IsCoveringMap.isLocallyHomeomorph
 
-/- warning: is_covering_map.is_open_map -> IsCoveringMap.isOpenMap is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} E] [_inst_2 : TopologicalSpace.{u2} X] {f : E -> X}, (IsCoveringMap.{u1, u2} E X _inst_1 _inst_2 f) -> (IsOpenMap.{u1, u2} E X _inst_1 _inst_2 f)
-but is expected to have type
-  forall {E : Type.{u2}} {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} E] [_inst_2 : TopologicalSpace.{u1} X] {f : E -> X}, (IsCoveringMap.{u2, u1} E X _inst_1 _inst_2 f) -> (IsOpenMap.{u2, u1} E X _inst_1 _inst_2 f)
-Case conversion may be inaccurate. Consider using '#align is_covering_map.is_open_map IsCoveringMap.isOpenMapₓ'. -/
 protected theorem isOpenMap (hf : IsCoveringMap f) : IsOpenMap f :=
   hf.IsLocallyHomeomorph.IsOpenMap
 #align is_covering_map.is_open_map IsCoveringMap.isOpenMap
 
-/- warning: is_covering_map.quotient_map -> IsCoveringMap.quotientMap is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} E] [_inst_2 : TopologicalSpace.{u2} X] {f : E -> X}, (IsCoveringMap.{u1, u2} E X _inst_1 _inst_2 f) -> (Function.Surjective.{succ u1, succ u2} E X f) -> (QuotientMap.{u1, u2} E X _inst_1 _inst_2 f)
-but is expected to have type
-  forall {E : Type.{u2}} {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} E] [_inst_2 : TopologicalSpace.{u1} X] {f : E -> X}, (IsCoveringMap.{u2, u1} E X _inst_1 _inst_2 f) -> (Function.Surjective.{succ u2, succ u1} E X f) -> (QuotientMap.{u2, u1} E X _inst_1 _inst_2 f)
-Case conversion may be inaccurate. Consider using '#align is_covering_map.quotient_map IsCoveringMap.quotientMapₓ'. -/
 protected theorem quotientMap (hf : IsCoveringMap f) (hf' : Function.Surjective f) :
     QuotientMap f :=
   hf.IsOpenMap.to_quotientMap hf.Continuous hf'
@@ -281,24 +197,12 @@ end IsCoveringMap
 
 variable {f}
 
-/- warning: is_fiber_bundle.is_covering_map -> IsFiberBundle.isCoveringMap is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} E] [_inst_2 : TopologicalSpace.{u2} X] {f : E -> X} {F : Type.{u3}} [_inst_3 : TopologicalSpace.{u3} F] [_inst_4 : DiscreteTopology.{u3} F _inst_3], (forall (x : X), Exists.{max (succ u2) (succ u3) (succ u1)} (Trivialization.{u2, u3, u1} X F E _inst_2 _inst_3 _inst_1 f) (fun (e : Trivialization.{u2, u3, u1} X F E _inst_2 _inst_3 _inst_1 f) => Membership.Mem.{u2, u2} X (Set.{u2} X) (Set.hasMem.{u2} X) x (Trivialization.baseSet.{u2, u3, u1} X F E _inst_2 _inst_3 _inst_1 f e))) -> (IsCoveringMap.{u1, u2} E X _inst_1 _inst_2 f)
-but is expected to have type
-  forall {E : Type.{u2}} {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} E] [_inst_2 : TopologicalSpace.{u1} X] {f : E -> X} {F : Type.{u3}} [_inst_3 : TopologicalSpace.{u3} F] [_inst_4 : DiscreteTopology.{u3} F _inst_3], (forall (x : X), Exists.{max (max (succ u2) (succ u1)) (succ u3)} (Trivialization.{u1, u3, u2} X F E _inst_2 _inst_3 _inst_1 f) (fun (e : Trivialization.{u1, u3, u2} X F E _inst_2 _inst_3 _inst_1 f) => Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) x (Trivialization.baseSet.{u1, u3, u2} X F E _inst_2 _inst_3 _inst_1 f e))) -> (IsCoveringMap.{u2, u1} E X _inst_1 _inst_2 f)
-Case conversion may be inaccurate. Consider using '#align is_fiber_bundle.is_covering_map IsFiberBundle.isCoveringMapₓ'. -/
 protected theorem IsFiberBundle.isCoveringMap {F : Type _} [TopologicalSpace F] [DiscreteTopology F]
     (hf : ∀ x : X, ∃ e : Trivialization F f, x ∈ e.baseSet) : IsCoveringMap f :=
   IsCoveringMap.mk f (fun x => F) (fun x => Classical.choose (hf x)) fun x =>
     Classical.choose_spec (hf x)
 #align is_fiber_bundle.is_covering_map IsFiberBundle.isCoveringMap
 
-/- warning: fiber_bundle.is_covering_map -> FiberBundle.isCoveringMap is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} [_inst_2 : TopologicalSpace.{u1} X] {F : Type.{u2}} {E : X -> Type.{u3}} [_inst_3 : TopologicalSpace.{u2} F] [_inst_4 : DiscreteTopology.{u2} F _inst_3] [_inst_5 : TopologicalSpace.{max u1 u3} (Bundle.TotalSpace.{u1, u3} X E)] [_inst_6 : forall (x : X), TopologicalSpace.{u3} (E x)] [hf : FiberBundle.{u1, u2, u3} X F _inst_2 _inst_3 E _inst_5 (fun (b : X) => _inst_6 b)], IsCoveringMap.{max u1 u3, u1} (Bundle.TotalSpace.{u1, u3} X E) X _inst_5 _inst_2 (Bundle.TotalSpace.proj.{u1, u3} X E)
-but is expected to have type
-  forall {X : Type.{u1}} [_inst_2 : TopologicalSpace.{u1} X] {F : Type.{u3}} {E : X -> Type.{u2}} [_inst_3 : TopologicalSpace.{u3} F] [_inst_4 : DiscreteTopology.{u3} F _inst_3] [_inst_5 : TopologicalSpace.{max u2 u1} (Bundle.TotalSpace.{u1, u2} X E)] [_inst_6 : forall (x : X), TopologicalSpace.{u2} (E x)] [hf : FiberBundle.{u1, u3, u2} X F _inst_2 _inst_3 E _inst_5 (fun (b : X) => _inst_6 b)], IsCoveringMap.{max u1 u2, u1} (Bundle.TotalSpace.{u1, u2} X E) X _inst_5 _inst_2 (Bundle.TotalSpace.proj.{u1, u2} X E)
-Case conversion may be inaccurate. Consider using '#align fiber_bundle.is_covering_map FiberBundle.isCoveringMapₓ'. -/
 protected theorem FiberBundle.isCoveringMap {F : Type _} {E : X → Type _} [TopologicalSpace F]
     [DiscreteTopology F] [TopologicalSpace (Bundle.TotalSpace E)] [∀ x, TopologicalSpace (E x)]
     [hf : FiberBundle F E] : IsCoveringMap (π E) :=

bump to nightly-2023-03-24-02

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

9cc39ff3

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Thomas Browning
 
 ! This file was ported from Lean 3 source module topology.covering
-! leanprover-community/mathlib commit b8c810e2aac4a30bf8cda1e1c38d4f2e6065b2e7
+! leanprover-community/mathlib commit 8ef6f08ff8c781c5c07a8b12843710e1a0d8a688
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -14,6 +14,9 @@ import Mathbin.Topology.FiberBundle.Basic
 /-!
 # Covering Maps
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 This file defines covering maps.
 
 ## Main definitions

bump to nightly-2023-03-22-16

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

85865d39

Diff

@@ -31,15 +31,23 @@ open Bundle
 
 variable {E X : Type _} [TopologicalSpace E] [TopologicalSpace X] (f : E → X) (s : Set X)
 
+#print IsEvenlyCovered /-
 /-- A point `x : X` is evenly covered by `f : E → X` if `x` has an evenly covered neighborhood. -/
 def IsEvenlyCovered (x : X) (I : Type _) [TopologicalSpace I] :=
   DiscreteTopology I ∧ ∃ t : Trivialization I f, x ∈ t.baseSet
 #align is_evenly_covered IsEvenlyCovered
+-/
 
 namespace IsEvenlyCovered
 
 variable {f}
 
+/- warning: is_evenly_covered.to_trivialization -> IsEvenlyCovered.toTrivialization is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u_1}} {X : Type.{u_2}} [_inst_1 : TopologicalSpace.{u_1} E] [_inst_2 : TopologicalSpace.{u_2} X] {f : E -> X} {x : X} {I : Type.{u_3}} [_inst_3 : TopologicalSpace.{u_3} I], (IsEvenlyCovered.{u_1, u_2, u_3} E X _inst_1 _inst_2 f x I _inst_3) -> (Trivialization.{u_2, u_1, u_1} X (coeSort.{max (succ u_1) 1, succ (succ u_1)} (Set.{u_1} E) Type.{u_1} (Set.hasCoeToSort.{u_1} E) (Set.preimage.{u_1, u_2} E X f (Singleton.singleton.{u_2, u_2} X (Set.{u_2} X) (Set.hasSingleton.{u_2} X) x))) E _inst_2 (Subtype.topologicalSpace.{u_1} E (fun (x_1 : E) => Membership.Mem.{u_1, u_1} E (Set.{u_1} E) (Set.hasMem.{u_1} E) x_1 (Set.preimage.{u_1, u_2} E X f (Singleton.singleton.{u_2, u_2} X (Set.{u_2} X) (Set.hasSingleton.{u_2} X) x))) _inst_1) _inst_1 f)
+but is expected to have type
+  forall {E : Type.{u_1}} {X : Type.{u_2}} [_inst_1 : TopologicalSpace.{u_1} E] [_inst_2 : TopologicalSpace.{u_2} X] {f : E -> X} {x : X} {I : Type.{u_3}} [_inst_3 : TopologicalSpace.{u_3} I], (IsEvenlyCovered.{u_1, u_2, u_3} E X _inst_1 _inst_2 f x I _inst_3) -> (Trivialization.{u_2, u_1, u_1} X (Set.Elem.{u_1} E (Set.preimage.{u_1, u_2} E X f (Singleton.singleton.{u_2, u_2} X (Set.{u_2} X) (Set.instSingletonSet.{u_2} X) x))) E _inst_2 (instTopologicalSpaceSubtype.{u_1} E (fun (x_1 : E) => Membership.mem.{u_1, u_1} E (Set.{u_1} E) (Set.instMembershipSet.{u_1} E) x_1 (Set.preimage.{u_1, u_2} E X f (Singleton.singleton.{u_2, u_2} X (Set.{u_2} X) (Set.instSingletonSet.{u_2} X) x))) _inst_1) _inst_1 f)
+Case conversion may be inaccurate. Consider using '#align is_evenly_covered.to_trivialization IsEvenlyCovered.toTrivializationₓ'. -/
 /-- If `x` is evenly covered by `f`, then we can construct a trivialization of `f` at `x`. -/
 noncomputable def toTrivialization {x : X} {I : Type _} [TopologicalSpace I]
     (h : IsEvenlyCovered f x I) : Trivialization (f ⁻¹' {x}) f :=
@@ -47,11 +55,23 @@ noncomputable def toTrivialization {x : X} {I : Type _} [TopologicalSpace I]
     ((Classical.choose h.2).preimageSingletonHomeomorph (Classical.choose_spec h.2)).symm
 #align is_evenly_covered.to_trivialization IsEvenlyCovered.toTrivialization
 
+/- warning: is_evenly_covered.mem_to_trivialization_base_set -> IsEvenlyCovered.mem_toTrivialization_baseSet is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u_1}} {X : Type.{u_2}} [_inst_1 : TopologicalSpace.{u_1} E] [_inst_2 : TopologicalSpace.{u_2} X] {f : E -> X} {x : X} {I : Type.{u_3}} [_inst_3 : TopologicalSpace.{u_3} I] (h : IsEvenlyCovered.{u_1, u_2, u_3} E X _inst_1 _inst_2 f x I _inst_3), Membership.Mem.{u_2, u_2} X (Set.{u_2} X) (Set.hasMem.{u_2} X) x (Trivialization.baseSet.{u_2, u_1, u_1} X (coeSort.{max (succ u_1) 1, succ (succ u_1)} (Set.{u_1} E) Type.{u_1} (Set.hasCoeToSort.{u_1} E) (Set.preimage.{u_1, u_2} E X f (Singleton.singleton.{u_2, u_2} X (Set.{u_2} X) (Set.hasSingleton.{u_2} X) x))) E _inst_2 (Subtype.topologicalSpace.{u_1} E (fun (x_1 : E) => Membership.Mem.{u_1, u_1} E (Set.{u_1} E) (Set.hasMem.{u_1} E) x_1 (Set.preimage.{u_1, u_2} E X f (Singleton.singleton.{u_2, u_2} X (Set.{u_2} X) (Set.hasSingleton.{u_2} X) x))) _inst_1) _inst_1 f (IsEvenlyCovered.toTrivialization.{u_1, u_2, u_3, u_4} E X _inst_1 _inst_2 f x I _inst_3 h))
+but is expected to have type
+  forall {E : Type.{u_2}} {X : Type.{u_3}} [_inst_1 : TopologicalSpace.{u_2} E] [_inst_2 : TopologicalSpace.{u_3} X] {f : E -> X} {x : X} {I : Type.{u_1}} [_inst_3 : TopologicalSpace.{u_1} I] (h : IsEvenlyCovered.{u_2, u_3, u_1} E X _inst_1 _inst_2 f x I _inst_3), Membership.mem.{u_3, u_3} X (Set.{u_3} X) (Set.instMembershipSet.{u_3} X) x (Trivialization.baseSet.{u_3, u_2, u_2} X (Set.Elem.{u_2} E (Set.preimage.{u_2, u_3} E X f (Singleton.singleton.{u_3, u_3} X (Set.{u_3} X) (Set.instSingletonSet.{u_3} X) x))) E _inst_2 (instTopologicalSpaceSubtype.{u_2} E (fun (x_1 : E) => Membership.mem.{u_2, u_2} E (Set.{u_2} E) (Set.instMembershipSet.{u_2} E) x_1 (Set.preimage.{u_2, u_3} E X f (Singleton.singleton.{u_3, u_3} X (Set.{u_3} X) (Set.instSingletonSet.{u_3} X) x))) _inst_1) _inst_1 f (IsEvenlyCovered.toTrivialization.{u_2, u_3, u_1} E X _inst_1 _inst_2 f x I _inst_3 h))
+Case conversion may be inaccurate. Consider using '#align is_evenly_covered.mem_to_trivialization_base_set IsEvenlyCovered.mem_toTrivialization_baseSetₓ'. -/
 theorem mem_toTrivialization_baseSet {x : X} {I : Type _} [TopologicalSpace I]
     (h : IsEvenlyCovered f x I) : x ∈ h.toTrivialization.baseSet :=
   Classical.choose_spec h.2
 #align is_evenly_covered.mem_to_trivialization_base_set IsEvenlyCovered.mem_toTrivialization_baseSet
 
+/- warning: is_evenly_covered.to_trivialization_apply -> IsEvenlyCovered.toTrivialization_apply is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u_1}} {X : Type.{u_2}} [_inst_1 : TopologicalSpace.{u_1} E] [_inst_2 : TopologicalSpace.{u_2} X] {f : E -> X} {x : E} {I : Type.{u_3}} [_inst_3 : TopologicalSpace.{u_3} I] (h : IsEvenlyCovered.{u_1, u_2, u_3} E X _inst_1 _inst_2 f (f x) I _inst_3), Eq.{succ u_1} (coeSort.{max (succ u_1) 1, succ (succ u_1)} (Set.{u_1} E) Type.{u_1} (Set.hasCoeToSort.{u_1} E) (Set.preimage.{u_1, u_2} E X f (Singleton.singleton.{u_2, u_2} X (Set.{u_2} X) (Set.hasSingleton.{u_2} X) (f x)))) (Prod.snd.{u_2, u_1} X (coeSort.{max (succ u_1) 1, succ (succ u_1)} (Set.{u_1} E) Type.{u_1} (Set.hasCoeToSort.{u_1} E) (Set.preimage.{u_1, u_2} E X f (Singleton.singleton.{u_2, u_2} X (Set.{u_2} X) (Set.hasSingleton.{u_2} X) (f x)))) (coeFn.{max (succ u_2) (succ u_1), max (succ u_2) (succ u_1)} (Trivialization.{u_2, u_1, u_1} X (coeSort.{max (succ u_1) 1, succ (succ u_1)} (Set.{u_1} E) Type.{u_1} (Set.hasCoeToSort.{u_1} E) (Set.preimage.{u_1, u_2} E X f (Singleton.singleton.{u_2, u_2} X (Set.{u_2} X) (Set.hasSingleton.{u_2} X) (f x)))) E _inst_2 (Subtype.topologicalSpace.{u_1} E (fun (x_1 : E) => Membership.Mem.{u_1, u_1} E (Set.{u_1} E) (Set.hasMem.{u_1} E) x_1 (Set.preimage.{u_1, u_2} E X f (Singleton.singleton.{u_2, u_2} X (Set.{u_2} X) (Set.hasSingleton.{u_2} X) (f x)))) _inst_1) _inst_1 f) (fun (_x : Trivialization.{u_2, u_1, u_1} X (coeSort.{max (succ u_1) 1, succ (succ u_1)} (Set.{u_1} E) Type.{u_1} (Set.hasCoeToSort.{u_1} E) (Set.preimage.{u_1, u_2} E X f (Singleton.singleton.{u_2, u_2} X (Set.{u_2} X) (Set.hasSingleton.{u_2} X) (f x)))) E _inst_2 (Subtype.topologicalSpace.{u_1} E (fun (x_1 : E) => Membership.Mem.{u_1, u_1} E (Set.{u_1} E) (Set.hasMem.{u_1} E) x_1 (Set.preimage.{u_1, u_2} E X f (Singleton.singleton.{u_2, u_2} X (Set.{u_2} X) (Set.hasSingleton.{u_2} X) (f x)))) _inst_1) _inst_1 f) => E -> (Prod.{u_2, u_1} X (coeSort.{max (succ u_1) 1, succ (succ u_1)} (Set.{u_1} E) Type.{u_1} (Set.hasCoeToSort.{u_1} E) (Set.preimage.{u_1, u_2} E X f (Singleton.singleton.{u_2, u_2} X (Set.{u_2} X) (Set.hasSingleton.{u_2} X) (f x)))))) (Trivialization.hasCoeToFun.{u_2, u_1, u_1} X (coeSort.{max (succ u_1) 1, succ (succ u_1)} (Set.{u_1} E) Type.{u_1} (Set.hasCoeToSort.{u_1} E) (Set.preimage.{u_1, u_2} E X f (Singleton.singleton.{u_2, u_2} X (Set.{u_2} X) (Set.hasSingleton.{u_2} X) (f x)))) E _inst_2 (Subtype.topologicalSpace.{u_1} E (fun (x_1 : E) => Membership.Mem.{u_1, u_1} E (Set.{u_1} E) (Set.hasMem.{u_1} E) x_1 (Set.preimage.{u_1, u_2} E X f (Singleton.singleton.{u_2, u_2} X (Set.{u_2} X) (Set.hasSingleton.{u_2} X) (f x)))) _inst_1) f _inst_1) (IsEvenlyCovered.toTrivialization.{u_1, u_2, u_3, u_4} E X _inst_1 _inst_2 f (f x) I _inst_3 h) x)) (Subtype.mk.{succ u_1} E (fun (x_1 : E) => Membership.Mem.{u_1, u_1} E (Set.{u_1} E) (Set.hasMem.{u_1} E) x_1 (Set.preimage.{u_1, u_2} E X f (Singleton.singleton.{u_2, u_2} X (Set.{u_2} X) (Set.hasSingleton.{u_2} X) (f x)))) x (rfl.{succ u_2} X (f x)))
+but is expected to have type
+  forall {E : Type.{u_2}} {X : Type.{u_3}} [_inst_1 : TopologicalSpace.{u_2} E] [_inst_2 : TopologicalSpace.{u_3} X] {f : E -> X} {x : E} {I : Type.{u_1}} [_inst_3 : TopologicalSpace.{u_1} I] (h : IsEvenlyCovered.{u_2, u_3, u_1} E X _inst_1 _inst_2 f (f x) I _inst_3), Eq.{succ u_2} (Set.Elem.{u_2} E (Set.preimage.{u_2, u_3} E X f (Singleton.singleton.{u_3, u_3} X (Set.{u_3} X) (Set.instSingletonSet.{u_3} X) (f x)))) (Prod.snd.{u_3, u_2} X (Set.Elem.{u_2} E (Set.preimage.{u_2, u_3} E X f (Singleton.singleton.{u_3, u_3} X (Set.{u_3} X) (Set.instSingletonSet.{u_3} X) (f x)))) (Trivialization.toFun'.{u_3, u_2, u_2} X (Set.Elem.{u_2} E (Set.preimage.{u_2, u_3} E X f (Singleton.singleton.{u_3, u_3} X (Set.{u_3} X) (Set.instSingletonSet.{u_3} X) (f x)))) E _inst_2 (instTopologicalSpaceSubtype.{u_2} E (fun (x_1 : E) => Membership.mem.{u_2, u_2} E (Set.{u_2} E) (Set.instMembershipSet.{u_2} E) x_1 (Set.preimage.{u_2, u_3} E X f (Singleton.singleton.{u_3, u_3} X (Set.{u_3} X) (Set.instSingletonSet.{u_3} X) (f x)))) _inst_1) f _inst_1 (IsEvenlyCovered.toTrivialization.{u_2, u_3, u_1} E X _inst_1 _inst_2 f (f x) I _inst_3 h) x)) (Subtype.mk.{succ u_2} E (fun (x_1 : E) => Membership.mem.{u_2, u_2} E (Set.{u_2} E) (Set.instMembershipSet.{u_2} E) x_1 (Set.preimage.{u_2, u_3} E X f (Singleton.singleton.{u_3, u_3} X (Set.{u_3} X) (Set.instSingletonSet.{u_3} X) (f x)))) x (rfl.{succ u_3} X (f x)))
+Case conversion may be inaccurate. Consider using '#align is_evenly_covered.to_trivialization_apply IsEvenlyCovered.toTrivialization_applyₓ'. -/
 theorem toTrivialization_apply {x : E} {I : Type _} [TopologicalSpace I]
     (h : IsEvenlyCovered f (f x) I) : (h.toTrivialization x).2 = ⟨x, rfl⟩ :=
   let e := Classical.choose h.2
@@ -63,12 +83,24 @@ theorem toTrivialization_apply {x : E} {I : Type _} [TopologicalSpace I]
         he.symm).symm
 #align is_evenly_covered.to_trivialization_apply IsEvenlyCovered.toTrivialization_apply
 
+/- warning: is_evenly_covered.continuous_at -> IsEvenlyCovered.continuousAt is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} E] [_inst_2 : TopologicalSpace.{u2} X] {f : E -> X} {x : E} {I : Type.{u3}} [_inst_3 : TopologicalSpace.{u3} I], (IsEvenlyCovered.{u1, u2, u3} E X _inst_1 _inst_2 f (f x) I _inst_3) -> (ContinuousAt.{u1, u2} E X _inst_1 _inst_2 f x)
+but is expected to have type
+  forall {E : Type.{u2}} {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} E] [_inst_2 : TopologicalSpace.{u1} X] {f : E -> X} {x : E} {I : Type.{u3}} [_inst_3 : TopologicalSpace.{u3} I], (IsEvenlyCovered.{u2, u1, u3} E X _inst_1 _inst_2 f (f x) I _inst_3) -> (ContinuousAt.{u2, u1} E X _inst_1 _inst_2 f x)
+Case conversion may be inaccurate. Consider using '#align is_evenly_covered.continuous_at IsEvenlyCovered.continuousAtₓ'. -/
 protected theorem continuousAt {x : E} {I : Type _} [TopologicalSpace I]
     (h : IsEvenlyCovered f (f x) I) : ContinuousAt f x :=
   let e := h.toTrivialization
   e.continuousAt_proj (e.mem_source.mpr (mem_toTrivialization_baseSet h))
 #align is_evenly_covered.continuous_at IsEvenlyCovered.continuousAt
 
+/- warning: is_evenly_covered.to_is_evenly_covered_preimage -> IsEvenlyCovered.to_isEvenlyCovered_preimage is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} E] [_inst_2 : TopologicalSpace.{u2} X] {f : E -> X} {x : X} {I : Type.{u3}} [_inst_3 : TopologicalSpace.{u3} I], (IsEvenlyCovered.{u1, u2, u3} E X _inst_1 _inst_2 f x I _inst_3) -> (IsEvenlyCovered.{u1, u2, u1} E X _inst_1 _inst_2 f x (coeSort.{succ u1, succ (succ u1)} (Set.{u1} E) Type.{u1} (Set.hasCoeToSort.{u1} E) (Set.preimage.{u1, u2} E X f (Singleton.singleton.{u2, u2} X (Set.{u2} X) (Set.hasSingleton.{u2} X) x))) (Subtype.topologicalSpace.{u1} E (fun (x_1 : E) => Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) x_1 (Set.preimage.{u1, u2} E X f (Singleton.singleton.{u2, u2} X (Set.{u2} X) (Set.hasSingleton.{u2} X) x))) _inst_1))
+but is expected to have type
+  forall {E : Type.{u2}} {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} E] [_inst_2 : TopologicalSpace.{u1} X] {f : E -> X} {x : X} {I : Type.{u3}} [_inst_3 : TopologicalSpace.{u3} I], (IsEvenlyCovered.{u2, u1, u3} E X _inst_1 _inst_2 f x I _inst_3) -> (IsEvenlyCovered.{u2, u1, u2} E X _inst_1 _inst_2 f x (Set.Elem.{u2} E (Set.preimage.{u2, u1} E X f (Singleton.singleton.{u1, u1} X (Set.{u1} X) (Set.instSingletonSet.{u1} X) x))) (instTopologicalSpaceSubtype.{u2} E (fun (x_1 : E) => Membership.mem.{u2, u2} E (Set.{u2} E) (Set.instMembershipSet.{u2} E) x_1 (Set.preimage.{u2, u1} E X f (Singleton.singleton.{u1, u1} X (Set.{u1} X) (Set.instSingletonSet.{u1} X) x))) _inst_1))
+Case conversion may be inaccurate. Consider using '#align is_evenly_covered.to_is_evenly_covered_preimage IsEvenlyCovered.to_isEvenlyCovered_preimageₓ'. -/
 theorem to_isEvenlyCovered_preimage {x : X} {I : Type _} [TopologicalSpace I]
     (h : IsEvenlyCovered f x I) : IsEvenlyCovered f x (f ⁻¹' {x}) :=
   let ⟨h1, h2⟩ := h
@@ -79,31 +111,53 @@ theorem to_isEvenlyCovered_preimage {x : X} {I : Type _} [TopologicalSpace I]
 
 end IsEvenlyCovered
 
+#print IsCoveringMapOn /-
 /-- A covering map is a continuous function `f : E → X` with discrete fibers such that each point
   of `X` has an evenly covered neighborhood. -/
 def IsCoveringMapOn :=
   ∀ x ∈ s, IsEvenlyCovered f x (f ⁻¹' {x})
 #align is_covering_map_on IsCoveringMapOn
+-/
 
 namespace IsCoveringMapOn
 
+#print IsCoveringMapOn.mk /-
 theorem mk (F : X → Type _) [∀ x, TopologicalSpace (F x)] [hF : ∀ x, DiscreteTopology (F x)]
     (e : ∀ x ∈ s, Trivialization (F x) f) (h : ∀ (x : X) (hx : x ∈ s), x ∈ (e x hx).baseSet) :
     IsCoveringMapOn f s := fun x hx =>
   IsEvenlyCovered.to_isEvenlyCovered_preimage ⟨hF x, e x hx, h x hx⟩
 #align is_covering_map_on.mk IsCoveringMapOn.mk
+-/
 
 variable {f} {s}
 
+/- warning: is_covering_map_on.continuous_at -> IsCoveringMapOn.continuousAt is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} E] [_inst_2 : TopologicalSpace.{u2} X] {f : E -> X} {s : Set.{u2} X}, (IsCoveringMapOn.{u1, u2} E X _inst_1 _inst_2 f s) -> (forall {x : E}, (Membership.Mem.{u2, u2} X (Set.{u2} X) (Set.hasMem.{u2} X) (f x) s) -> (ContinuousAt.{u1, u2} E X _inst_1 _inst_2 f x))
+but is expected to have type
+  forall {E : Type.{u2}} {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} E] [_inst_2 : TopologicalSpace.{u1} X] {f : E -> X} {s : Set.{u1} X}, (IsCoveringMapOn.{u2, u1} E X _inst_1 _inst_2 f s) -> (forall {x : E}, (Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) (f x) s) -> (ContinuousAt.{u2, u1} E X _inst_1 _inst_2 f x))
+Case conversion may be inaccurate. Consider using '#align is_covering_map_on.continuous_at IsCoveringMapOn.continuousAtₓ'. -/
 protected theorem continuousAt (hf : IsCoveringMapOn f s) {x : E} (hx : f x ∈ s) :
     ContinuousAt f x :=
   (hf (f x) hx).ContinuousAt
 #align is_covering_map_on.continuous_at IsCoveringMapOn.continuousAt
 
+/- warning: is_covering_map_on.continuous_on -> IsCoveringMapOn.continuousOn is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} E] [_inst_2 : TopologicalSpace.{u2} X] {f : E -> X} {s : Set.{u2} X}, (IsCoveringMapOn.{u1, u2} E X _inst_1 _inst_2 f s) -> (ContinuousOn.{u1, u2} E X _inst_1 _inst_2 f (Set.preimage.{u1, u2} E X f s))
+but is expected to have type
+  forall {E : Type.{u2}} {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} E] [_inst_2 : TopologicalSpace.{u1} X] {f : E -> X} {s : Set.{u1} X}, (IsCoveringMapOn.{u2, u1} E X _inst_1 _inst_2 f s) -> (ContinuousOn.{u2, u1} E X _inst_1 _inst_2 f (Set.preimage.{u2, u1} E X f s))
+Case conversion may be inaccurate. Consider using '#align is_covering_map_on.continuous_on IsCoveringMapOn.continuousOnₓ'. -/
 protected theorem continuousOn (hf : IsCoveringMapOn f s) : ContinuousOn f (f ⁻¹' s) :=
   ContinuousAt.continuousOn fun x => hf.ContinuousAt
 #align is_covering_map_on.continuous_on IsCoveringMapOn.continuousOn
 
+/- warning: is_covering_map_on.is_locally_homeomorph_on -> IsCoveringMapOn.isLocallyHomeomorphOn is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} E] [_inst_2 : TopologicalSpace.{u2} X] {f : E -> X} {s : Set.{u2} X}, (IsCoveringMapOn.{u1, u2} E X _inst_1 _inst_2 f s) -> (IsLocallyHomeomorphOn.{u1, u2} E X _inst_1 _inst_2 f (Set.preimage.{u1, u2} E X f s))
+but is expected to have type
+  forall {E : Type.{u2}} {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} E] [_inst_2 : TopologicalSpace.{u1} X] {f : E -> X} {s : Set.{u1} X}, (IsCoveringMapOn.{u2, u1} E X _inst_1 _inst_2 f s) -> (IsLocallyHomeomorphOn.{u2, u1} E X _inst_1 _inst_2 f (Set.preimage.{u2, u1} E X f s))
+Case conversion may be inaccurate. Consider using '#align is_covering_map_on.is_locally_homeomorph_on IsCoveringMapOn.isLocallyHomeomorphOnₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 protected theorem isLocallyHomeomorphOn (hf : IsCoveringMapOn f s) :
     IsLocallyHomeomorphOn f (f ⁻¹' s) :=
@@ -134,18 +188,32 @@ protected theorem isLocallyHomeomorphOn (hf : IsCoveringMapOn f s) :
 
 end IsCoveringMapOn
 
+#print IsCoveringMap /-
 /-- A covering map is a continuous function `f : E → X` with discrete fibers such that each point
   of `X` has an evenly covered neighborhood. -/
 def IsCoveringMap :=
   ∀ x, IsEvenlyCovered f x (f ⁻¹' {x})
 #align is_covering_map IsCoveringMap
+-/
 
 variable {f}
 
+/- warning: is_covering_map_iff_is_covering_map_on_univ -> isCoveringMap_iff_isCoveringMapOn_univ is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} E] [_inst_2 : TopologicalSpace.{u2} X] {f : E -> X}, Iff (IsCoveringMap.{u1, u2} E X _inst_1 _inst_2 f) (IsCoveringMapOn.{u1, u2} E X _inst_1 _inst_2 f (Set.univ.{u2} X))
+but is expected to have type
+  forall {E : Type.{u2}} {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} E] [_inst_2 : TopologicalSpace.{u1} X] {f : E -> X}, Iff (IsCoveringMap.{u2, u1} E X _inst_1 _inst_2 f) (IsCoveringMapOn.{u2, u1} E X _inst_1 _inst_2 f (Set.univ.{u1} X))
+Case conversion may be inaccurate. Consider using '#align is_covering_map_iff_is_covering_map_on_univ isCoveringMap_iff_isCoveringMapOn_univₓ'. -/
 theorem isCoveringMap_iff_isCoveringMapOn_univ : IsCoveringMap f ↔ IsCoveringMapOn f Set.univ := by
   simp only [IsCoveringMap, IsCoveringMapOn, Set.mem_univ, forall_true_left]
 #align is_covering_map_iff_is_covering_map_on_univ isCoveringMap_iff_isCoveringMapOn_univ
 
+/- warning: is_covering_map.is_covering_map_on -> IsCoveringMap.isCoveringMapOn is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} E] [_inst_2 : TopologicalSpace.{u2} X] {f : E -> X}, (IsCoveringMap.{u1, u2} E X _inst_1 _inst_2 f) -> (IsCoveringMapOn.{u1, u2} E X _inst_1 _inst_2 f (Set.univ.{u2} X))
+but is expected to have type
+  forall {E : Type.{u2}} {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} E] [_inst_2 : TopologicalSpace.{u1} X] {f : E -> X}, (IsCoveringMap.{u2, u1} E X _inst_1 _inst_2 f) -> (IsCoveringMapOn.{u2, u1} E X _inst_1 _inst_2 f (Set.univ.{u1} X))
+Case conversion may be inaccurate. Consider using '#align is_covering_map.is_covering_map_on IsCoveringMap.isCoveringMapOnₓ'. -/
 protected theorem IsCoveringMap.isCoveringMapOn (hf : IsCoveringMap f) :
     IsCoveringMapOn f Set.univ :=
   isCoveringMap_iff_isCoveringMapOn_univ.mp hf
@@ -155,26 +223,52 @@ variable (f)
 
 namespace IsCoveringMap
 
+#print IsCoveringMap.mk /-
 theorem mk (F : X → Type _) [∀ x, TopologicalSpace (F x)] [hF : ∀ x, DiscreteTopology (F x)]
     (e : ∀ x, Trivialization (F x) f) (h : ∀ x, x ∈ (e x).baseSet) : IsCoveringMap f :=
   isCoveringMap_iff_isCoveringMapOn_univ.mpr
     (IsCoveringMapOn.mk f Set.univ F (fun x hx => e x) fun x hx => h x)
 #align is_covering_map.mk IsCoveringMap.mk
+-/
 
 variable {f}
 
+/- warning: is_covering_map.continuous -> IsCoveringMap.continuous is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} E] [_inst_2 : TopologicalSpace.{u2} X] {f : E -> X}, (IsCoveringMap.{u1, u2} E X _inst_1 _inst_2 f) -> (Continuous.{u1, u2} E X _inst_1 _inst_2 f)
+but is expected to have type
+  forall {E : Type.{u2}} {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} E] [_inst_2 : TopologicalSpace.{u1} X] {f : E -> X}, (IsCoveringMap.{u2, u1} E X _inst_1 _inst_2 f) -> (Continuous.{u2, u1} E X _inst_1 _inst_2 f)
+Case conversion may be inaccurate. Consider using '#align is_covering_map.continuous IsCoveringMap.continuousₓ'. -/
 protected theorem continuous (hf : IsCoveringMap f) : Continuous f :=
   continuous_iff_continuousOn_univ.mpr hf.IsCoveringMapOn.ContinuousOn
 #align is_covering_map.continuous IsCoveringMap.continuous
 
+/- warning: is_covering_map.is_locally_homeomorph -> IsCoveringMap.isLocallyHomeomorph is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} E] [_inst_2 : TopologicalSpace.{u2} X] {f : E -> X}, (IsCoveringMap.{u1, u2} E X _inst_1 _inst_2 f) -> (IsLocallyHomeomorph.{u1, u2} E X _inst_1 _inst_2 f)
+but is expected to have type
+  forall {E : Type.{u2}} {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} E] [_inst_2 : TopologicalSpace.{u1} X] {f : E -> X}, (IsCoveringMap.{u2, u1} E X _inst_1 _inst_2 f) -> (IsLocallyHomeomorph.{u2, u1} E X _inst_1 _inst_2 f)
+Case conversion may be inaccurate. Consider using '#align is_covering_map.is_locally_homeomorph IsCoveringMap.isLocallyHomeomorphₓ'. -/
 protected theorem isLocallyHomeomorph (hf : IsCoveringMap f) : IsLocallyHomeomorph f :=
   isLocallyHomeomorph_iff_isLocallyHomeomorphOn_univ.mpr hf.IsCoveringMapOn.IsLocallyHomeomorphOn
 #align is_covering_map.is_locally_homeomorph IsCoveringMap.isLocallyHomeomorph
 
+/- warning: is_covering_map.is_open_map -> IsCoveringMap.isOpenMap is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} E] [_inst_2 : TopologicalSpace.{u2} X] {f : E -> X}, (IsCoveringMap.{u1, u2} E X _inst_1 _inst_2 f) -> (IsOpenMap.{u1, u2} E X _inst_1 _inst_2 f)
+but is expected to have type
+  forall {E : Type.{u2}} {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} E] [_inst_2 : TopologicalSpace.{u1} X] {f : E -> X}, (IsCoveringMap.{u2, u1} E X _inst_1 _inst_2 f) -> (IsOpenMap.{u2, u1} E X _inst_1 _inst_2 f)
+Case conversion may be inaccurate. Consider using '#align is_covering_map.is_open_map IsCoveringMap.isOpenMapₓ'. -/
 protected theorem isOpenMap (hf : IsCoveringMap f) : IsOpenMap f :=
   hf.IsLocallyHomeomorph.IsOpenMap
 #align is_covering_map.is_open_map IsCoveringMap.isOpenMap
 
+/- warning: is_covering_map.quotient_map -> IsCoveringMap.quotientMap is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} E] [_inst_2 : TopologicalSpace.{u2} X] {f : E -> X}, (IsCoveringMap.{u1, u2} E X _inst_1 _inst_2 f) -> (Function.Surjective.{succ u1, succ u2} E X f) -> (QuotientMap.{u1, u2} E X _inst_1 _inst_2 f)
+but is expected to have type
+  forall {E : Type.{u2}} {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} E] [_inst_2 : TopologicalSpace.{u1} X] {f : E -> X}, (IsCoveringMap.{u2, u1} E X _inst_1 _inst_2 f) -> (Function.Surjective.{succ u2, succ u1} E X f) -> (QuotientMap.{u2, u1} E X _inst_1 _inst_2 f)
+Case conversion may be inaccurate. Consider using '#align is_covering_map.quotient_map IsCoveringMap.quotientMapₓ'. -/
 protected theorem quotientMap (hf : IsCoveringMap f) (hf' : Function.Surjective f) :
     QuotientMap f :=
   hf.IsOpenMap.to_quotientMap hf.Continuous hf'
@@ -184,12 +278,24 @@ end IsCoveringMap
 
 variable {f}
 
+/- warning: is_fiber_bundle.is_covering_map -> IsFiberBundle.isCoveringMap is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} {X : Type.{u2}} [_inst_1 : TopologicalSpace.{u1} E] [_inst_2 : TopologicalSpace.{u2} X] {f : E -> X} {F : Type.{u3}} [_inst_3 : TopologicalSpace.{u3} F] [_inst_4 : DiscreteTopology.{u3} F _inst_3], (forall (x : X), Exists.{max (succ u2) (succ u3) (succ u1)} (Trivialization.{u2, u3, u1} X F E _inst_2 _inst_3 _inst_1 f) (fun (e : Trivialization.{u2, u3, u1} X F E _inst_2 _inst_3 _inst_1 f) => Membership.Mem.{u2, u2} X (Set.{u2} X) (Set.hasMem.{u2} X) x (Trivialization.baseSet.{u2, u3, u1} X F E _inst_2 _inst_3 _inst_1 f e))) -> (IsCoveringMap.{u1, u2} E X _inst_1 _inst_2 f)
+but is expected to have type
+  forall {E : Type.{u2}} {X : Type.{u1}} [_inst_1 : TopologicalSpace.{u2} E] [_inst_2 : TopologicalSpace.{u1} X] {f : E -> X} {F : Type.{u3}} [_inst_3 : TopologicalSpace.{u3} F] [_inst_4 : DiscreteTopology.{u3} F _inst_3], (forall (x : X), Exists.{max (max (succ u2) (succ u1)) (succ u3)} (Trivialization.{u1, u3, u2} X F E _inst_2 _inst_3 _inst_1 f) (fun (e : Trivialization.{u1, u3, u2} X F E _inst_2 _inst_3 _inst_1 f) => Membership.mem.{u1, u1} X (Set.{u1} X) (Set.instMembershipSet.{u1} X) x (Trivialization.baseSet.{u1, u3, u2} X F E _inst_2 _inst_3 _inst_1 f e))) -> (IsCoveringMap.{u2, u1} E X _inst_1 _inst_2 f)
+Case conversion may be inaccurate. Consider using '#align is_fiber_bundle.is_covering_map IsFiberBundle.isCoveringMapₓ'. -/
 protected theorem IsFiberBundle.isCoveringMap {F : Type _} [TopologicalSpace F] [DiscreteTopology F]
     (hf : ∀ x : X, ∃ e : Trivialization F f, x ∈ e.baseSet) : IsCoveringMap f :=
   IsCoveringMap.mk f (fun x => F) (fun x => Classical.choose (hf x)) fun x =>
     Classical.choose_spec (hf x)
 #align is_fiber_bundle.is_covering_map IsFiberBundle.isCoveringMap
 
+/- warning: fiber_bundle.is_covering_map -> FiberBundle.isCoveringMap is a dubious translation:
+lean 3 declaration is
+  forall {X : Type.{u1}} [_inst_2 : TopologicalSpace.{u1} X] {F : Type.{u2}} {E : X -> Type.{u3}} [_inst_3 : TopologicalSpace.{u2} F] [_inst_4 : DiscreteTopology.{u2} F _inst_3] [_inst_5 : TopologicalSpace.{max u1 u3} (Bundle.TotalSpace.{u1, u3} X E)] [_inst_6 : forall (x : X), TopologicalSpace.{u3} (E x)] [hf : FiberBundle.{u1, u2, u3} X F _inst_2 _inst_3 E _inst_5 (fun (b : X) => _inst_6 b)], IsCoveringMap.{max u1 u3, u1} (Bundle.TotalSpace.{u1, u3} X E) X _inst_5 _inst_2 (Bundle.TotalSpace.proj.{u1, u3} X E)
+but is expected to have type
+  forall {X : Type.{u1}} [_inst_2 : TopologicalSpace.{u1} X] {F : Type.{u3}} {E : X -> Type.{u2}} [_inst_3 : TopologicalSpace.{u3} F] [_inst_4 : DiscreteTopology.{u3} F _inst_3] [_inst_5 : TopologicalSpace.{max u2 u1} (Bundle.TotalSpace.{u1, u2} X E)] [_inst_6 : forall (x : X), TopologicalSpace.{u2} (E x)] [hf : FiberBundle.{u1, u3, u2} X F _inst_2 _inst_3 E _inst_5 (fun (b : X) => _inst_6 b)], IsCoveringMap.{max u1 u2, u1} (Bundle.TotalSpace.{u1, u2} X E) X _inst_5 _inst_2 (Bundle.TotalSpace.proj.{u1, u2} X E)
+Case conversion may be inaccurate. Consider using '#align fiber_bundle.is_covering_map FiberBundle.isCoveringMapₓ'. -/
 protected theorem FiberBundle.isCoveringMap {F : Type _} {E : X → Type _} [TopologicalSpace F]
     [DiscreteTopology F] [TopologicalSpace (Bundle.TotalSpace E)] [∀ x, TopologicalSpace (E x)]
     [hf : FiberBundle F E] : IsCoveringMap (π E) :=

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

chore: rename LocalEquiv to PartialEquiv (#8984)

The current name is misleading: there's no open set involved; it's just an equivalence between subsets of domain and target. zulip discussion

PEquiv is similarly named: this is fine, as they're different designs for the same concept.

Co-authored-by: Michael Rothgang <rothgami@math.hu-berlin.de>

f7006a73

Diff

@@ -55,7 +55,7 @@ theorem toTrivialization_apply {x : E} {I : Type*} [TopologicalSpace I]
   let h := Classical.choose_spec h.2
   let he := e.mk_proj_snd' h
   Subtype.ext
-    ((e.toLocalEquiv.eq_symm_apply (e.mem_source.mpr h)
+    ((e.toPartialEquiv.eq_symm_apply (e.mem_source.mpr h)
             (by rwa [he, e.mem_target, e.coe_fst (e.mem_source.mpr h)])).mpr
         he.symm).symm
 #align is_evenly_covered.to_trivialization_apply IsEvenlyCovered.toTrivialization_apply

chore: rename LocalHomeomorph to PartialHomeomorph (#8982)

LocalHomeomorph evokes a "local homeomorphism": this is not what this means. Instead, this is a homeomorphism on an open set of the domain (extended to the whole space, by the junk value pattern). Hence, partial homeomorphism is more appropriate, and avoids confusion with IsLocallyHomeomorph.

A future PR will rename LocalEquiv to PartialEquiv.

Zulip discussion

bbc6e56d

Diff

@@ -108,7 +108,7 @@ protected theorem isLocalHomeomorphOn (hf : IsCoveringMapOn f s) :
   have h := (hf (f x) hx).mem_toTrivialization_baseSet
   let he := e.mem_source.2 h
   refine'
-    ⟨e.toLocalHomeomorph.trans
+    ⟨e.toPartialHomeomorph.trans
         { toFun := fun p => p.1
           invFun := fun p => ⟨p, x, rfl⟩
           source := e.baseSet ×ˢ ({⟨x, rfl⟩} : Set (f ⁻¹' {f x}))
@@ -122,7 +122,7 @@ protected theorem isLocalHomeomorphOn (hf : IsCoveringMapOn f s) :
           right_inv' := fun p _ => rfl
           continuousOn_toFun := continuous_fst.continuousOn
           continuousOn_invFun := (continuous_id'.prod_mk continuous_const).continuousOn },
-      ⟨he, by rwa [e.toLocalHomeomorph.symm_symm, e.proj_toFun x he],
+      ⟨he, by rwa [e.toPartialHomeomorph.symm_symm, e.proj_toFun x he],
         (hf (f x) hx).toTrivialization_apply⟩,
       fun p h => (e.proj_toFun p h.1).symm⟩
 #align is_covering_map_on.is_locally_homeomorph_on IsCoveringMapOn.isLocalHomeomorphOn

chore: rename IsLocallyHomeomorph{On} to IsLocalHomeomorph{On} (#8983)

This matches informal math terminology: IsLocallyHomeomorph f means "f is a local homeomorphism".

zulip discussion

fe44d905

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2022 Thomas Browning. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Thomas Browning
 -/
-import Mathlib.Topology.IsLocallyHomeomorph
+import Mathlib.Topology.IsLocalHomeomorph
 import Mathlib.Topology.FiberBundle.Basic
 
 #align_import topology.covering from "leanprover-community/mathlib"@"e473c3198bb41f68560cab68a0529c854b618833"
@@ -101,9 +101,9 @@ protected theorem continuousOn (hf : IsCoveringMapOn f s) : ContinuousOn f (f 
   ContinuousAt.continuousOn fun _ => hf.continuousAt
 #align is_covering_map_on.continuous_on IsCoveringMapOn.continuousOn
 
-protected theorem isLocallyHomeomorphOn (hf : IsCoveringMapOn f s) :
-    IsLocallyHomeomorphOn f (f ⁻¹' s) := by
-  refine' IsLocallyHomeomorphOn.mk f (f ⁻¹' s) fun x hx => _
+protected theorem isLocalHomeomorphOn (hf : IsCoveringMapOn f s) :
+    IsLocalHomeomorphOn f (f ⁻¹' s) := by
+  refine' IsLocalHomeomorphOn.mk f (f ⁻¹' s) fun x hx => _
   let e := (hf (f x) hx).toTrivialization
   have h := (hf (f x) hx).mem_toTrivialization_baseSet
   let he := e.mem_source.2 h
@@ -125,7 +125,7 @@ protected theorem isLocallyHomeomorphOn (hf : IsCoveringMapOn f s) :
       ⟨he, by rwa [e.toLocalHomeomorph.symm_symm, e.proj_toFun x he],
         (hf (f x) hx).toTrivialization_apply⟩,
       fun p h => (e.proj_toFun p h.1).symm⟩
-#align is_covering_map_on.is_locally_homeomorph_on IsCoveringMapOn.isLocallyHomeomorphOn
+#align is_covering_map_on.is_locally_homeomorph_on IsCoveringMapOn.isLocalHomeomorphOn
 
 end IsCoveringMapOn
 
@@ -162,12 +162,12 @@ protected theorem continuous : Continuous f :=
   continuous_iff_continuousOn_univ.mpr hf.isCoveringMapOn.continuousOn
 #align is_covering_map.continuous IsCoveringMap.continuous
 
-protected theorem isLocallyHomeomorph : IsLocallyHomeomorph f :=
-  isLocallyHomeomorph_iff_isLocallyHomeomorphOn_univ.mpr hf.isCoveringMapOn.isLocallyHomeomorphOn
-#align is_covering_map.is_locally_homeomorph IsCoveringMap.isLocallyHomeomorph
+protected theorem isLocalHomeomorph : IsLocalHomeomorph f :=
+  isLocalHomeomorph_iff_isLocalHomeomorphOn_univ.mpr hf.isCoveringMapOn.isLocalHomeomorphOn
+#align is_covering_map.is_locally_homeomorph IsCoveringMap.isLocalHomeomorph
 
 protected theorem isOpenMap : IsOpenMap f :=
-  hf.isLocallyHomeomorph.isOpenMap
+  hf.isLocalHomeomorph.isOpenMap
 #align is_covering_map.is_open_map IsCoveringMap.isOpenMap
 
 protected theorem quotientMap (hf' : Function.Surjective f) : QuotientMap f :=
@@ -190,20 +190,20 @@ variable {A} [TopologicalSpace A] {s : Set A} (hs : IsPreconnected s) {g g₁ g
 
 theorem eq_of_comp_eq [PreconnectedSpace A] (h₁ : Continuous g₁) (h₂ : Continuous g₂)
     (he : f ∘ g₁ = f ∘ g₂) (a : A) (ha : g₁ a = g₂ a) : g₁ = g₂ :=
-  hf.isSeparatedMap.eq_of_comp_eq hf.isLocallyHomeomorph.isLocallyInjective h₁ h₂ he a ha
+  hf.isSeparatedMap.eq_of_comp_eq hf.isLocalHomeomorph.isLocallyInjective h₁ h₂ he a ha
 
 theorem eqOn_of_comp_eqOn (h₁ : ContinuousOn g₁ s) (h₂ : ContinuousOn g₂ s)
     (he : s.EqOn (f ∘ g₁) (f ∘ g₂)) {a : A} (has : a ∈ s) (ha : g₁ a = g₂ a) : s.EqOn g₁ g₂ :=
-  hf.isSeparatedMap.eqOn_of_comp_eqOn hf.isLocallyHomeomorph.isLocallyInjective hs h₁ h₂ he has ha
+  hf.isSeparatedMap.eqOn_of_comp_eqOn hf.isLocalHomeomorph.isLocallyInjective hs h₁ h₂ he has ha
 
 theorem const_of_comp [PreconnectedSpace A] (cont : Continuous g)
     (he : ∀ a a', f (g a) = f (g a')) (a a') : g a = g a' :=
-  hf.isSeparatedMap.const_of_comp hf.isLocallyHomeomorph.isLocallyInjective cont he a a'
+  hf.isSeparatedMap.const_of_comp hf.isLocalHomeomorph.isLocallyInjective cont he a a'
 
 theorem constOn_of_comp (cont : ContinuousOn g s)
     (he : ∀ a ∈ s, ∀ a' ∈ s, f (g a) = f (g a'))
     {a a'} (ha : a ∈ s) (ha' : a' ∈ s) : g a = g a' :=
-  hf.isSeparatedMap.constOn_of_comp hf.isLocallyHomeomorph.isLocallyInjective hs cont he ha ha'
+  hf.isSeparatedMap.constOn_of_comp hf.isLocalHomeomorph.isLocallyInjective hs cont he ha ha'
 
 end IsCoveringMap

chore: rename {LocalHomeomorph,ChartedSpace}.continuous_{to,inv}Fun fields to continuousOn_{to,inv}Fun (#8848)

They have type ContinuousOn ..., hence should be named accordingly. Suggested by @fpvandoorn in #8736.

d10d71d7

Diff

@@ -120,8 +120,8 @@ protected theorem isLocallyHomeomorphOn (hf : IsCoveringMapOn f s) :
           map_target' := fun p hp => ⟨hp, rfl⟩
           left_inv' := fun p hp => Prod.ext rfl hp.2.symm
           right_inv' := fun p _ => rfl
-          continuous_toFun := continuous_fst.continuousOn
-          continuous_invFun := (continuous_id'.prod_mk continuous_const).continuousOn },
+          continuousOn_toFun := continuous_fst.continuousOn
+          continuousOn_invFun := (continuous_id'.prod_mk continuous_const).continuousOn },
       ⟨he, by rwa [e.toLocalHomeomorph.symm_symm, e.proj_toFun x he],
         (hf (f x) hx).toTrivialization_apply⟩,
       fun p h => (e.proj_toFun p h.1).symm⟩
@@ -181,7 +181,7 @@ protected theorem isSeparatedMap : IsSeparatedMap f :=
     refine ⟨t.source ∩ (Prod.snd ∘ t) ⁻¹' {(t e₁).2}, t.source ∩ (Prod.snd ∘ t) ⁻¹' {(t e₂).2},
       ?_, ?_, ⟨he₁, rfl⟩, ⟨he₂, rfl⟩, Set.disjoint_left.mpr fun x h₁ h₂ ↦ hne (t.injOn he₁ he₂ ?_)⟩
     iterate 2
-      exact t.continuous_toFun.isOpen_inter_preimage t.open_source
+      exact t.continuousOn_toFun.isOpen_inter_preimage t.open_source
         (continuous_snd.isOpen_preimage _ <| isOpen_discrete _)
     refine Prod.ext ?_ (h₁.2.symm.trans h₂.2)
     rwa [t.proj_toFun e₁ he₁, t.proj_toFun e₂ he₂]

chore: rename lemmas containing "of_open" to match the naming convention (#8229)

Mostly, this means replacing "of_open" by "of_isOpen". A few lemmas names were misleading and are corrected differently. Zulip discussion.

8b8aaa21

Diff

@@ -181,7 +181,7 @@ protected theorem isSeparatedMap : IsSeparatedMap f :=
     refine ⟨t.source ∩ (Prod.snd ∘ t) ⁻¹' {(t e₁).2}, t.source ∩ (Prod.snd ∘ t) ⁻¹' {(t e₂).2},
       ?_, ?_, ⟨he₁, rfl⟩, ⟨he₂, rfl⟩, Set.disjoint_left.mpr fun x h₁ h₂ ↦ hne (t.injOn he₁ he₂ ?_)⟩
     iterate 2
-      exact t.continuous_toFun.preimage_open_of_open t.open_source
+      exact t.continuous_toFun.isOpen_inter_preimage t.open_source
         (continuous_snd.isOpen_preimage _ <| isOpen_discrete _)
     refine Prod.ext ?_ (h₁.2.symm.trans h₂.2)
     rwa [t.proj_toFun e₁ he₁, t.proj_toFun e₂ he₂]

feat: separated and locally injective maps (#7911)

A function from a topological space X to a type Y is a separated map if any two distinct points in X with the same image in Y can be separated by open neighborhoods. A constant function is a separated map if and only if X is a T2Space.

A function from a topological space X is locally injective if every point of X has a neighborhood on which f is injective. A constant function is locally injective if and only if X is discrete.

Given f : X → Y one can form the pullback $X \times_Y X$; the diagonal map $\Delta: X \to X \times_Y X$ is always an embedding. It is a closed embedding iff f is a separated map, iff the equal locus of any two continuous maps equalized by f is closed. It is an open embedding iff f is locally injective, iff any such equal locus is open. Therefore, if f is a locally injective separated map (e.g. a covering map), the equal locus of two continuous maps equalized by f is clopen, so if the two maps agree on a point, then they agree on the whole connected component. This is crucial to showing the uniqueness of path lifting and the uniqueness and continuity of homotopy lifting for covering spaces.

The analogue of separated maps and locally injective maps in algebraic geometry are separated morphisms and unramified morphisms, respectively.

83b113a5

Diff

@@ -156,25 +156,55 @@ theorem mk (F : X → Type*) [∀ x, TopologicalSpace (F x)] [∀ x, DiscreteTop
     (IsCoveringMapOn.mk f Set.univ F (fun x _ => e x) fun x _ => h x)
 #align is_covering_map.mk IsCoveringMap.mk
 
-variable {f}
+variable {f} (hf : IsCoveringMap f)
 
-protected theorem continuous (hf : IsCoveringMap f) : Continuous f :=
+protected theorem continuous : Continuous f :=
   continuous_iff_continuousOn_univ.mpr hf.isCoveringMapOn.continuousOn
 #align is_covering_map.continuous IsCoveringMap.continuous
 
-protected theorem isLocallyHomeomorph (hf : IsCoveringMap f) : IsLocallyHomeomorph f :=
+protected theorem isLocallyHomeomorph : IsLocallyHomeomorph f :=
   isLocallyHomeomorph_iff_isLocallyHomeomorphOn_univ.mpr hf.isCoveringMapOn.isLocallyHomeomorphOn
 #align is_covering_map.is_locally_homeomorph IsCoveringMap.isLocallyHomeomorph
 
-protected theorem isOpenMap (hf : IsCoveringMap f) : IsOpenMap f :=
+protected theorem isOpenMap : IsOpenMap f :=
   hf.isLocallyHomeomorph.isOpenMap
 #align is_covering_map.is_open_map IsCoveringMap.isOpenMap
 
-protected theorem quotientMap (hf : IsCoveringMap f) (hf' : Function.Surjective f) :
-    QuotientMap f :=
+protected theorem quotientMap (hf' : Function.Surjective f) : QuotientMap f :=
   hf.isOpenMap.to_quotientMap hf.continuous hf'
 #align is_covering_map.quotient_map IsCoveringMap.quotientMap
 
+protected theorem isSeparatedMap : IsSeparatedMap f :=
+  fun e₁ e₂ he hne ↦ by
+    obtain ⟨_, t, he₁⟩ := hf (f e₁)
+    have he₂ := he₁; simp_rw [he] at he₂; rw [← t.mem_source] at he₁ he₂
+    refine ⟨t.source ∩ (Prod.snd ∘ t) ⁻¹' {(t e₁).2}, t.source ∩ (Prod.snd ∘ t) ⁻¹' {(t e₂).2},
+      ?_, ?_, ⟨he₁, rfl⟩, ⟨he₂, rfl⟩, Set.disjoint_left.mpr fun x h₁ h₂ ↦ hne (t.injOn he₁ he₂ ?_)⟩
+    iterate 2
+      exact t.continuous_toFun.preimage_open_of_open t.open_source
+        (continuous_snd.isOpen_preimage _ <| isOpen_discrete _)
+    refine Prod.ext ?_ (h₁.2.symm.trans h₂.2)
+    rwa [t.proj_toFun e₁ he₁, t.proj_toFun e₂ he₂]
+
+variable {A} [TopologicalSpace A] {s : Set A} (hs : IsPreconnected s) {g g₁ g₂ : A → E}
+
+theorem eq_of_comp_eq [PreconnectedSpace A] (h₁ : Continuous g₁) (h₂ : Continuous g₂)
+    (he : f ∘ g₁ = f ∘ g₂) (a : A) (ha : g₁ a = g₂ a) : g₁ = g₂ :=
+  hf.isSeparatedMap.eq_of_comp_eq hf.isLocallyHomeomorph.isLocallyInjective h₁ h₂ he a ha
+
+theorem eqOn_of_comp_eqOn (h₁ : ContinuousOn g₁ s) (h₂ : ContinuousOn g₂ s)
+    (he : s.EqOn (f ∘ g₁) (f ∘ g₂)) {a : A} (has : a ∈ s) (ha : g₁ a = g₂ a) : s.EqOn g₁ g₂ :=
+  hf.isSeparatedMap.eqOn_of_comp_eqOn hf.isLocallyHomeomorph.isLocallyInjective hs h₁ h₂ he has ha
+
+theorem const_of_comp [PreconnectedSpace A] (cont : Continuous g)
+    (he : ∀ a a', f (g a) = f (g a')) (a a') : g a = g a' :=
+  hf.isSeparatedMap.const_of_comp hf.isLocallyHomeomorph.isLocallyInjective cont he a a'
+
+theorem constOn_of_comp (cont : ContinuousOn g s)
+    (he : ∀ a ∈ s, ∀ a' ∈ s, f (g a) = f (g a'))
+    {a a'} (ha : a ∈ s) (ha' : a' ∈ s) : g a = g a' :=
+  hf.isSeparatedMap.constOn_of_comp hf.isLocallyHomeomorph.isLocallyInjective hs cont he ha ha'
+
 end IsCoveringMap
 
 variable {f}

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

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

This has nice performance benefits.

32de3f67

Diff

@@ -26,10 +26,10 @@ This file defines covering maps.
 
 open Bundle
 
-variable {E X : Type _} [TopologicalSpace E] [TopologicalSpace X] (f : E → X) (s : Set X)
+variable {E X : Type*} [TopologicalSpace E] [TopologicalSpace X] (f : E → X) (s : Set X)
 
 /-- A point `x : X` is evenly covered by `f : E → X` if `x` has an evenly covered neighborhood. -/
-def IsEvenlyCovered (x : X) (I : Type _) [TopologicalSpace I] :=
+def IsEvenlyCovered (x : X) (I : Type*) [TopologicalSpace I] :=
   DiscreteTopology I ∧ ∃ t : Trivialization I f, x ∈ t.baseSet
 #align is_evenly_covered IsEvenlyCovered
 
@@ -38,18 +38,18 @@ namespace IsEvenlyCovered
 variable {f}
 
 /-- If `x` is evenly covered by `f`, then we can construct a trivialization of `f` at `x`. -/
-noncomputable def toTrivialization {x : X} {I : Type _} [TopologicalSpace I]
+noncomputable def toTrivialization {x : X} {I : Type*} [TopologicalSpace I]
     (h : IsEvenlyCovered f x I) : Trivialization (f ⁻¹' {x}) f :=
   (Classical.choose h.2).transFiberHomeomorph
     ((Classical.choose h.2).preimageSingletonHomeomorph (Classical.choose_spec h.2)).symm
 #align is_evenly_covered.to_trivialization IsEvenlyCovered.toTrivialization
 
-theorem mem_toTrivialization_baseSet {x : X} {I : Type _} [TopologicalSpace I]
+theorem mem_toTrivialization_baseSet {x : X} {I : Type*} [TopologicalSpace I]
     (h : IsEvenlyCovered f x I) : x ∈ h.toTrivialization.baseSet :=
   Classical.choose_spec h.2
 #align is_evenly_covered.mem_to_trivialization_base_set IsEvenlyCovered.mem_toTrivialization_baseSet
 
-theorem toTrivialization_apply {x : E} {I : Type _} [TopologicalSpace I]
+theorem toTrivialization_apply {x : E} {I : Type*} [TopologicalSpace I]
     (h : IsEvenlyCovered f (f x) I) : (h.toTrivialization x).2 = ⟨x, rfl⟩ :=
   let e := Classical.choose h.2
   let h := Classical.choose_spec h.2
@@ -60,13 +60,13 @@ theorem toTrivialization_apply {x : E} {I : Type _} [TopologicalSpace I]
         he.symm).symm
 #align is_evenly_covered.to_trivialization_apply IsEvenlyCovered.toTrivialization_apply
 
-protected theorem continuousAt {x : E} {I : Type _} [TopologicalSpace I]
+protected theorem continuousAt {x : E} {I : Type*} [TopologicalSpace I]
     (h : IsEvenlyCovered f (f x) I) : ContinuousAt f x :=
   let e := h.toTrivialization
   e.continuousAt_proj (e.mem_source.mpr (mem_toTrivialization_baseSet h))
 #align is_evenly_covered.continuous_at IsEvenlyCovered.continuousAt
 
-theorem to_isEvenlyCovered_preimage {x : X} {I : Type _} [TopologicalSpace I]
+theorem to_isEvenlyCovered_preimage {x : X} {I : Type*} [TopologicalSpace I]
     (h : IsEvenlyCovered f x I) : IsEvenlyCovered f x (f ⁻¹' {x}) :=
   let ⟨_, h2⟩ := h
   ⟨((Classical.choose h2).preimageSingletonHomeomorph
@@ -84,7 +84,7 @@ def IsCoveringMapOn :=
 
 namespace IsCoveringMapOn
 
-theorem mk (F : X → Type _) [∀ x, TopologicalSpace (F x)] [hF : ∀ x, DiscreteTopology (F x)]
+theorem mk (F : X → Type*) [∀ x, TopologicalSpace (F x)] [hF : ∀ x, DiscreteTopology (F x)]
     (e : ∀ x ∈ s, Trivialization (F x) f) (h : ∀ (x : X) (hx : x ∈ s), x ∈ (e x hx).baseSet) :
     IsCoveringMapOn f s := fun x hx =>
   IsEvenlyCovered.to_isEvenlyCovered_preimage ⟨hF x, e x hx, h x hx⟩
@@ -150,7 +150,7 @@ variable (f)
 
 namespace IsCoveringMap
 
-theorem mk (F : X → Type _) [∀ x, TopologicalSpace (F x)] [∀ x, DiscreteTopology (F x)]
+theorem mk (F : X → Type*) [∀ x, TopologicalSpace (F x)] [∀ x, DiscreteTopology (F x)]
     (e : ∀ x, Trivialization (F x) f) (h : ∀ x, x ∈ (e x).baseSet) : IsCoveringMap f :=
   isCoveringMap_iff_isCoveringMapOn_univ.mpr
     (IsCoveringMapOn.mk f Set.univ F (fun x _ => e x) fun x _ => h x)
@@ -179,13 +179,13 @@ end IsCoveringMap
 
 variable {f}
 
-protected theorem IsFiberBundle.isCoveringMap {F : Type _} [TopologicalSpace F] [DiscreteTopology F]
+protected theorem IsFiberBundle.isCoveringMap {F : Type*} [TopologicalSpace F] [DiscreteTopology F]
     (hf : ∀ x : X, ∃ e : Trivialization F f, x ∈ e.baseSet) : IsCoveringMap f :=
   IsCoveringMap.mk f (fun _ => F) (fun x => Classical.choose (hf x)) fun x =>
     Classical.choose_spec (hf x)
 #align is_fiber_bundle.is_covering_map IsFiberBundle.isCoveringMap
 
-protected theorem FiberBundle.isCoveringMap {F : Type _} {E : X → Type _} [TopologicalSpace F]
+protected theorem FiberBundle.isCoveringMap {F : Type*} {E : X → Type*} [TopologicalSpace F]
     [DiscreteTopology F] [TopologicalSpace (Bundle.TotalSpace F E)] [∀ x, TopologicalSpace (E x)]
     [FiberBundle F E] : IsCoveringMap (π F E) :=
   IsFiberBundle.isCoveringMap fun x => ⟨trivializationAt F E x, mem_baseSet_trivializationAt F E x⟩

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

depends on: #5966

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

89aa3a3b

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2022 Thomas Browning. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Thomas Browning
-
-! This file was ported from Lean 3 source module topology.covering
-! leanprover-community/mathlib commit e473c3198bb41f68560cab68a0529c854b618833
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Topology.IsLocallyHomeomorph
 import Mathlib.Topology.FiberBundle.Basic
 
+#align_import topology.covering from "leanprover-community/mathlib"@"e473c3198bb41f68560cab68a0529c854b618833"
+
 /-!
 # Covering Maps

refactor: redefine Bundle.TotalSpace (#5720)

Forward-port leanprover-community/mathlib#19221

5edb251a

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Thomas Browning
 
 ! This file was ported from Lean 3 source module topology.covering
-! leanprover-community/mathlib commit b8c810e2aac4a30bf8cda1e1c38d4f2e6065b2e7
+! leanprover-community/mathlib commit e473c3198bb41f68560cab68a0529c854b618833
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -189,7 +189,7 @@ protected theorem IsFiberBundle.isCoveringMap {F : Type _} [TopologicalSpace F]
 #align is_fiber_bundle.is_covering_map IsFiberBundle.isCoveringMap
 
 protected theorem FiberBundle.isCoveringMap {F : Type _} {E : X → Type _} [TopologicalSpace F]
-    [DiscreteTopology F] [TopologicalSpace (Bundle.TotalSpace E)] [∀ x, TopologicalSpace (E x)]
-    [FiberBundle F E] : IsCoveringMap (π E) :=
+    [DiscreteTopology F] [TopologicalSpace (Bundle.TotalSpace F E)] [∀ x, TopologicalSpace (E x)]
+    [FiberBundle F E] : IsCoveringMap (π F E) :=
   IsFiberBundle.isCoveringMap fun x => ⟨trivializationAt F E x, mem_baseSet_trivializationAt F E x⟩
 #align fiber_bundle.is_covering_map FiberBundle.isCoveringMap