topology.fiber_bundle.constructions | 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

@@ -37,23 +37,21 @@ namespace trivial
 
 variables (B : Type*) (F : Type*)
 
-instance [I : topological_space F] : ∀ x : B, topological_space (trivial B F x) := λ x, I
-
 instance [t₁ : topological_space B] [t₂ : topological_space F] :
-  topological_space (total_space (trivial B F)) :=
-induced total_space.proj t₁ ⊓ induced (trivial.proj_snd B F) t₂
+  topological_space (total_space F (trivial B F)) :=
+induced total_space.proj t₁ ⊓ induced (total_space.trivial_snd B F) t₂
 
 variables [topological_space B] [topological_space F]
 
 /-- Local trivialization for trivial bundle. -/
-def trivialization : trivialization F (π (bundle.trivial B F)) :=
-{ to_fun := λ x, (x.fst, x.snd),
+def trivialization : trivialization F (π F (λ _ : B, F)) :=
+{ to_fun := λ x, (x.proj, x.snd),
   inv_fun := λ y, ⟨y.fst, y.snd⟩,
   source := univ,
   target := univ,
-  map_source' := λ x h, mem_univ (x.fst, x.snd),
-  map_target' := λ y h,  mem_univ ⟨y.fst, y.snd⟩,
-  left_inv' := λ x h, sigma.eq rfl rfl,
+  map_source' := λ x h, mem_univ _,
+  map_target' := λ y h, mem_univ _,
+  left_inv' := λ x h, total_space.ext _ _ rfl heq.rfl,
   right_inv' := λ x h, prod.ext rfl rfl,
   open_source := is_open_univ,
   open_target := is_open_univ,
@@ -83,11 +81,10 @@ instance fiber_bundle : fiber_bundle F (bundle.trivial B F) :=
   total_space_mk_inducing := λ b, ⟨begin
     have : (λ (x : trivial B F b), x) = @id F, by { ext x, refl },
     simp only [total_space.topological_space, induced_inf, induced_compose, function.comp,
-      total_space.proj, induced_const, top_inf_eq, trivial.proj_snd, id.def,
-      trivial.topological_space, this, induced_id],
+      induced_const, top_inf_eq, total_space.trivial_snd, id.def, this, induced_id],
   end⟩ }
 
-lemma eq_trivialization (e : _root_.trivialization F (π (bundle.trivial B F)))
+lemma eq_trivialization (e : _root_.trivialization F (π F (bundle.trivial B F)))
   [i : mem_trivialization_atlas e] :
   e = trivialization B F :=
 i.out
@@ -102,21 +99,22 @@ section prod
 variables {B : Type*}
 
 section defs
-variables (E₁ : B → Type*) (E₂ : B → Type*)
-variables [topological_space (total_space E₁)] [topological_space (total_space E₂)]
+variables (F₁ : Type*) (E₁ : B → Type*) (F₂ : Type*) (E₂ : B → Type*)
+variables [topological_space (total_space F₁ E₁)] [topological_space (total_space F₂ E₂)]
 
 /-- Equip the total space of the fiberwise product of two fiber bundles `E₁`, `E₂` with
 the induced topology from the diagonal embedding into `total_space E₁ × total_space E₂`. -/
-instance fiber_bundle.prod.topological_space : topological_space (total_space (E₁ ×ᵇ E₂)) :=
+instance fiber_bundle.prod.topological_space :
+  topological_space (total_space (F₁ × F₂) (E₁ ×ᵇ E₂)) :=
 topological_space.induced
-  (λ p, ((⟨p.1, p.2.1⟩ : total_space E₁), (⟨p.1, p.2.2⟩ : total_space E₂)))
-  (by apply_instance : topological_space (total_space E₁ × total_space E₂))
+  (λ p, ((⟨p.1, p.2.1⟩ : total_space F₁ E₁), (⟨p.1, p.2.2⟩ : total_space F₂ E₂)))
+  (by apply_instance : topological_space (total_space F₁ E₁ × total_space F₂ E₂))
 
 /-- The diagonal map from the total space of the fiberwise product of two fiber bundles
 `E₁`, `E₂` into `total_space E₁ × total_space E₂` is `inducing`. -/
 lemma fiber_bundle.prod.inducing_diag : inducing
   (λ p, (⟨p.1, p.2.1⟩, ⟨p.1, p.2.2⟩) :
-    total_space (E₁ ×ᵇ E₂) → total_space E₁ × total_space E₂) :=
+    total_space (F₁ × F₂) (E₁ ×ᵇ E₂) → total_space F₁ E₁ × total_space F₂ E₂) :=
 ⟨rfl⟩
 
 end defs
@@ -124,28 +122,28 @@ end defs
 open fiber_bundle
 
 variables [topological_space B]
-  (F₁ : Type*) [topological_space F₁] (E₁ : B → Type*) [topological_space (total_space E₁)]
-  (F₂ : Type*) [topological_space F₂] (E₂ : B → Type*) [topological_space (total_space E₂)]
+  (F₁ : Type*) [topological_space F₁] (E₁ : B → Type*) [topological_space (total_space F₁ E₁)]
+  (F₂ : Type*) [topological_space F₂] (E₂ : B → Type*) [topological_space (total_space F₂ E₂)]
 
 namespace trivialization
-variables {F₁ E₁ F₂ E₂} (e₁ : trivialization F₁ (π E₁)) (e₂ : trivialization F₂ (π E₂))
+variables {F₁ E₁ F₂ E₂} (e₁ : trivialization F₁ (π F₁ E₁)) (e₂ : trivialization F₂ (π F₂ E₂))
 
 /-- Given trivializations `e₁`, `e₂` for fiber bundles `E₁`, `E₂` over a base `B`, the forward
 function for the construction `trivialization.prod`, the induced
 trivialization for the fiberwise product of `E₁` and `E₂`. -/
-def prod.to_fun' : total_space (E₁ ×ᵇ E₂) → B × (F₁ × F₂) :=
+def prod.to_fun' : total_space (F₁ × F₂) (E₁ ×ᵇ E₂) → B × (F₁ × F₂) :=
 λ p, ⟨p.1, (e₁ ⟨p.1, p.2.1⟩).2, (e₂ ⟨p.1, p.2.2⟩).2⟩
 
 variables {e₁ e₂}
 
-lemma prod.continuous_to_fun : continuous_on (prod.to_fun' e₁ e₂)
-  (@total_space.proj B (E₁ ×ᵇ E₂) ⁻¹' (e₁.base_set ∩ e₂.base_set)) :=
+lemma prod.continuous_to_fun :
+  continuous_on (prod.to_fun' e₁ e₂) (π (F₁ × F₂) (E₁ ×ᵇ E₂) ⁻¹' (e₁.base_set ∩ e₂.base_set)) :=
 begin
-  let f₁ : total_space (E₁ ×ᵇ E₂) → total_space E₁ × total_space E₂ :=
-    λ p, ((⟨p.1, p.2.1⟩ : total_space E₁), (⟨p.1, p.2.2⟩ : total_space E₂)),
-  let f₂ : total_space E₁ × total_space E₂ → (B × F₁) × (B × F₂) := λ p, ⟨e₁ p.1, e₂ p.2⟩,
+  let f₁ : total_space (F₁ × F₂) (E₁ ×ᵇ E₂) → total_space F₁ E₁ × total_space F₂ E₂ :=
+    λ p, ((⟨p.1, p.2.1⟩ : total_space F₁ E₁), (⟨p.1, p.2.2⟩ : total_space F₂ E₂)),
+  let f₂ : total_space F₁ E₁ × total_space F₂ E₂ → (B × F₁) × (B × F₂) := λ p, ⟨e₁ p.1, e₂ p.2⟩,
   let f₃ : (B × F₁) × (B × F₂) → B × F₁ × F₂ := λ p, ⟨p.1.1, p.1.2, p.2.2⟩,
-  have hf₁ : continuous f₁ := (prod.inducing_diag E₁ E₂).continuous,
+  have hf₁ : continuous f₁ := (prod.inducing_diag F₁ E₁ F₂ E₂).continuous,
   have hf₂ : continuous_on f₂ (e₁.source ×ˢ e₂.source) :=
     e₁.to_local_homeomorph.continuous_on.prod_map e₂.to_local_homeomorph.continuous_on,
   have hf₃ : continuous f₃ :=
@@ -165,18 +163,19 @@ variables (e₁ e₂) [Π x, has_zero (E₁ x)] [∀ x, has_zero (E₂ x)]
 /-- Given trivializations `e₁`, `e₂` for fiber bundles `E₁`, `E₂` over a base `B`, the inverse
 function for the construction `trivialization.prod`, the induced
 trivialization for the fiberwise product of `E₁` and `E₂`. -/
-noncomputable def prod.inv_fun' (p : B × (F₁ × F₂)) : total_space (E₁ ×ᵇ E₂) :=
+noncomputable def prod.inv_fun' (p : B × (F₁ × F₂)) : total_space (F₁ × F₂) (E₁ ×ᵇ E₂) :=
 ⟨p.1, e₁.symm p.1 p.2.1, e₂.symm p.1 p.2.2⟩
 
 variables {e₁ e₂}
 
-lemma prod.left_inv {x : total_space (E₁ ×ᵇ E₂)}
-  (h : x ∈ @total_space.proj B (E₁ ×ᵇ E₂) ⁻¹' (e₁.base_set ∩ e₂.base_set)) :
+lemma prod.left_inv {x : total_space (F₁ × F₂) (E₁ ×ᵇ E₂)}
+  (h : x ∈ π (F₁ × F₂) (E₁ ×ᵇ E₂) ⁻¹' (e₁.base_set ∩ e₂.base_set)) :
   prod.inv_fun' e₁ e₂ (prod.to_fun' e₁ e₂ x) = x :=
 begin
   obtain ⟨x, v₁, v₂⟩ := x,
   obtain ⟨h₁ : x ∈ e₁.base_set, h₂ : x ∈ e₂.base_set⟩ := h,
-  simp only [prod.to_fun', prod.inv_fun', symm_apply_apply_mk, h₁, h₂]
+  simp only [prod.to_fun', prod.inv_fun', symm_apply_apply_mk, h₁, h₂,
+    eq_self_iff_true, heq_iff_eq, and_self]
 end
 
 lemma prod.right_inv {x : B × F₁ × F₂}
@@ -191,22 +190,22 @@ end
 lemma prod.continuous_inv_fun :
   continuous_on (prod.inv_fun' e₁ e₂) ((e₁.base_set ∩ e₂.base_set) ×ˢ univ) :=
 begin
-  rw (prod.inducing_diag E₁ E₂).continuous_on_iff,
+  rw (prod.inducing_diag F₁ E₁ F₂ E₂).continuous_on_iff,
   have H₁ : continuous (λ p : B × F₁ × F₂, ((p.1, p.2.1), (p.1, p.2.2))) :=
     (continuous_id.prod_map continuous_fst).prod_mk (continuous_id.prod_map continuous_snd),
   refine (e₁.continuous_on_symm.prod_map e₂.continuous_on_symm).comp H₁.continuous_on _,
   exact λ x h, ⟨⟨h.1.1, mem_univ _⟩, ⟨h.1.2, mem_univ _⟩⟩
 end
 
-variables (e₁ e₂ e₁ e₂)
+variables (e₁ e₂)
 
 /-- Given trivializations `e₁`, `e₂` for bundle types `E₁`, `E₂` over a base `B`, the induced
 trivialization for the fiberwise product of `E₁` and `E₂`, whose base set is
 `e₁.base_set ∩ e₂.base_set`. -/
-noncomputable def prod : trivialization (F₁ × F₂) (π (E₁ ×ᵇ E₂)) :=
+noncomputable def prod : trivialization (F₁ × F₂) (π (F₁ × F₂) (E₁ ×ᵇ E₂)) :=
 { to_fun := prod.to_fun' e₁ e₂,
   inv_fun := prod.inv_fun' e₁ e₂,
-  source := (@total_space.proj B (E₁ ×ᵇ E₂)) ⁻¹' (e₁.base_set ∩ e₂.base_set),
+  source := (π (F₁ × F₂) (E₁ ×ᵇ E₂)) ⁻¹' (e₁.base_set ∩ e₂.base_set),
   target := (e₁.base_set ∩ e₂.base_set) ×ˢ set.univ,
   map_source' := λ x h, ⟨h, set.mem_univ _⟩,
   map_target' := λ x h, h.1,
@@ -214,7 +213,7 @@ noncomputable def prod : trivialization (F₁ × F₂) (π (E₁ ×ᵇ E₂)) :=
   right_inv' := λ x, prod.right_inv,
   open_source := begin
     convert (e₁.open_source.prod e₂.open_source).preimage
-      (fiber_bundle.prod.inducing_diag E₁ E₂).continuous,
+      (fiber_bundle.prod.inducing_diag F₁ E₁ F₂ E₂).continuous,
     ext x,
     simp only [trivialization.source_eq] with mfld_simps,
   end,
@@ -230,8 +229,8 @@ noncomputable def prod : trivialization (F₁ × F₂) (π (E₁ ×ᵇ E₂)) :=
 @[simp] lemma base_set_prod : (prod e₁ e₂).base_set = e₁.base_set ∩ e₂.base_set :=
 rfl
 
-lemma prod_symm_apply (x : B) (w₁ : F₁) (w₂ : F₂) : (prod e₁ e₂).to_local_equiv.symm (x, w₁, w₂)
-  = ⟨x, e₁.symm x w₁, e₂.symm x w₂⟩ :=
+lemma prod_symm_apply (x : B) (w₁ : F₁) (w₂ : F₂) :
+  (prod e₁ e₂).to_local_equiv.symm (x, w₁, w₂) = ⟨x, e₁.symm x w₁, e₂.symm x w₂⟩ :=
 rfl
 
 end trivialization
@@ -246,11 +245,11 @@ variables [Π x, has_zero (E₁ x)] [∀ x, has_zero (E₂ x)]
 noncomputable instance fiber_bundle.prod : fiber_bundle (F₁ × F₂) (E₁ ×ᵇ E₂) :=
 { total_space_mk_inducing := λ b,
   begin
-    rw (prod.inducing_diag E₁ E₂).inducing_iff,
+    rw (prod.inducing_diag F₁ E₁ F₂ E₂).inducing_iff,
     exact (total_space_mk_inducing F₁ E₁ b).prod_mk (total_space_mk_inducing F₂ E₂ b),
   end,
   trivialization_atlas :=
-    {e |  ∃ (e₁ : trivialization F₁ (π E₁)) (e₂ : trivialization F₂ (π E₂))
+    {e |  ∃ (e₁ : trivialization F₁ (π F₁ E₁)) (e₂ : trivialization F₂ (π F₂ E₂))
     [mem_trivialization_atlas e₁] [mem_trivialization_atlas e₂], by exactI
     e = trivialization.prod e₁ e₂},
   trivialization_at := λ b, (trivialization_at F₁ E₁ b).prod (trivialization_at F₂ E₂ b),
@@ -259,9 +258,9 @@ noncomputable instance fiber_bundle.prod : fiber_bundle (F₁ × F₂) (E₁ ×
   trivialization_mem_atlas := λ b, ⟨trivialization_at F₁ E₁ b, trivialization_at F₂ E₂ b,
     by apply_instance, by apply_instance, rfl⟩ }
 
-instance {e₁ : trivialization F₁ (π E₁)} {e₂ : trivialization F₂ (π E₂)}
+instance {e₁ : trivialization F₁ (π F₁ E₁)} {e₂ : trivialization F₂ (π F₂ E₂)}
   [mem_trivialization_atlas e₁] [mem_trivialization_atlas e₂] :
-  mem_trivialization_atlas (e₁.prod e₂ : trivialization (F₁ × F₂) (π (E₁ ×ᵇ E₂))) :=
+  mem_trivialization_atlas (e₁.prod e₂ : trivialization (F₁ × F₂) (π (F₁ × F₂) (E₁ ×ᵇ E₂))) :=
 { out := ⟨e₁, e₂, by apply_instance, by apply_instance, rfl⟩ }
 
 end prod
@@ -274,32 +273,32 @@ variables {B : Type*} (F : Type*) (E : B → Type*) {B' : Type*} (f : B' → B)
 instance [∀ (x : B), topological_space (E x)] : ∀ (x : B'), topological_space ((f *ᵖ E) x) :=
 by delta_instance bundle.pullback
 
-variables [topological_space B'] [topological_space (total_space E)]
+variables [topological_space B'] [topological_space (total_space F E)]
 
 /-- Definition of `pullback.total_space.topological_space`, which we make irreducible. -/
-@[irreducible] def pullback_topology : topological_space (total_space (f *ᵖ E)) :=
+@[irreducible] def pullback_topology : topological_space (total_space F (f *ᵖ E)) :=
 induced total_space.proj ‹topological_space B'› ⊓
-induced (pullback.lift f) ‹topological_space (total_space E)›
+induced (pullback.lift f) ‹topological_space (total_space F E)›
 
 /-- The topology on the total space of a pullback bundle is the coarsest topology for which both
 the projections to the base and the map to the original bundle are continuous. -/
-instance pullback.total_space.topological_space : topological_space (total_space (f *ᵖ E)) :=
-pullback_topology E f
+instance pullback.total_space.topological_space : topological_space (total_space F (f *ᵖ E)) :=
+pullback_topology F E f
 
-lemma pullback.continuous_proj (f : B' → B) : continuous (@total_space.proj _ (f *ᵖ E)) :=
+lemma pullback.continuous_proj (f : B' → B) : continuous (π F (f *ᵖ E)) :=
 begin
   rw [continuous_iff_le_induced, pullback.total_space.topological_space, pullback_topology],
   exact inf_le_left,
 end
 
-lemma pullback.continuous_lift (f : B' → B) : continuous (@pullback.lift B E B' f) :=
+lemma pullback.continuous_lift (f : B' → B) : continuous (@pullback.lift B F E B' f) :=
 begin
   rw [continuous_iff_le_induced, pullback.total_space.topological_space, pullback_topology],
   exact inf_le_right,
 end
 
 lemma inducing_pullback_total_space_embedding (f : B' → B) :
-  inducing (@pullback_total_space_embedding B E B' f) :=
+  inducing (@pullback_total_space_embedding B F E B' f) :=
 begin
   constructor,
   simp_rw [prod.topological_space, induced_inf, induced_compose,
@@ -312,44 +311,42 @@ variables (F) [topological_space F] [topological_space B]
 
 lemma pullback.continuous_total_space_mk [∀ x, topological_space (E x)]
   [fiber_bundle F E] {f : B' → B} {x : B'} :
-  continuous (@total_space_mk _ (f *ᵖ E) x) :=
+  continuous (@total_space.mk _ F (f *ᵖ E) x) :=
 begin
   simp only [continuous_iff_le_induced, pullback.total_space.topological_space, induced_compose,
-    induced_inf, function.comp, total_space_mk, total_space.proj, induced_const, top_inf_eq,
-    pullback_topology],
+    induced_inf, function.comp, induced_const, top_inf_eq, pullback_topology],
   exact le_of_eq (fiber_bundle.total_space_mk_inducing F E (f x)).induced,
 end
 
 variables {E F} [∀ b, has_zero (E b)] {K : Type*} [continuous_map_class K B' B]
 
 /-- A fiber bundle trivialization can be pulled back to a trivialization on the pullback bundle. -/
-noncomputable def trivialization.pullback (e : trivialization F (π E)) (f : K) :
-  trivialization F (π ((f : B' → B) *ᵖ E)) :=
+noncomputable def trivialization.pullback (e : trivialization F (π F E)) (f : K) :
+  trivialization F (π F ((f : B' → B) *ᵖ E)) :=
 { to_fun := λ z, (z.proj, (e (pullback.lift f z)).2),
-  inv_fun := λ y, @total_space_mk _ (f *ᵖ E) y.1 (e.symm (f y.1) y.2),
+  inv_fun := λ y, @total_space.mk _ _ (f *ᵖ E) y.1 (e.symm (f y.1) y.2),
   source := pullback.lift f ⁻¹' e.source,
   base_set := f ⁻¹' e.base_set,
   target := (f ⁻¹' e.base_set) ×ˢ univ,
-  map_source' := λ x h, by { simp_rw [e.source_eq, mem_preimage, pullback.proj_lift] at h,
+  map_source' := λ x h, by { simp_rw [e.source_eq, mem_preimage, pullback.lift_proj] at h,
     simp_rw [prod_mk_mem_set_prod_eq, mem_univ, and_true, mem_preimage, h] },
   map_target' := λ y h, by { rw [mem_prod, mem_preimage] at h,
-    simp_rw [e.source_eq, mem_preimage, pullback.proj_lift, h.1] },
-  left_inv' := λ x h, by { simp_rw [mem_preimage, e.mem_source, pullback.proj_lift] at h,
+    simp_rw [e.source_eq, mem_preimage, pullback.lift_proj, h.1] },
+  left_inv' := λ x h, by { simp_rw [mem_preimage, e.mem_source, pullback.lift_proj] at h,
     simp_rw [pullback.lift, e.symm_apply_apply_mk h, total_space.eta] },
   right_inv' := λ x h, by { simp_rw [mem_prod, mem_preimage, mem_univ, and_true] at h,
-    simp_rw [total_space.proj_mk, pullback.lift_mk, e.apply_mk_symm h, prod.mk.eta] },
+    simp_rw [pullback.lift_mk, e.apply_mk_symm h, prod.mk.eta] },
   open_source := by { simp_rw [e.source_eq, ← preimage_comp], exact ((map_continuous f).comp $
-    pullback.continuous_proj E f).is_open_preimage _ e.open_base_set },
+    pullback.continuous_proj F E f).is_open_preimage _ e.open_base_set },
   open_target := ((map_continuous f).is_open_preimage _ e.open_base_set).prod is_open_univ,
   open_base_set := (map_continuous f).is_open_preimage _ e.open_base_set,
-  continuous_to_fun := (pullback.continuous_proj E f).continuous_on.prod
+  continuous_to_fun := (pullback.continuous_proj F E f).continuous_on.prod
     (continuous_snd.comp_continuous_on $
-    e.continuous_on.comp (pullback.continuous_lift E f).continuous_on subset.rfl),
+    e.continuous_on.comp (pullback.continuous_lift F E f).continuous_on subset.rfl),
   continuous_inv_fun := begin
     dsimp only,
-    simp_rw [(inducing_pullback_total_space_embedding E f).continuous_on_iff, function.comp,
-      pullback_total_space_embedding, total_space.proj_mk],
-    dsimp only [total_space.proj_mk],
+    simp_rw [(inducing_pullback_total_space_embedding F E f).continuous_on_iff, function.comp,
+      pullback_total_space_embedding],
     refine continuous_on_fst.prod (e.continuous_on_symm.comp
       ((map_continuous f).prod_map continuous_id).continuous_on subset.rfl)
   end,
@@ -360,10 +357,10 @@ noncomputable def trivialization.pullback (e : trivialization F (π E)) (f : K)
 noncomputable instance fiber_bundle.pullback [∀ x, topological_space (E x)]
   [fiber_bundle F E] (f : K) : fiber_bundle F ((f : B' → B) *ᵖ E) :=
 { total_space_mk_inducing := λ x, inducing_of_inducing_compose
-    (pullback.continuous_total_space_mk F E) (pullback.continuous_lift E f)
+    (pullback.continuous_total_space_mk F E) (pullback.continuous_lift F E f)
     (total_space_mk_inducing F E (f x)),
   trivialization_atlas :=
-    {ef | ∃ (e : trivialization F (π E)) [mem_trivialization_atlas e], ef = e.pullback f},
+    {ef | ∃ (e : trivialization F (π F E)) [mem_trivialization_atlas e], ef = e.pullback f},
   trivialization_at := λ x, (trivialization_at F E (f x)).pullback f,
   mem_base_set_trivialization_at := λ x, mem_base_set_trivialization_at F E (f x),
   trivialization_mem_atlas := λ x, ⟨trivialization_at F E (f x), by apply_instance, rfl⟩ }

(first ported)

Changes in mathlib3port

mathlib3

mathlib3port

bump to nightly-2024-03-17-08

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

22f01ce4

Diff

@@ -421,17 +421,16 @@ noncomputable def Trivialization.pullback (e : Trivialization F (π F E)) (f : K
   target := (f ⁻¹' e.baseSet) ×ˢ univ
   map_source' x h :=
     by
-    simp_rw [e.source_eq, mem_preimage, pullback.lift_proj] at h 
+    simp_rw [e.source_eq, mem_preimage, pullback.lift_proj] at h
     simp_rw [prod_mk_mem_set_prod_eq, mem_univ, and_true_iff, mem_preimage, h]
   map_target' y h := by
-    rw [mem_prod, mem_preimage] at h 
+    rw [mem_prod, mem_preimage] at h
     simp_rw [e.source_eq, mem_preimage, pullback.lift_proj, h.1]
   left_inv' x h := by
-    simp_rw [mem_preimage, e.mem_source, pullback.lift_proj] at h 
+    simp_rw [mem_preimage, e.mem_source, pullback.lift_proj] at h
     simp_rw [pullback.lift, e.symm_apply_apply_mk h, total_space.eta]
-  right_inv' x h :=
-    by
-    simp_rw [mem_prod, mem_preimage, mem_univ, and_true_iff] at h 
+  right_inv' x h := by
+    simp_rw [mem_prod, mem_preimage, mem_univ, and_true_iff] at h
     simp_rw [pullback.lift_mk, e.apply_mk_symm h, Prod.mk.eta]
   open_source := by simp_rw [e.source_eq, ← preimage_comp];
     exact

bump to nightly-2023-12-14-06

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

a154f5e6

Diff

@@ -298,7 +298,7 @@ theorem baseSet_prod : (prod e₁ e₂).baseSet = e₁.baseSet ∩ e₂.baseSet
 
 #print Trivialization.prod_symm_apply /-
 theorem prod_symm_apply (x : B) (w₁ : F₁) (w₂ : F₂) :
-    (prod e₁ e₂).toLocalEquiv.symm (x, w₁, w₂) = ⟨x, e₁.symm x w₁, e₂.symm x w₂⟩ :=
+    (prod e₁ e₂).toPartialEquiv.symm (x, w₁, w₂) = ⟨x, e₁.symm x w₁, e₂.symm x w₂⟩ :=
   rfl
 #align trivialization.prod_symm_apply Trivialization.prod_symm_apply
 -/

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,7 +3,7 @@ Copyright © 2022 Nicolò Cavalleri. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Nicolò Cavalleri, Sébastien Gouëzel, Heather Macbeth, Floris van Doorn
 -/
-import Mathbin.Topology.FiberBundle.Basic
+import Topology.FiberBundle.Basic
 
 #align_import topology.fiber_bundle.constructions 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,14 +2,11 @@
 Copyright © 2022 Nicolò Cavalleri. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Nicolò Cavalleri, Sébastien Gouëzel, Heather Macbeth, Floris van Doorn
-
-! This file was ported from Lean 3 source module topology.fiber_bundle.constructions
-! 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.FiberBundle.Basic
 
+#align_import topology.fiber_bundle.constructions from "leanprover-community/mathlib"@"e473c3198bb41f68560cab68a0529c854b618833"
+
 /-!
 # Standard constructions on fiber bundles

bump to nightly-2023-07-06-11

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

a2f50eda

Diff

@@ -106,7 +106,7 @@ instance fiberBundle : FiberBundle F (Bundle.Trivial B F)
   trivializationAt x := Bundle.Trivial.trivialization B F
   mem_baseSet_trivializationAt := mem_univ
   trivialization_mem_atlas x := mem_singleton _
-  totalSpaceₓ_mk_inducing b :=
+  totalSpace_mk_inducing b :=
     ⟨by
       have : (fun x : trivial B F b => x) = @id F := by ext x; rfl
       simp only [total_space.topological_space, induced_inf, induced_compose, Function.comp,
@@ -317,7 +317,7 @@ variable [∀ x, Zero (E₁ x)] [∀ x, Zero (E₂ x)] [∀ x : B, TopologicalSp
 /-- The product of two fiber bundles is a fiber bundle. -/
 noncomputable instance FiberBundle.prod : FiberBundle (F₁ × F₂) (E₁ ×ᵇ E₂)
     where
-  totalSpaceₓ_mk_inducing b :=
+  totalSpace_mk_inducing b :=
     by
     rw [(prod.inducing_diag F₁ E₁ F₂ E₂).inducing_iff]
     exact (total_space_mk_inducing F₁ E₁ b).prod_mk (total_space_mk_inducing F₂ E₂ b)
@@ -463,7 +463,7 @@ noncomputable def Trivialization.pullback (e : Trivialization F (π F E)) (f : K
 noncomputable instance FiberBundle.pullback [∀ x, TopologicalSpace (E x)] [FiberBundle F E]
     (f : K) : FiberBundle F ((f : B' → B) *ᵖ E)
     where
-  totalSpaceₓ_mk_inducing x :=
+  totalSpace_mk_inducing x :=
     inducing_of_inducing_compose (Pullback.continuous_totalSpaceMk F E)
       (Pullback.continuous_lift F E f) (totalSpace_mk_inducing F E (f x))
   trivializationAtlas :=

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: Nicolò Cavalleri, Sébastien Gouëzel, Heather Macbeth, Floris van Doorn
 
 ! This file was ported from Lean 3 source module topology.fiber_bundle.constructions
-! leanprover-community/mathlib commit 33c67ae661dd8988516ff7f247b0be3018cdd952
+! leanprover-community/mathlib commit e473c3198bb41f68560cab68a0529c854b618833
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -47,25 +47,23 @@ namespace trivial
 
 variable (B : Type _) (F : Type _)
 
-instance [I : TopologicalSpace F] : ∀ x : B, TopologicalSpace (Trivial B F x) := fun x => I
-
 instance [t₁ : TopologicalSpace B] [t₂ : TopologicalSpace F] :
-    TopologicalSpace (TotalSpace (Trivial B F)) :=
-  induced TotalSpace.proj t₁ ⊓ induced (Trivial.projSnd B F) t₂
+    TopologicalSpace (TotalSpace F (Trivial B F)) :=
+  induced TotalSpace.proj t₁ ⊓ induced (TotalSpace.trivialSnd B F) t₂
 
 variable [TopologicalSpace B] [TopologicalSpace F]
 
 #print Bundle.Trivial.trivialization /-
 /-- Local trivialization for trivial bundle. -/
-def trivialization : Trivialization F (π (Bundle.Trivial B F))
+def trivialization : Trivialization F (π F fun _ : B => F)
     where
-  toFun x := (x.fst, x.snd)
+  toFun x := (x.proj, x.snd)
   invFun y := ⟨y.fst, y.snd⟩
   source := univ
   target := univ
-  map_source' x h := mem_univ (x.fst, x.snd)
-  map_target' y h := mem_univ ⟨y.fst, y.snd⟩
-  left_inv' x h := Sigma.eq rfl rfl
+  map_source' x h := mem_univ _
+  map_target' y h := mem_univ _
+  left_inv' x h := TotalSpace.ext _ _ rfl HEq.rfl
   right_inv' x h := Prod.ext rfl rfl
   open_source := isOpen_univ
   open_target := isOpen_univ
@@ -108,17 +106,16 @@ instance fiberBundle : FiberBundle F (Bundle.Trivial B F)
   trivializationAt x := Bundle.Trivial.trivialization B F
   mem_baseSet_trivializationAt := mem_univ
   trivialization_mem_atlas x := mem_singleton _
-  totalSpaceMk_inducing b :=
+  totalSpaceₓ_mk_inducing b :=
     ⟨by
       have : (fun x : trivial B F b => x) = @id F := by ext x; rfl
       simp only [total_space.topological_space, induced_inf, induced_compose, Function.comp,
-        total_space.proj, induced_const, top_inf_eq, trivial.proj_snd, id.def,
-        trivial.topological_space, this, induced_id]⟩
+        induced_const, top_inf_eq, total_space.trivial_snd, id.def, this, induced_id]⟩
 #align bundle.trivial.fiber_bundle Bundle.Trivial.fiberBundle
 -/
 
 #print Bundle.Trivial.eq_trivialization /-
-theorem eq_trivialization (e : Trivialization F (π (Bundle.Trivial B F)))
+theorem eq_trivialization (e : Trivialization F (π F (Bundle.Trivial B F)))
     [i : MemTrivializationAtlas e] : e = trivialization B F :=
   i.out
 #align bundle.trivial.eq_trivialization Bundle.Trivial.eq_trivialization
@@ -137,17 +134,17 @@ variable {B : Type _}
 
 section Defs
 
-variable (E₁ : B → Type _) (E₂ : B → Type _)
+variable (F₁ : Type _) (E₁ : B → Type _) (F₂ : Type _) (E₂ : B → Type _)
 
-variable [TopologicalSpace (TotalSpace E₁)] [TopologicalSpace (TotalSpace E₂)]
+variable [TopologicalSpace (TotalSpace F₁ E₁)] [TopologicalSpace (TotalSpace F₂ E₂)]
 
 #print FiberBundle.Prod.topologicalSpace /-
 /-- Equip the total space of the fiberwise product of two fiber bundles `E₁`, `E₂` with
 the induced topology from the diagonal embedding into `total_space E₁ × total_space E₂`. -/
-instance FiberBundle.Prod.topologicalSpace : TopologicalSpace (TotalSpace (E₁ ×ᵇ E₂)) :=
+instance FiberBundle.Prod.topologicalSpace : TopologicalSpace (TotalSpace (F₁ × F₂) (E₁ ×ᵇ E₂)) :=
   TopologicalSpace.induced
-    (fun p => ((⟨p.1, p.2.1⟩ : TotalSpace E₁), (⟨p.1, p.2.2⟩ : TotalSpace E₂)))
-    (by infer_instance : TopologicalSpace (TotalSpace E₁ × TotalSpace E₂))
+    (fun p => ((⟨p.1, p.2.1⟩ : TotalSpace F₁ E₁), (⟨p.1, p.2.2⟩ : TotalSpace F₂ E₂)))
+    (by infer_instance : TopologicalSpace (TotalSpace F₁ E₁ × TotalSpace F₂ E₂))
 #align fiber_bundle.prod.topological_space FiberBundle.Prod.topologicalSpace
 -/
 
@@ -157,7 +154,7 @@ instance FiberBundle.Prod.topologicalSpace : TopologicalSpace (TotalSpace (E₁
 theorem FiberBundle.Prod.inducing_diag :
     Inducing
       (fun p => (⟨p.1, p.2.1⟩, ⟨p.1, p.2.2⟩) :
-        TotalSpace (E₁ ×ᵇ E₂) → TotalSpace E₁ × TotalSpace E₂) :=
+        TotalSpace (F₁ × F₂) (E₁ ×ᵇ E₂) → TotalSpace F₁ E₁ × TotalSpace F₂ E₂) :=
   ⟨rfl⟩
 #align fiber_bundle.prod.inducing_diag FiberBundle.Prod.inducing_diag
 -/
@@ -167,18 +164,18 @@ end Defs
 open FiberBundle
 
 variable [TopologicalSpace B] (F₁ : Type _) [TopologicalSpace F₁] (E₁ : B → Type _)
-  [TopologicalSpace (TotalSpace E₁)] (F₂ : Type _) [TopologicalSpace F₂] (E₂ : B → Type _)
-  [TopologicalSpace (TotalSpace E₂)]
+  [TopologicalSpace (TotalSpace F₁ E₁)] (F₂ : Type _) [TopologicalSpace F₂] (E₂ : B → Type _)
+  [TopologicalSpace (TotalSpace F₂ E₂)]
 
 namespace Trivialization
 
-variable {F₁ E₁ F₂ E₂} (e₁ : Trivialization F₁ (π E₁)) (e₂ : Trivialization F₂ (π E₂))
+variable {F₁ E₁ F₂ E₂} (e₁ : Trivialization F₁ (π F₁ E₁)) (e₂ : Trivialization F₂ (π F₂ E₂))
 
 #print Trivialization.Prod.toFun' /-
 /-- Given trivializations `e₁`, `e₂` for fiber bundles `E₁`, `E₂` over a base `B`, the forward
 function for the construction `trivialization.prod`, the induced
 trivialization for the fiberwise product of `E₁` and `E₂`. -/
-def Prod.toFun' : TotalSpace (E₁ ×ᵇ E₂) → B × F₁ × F₂ := fun p =>
+def Prod.toFun' : TotalSpace (F₁ × F₂) (E₁ ×ᵇ E₂) → B × F₁ × F₂ := fun p =>
   ⟨p.1, (e₁ ⟨p.1, p.2.1⟩).2, (e₂ ⟨p.1, p.2.2⟩).2⟩
 #align trivialization.prod.to_fun' Trivialization.Prod.toFun'
 -/
@@ -188,14 +185,13 @@ variable {e₁ e₂}
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 #print Trivialization.Prod.continuous_to_fun /-
 theorem Prod.continuous_to_fun :
-    ContinuousOn (Prod.toFun' e₁ e₂)
-      (@TotalSpace.proj B (E₁ ×ᵇ E₂) ⁻¹' (e₁.baseSet ∩ e₂.baseSet)) :=
+    ContinuousOn (Prod.toFun' e₁ e₂) (π (F₁ × F₂) (E₁ ×ᵇ E₂) ⁻¹' (e₁.baseSet ∩ e₂.baseSet)) :=
   by
-  let f₁ : total_space (E₁ ×ᵇ E₂) → total_space E₁ × total_space E₂ := fun p =>
-    ((⟨p.1, p.2.1⟩ : total_space E₁), (⟨p.1, p.2.2⟩ : total_space E₂))
-  let f₂ : total_space E₁ × total_space E₂ → (B × F₁) × B × F₂ := fun p => ⟨e₁ p.1, e₂ p.2⟩
+  let f₁ : total_space (F₁ × F₂) (E₁ ×ᵇ E₂) → total_space F₁ E₁ × total_space F₂ E₂ := fun p =>
+    ((⟨p.1, p.2.1⟩ : total_space F₁ E₁), (⟨p.1, p.2.2⟩ : total_space F₂ E₂))
+  let f₂ : total_space F₁ E₁ × total_space F₂ E₂ → (B × F₁) × B × F₂ := fun p => ⟨e₁ p.1, e₂ p.2⟩
   let f₃ : (B × F₁) × B × F₂ → B × F₁ × F₂ := fun p => ⟨p.1.1, p.1.2, p.2.2⟩
-  have hf₁ : Continuous f₁ := (prod.inducing_diag E₁ E₂).Continuous
+  have hf₁ : Continuous f₁ := (prod.inducing_diag F₁ E₁ F₂ E₂).Continuous
   have hf₂ : ContinuousOn f₂ (e₁.source ×ˢ e₂.source) :=
     e₁.to_local_homeomorph.continuous_on.prod_map e₂.to_local_homeomorph.continuous_on
   have hf₃ : Continuous f₃ :=
@@ -217,7 +213,7 @@ variable (e₁ e₂) [∀ x, Zero (E₁ x)] [∀ x, Zero (E₂ x)]
 /-- Given trivializations `e₁`, `e₂` for fiber bundles `E₁`, `E₂` over a base `B`, the inverse
 function for the construction `trivialization.prod`, the induced
 trivialization for the fiberwise product of `E₁` and `E₂`. -/
-noncomputable def Prod.invFun' (p : B × F₁ × F₂) : TotalSpace (E₁ ×ᵇ E₂) :=
+noncomputable def Prod.invFun' (p : B × F₁ × F₂) : TotalSpace (F₁ × F₂) (E₁ ×ᵇ E₂) :=
   ⟨p.1, e₁.symm p.1 p.2.1, e₂.symm p.1 p.2.2⟩
 #align trivialization.prod.inv_fun' Trivialization.Prod.invFun'
 -/
@@ -225,13 +221,14 @@ noncomputable def Prod.invFun' (p : B × F₁ × F₂) : TotalSpace (E₁ ×ᵇ
 variable {e₁ e₂}
 
 #print Trivialization.Prod.left_inv /-
-theorem Prod.left_inv {x : TotalSpace (E₁ ×ᵇ E₂)}
-    (h : x ∈ @TotalSpace.proj B (E₁ ×ᵇ E₂) ⁻¹' (e₁.baseSet ∩ e₂.baseSet)) :
+theorem Prod.left_inv {x : TotalSpace (F₁ × F₂) (E₁ ×ᵇ E₂)}
+    (h : x ∈ π (F₁ × F₂) (E₁ ×ᵇ E₂) ⁻¹' (e₁.baseSet ∩ e₂.baseSet)) :
     Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x :=
   by
   obtain ⟨x, v₁, v₂⟩ := x
   obtain ⟨h₁ : x ∈ e₁.base_set, h₂ : x ∈ e₂.base_set⟩ := h
-  simp only [prod.to_fun', prod.inv_fun', symm_apply_apply_mk, h₁, h₂]
+  simp only [prod.to_fun', prod.inv_fun', symm_apply_apply_mk, h₁, h₂, eq_self_iff_true, heq_iff_eq,
+    and_self_iff]
 #align trivialization.prod.left_inv Trivialization.Prod.left_inv
 -/
 
@@ -252,7 +249,7 @@ theorem Prod.right_inv {x : B × F₁ × F₂}
 theorem Prod.continuous_inv_fun :
     ContinuousOn (Prod.invFun' e₁ e₂) ((e₁.baseSet ∩ e₂.baseSet) ×ˢ univ) :=
   by
-  rw [(prod.inducing_diag E₁ E₂).continuousOn_iff]
+  rw [(prod.inducing_diag F₁ E₁ F₂ E₂).continuousOn_iff]
   have H₁ : Continuous fun p : B × F₁ × F₂ => ((p.1, p.2.1), (p.1, p.2.2)) :=
     (continuous_id.prod_map continuous_fst).prod_mk (continuous_id.prod_map continuous_snd)
   refine' (e₁.continuous_on_symm.prod_map e₂.continuous_on_symm).comp H₁.continuous_on _
@@ -260,18 +257,18 @@ theorem Prod.continuous_inv_fun :
 #align trivialization.prod.continuous_inv_fun Trivialization.Prod.continuous_inv_fun
 -/
 
-variable (e₁ e₂ e₁ e₂)
+variable (e₁ e₂)
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 #print Trivialization.prod /-
 /-- Given trivializations `e₁`, `e₂` for bundle types `E₁`, `E₂` over a base `B`, the induced
 trivialization for the fiberwise product of `E₁` and `E₂`, whose base set is
 `e₁.base_set ∩ e₂.base_set`. -/
-noncomputable def prod : Trivialization (F₁ × F₂) (π (E₁ ×ᵇ E₂))
+noncomputable def prod : Trivialization (F₁ × F₂) (π (F₁ × F₂) (E₁ ×ᵇ E₂))
     where
   toFun := Prod.toFun' e₁ e₂
   invFun := Prod.invFun' e₁ e₂
-  source := @TotalSpace.proj B (E₁ ×ᵇ E₂) ⁻¹' (e₁.baseSet ∩ e₂.baseSet)
+  source := π (F₁ × F₂) (E₁ ×ᵇ E₂) ⁻¹' (e₁.baseSet ∩ e₂.baseSet)
   target := (e₁.baseSet ∩ e₂.baseSet) ×ˢ Set.univ
   map_source' x h := ⟨h, Set.mem_univ _⟩
   map_target' x h := h.1
@@ -281,7 +278,7 @@ noncomputable def prod : Trivialization (F₁ × F₂) (π (E₁ ×ᵇ E₂))
     by
     convert
       (e₁.open_source.prod e₂.open_source).Preimage
-        (FiberBundle.Prod.inducing_diag E₁ E₂).Continuous
+        (FiberBundle.Prod.inducing_diag F₁ E₁ F₂ E₂).Continuous
     ext x
     simp only [Trivialization.source_eq, mfld_simps]
   open_target := (e₁.open_baseSet.inter e₂.open_baseSet).Prod isOpen_univ
@@ -320,13 +317,13 @@ variable [∀ x, Zero (E₁ x)] [∀ x, Zero (E₂ x)] [∀ x : B, TopologicalSp
 /-- The product of two fiber bundles is a fiber bundle. -/
 noncomputable instance FiberBundle.prod : FiberBundle (F₁ × F₂) (E₁ ×ᵇ E₂)
     where
-  totalSpaceMk_inducing b :=
+  totalSpaceₓ_mk_inducing b :=
     by
-    rw [(prod.inducing_diag E₁ E₂).inducing_iff]
+    rw [(prod.inducing_diag F₁ E₁ F₂ E₂).inducing_iff]
     exact (total_space_mk_inducing F₁ E₁ b).prod_mk (total_space_mk_inducing F₂ E₂ b)
   trivializationAtlas :=
     {e |
-      ∃ (e₁ : Trivialization F₁ (π E₁)) (e₂ : Trivialization F₂ (π E₂)) (_ :
+      ∃ (e₁ : Trivialization F₁ (π F₁ E₁)) (e₂ : Trivialization F₂ (π F₂ E₂)) (_ :
         MemTrivializationAtlas e₁) (_ : MemTrivializationAtlas e₂), e = Trivialization.prod e₁ e₂}
   trivializationAt b := (trivializationAt F₁ E₁ b).Prod (trivializationAt F₂ E₂ b)
   mem_baseSet_trivializationAt b :=
@@ -336,9 +333,9 @@ noncomputable instance FiberBundle.prod : FiberBundle (F₁ × F₂) (E₁ ×ᵇ
 #align fiber_bundle.prod FiberBundle.prod
 -/
 
-instance {e₁ : Trivialization F₁ (π E₁)} {e₂ : Trivialization F₂ (π E₂)} [MemTrivializationAtlas e₁]
-    [MemTrivializationAtlas e₂] :
-    MemTrivializationAtlas (e₁.Prod e₂ : Trivialization (F₁ × F₂) (π (E₁ ×ᵇ E₂)))
+instance {e₁ : Trivialization F₁ (π F₁ E₁)} {e₂ : Trivialization F₂ (π F₂ E₂)}
+    [MemTrivializationAtlas e₁] [MemTrivializationAtlas e₂] :
+    MemTrivializationAtlas (e₁.Prod e₂ : Trivialization (F₁ × F₂) (π (F₁ × F₂) (E₁ ×ᵇ E₂)))
     where out := ⟨e₁, e₂, by infer_instance, by infer_instance, rfl⟩
 
 end Prod
@@ -353,26 +350,26 @@ variable {B : Type _} (F : Type _) (E : B → Type _) {B' : Type _} (f : B' →
 instance [∀ x : B, TopologicalSpace (E x)] : ∀ x : B', TopologicalSpace ((f *ᵖ E) x) := by
   delta_instance bundle.pullback
 
-variable [TopologicalSpace B'] [TopologicalSpace (TotalSpace E)]
+variable [TopologicalSpace B'] [TopologicalSpace (TotalSpace F E)]
 
 #print pullbackTopology /-
 /-- Definition of `pullback.total_space.topological_space`, which we make irreducible. -/
-irreducible_def pullbackTopology : TopologicalSpace (TotalSpace (f *ᵖ E)) :=
+irreducible_def pullbackTopology : TopologicalSpace (TotalSpace F (f *ᵖ E)) :=
   induced TotalSpace.proj ‹TopologicalSpace B'› ⊓
-    induced (Pullback.lift f) ‹TopologicalSpace (TotalSpace E)›
+    induced (Pullback.lift f) ‹TopologicalSpace (TotalSpace F E)›
 #align pullback_topology pullbackTopology
 -/
 
 #print Pullback.TotalSpace.topologicalSpace /-
 /-- The topology on the total space of a pullback bundle is the coarsest topology for which both
 the projections to the base and the map to the original bundle are continuous. -/
-instance Pullback.TotalSpace.topologicalSpace : TopologicalSpace (TotalSpace (f *ᵖ E)) :=
-  pullbackTopology E f
+instance Pullback.TotalSpace.topologicalSpace : TopologicalSpace (TotalSpace F (f *ᵖ E)) :=
+  pullbackTopology F E f
 #align pullback.total_space.topological_space Pullback.TotalSpace.topologicalSpace
 -/
 
 #print Pullback.continuous_proj /-
-theorem Pullback.continuous_proj (f : B' → B) : Continuous (@TotalSpace.proj _ (f *ᵖ E)) :=
+theorem Pullback.continuous_proj (f : B' → B) : Continuous (π F (f *ᵖ E)) :=
   by
   rw [continuous_iff_le_induced, Pullback.TotalSpace.topologicalSpace, pullbackTopology]
   exact inf_le_left
@@ -380,7 +377,7 @@ theorem Pullback.continuous_proj (f : B' → B) : Continuous (@TotalSpace.proj _
 -/
 
 #print Pullback.continuous_lift /-
-theorem Pullback.continuous_lift (f : B' → B) : Continuous (@Pullback.lift B E B' f) :=
+theorem Pullback.continuous_lift (f : B' → B) : Continuous (@Pullback.lift B F E B' f) :=
   by
   rw [continuous_iff_le_induced, Pullback.TotalSpace.topologicalSpace, pullbackTopology]
   exact inf_le_right
@@ -389,7 +386,7 @@ theorem Pullback.continuous_lift (f : B' → B) : Continuous (@Pullback.lift B E
 
 #print inducing_pullbackTotalSpaceEmbedding /-
 theorem inducing_pullbackTotalSpaceEmbedding (f : B' → B) :
-    Inducing (@pullbackTotalSpaceEmbedding B E B' f) :=
+    Inducing (@pullbackTotalSpaceEmbedding B F E B' f) :=
   by
   constructor
   simp_rw [Prod.topologicalSpace, induced_inf, induced_compose,
@@ -404,12 +401,11 @@ variable (F) [TopologicalSpace F] [TopologicalSpace B]
 
 #print Pullback.continuous_totalSpaceMk /-
 theorem Pullback.continuous_totalSpaceMk [∀ x, TopologicalSpace (E x)] [FiberBundle F E]
-    {f : B' → B} {x : B'} : Continuous (@totalSpaceMk _ (f *ᵖ E) x) :=
+    {f : B' → B} {x : B'} : Continuous (@TotalSpace.mk _ F (f *ᵖ E) x) :=
   by
   simp only [continuous_iff_le_induced, Pullback.TotalSpace.topologicalSpace, induced_compose,
-    induced_inf, Function.comp, total_space_mk, total_space.proj, induced_const, top_inf_eq,
-    pullbackTopology]
-  exact le_of_eq (FiberBundle.totalSpaceMk_inducing F E (f x)).induced
+    induced_inf, Function.comp, induced_const, top_inf_eq, pullbackTopology]
+  exact le_of_eq (FiberBundle.totalSpace_mk_inducing F E (f x)).induced
 #align pullback.continuous_total_space_mk Pullback.continuous_totalSpaceMk
 -/
 
@@ -418,42 +414,41 @@ variable {E F} [∀ b, Zero (E b)] {K : Type _} [ContinuousMapClass K B' B]
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 #print Trivialization.pullback /-
 /-- A fiber bundle trivialization can be pulled back to a trivialization on the pullback bundle. -/
-noncomputable def Trivialization.pullback (e : Trivialization F (π E)) (f : K) :
-    Trivialization F (π ((f : B' → B) *ᵖ E))
+noncomputable def Trivialization.pullback (e : Trivialization F (π F E)) (f : K) :
+    Trivialization F (π F ((f : B' → B) *ᵖ E))
     where
   toFun z := (z.proj, (e (Pullback.lift f z)).2)
-  invFun y := @totalSpaceMk _ (f *ᵖ E) y.1 (e.symm (f y.1) y.2)
+  invFun y := @TotalSpace.mk _ _ (f *ᵖ E) y.1 (e.symm (f y.1) y.2)
   source := Pullback.lift f ⁻¹' e.source
   baseSet := f ⁻¹' e.baseSet
   target := (f ⁻¹' e.baseSet) ×ˢ univ
   map_source' x h :=
     by
-    simp_rw [e.source_eq, mem_preimage, pullback.proj_lift] at h 
+    simp_rw [e.source_eq, mem_preimage, pullback.lift_proj] at h 
     simp_rw [prod_mk_mem_set_prod_eq, mem_univ, and_true_iff, mem_preimage, h]
   map_target' y h := by
     rw [mem_prod, mem_preimage] at h 
-    simp_rw [e.source_eq, mem_preimage, pullback.proj_lift, h.1]
+    simp_rw [e.source_eq, mem_preimage, pullback.lift_proj, h.1]
   left_inv' x h := by
-    simp_rw [mem_preimage, e.mem_source, pullback.proj_lift] at h 
+    simp_rw [mem_preimage, e.mem_source, pullback.lift_proj] at h 
     simp_rw [pullback.lift, e.symm_apply_apply_mk h, total_space.eta]
   right_inv' x h :=
     by
     simp_rw [mem_prod, mem_preimage, mem_univ, and_true_iff] at h 
-    simp_rw [total_space.proj_mk, pullback.lift_mk, e.apply_mk_symm h, Prod.mk.eta]
+    simp_rw [pullback.lift_mk, e.apply_mk_symm h, Prod.mk.eta]
   open_source := by simp_rw [e.source_eq, ← preimage_comp];
     exact
-      ((map_continuous f).comp <| Pullback.continuous_proj E f).isOpen_preimage _ e.open_base_set
+      ((map_continuous f).comp <| Pullback.continuous_proj F E f).isOpen_preimage _ e.open_base_set
   open_target := ((map_continuous f).isOpen_preimage _ e.open_baseSet).Prod isOpen_univ
   open_baseSet := (map_continuous f).isOpen_preimage _ e.open_baseSet
   continuous_toFun :=
-    (Pullback.continuous_proj E f).ContinuousOn.Prod
+    (Pullback.continuous_proj F E f).ContinuousOn.Prod
       (continuous_snd.comp_continuousOn <|
-        e.ContinuousOn.comp (Pullback.continuous_lift E f).ContinuousOn Subset.rfl)
+        e.ContinuousOn.comp (Pullback.continuous_lift F E f).ContinuousOn Subset.rfl)
   continuous_invFun := by
     dsimp only
-    simp_rw [(inducing_pullbackTotalSpaceEmbedding E f).continuousOn_iff, Function.comp,
-      pullback_total_space_embedding, total_space.proj_mk]
-    dsimp only [total_space.proj_mk]
+    simp_rw [(inducing_pullbackTotalSpaceEmbedding F E f).continuousOn_iff, Function.comp,
+      pullback_total_space_embedding]
     refine'
       continuous_on_fst.prod
         (e.continuous_on_symm.comp ((map_continuous f).Prod_map continuous_id).ContinuousOn
@@ -468,11 +463,11 @@ noncomputable def Trivialization.pullback (e : Trivialization F (π E)) (f : K)
 noncomputable instance FiberBundle.pullback [∀ x, TopologicalSpace (E x)] [FiberBundle F E]
     (f : K) : FiberBundle F ((f : B' → B) *ᵖ E)
     where
-  totalSpaceMk_inducing x :=
+  totalSpaceₓ_mk_inducing x :=
     inducing_of_inducing_compose (Pullback.continuous_totalSpaceMk F E)
-      (Pullback.continuous_lift E f) (totalSpaceMk_inducing F E (f x))
+      (Pullback.continuous_lift F E f) (totalSpace_mk_inducing F E (f x))
   trivializationAtlas :=
-    {ef | ∃ (e : Trivialization F (π E)) (_ : MemTrivializationAtlas e), ef = e.Pullback f}
+    {ef | ∃ (e : Trivialization F (π F E)) (_ : MemTrivializationAtlas e), ef = e.Pullback f}
   trivializationAt x := (trivializationAt F E (f x)).Pullback f
   mem_baseSet_trivializationAt x := mem_baseSet_trivializationAt F E (f x)
   trivialization_mem_atlas x := ⟨trivializationAt F E (f x), by infer_instance, rfl⟩

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -86,15 +86,19 @@ def trivialization : Trivialization F (π (Bundle.Trivial B F))
 #align bundle.trivial.trivialization Bundle.Trivial.trivialization
 -/
 
+#print Bundle.Trivial.trivialization_source /-
 @[simp]
 theorem trivialization_source : (trivialization B F).source = univ :=
   rfl
 #align bundle.trivial.trivialization_source Bundle.Trivial.trivialization_source
+-/
 
+#print Bundle.Trivial.trivialization_target /-
 @[simp]
 theorem trivialization_target : (trivialization B F).target = univ :=
   rfl
 #align bundle.trivial.trivialization_target Bundle.Trivial.trivialization_target
+-/
 
 #print Bundle.Trivial.fiberBundle /-
 /-- Fiber bundle instance on the trivial bundle. -/
@@ -113,10 +117,12 @@ instance fiberBundle : FiberBundle F (Bundle.Trivial B F)
 #align bundle.trivial.fiber_bundle Bundle.Trivial.fiberBundle
 -/
 
+#print Bundle.Trivial.eq_trivialization /-
 theorem eq_trivialization (e : Trivialization F (π (Bundle.Trivial B F)))
     [i : MemTrivializationAtlas e] : e = trivialization B F :=
   i.out
 #align bundle.trivial.eq_trivialization Bundle.Trivial.eq_trivialization
+-/
 
 end trivial
 
@@ -145,6 +151,7 @@ instance FiberBundle.Prod.topologicalSpace : TopologicalSpace (TotalSpace (E₁
 #align fiber_bundle.prod.topological_space FiberBundle.Prod.topologicalSpace
 -/
 
+#print FiberBundle.Prod.inducing_diag /-
 /-- The diagonal map from the total space of the fiberwise product of two fiber bundles
 `E₁`, `E₂` into `total_space E₁ × total_space E₂` is `inducing`. -/
 theorem FiberBundle.Prod.inducing_diag :
@@ -153,6 +160,7 @@ theorem FiberBundle.Prod.inducing_diag :
         TotalSpace (E₁ ×ᵇ E₂) → TotalSpace E₁ × TotalSpace E₂) :=
   ⟨rfl⟩
 #align fiber_bundle.prod.inducing_diag FiberBundle.Prod.inducing_diag
+-/
 
 end Defs
 
@@ -178,6 +186,7 @@ def Prod.toFun' : TotalSpace (E₁ ×ᵇ E₂) → B × F₁ × F₂ := fun p =>
 variable {e₁ e₂}
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Trivialization.Prod.continuous_to_fun /-
 theorem Prod.continuous_to_fun :
     ContinuousOn (Prod.toFun' e₁ e₂)
       (@TotalSpace.proj B (E₁ ×ᵇ E₂) ⁻¹' (e₁.baseSet ∩ e₂.baseSet)) :=
@@ -200,6 +209,7 @@ theorem Prod.continuous_to_fun :
   rw [e₁.source_eq, mem_preimage]
   exact hb₁
 #align trivialization.prod.continuous_to_fun Trivialization.Prod.continuous_to_fun
+-/
 
 variable (e₁ e₂) [∀ x, Zero (E₁ x)] [∀ x, Zero (E₂ x)]
 
@@ -214,6 +224,7 @@ noncomputable def Prod.invFun' (p : B × F₁ × F₂) : TotalSpace (E₁ ×ᵇ
 
 variable {e₁ e₂}
 
+#print Trivialization.Prod.left_inv /-
 theorem Prod.left_inv {x : TotalSpace (E₁ ×ᵇ E₂)}
     (h : x ∈ @TotalSpace.proj B (E₁ ×ᵇ E₂) ⁻¹' (e₁.baseSet ∩ e₂.baseSet)) :
     Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x :=
@@ -222,8 +233,10 @@ theorem Prod.left_inv {x : TotalSpace (E₁ ×ᵇ E₂)}
   obtain ⟨h₁ : x ∈ e₁.base_set, h₂ : x ∈ e₂.base_set⟩ := h
   simp only [prod.to_fun', prod.inv_fun', symm_apply_apply_mk, h₁, h₂]
 #align trivialization.prod.left_inv Trivialization.Prod.left_inv
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Trivialization.Prod.right_inv /-
 theorem Prod.right_inv {x : B × F₁ × F₂}
     (h : x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ (univ : Set (F₁ × F₂))) :
     Prod.toFun' e₁ e₂ (Prod.invFun' e₁ e₂ x) = x :=
@@ -232,8 +245,10 @@ theorem Prod.right_inv {x : B × F₁ × F₂}
   obtain ⟨⟨h₁ : x ∈ e₁.base_set, h₂ : x ∈ e₂.base_set⟩, -⟩ := h
   simp only [prod.to_fun', prod.inv_fun', apply_mk_symm, h₁, h₂]
 #align trivialization.prod.right_inv Trivialization.Prod.right_inv
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Trivialization.Prod.continuous_inv_fun /-
 theorem Prod.continuous_inv_fun :
     ContinuousOn (Prod.invFun' e₁ e₂) ((e₁.baseSet ∩ e₂.baseSet) ×ˢ univ) :=
   by
@@ -243,10 +258,12 @@ theorem Prod.continuous_inv_fun :
   refine' (e₁.continuous_on_symm.prod_map e₂.continuous_on_symm).comp H₁.continuous_on _
   exact fun x h => ⟨⟨h.1.1, mem_univ _⟩, ⟨h.1.2, mem_univ _⟩⟩
 #align trivialization.prod.continuous_inv_fun Trivialization.Prod.continuous_inv_fun
+-/
 
 variable (e₁ e₂ e₁ e₂)
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Trivialization.prod /-
 /-- Given trivializations `e₁`, `e₂` for bundle types `E₁`, `E₂` over a base `B`, the induced
 trivialization for the fiberwise product of `E₁` and `E₂`, whose base set is
 `e₁.base_set ∩ e₂.base_set`. -/
@@ -276,16 +293,21 @@ noncomputable def prod : Trivialization (F₁ × F₂) (π (E₁ ×ᵇ E₂))
   target_eq := rfl
   proj_toFun x h := rfl
 #align trivialization.prod Trivialization.prod
+-/
 
+#print Trivialization.baseSet_prod /-
 @[simp]
 theorem baseSet_prod : (prod e₁ e₂).baseSet = e₁.baseSet ∩ e₂.baseSet :=
   rfl
 #align trivialization.base_set_prod Trivialization.baseSet_prod
+-/
 
+#print Trivialization.prod_symm_apply /-
 theorem prod_symm_apply (x : B) (w₁ : F₁) (w₂ : F₂) :
     (prod e₁ e₂).toLocalEquiv.symm (x, w₁, w₂) = ⟨x, e₁.symm x w₁, e₂.symm x w₂⟩ :=
   rfl
 #align trivialization.prod_symm_apply Trivialization.prod_symm_apply
+-/
 
 end Trivialization
 
@@ -294,6 +316,7 @@ open Trivialization
 variable [∀ x, Zero (E₁ x)] [∀ x, Zero (E₂ x)] [∀ x : B, TopologicalSpace (E₁ x)]
   [∀ x : B, TopologicalSpace (E₂ x)] [FiberBundle F₁ E₁] [FiberBundle F₂ E₂]
 
+#print FiberBundle.prod /-
 /-- The product of two fiber bundles is a fiber bundle. -/
 noncomputable instance FiberBundle.prod : FiberBundle (F₁ × F₂) (E₁ ×ᵇ E₂)
     where
@@ -311,6 +334,7 @@ noncomputable instance FiberBundle.prod : FiberBundle (F₁ × F₂) (E₁ ×ᵇ
   trivialization_mem_atlas b :=
     ⟨trivializationAt F₁ E₁ b, trivializationAt F₂ E₂ b, by infer_instance, by infer_instance, rfl⟩
 #align fiber_bundle.prod FiberBundle.prod
+-/
 
 instance {e₁ : Trivialization F₁ (π E₁)} {e₂ : Trivialization F₂ (π E₂)} [MemTrivializationAtlas e₁]
     [MemTrivializationAtlas e₂] :
@@ -363,6 +387,7 @@ theorem Pullback.continuous_lift (f : B' → B) : Continuous (@Pullback.lift B E
 #align pullback.continuous_lift Pullback.continuous_lift
 -/
 
+#print inducing_pullbackTotalSpaceEmbedding /-
 theorem inducing_pullbackTotalSpaceEmbedding (f : B' → B) :
     Inducing (@pullbackTotalSpaceEmbedding B E B' f) :=
   by
@@ -371,6 +396,7 @@ theorem inducing_pullbackTotalSpaceEmbedding (f : B' → B) :
     Pullback.TotalSpace.topologicalSpace, pullbackTopology]
   rfl
 #align inducing_pullback_total_space_embedding inducing_pullbackTotalSpaceEmbedding
+-/
 
 section FiberBundle

bump to nightly-2023-06-04-18

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

3fb4268b

Diff

@@ -262,7 +262,8 @@ noncomputable def prod : Trivialization (F₁ × F₂) (π (E₁ ×ᵇ E₂))
   right_inv' x := Prod.right_inv
   open_source :=
     by
-    convert(e₁.open_source.prod e₂.open_source).Preimage
+    convert
+      (e₁.open_source.prod e₂.open_source).Preimage
         (FiberBundle.Prod.inducing_diag E₁ E₂).Continuous
     ext x
     simp only [Trivialization.source_eq, mfld_simps]
@@ -301,9 +302,9 @@ noncomputable instance FiberBundle.prod : FiberBundle (F₁ × F₂) (E₁ ×ᵇ
     rw [(prod.inducing_diag E₁ E₂).inducing_iff]
     exact (total_space_mk_inducing F₁ E₁ b).prod_mk (total_space_mk_inducing F₂ E₂ b)
   trivializationAtlas :=
-    { e |
+    {e |
       ∃ (e₁ : Trivialization F₁ (π E₁)) (e₂ : Trivialization F₂ (π E₂)) (_ :
-        MemTrivializationAtlas e₁) (_ : MemTrivializationAtlas e₂), e = Trivialization.prod e₁ e₂ }
+        MemTrivializationAtlas e₁) (_ : MemTrivializationAtlas e₂), e = Trivialization.prod e₁ e₂}
   trivializationAt b := (trivializationAt F₁ E₁ b).Prod (trivializationAt F₂ E₂ b)
   mem_baseSet_trivializationAt b :=
     ⟨mem_baseSet_trivializationAt F₁ E₁ b, mem_baseSet_trivializationAt F₂ E₂ b⟩
@@ -445,7 +446,7 @@ noncomputable instance FiberBundle.pullback [∀ x, TopologicalSpace (E x)] [Fib
     inducing_of_inducing_compose (Pullback.continuous_totalSpaceMk F E)
       (Pullback.continuous_lift E f) (totalSpaceMk_inducing F E (f x))
   trivializationAtlas :=
-    { ef | ∃ (e : Trivialization F (π E)) (_ : MemTrivializationAtlas e), ef = e.Pullback f }
+    {ef | ∃ (e : Trivialization F (π E)) (_ : MemTrivializationAtlas e), ef = e.Pullback f}
   trivializationAt x := (trivializationAt F E (f x)).Pullback f
   mem_baseSet_trivializationAt x := mem_baseSet_trivializationAt F E (f x)
   trivialization_mem_atlas x := ⟨trivializationAt F E (f x), by infer_instance, rfl⟩

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -302,8 +302,8 @@ noncomputable instance FiberBundle.prod : FiberBundle (F₁ × F₂) (E₁ ×ᵇ
     exact (total_space_mk_inducing F₁ E₁ b).prod_mk (total_space_mk_inducing F₂ E₂ b)
   trivializationAtlas :=
     { e |
-      ∃ (e₁ : Trivialization F₁ (π E₁))(e₂ : Trivialization F₂ (π E₂))(_ :
-        MemTrivializationAtlas e₁)(_ : MemTrivializationAtlas e₂), e = Trivialization.prod e₁ e₂ }
+      ∃ (e₁ : Trivialization F₁ (π E₁)) (e₂ : Trivialization F₂ (π E₂)) (_ :
+        MemTrivializationAtlas e₁) (_ : MemTrivializationAtlas e₂), e = Trivialization.prod e₁ e₂ }
   trivializationAt b := (trivializationAt F₁ E₁ b).Prod (trivializationAt F₂ E₂ b)
   mem_baseSet_trivializationAt b :=
     ⟨mem_baseSet_trivializationAt F₁ E₁ b, mem_baseSet_trivializationAt F₂ E₂ b⟩
@@ -401,16 +401,17 @@ noncomputable def Trivialization.pullback (e : Trivialization F (π E)) (f : K)
   target := (f ⁻¹' e.baseSet) ×ˢ univ
   map_source' x h :=
     by
-    simp_rw [e.source_eq, mem_preimage, pullback.proj_lift] at h
+    simp_rw [e.source_eq, mem_preimage, pullback.proj_lift] at h 
     simp_rw [prod_mk_mem_set_prod_eq, mem_univ, and_true_iff, mem_preimage, h]
   map_target' y h := by
-    rw [mem_prod, mem_preimage] at h
+    rw [mem_prod, mem_preimage] at h 
     simp_rw [e.source_eq, mem_preimage, pullback.proj_lift, h.1]
   left_inv' x h := by
-    simp_rw [mem_preimage, e.mem_source, pullback.proj_lift] at h
+    simp_rw [mem_preimage, e.mem_source, pullback.proj_lift] at h 
     simp_rw [pullback.lift, e.symm_apply_apply_mk h, total_space.eta]
-  right_inv' x h := by
-    simp_rw [mem_prod, mem_preimage, mem_univ, and_true_iff] at h
+  right_inv' x h :=
+    by
+    simp_rw [mem_prod, mem_preimage, mem_univ, and_true_iff] at h 
     simp_rw [total_space.proj_mk, pullback.lift_mk, e.apply_mk_symm h, Prod.mk.eta]
   open_source := by simp_rw [e.source_eq, ← preimage_comp];
     exact
@@ -444,7 +445,7 @@ noncomputable instance FiberBundle.pullback [∀ x, TopologicalSpace (E x)] [Fib
     inducing_of_inducing_compose (Pullback.continuous_totalSpaceMk F E)
       (Pullback.continuous_lift E f) (totalSpaceMk_inducing F E (f x))
   trivializationAtlas :=
-    { ef | ∃ (e : Trivialization F (π E))(_ : MemTrivializationAtlas e), ef = e.Pullback f }
+    { ef | ∃ (e : Trivialization F (π E)) (_ : MemTrivializationAtlas e), ef = e.Pullback f }
   trivializationAt x := (trivializationAt F E (f x)).Pullback f
   mem_baseSet_trivializationAt x := mem_baseSet_trivializationAt F E (f x)
   trivialization_mem_atlas x := ⟨trivializationAt F E (f x), by infer_instance, rfl⟩

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -36,7 +36,7 @@ fiber bundle, fibre bundle, fiberwise product, pullback
 
 open TopologicalSpace Filter Set Bundle
 
-open Topology Classical Bundle
+open scoped Topology Classical Bundle
 
 /-! ### The trivial bundle -/

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -86,23 +86,11 @@ def trivialization : Trivialization F (π (Bundle.Trivial B F))
 #align bundle.trivial.trivialization Bundle.Trivial.trivialization
 -/
 
-/- warning: bundle.trivial.trivialization_source -> Bundle.Trivial.trivialization_source is a dubious translation:
-lean 3 declaration is
-  forall (B : Type.{u1}) (F : Type.{u2}) [_inst_1 : TopologicalSpace.{u1} B] [_inst_2 : TopologicalSpace.{u2} F], Eq.{succ (max u1 u2)} (Set.{max u1 u2} (Bundle.TotalSpace.{u1, u2} B (Bundle.Trivial.{u1, u2} B F))) (LocalEquiv.source.{max u1 u2, max u1 u2} (Bundle.TotalSpace.{u1, u2} B (Bundle.Trivial.{u1, u2} B F)) (Prod.{u1, u2} B F) (LocalHomeomorph.toLocalEquiv.{max u1 u2, max u1 u2} (Bundle.TotalSpace.{u1, u2} B (Bundle.Trivial.{u1, u2} B F)) (Prod.{u1, u2} B F) (Bundle.Trivial.Bundle.TotalSpace.topologicalSpace.{u1, u2} B F _inst_1 _inst_2) (Prod.topologicalSpace.{u1, u2} B F _inst_1 _inst_2) (Trivialization.toLocalHomeomorph.{u1, u2, max u1 u2} B F (Bundle.TotalSpace.{u1, u2} B (Bundle.Trivial.{u1, u2} B F)) _inst_1 _inst_2 (Bundle.Trivial.Bundle.TotalSpace.topologicalSpace.{u1, u2} B F _inst_1 _inst_2) (Bundle.TotalSpace.proj.{u1, u2} B (Bundle.Trivial.{u1, u2} B F)) (Bundle.Trivial.trivialization.{u1, u2} B F _inst_1 _inst_2)))) (Set.univ.{max u1 u2} (Bundle.TotalSpace.{u1, u2} B (Bundle.Trivial.{u1, u2} B F)))
-but is expected to have type
-  forall (B : Type.{u2}) (F : Type.{u1}) [_inst_1 : TopologicalSpace.{u2} B] [_inst_2 : TopologicalSpace.{u1} F], Eq.{max (succ u2) (succ u1)} (Set.{max u2 u1} (Bundle.TotalSpace.{u2, u1} B (Bundle.Trivial.{u2, u1} B F))) (LocalEquiv.source.{max u2 u1, max u2 u1} (Bundle.TotalSpace.{u2, u1} B (Bundle.Trivial.{u2, u1} B F)) (Prod.{u2, u1} B F) (LocalHomeomorph.toLocalEquiv.{max u2 u1, max u2 u1} (Bundle.TotalSpace.{u2, u1} B (Bundle.Trivial.{u2, u1} B F)) (Prod.{u2, u1} B F) (Bundle.Trivial.Bundle.TotalSpace.topologicalSpace.{u2, u1} B F _inst_1 _inst_2) (instTopologicalSpaceProd.{u2, u1} B F _inst_1 _inst_2) (Trivialization.toLocalHomeomorph.{u2, u1, max u2 u1} B F (Bundle.TotalSpace.{u2, u1} B (Bundle.Trivial.{u2, u1} B F)) _inst_1 _inst_2 (Bundle.Trivial.Bundle.TotalSpace.topologicalSpace.{u2, u1} B F _inst_1 _inst_2) (Bundle.TotalSpace.proj.{u2, u1} B (Bundle.Trivial.{u2, u1} B F)) (Bundle.Trivial.trivialization.{u2, u1} B F _inst_1 _inst_2)))) (Set.univ.{max u2 u1} (Bundle.TotalSpace.{u2, u1} B (Bundle.Trivial.{u2, u1} B F)))
-Case conversion may be inaccurate. Consider using '#align bundle.trivial.trivialization_source Bundle.Trivial.trivialization_sourceₓ'. -/
 @[simp]
 theorem trivialization_source : (trivialization B F).source = univ :=
   rfl
 #align bundle.trivial.trivialization_source Bundle.Trivial.trivialization_source
 
-/- warning: bundle.trivial.trivialization_target -> Bundle.Trivial.trivialization_target is a dubious translation:
-lean 3 declaration is
-  forall (B : Type.{u1}) (F : Type.{u2}) [_inst_1 : TopologicalSpace.{u1} B] [_inst_2 : TopologicalSpace.{u2} F], Eq.{succ (max u1 u2)} (Set.{max u1 u2} (Prod.{u1, u2} B F)) (LocalEquiv.target.{max u1 u2, max u1 u2} (Bundle.TotalSpace.{u1, u2} B (Bundle.Trivial.{u1, u2} B F)) (Prod.{u1, u2} B F) (LocalHomeomorph.toLocalEquiv.{max u1 u2, max u1 u2} (Bundle.TotalSpace.{u1, u2} B (Bundle.Trivial.{u1, u2} B F)) (Prod.{u1, u2} B F) (Bundle.Trivial.Bundle.TotalSpace.topologicalSpace.{u1, u2} B F _inst_1 _inst_2) (Prod.topologicalSpace.{u1, u2} B F _inst_1 _inst_2) (Trivialization.toLocalHomeomorph.{u1, u2, max u1 u2} B F (Bundle.TotalSpace.{u1, u2} B (Bundle.Trivial.{u1, u2} B F)) _inst_1 _inst_2 (Bundle.Trivial.Bundle.TotalSpace.topologicalSpace.{u1, u2} B F _inst_1 _inst_2) (Bundle.TotalSpace.proj.{u1, u2} B (Bundle.Trivial.{u1, u2} B F)) (Bundle.Trivial.trivialization.{u1, u2} B F _inst_1 _inst_2)))) (Set.univ.{max u1 u2} (Prod.{u1, u2} B F))
-but is expected to have type
-  forall (B : Type.{u2}) (F : Type.{u1}) [_inst_1 : TopologicalSpace.{u2} B] [_inst_2 : TopologicalSpace.{u1} F], Eq.{max (succ u2) (succ u1)} (Set.{max u2 u1} (Prod.{u2, u1} B F)) (LocalEquiv.target.{max u2 u1, max u2 u1} (Bundle.TotalSpace.{u2, u1} B (Bundle.Trivial.{u2, u1} B F)) (Prod.{u2, u1} B F) (LocalHomeomorph.toLocalEquiv.{max u2 u1, max u2 u1} (Bundle.TotalSpace.{u2, u1} B (Bundle.Trivial.{u2, u1} B F)) (Prod.{u2, u1} B F) (Bundle.Trivial.Bundle.TotalSpace.topologicalSpace.{u2, u1} B F _inst_1 _inst_2) (instTopologicalSpaceProd.{u2, u1} B F _inst_1 _inst_2) (Trivialization.toLocalHomeomorph.{u2, u1, max u2 u1} B F (Bundle.TotalSpace.{u2, u1} B (Bundle.Trivial.{u2, u1} B F)) _inst_1 _inst_2 (Bundle.Trivial.Bundle.TotalSpace.topologicalSpace.{u2, u1} B F _inst_1 _inst_2) (Bundle.TotalSpace.proj.{u2, u1} B (Bundle.Trivial.{u2, u1} B F)) (Bundle.Trivial.trivialization.{u2, u1} B F _inst_1 _inst_2)))) (Set.univ.{max u2 u1} (Prod.{u2, u1} B F))
-Case conversion may be inaccurate. Consider using '#align bundle.trivial.trivialization_target Bundle.Trivial.trivialization_targetₓ'. -/
 @[simp]
 theorem trivialization_target : (trivialization B F).target = univ :=
   rfl
@@ -125,12 +113,6 @@ instance fiberBundle : FiberBundle F (Bundle.Trivial B F)
 #align bundle.trivial.fiber_bundle Bundle.Trivial.fiberBundle
 -/
 
-/- warning: bundle.trivial.eq_trivialization -> Bundle.Trivial.eq_trivialization is a dubious translation:
-lean 3 declaration is
-  forall (B : Type.{u1}) (F : Type.{u2}) [_inst_1 : TopologicalSpace.{u1} B] [_inst_2 : TopologicalSpace.{u2} F] (e : Trivialization.{u1, u2, max u1 u2} B F (Bundle.TotalSpace.{u1, u2} B (Bundle.Trivial.{u1, u2} B F)) _inst_1 _inst_2 (Bundle.Trivial.Bundle.TotalSpace.topologicalSpace.{u1, u2} B F _inst_1 _inst_2) (Bundle.TotalSpace.proj.{u1, u2} B (Bundle.Trivial.{u1, u2} B F))) [i : MemTrivializationAtlas.{u1, u2, u2} B F _inst_1 _inst_2 (Bundle.Trivial.{u1, u2} B F) (Bundle.Trivial.Bundle.TotalSpace.topologicalSpace.{u1, u2} B F _inst_1 _inst_2) (fun (b : B) => Bundle.Trivial.topologicalSpace.{u1, u2} B F _inst_2 b) (Bundle.Trivial.fiberBundle.{u1, u2} B F _inst_1 _inst_2) e], Eq.{max (succ u1) (succ u2) (succ (max u1 u2))} (Trivialization.{u1, u2, max u1 u2} B F (Bundle.TotalSpace.{u1, u2} B (Bundle.Trivial.{u1, u2} B F)) _inst_1 _inst_2 (Bundle.Trivial.Bundle.TotalSpace.topologicalSpace.{u1, u2} B F _inst_1 _inst_2) (Bundle.TotalSpace.proj.{u1, u2} B (Bundle.Trivial.{u1, u2} B F))) e (Bundle.Trivial.trivialization.{u1, u2} B F _inst_1 _inst_2)
-but is expected to have type
-  forall (B : Type.{u2}) (F : Type.{u1}) [_inst_1 : TopologicalSpace.{u2} B] [_inst_2 : TopologicalSpace.{u1} F] (e : Trivialization.{u2, u1, max u2 u1} B F (Bundle.TotalSpace.{u2, u1} B (Bundle.Trivial.{u2, u1} B F)) _inst_1 _inst_2 (Bundle.Trivial.Bundle.TotalSpace.topologicalSpace.{u2, u1} B F _inst_1 _inst_2) (Bundle.TotalSpace.proj.{u2, u1} B (Bundle.Trivial.{u2, u1} B F))) [i : MemTrivializationAtlas.{u2, u1, u1} B F _inst_1 _inst_2 (Bundle.Trivial.{u2, u1} B F) (Bundle.Trivial.Bundle.TotalSpace.topologicalSpace.{u2, u1} B F _inst_1 _inst_2) (fun (b : B) => Bundle.Trivial.topologicalSpace.{u2, u1} B F _inst_2 b) (Bundle.Trivial.fiberBundle.{u2, u1} B F _inst_1 _inst_2) e], Eq.{max (succ u2) (succ u1)} (Trivialization.{u2, u1, max u2 u1} B F (Bundle.TotalSpace.{u2, u1} B (Bundle.Trivial.{u2, u1} B F)) _inst_1 _inst_2 (Bundle.Trivial.Bundle.TotalSpace.topologicalSpace.{u2, u1} B F _inst_1 _inst_2) (Bundle.TotalSpace.proj.{u2, u1} B (Bundle.Trivial.{u2, u1} B F))) e (Bundle.Trivial.trivialization.{u2, u1} B F _inst_1 _inst_2)
-Case conversion may be inaccurate. Consider using '#align bundle.trivial.eq_trivialization Bundle.Trivial.eq_trivializationₓ'. -/
 theorem eq_trivialization (e : Trivialization F (π (Bundle.Trivial B F)))
     [i : MemTrivializationAtlas e] : e = trivialization B F :=
   i.out
@@ -163,12 +145,6 @@ instance FiberBundle.Prod.topologicalSpace : TopologicalSpace (TotalSpace (E₁
 #align fiber_bundle.prod.topological_space FiberBundle.Prod.topologicalSpace
 -/
 
-/- warning: fiber_bundle.prod.inducing_diag -> FiberBundle.Prod.inducing_diag is a dubious translation:
-lean 3 declaration is
-  forall {B : Type.{u1}} (E₁ : B -> Type.{u2}) (E₂ : B -> Type.{u3}) [_inst_1 : TopologicalSpace.{max u1 u2} (Bundle.TotalSpace.{u1, u2} B E₁)] [_inst_2 : TopologicalSpace.{max u1 u3} (Bundle.TotalSpace.{u1, u3} B E₂)], Inducing.{max u1 u2 u3, max (max u1 u2) u1 u3} (Bundle.TotalSpace.{u1, max u2 u3} B (fun (x : B) => Prod.{u2, u3} (E₁ x) (E₂ x))) (Prod.{max u1 u2, max u1 u3} (Bundle.TotalSpace.{u1, u2} B E₁) (Bundle.TotalSpace.{u1, u3} B E₂)) (FiberBundle.Prod.topologicalSpace.{u1, u2, u3} B (fun (x : B) => E₁ x) (fun (x : B) => E₂ x) _inst_1 _inst_2) (Prod.topologicalSpace.{max u1 u2, max u1 u3} (Bundle.TotalSpace.{u1, u2} B E₁) (Bundle.TotalSpace.{u1, u3} B E₂) _inst_1 _inst_2) (fun (p : Bundle.TotalSpace.{u1, max u2 u3} B (fun (x : B) => Prod.{u2, u3} (E₁ x) (E₂ x))) => Prod.mk.{max u1 u2, max u1 u3} (Bundle.TotalSpace.{u1, u2} B E₁) (Bundle.TotalSpace.{u1, u3} B E₂) (Sigma.mk.{u1, u2} B (fun (x : B) => E₁ x) (Sigma.fst.{u1, max u2 u3} B (fun (x : B) => (fun (x : B) => Prod.{u2, u3} (E₁ x) (E₂ x)) x) p) (Prod.fst.{u2, u3} (E₁ (Sigma.fst.{u1, max u2 u3} B (fun (x : B) => (fun (x : B) => Prod.{u2, u3} (E₁ x) (E₂ x)) x) p)) (E₂ (Sigma.fst.{u1, max u2 u3} B (fun (x : B) => (fun (x : B) => Prod.{u2, u3} (E₁ x) (E₂ x)) x) p)) (Sigma.snd.{u1, max u2 u3} B (fun (x : B) => (fun (x : B) => Prod.{u2, u3} (E₁ x) (E₂ x)) x) p))) (Sigma.mk.{u1, u3} B (fun (x : B) => E₂ x) (Sigma.fst.{u1, max u2 u3} B (fun (x : B) => (fun (x : B) => Prod.{u2, u3} (E₁ x) (E₂ x)) x) p) (Prod.snd.{u2, u3} (E₁ (Sigma.fst.{u1, max u2 u3} B (fun (x : B) => (fun (x : B) => Prod.{u2, u3} (E₁ x) (E₂ x)) x) p)) (E₂ (Sigma.fst.{u1, max u2 u3} B (fun (x : B) => (fun (x : B) => Prod.{u2, u3} (E₁ x) (E₂ x)) x) p)) (Sigma.snd.{u1, max u2 u3} B (fun (x : B) => (fun (x : B) => Prod.{u2, u3} (E₁ x) (E₂ x)) x) p))))
-but is expected to have type
-  forall {B : Type.{u3}} (E₁ : B -> Type.{u2}) (E₂ : B -> Type.{u1}) [_inst_1 : TopologicalSpace.{max u2 u3} (Bundle.TotalSpace.{u3, u2} B E₁)] [_inst_2 : TopologicalSpace.{max u1 u3} (Bundle.TotalSpace.{u3, u1} B E₂)], Inducing.{max (max u3 u2) u1, max (max u3 u2) u1} (Bundle.TotalSpace.{u3, max u1 u2} B (fun (x : B) => Prod.{u2, u1} (E₁ x) (E₂ x))) (Prod.{max u3 u2, max u3 u1} (Bundle.TotalSpace.{u3, u2} B E₁) (Bundle.TotalSpace.{u3, u1} B E₂)) (FiberBundle.Prod.topologicalSpace.{u3, u2, u1} B (fun (x : B) => E₁ x) (fun (x : B) => E₂ x) _inst_1 _inst_2) (instTopologicalSpaceProd.{max u3 u2, max u3 u1} (Bundle.TotalSpace.{u3, u2} B E₁) (Bundle.TotalSpace.{u3, u1} B E₂) _inst_1 _inst_2) (fun (p : Bundle.TotalSpace.{u3, max u1 u2} B (fun (x : B) => Prod.{u2, u1} (E₁ x) (E₂ x))) => Prod.mk.{max u3 u2, max u3 u1} (Bundle.TotalSpace.{u3, u2} B E₁) (Bundle.TotalSpace.{u3, u1} B E₂) (Sigma.mk.{u3, u2} B (fun (x : B) => E₁ x) (Sigma.fst.{u3, max u2 u1} B (fun (x : B) => (fun (x : B) => Prod.{u2, u1} (E₁ x) (E₂ x)) x) p) (Prod.fst.{u2, u1} (E₁ (Sigma.fst.{u3, max u2 u1} B (fun (x : B) => (fun (x : B) => Prod.{u2, u1} (E₁ x) (E₂ x)) x) p)) (E₂ (Sigma.fst.{u3, max u2 u1} B (fun (x : B) => (fun (x : B) => Prod.{u2, u1} (E₁ x) (E₂ x)) x) p)) (Sigma.snd.{u3, max u2 u1} B (fun (x : B) => (fun (x : B) => Prod.{u2, u1} (E₁ x) (E₂ x)) x) p))) (Sigma.mk.{u3, u1} B (fun (x : B) => E₂ x) (Sigma.fst.{u3, max u2 u1} B (fun (x : B) => (fun (x : B) => Prod.{u2, u1} (E₁ x) (E₂ x)) x) p) (Prod.snd.{u2, u1} (E₁ (Sigma.fst.{u3, max u2 u1} B (fun (x : B) => (fun (x : B) => Prod.{u2, u1} (E₁ x) (E₂ x)) x) p)) (E₂ (Sigma.fst.{u3, max u2 u1} B (fun (x : B) => (fun (x : B) => Prod.{u2, u1} (E₁ x) (E₂ x)) x) p)) (Sigma.snd.{u3, max u2 u1} B (fun (x : B) => (fun (x : B) => Prod.{u2, u1} (E₁ x) (E₂ x)) x) p))))
-Case conversion may be inaccurate. Consider using '#align fiber_bundle.prod.inducing_diag FiberBundle.Prod.inducing_diagₓ'. -/
 /-- The diagonal map from the total space of the fiberwise product of two fiber bundles
 `E₁`, `E₂` into `total_space E₁ × total_space E₂` is `inducing`. -/
 theorem FiberBundle.Prod.inducing_diag :
@@ -201,12 +177,6 @@ def Prod.toFun' : TotalSpace (E₁ ×ᵇ E₂) → B × F₁ × F₂ := fun p =>
 
 variable {e₁ e₂}
 
-/- warning: trivialization.prod.continuous_to_fun -> Trivialization.Prod.continuous_to_fun is a dubious translation:
-lean 3 declaration is
-  forall {B : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} B] {F₁ : Type.{u2}} [_inst_2 : TopologicalSpace.{u2} F₁] {E₁ : B -> Type.{u3}} [_inst_3 : TopologicalSpace.{max u1 u3} (Bundle.TotalSpace.{u1, u3} B E₁)] {F₂ : Type.{u4}} [_inst_4 : TopologicalSpace.{u4} F₂] {E₂ : B -> Type.{u5}} [_inst_5 : TopologicalSpace.{max u1 u5} (Bundle.TotalSpace.{u1, u5} B E₂)] {e₁ : Trivialization.{u1, u2, max u1 u3} B F₁ (Bundle.TotalSpace.{u1, u3} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u1, u3} B E₁)} {e₂ : Trivialization.{u1, u4, max u1 u5} B F₂ (Bundle.TotalSpace.{u1, u5} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u1, u5} B E₂)}, ContinuousOn.{max u1 u3 u5, max u1 u2 u4} (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))) (Prod.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂)) (FiberBundle.Prod.topologicalSpace.{u1, u3, u5} B (fun (x : B) => E₁ x) (fun (x : B) => E₂ x) _inst_3 _inst_5) (Prod.topologicalSpace.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂) _inst_1 (Prod.topologicalSpace.{u2, u4} F₁ F₂ _inst_2 _inst_4)) (Trivialization.Prod.toFun'.{u1, u2, u3, u4, u5} B _inst_1 F₁ _inst_2 E₁ _inst_3 F₂ _inst_4 E₂ _inst_5 e₁ e₂) (Set.preimage.{max u1 u3 u5, u1} (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))) B (Bundle.TotalSpace.proj.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))) (Inter.inter.{u1} (Set.{u1} B) (Set.hasInter.{u1} B) (Trivialization.baseSet.{u1, u2, max u1 u3} B F₁ (Bundle.TotalSpace.{u1, u3} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u1, u3} B E₁) e₁) (Trivialization.baseSet.{u1, u4, max u1 u5} B F₂ (Bundle.TotalSpace.{u1, u5} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u1, u5} B E₂) e₂)))
-but is expected to have type
-  forall {B : Type.{u3}} [_inst_1 : TopologicalSpace.{u3} B] {F₁ : Type.{u1}} [_inst_2 : TopologicalSpace.{u1} F₁] {E₁ : B -> Type.{u4}} [_inst_3 : TopologicalSpace.{max u4 u3} (Bundle.TotalSpace.{u3, u4} B E₁)] {F₂ : Type.{u2}} [_inst_4 : TopologicalSpace.{u2} F₂] {E₂ : B -> Type.{u5}} [_inst_5 : TopologicalSpace.{max u5 u3} (Bundle.TotalSpace.{u3, u5} B E₂)] {e₁ : Trivialization.{u3, u1, max u3 u4} B F₁ (Bundle.TotalSpace.{u3, u4} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u3, u4} B E₁)} {e₂ : Trivialization.{u3, u2, max u3 u5} B F₂ (Bundle.TotalSpace.{u3, u5} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u3, u5} B E₂)}, ContinuousOn.{max (max u5 u4) u3, max (max u2 u1) u3} (Bundle.TotalSpace.{u3, max u5 u4} B (fun (x : B) => Prod.{u4, u5} (E₁ x) (E₂ x))) (Prod.{u3, max u2 u1} B (Prod.{u1, u2} F₁ F₂)) (FiberBundle.Prod.topologicalSpace.{u3, u4, u5} B (fun (x : B) => E₁ x) (fun (x : B) => E₂ x) _inst_3 _inst_5) (instTopologicalSpaceProd.{u3, max u1 u2} B (Prod.{u1, u2} F₁ F₂) _inst_1 (instTopologicalSpaceProd.{u1, u2} F₁ F₂ _inst_2 _inst_4)) (Trivialization.Prod.toFun'.{u3, u1, u4, u2, u5} B _inst_1 F₁ _inst_2 E₁ _inst_3 F₂ _inst_4 E₂ _inst_5 e₁ e₂) (Set.preimage.{max (max u3 u4) u5, u3} (Bundle.TotalSpace.{u3, max u5 u4} B (fun (x : B) => Prod.{u4, u5} (E₁ x) (E₂ x))) B (Bundle.TotalSpace.proj.{u3, max u5 u4} B (fun (x : B) => Prod.{u4, u5} (E₁ x) (E₂ x))) (Inter.inter.{u3} (Set.{u3} B) (Set.instInterSet.{u3} B) (Trivialization.baseSet.{u3, u1, max u3 u4} B F₁ (Bundle.TotalSpace.{u3, u4} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u3, u4} B E₁) e₁) (Trivialization.baseSet.{u3, u2, max u3 u5} B F₂ (Bundle.TotalSpace.{u3, u5} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u3, u5} B E₂) e₂)))
-Case conversion may be inaccurate. Consider using '#align trivialization.prod.continuous_to_fun Trivialization.Prod.continuous_to_funₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem Prod.continuous_to_fun :
     ContinuousOn (Prod.toFun' e₁ e₂)
@@ -244,9 +214,6 @@ noncomputable def Prod.invFun' (p : B × F₁ × F₂) : TotalSpace (E₁ ×ᵇ
 
 variable {e₁ e₂}
 
-/- warning: trivialization.prod.left_inv -> Trivialization.Prod.left_inv is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align trivialization.prod.left_inv Trivialization.Prod.left_invₓ'. -/
 theorem Prod.left_inv {x : TotalSpace (E₁ ×ᵇ E₂)}
     (h : x ∈ @TotalSpace.proj B (E₁ ×ᵇ E₂) ⁻¹' (e₁.baseSet ∩ e₂.baseSet)) :
     Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x :=
@@ -256,9 +223,6 @@ theorem Prod.left_inv {x : TotalSpace (E₁ ×ᵇ E₂)}
   simp only [prod.to_fun', prod.inv_fun', symm_apply_apply_mk, h₁, h₂]
 #align trivialization.prod.left_inv Trivialization.Prod.left_inv
 
-/- warning: trivialization.prod.right_inv -> Trivialization.Prod.right_inv is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align trivialization.prod.right_inv Trivialization.Prod.right_invₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem Prod.right_inv {x : B × F₁ × F₂}
     (h : x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ (univ : Set (F₁ × F₂))) :
@@ -269,12 +233,6 @@ theorem Prod.right_inv {x : B × F₁ × F₂}
   simp only [prod.to_fun', prod.inv_fun', apply_mk_symm, h₁, h₂]
 #align trivialization.prod.right_inv Trivialization.Prod.right_inv
 
-/- warning: trivialization.prod.continuous_inv_fun -> Trivialization.Prod.continuous_inv_fun is a dubious translation:
-lean 3 declaration is
-  forall {B : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} B] {F₁ : Type.{u2}} [_inst_2 : TopologicalSpace.{u2} F₁] {E₁ : B -> Type.{u3}} [_inst_3 : TopologicalSpace.{max u1 u3} (Bundle.TotalSpace.{u1, u3} B E₁)] {F₂ : Type.{u4}} [_inst_4 : TopologicalSpace.{u4} F₂] {E₂ : B -> Type.{u5}} [_inst_5 : TopologicalSpace.{max u1 u5} (Bundle.TotalSpace.{u1, u5} B E₂)] {e₁ : Trivialization.{u1, u2, max u1 u3} B F₁ (Bundle.TotalSpace.{u1, u3} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u1, u3} B E₁)} {e₂ : Trivialization.{u1, u4, max u1 u5} B F₂ (Bundle.TotalSpace.{u1, u5} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u1, u5} B E₂)} [_inst_6 : forall (x : B), Zero.{u3} (E₁ x)] [_inst_7 : forall (x : B), Zero.{u5} (E₂ x)], ContinuousOn.{max u1 u2 u4, max u1 u3 u5} (Prod.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂)) (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))) (Prod.topologicalSpace.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂) _inst_1 (Prod.topologicalSpace.{u2, u4} F₁ F₂ _inst_2 _inst_4)) (FiberBundle.Prod.topologicalSpace.{u1, u3, u5} B (fun (x : B) => E₁ x) (fun (x : B) => E₂ x) _inst_3 _inst_5) (Trivialization.Prod.invFun'.{u1, u2, u3, u4, u5} B _inst_1 F₁ _inst_2 E₁ _inst_3 F₂ _inst_4 E₂ _inst_5 e₁ e₂ (fun (x : B) => _inst_6 x) (fun (x : B) => _inst_7 x)) (Set.prod.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂) (Inter.inter.{u1} (Set.{u1} B) (Set.hasInter.{u1} B) (Trivialization.baseSet.{u1, u2, max u1 u3} B F₁ (Bundle.TotalSpace.{u1, u3} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u1, u3} B E₁) e₁) (Trivialization.baseSet.{u1, u4, max u1 u5} B F₂ (Bundle.TotalSpace.{u1, u5} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u1, u5} B E₂) e₂)) (Set.univ.{max u2 u4} (Prod.{u2, u4} F₁ F₂)))
-but is expected to have type
-  forall {B : Type.{u3}} [_inst_1 : TopologicalSpace.{u3} B] {F₁ : Type.{u4}} [_inst_2 : TopologicalSpace.{u4} F₁] {E₁ : B -> Type.{u1}} [_inst_3 : TopologicalSpace.{max u1 u3} (Bundle.TotalSpace.{u3, u1} B E₁)] {F₂ : Type.{u5}} [_inst_4 : TopologicalSpace.{u5} F₂] {E₂ : B -> Type.{u2}} [_inst_5 : TopologicalSpace.{max u2 u3} (Bundle.TotalSpace.{u3, u2} B E₂)] {e₁ : Trivialization.{u3, u4, max u3 u1} B F₁ (Bundle.TotalSpace.{u3, u1} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u3, u1} B E₁)} {e₂ : Trivialization.{u3, u5, max u3 u2} B F₂ (Bundle.TotalSpace.{u3, u2} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u3, u2} B E₂)} [_inst_6 : forall (x : B), Zero.{u1} (E₁ x)] [_inst_7 : forall (x : B), Zero.{u2} (E₂ x)], ContinuousOn.{max (max u5 u4) u3, max (max u2 u1) u3} (Prod.{u3, max u5 u4} B (Prod.{u4, u5} F₁ F₂)) (Bundle.TotalSpace.{u3, max u2 u1} B (fun (x : B) => Prod.{u1, u2} (E₁ x) (E₂ x))) (instTopologicalSpaceProd.{u3, max u4 u5} B (Prod.{u4, u5} F₁ F₂) _inst_1 (instTopologicalSpaceProd.{u4, u5} F₁ F₂ _inst_2 _inst_4)) (FiberBundle.Prod.topologicalSpace.{u3, u1, u2} B (fun (x : B) => E₁ x) (fun (x : B) => E₂ x) _inst_3 _inst_5) (Trivialization.Prod.invFun'.{u3, u4, u1, u5, u2} B _inst_1 F₁ _inst_2 E₁ _inst_3 F₂ _inst_4 E₂ _inst_5 e₁ e₂ (fun (x : B) => _inst_6 x) (fun (x : B) => _inst_7 x)) (Set.prod.{u3, max u4 u5} B (Prod.{u4, u5} F₁ F₂) (Inter.inter.{u3} (Set.{u3} B) (Set.instInterSet.{u3} B) (Trivialization.baseSet.{u3, u4, max u3 u1} B F₁ (Bundle.TotalSpace.{u3, u1} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u3, u1} B E₁) e₁) (Trivialization.baseSet.{u3, u5, max u3 u2} B F₂ (Bundle.TotalSpace.{u3, u2} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u3, u2} B E₂) e₂)) (Set.univ.{max u4 u5} (Prod.{u4, u5} F₁ F₂)))
-Case conversion may be inaccurate. Consider using '#align trivialization.prod.continuous_inv_fun Trivialization.Prod.continuous_inv_funₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem Prod.continuous_inv_fun :
     ContinuousOn (Prod.invFun' e₁ e₂) ((e₁.baseSet ∩ e₂.baseSet) ×ˢ univ) :=
@@ -288,12 +246,6 @@ theorem Prod.continuous_inv_fun :
 
 variable (e₁ e₂ e₁ e₂)
 
-/- warning: trivialization.prod -> Trivialization.prod is a dubious translation:
-lean 3 declaration is
-  forall {B : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} B] {F₁ : Type.{u2}} [_inst_2 : TopologicalSpace.{u2} F₁] {E₁ : B -> Type.{u3}} [_inst_3 : TopologicalSpace.{max u1 u3} (Bundle.TotalSpace.{u1, u3} B E₁)] {F₂ : Type.{u4}} [_inst_4 : TopologicalSpace.{u4} F₂] {E₂ : B -> Type.{u5}} [_inst_5 : TopologicalSpace.{max u1 u5} (Bundle.TotalSpace.{u1, u5} B E₂)], (Trivialization.{u1, u2, max u1 u3} B F₁ (Bundle.TotalSpace.{u1, u3} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u1, u3} B E₁)) -> (Trivialization.{u1, u4, max u1 u5} B F₂ (Bundle.TotalSpace.{u1, u5} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u1, u5} B E₂)) -> (forall [_inst_6 : forall (x : B), Zero.{u3} (E₁ x)] [_inst_7 : forall (x : B), Zero.{u5} (E₂ x)], Trivialization.{u1, max u2 u4, max u1 u3 u5} B (Prod.{u2, u4} F₁ F₂) (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))) _inst_1 (Prod.topologicalSpace.{u2, u4} F₁ F₂ _inst_2 _inst_4) (FiberBundle.Prod.topologicalSpace.{u1, u3, u5} B (fun (x : B) => E₁ x) (fun (x : B) => E₂ x) _inst_3 _inst_5) (Bundle.TotalSpace.proj.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))))
-but is expected to have type
-  forall {B : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} B] {F₁ : Type.{u2}} [_inst_2 : TopologicalSpace.{u2} F₁] {E₁ : B -> Type.{u3}} [_inst_3 : TopologicalSpace.{max u3 u1} (Bundle.TotalSpace.{u1, u3} B E₁)] {F₂ : Type.{u4}} [_inst_4 : TopologicalSpace.{u4} F₂] {E₂ : B -> Type.{u5}} [_inst_5 : TopologicalSpace.{max u5 u1} (Bundle.TotalSpace.{u1, u5} B E₂)], (Trivialization.{u1, u2, max u1 u3} B F₁ (Bundle.TotalSpace.{u1, u3} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u1, u3} B E₁)) -> (Trivialization.{u1, u4, max u1 u5} B F₂ (Bundle.TotalSpace.{u1, u5} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u1, u5} B E₂)) -> (forall [_inst_6 : forall (x : B), Zero.{u3} (E₁ x)] [_inst_7 : forall (x : B), Zero.{u5} (E₂ x)], Trivialization.{u1, max u4 u2, max (max u1 u3) u5} B (Prod.{u2, u4} F₁ F₂) (Bundle.TotalSpace.{u1, max u5 u3} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))) _inst_1 (instTopologicalSpaceProd.{u2, u4} F₁ F₂ _inst_2 _inst_4) (FiberBundle.Prod.topologicalSpace.{u1, u3, u5} B (fun (x : B) => E₁ x) (fun (x : B) => E₂ x) _inst_3 _inst_5) (Bundle.TotalSpace.proj.{u1, max u5 u3} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))))
-Case conversion may be inaccurate. Consider using '#align trivialization.prod Trivialization.prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /-- Given trivializations `e₁`, `e₂` for bundle types `E₁`, `E₂` over a base `B`, the induced
 trivialization for the fiberwise product of `E₁` and `E₂`, whose base set is
@@ -324,17 +276,11 @@ noncomputable def prod : Trivialization (F₁ × F₂) (π (E₁ ×ᵇ E₂))
   proj_toFun x h := rfl
 #align trivialization.prod Trivialization.prod
 
-/- warning: trivialization.base_set_prod -> Trivialization.baseSet_prod is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align trivialization.base_set_prod Trivialization.baseSet_prodₓ'. -/
 @[simp]
 theorem baseSet_prod : (prod e₁ e₂).baseSet = e₁.baseSet ∩ e₂.baseSet :=
   rfl
 #align trivialization.base_set_prod Trivialization.baseSet_prod
 
-/- warning: trivialization.prod_symm_apply -> Trivialization.prod_symm_apply is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align trivialization.prod_symm_apply Trivialization.prod_symm_applyₓ'. -/
 theorem prod_symm_apply (x : B) (w₁ : F₁) (w₂ : F₂) :
     (prod e₁ e₂).toLocalEquiv.symm (x, w₁, w₂) = ⟨x, e₁.symm x w₁, e₂.symm x w₂⟩ :=
   rfl
@@ -347,12 +293,6 @@ open Trivialization
 variable [∀ x, Zero (E₁ x)] [∀ x, Zero (E₂ x)] [∀ x : B, TopologicalSpace (E₁ x)]
   [∀ x : B, TopologicalSpace (E₂ x)] [FiberBundle F₁ E₁] [FiberBundle F₂ E₂]
 
-/- warning: fiber_bundle.prod -> FiberBundle.prod is a dubious translation:
-lean 3 declaration is
-  forall {B : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} B] (F₁ : Type.{u2}) [_inst_2 : TopologicalSpace.{u2} F₁] (E₁ : B -> Type.{u3}) [_inst_3 : TopologicalSpace.{max u1 u3} (Bundle.TotalSpace.{u1, u3} B E₁)] (F₂ : Type.{u4}) [_inst_4 : TopologicalSpace.{u4} F₂] (E₂ : B -> Type.{u5}) [_inst_5 : TopologicalSpace.{max u1 u5} (Bundle.TotalSpace.{u1, u5} B E₂)] [_inst_6 : forall (x : B), Zero.{u3} (E₁ x)] [_inst_7 : forall (x : B), Zero.{u5} (E₂ x)] [_inst_8 : forall (x : B), TopologicalSpace.{u3} (E₁ x)] [_inst_9 : forall (x : B), TopologicalSpace.{u5} (E₂ x)] [_inst_10 : FiberBundle.{u1, u2, u3} B F₁ _inst_1 _inst_2 E₁ _inst_3 (fun (b : B) => _inst_8 b)] [_inst_11 : FiberBundle.{u1, u4, u5} B F₂ _inst_1 _inst_4 E₂ _inst_5 (fun (b : B) => _inst_9 b)], FiberBundle.{u1, max u2 u4, max u3 u5} B (Prod.{u2, u4} F₁ F₂) _inst_1 (Prod.topologicalSpace.{u2, u4} F₁ F₂ _inst_2 _inst_4) (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x)) (FiberBundle.Prod.topologicalSpace.{u1, u3, u5} B (fun (x : B) => E₁ x) (fun (x : B) => E₂ x) _inst_3 _inst_5) (fun (b : B) => Prod.topologicalSpace.{u3, u5} (E₁ b) (E₂ b) (_inst_8 b) (_inst_9 b))
-but is expected to have type
-  forall {B : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} B] (F₁ : Type.{u2}) [_inst_2 : TopologicalSpace.{u2} F₁] (E₁ : B -> Type.{u3}) [_inst_3 : TopologicalSpace.{max u3 u1} (Bundle.TotalSpace.{u1, u3} B E₁)] (F₂ : Type.{u4}) [_inst_4 : TopologicalSpace.{u4} F₂] (E₂ : B -> Type.{u5}) [_inst_5 : TopologicalSpace.{max u5 u1} (Bundle.TotalSpace.{u1, u5} B E₂)] [_inst_6 : forall (x : B), Zero.{u3} (E₁ x)] [_inst_7 : forall (x : B), Zero.{u5} (E₂ x)] [_inst_8 : forall (x : B), TopologicalSpace.{u3} (E₁ x)] [_inst_9 : forall (x : B), TopologicalSpace.{u5} (E₂ x)] [_inst_10 : FiberBundle.{u1, u2, u3} B F₁ _inst_1 _inst_2 E₁ _inst_3 (fun (b : B) => _inst_8 b)] [_inst_11 : FiberBundle.{u1, u4, u5} B F₂ _inst_1 _inst_4 E₂ _inst_5 (fun (b : B) => _inst_9 b)], FiberBundle.{u1, max u4 u2, max u5 u3} B (Prod.{u2, u4} F₁ F₂) _inst_1 (instTopologicalSpaceProd.{u2, u4} F₁ F₂ _inst_2 _inst_4) (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x)) (FiberBundle.Prod.topologicalSpace.{u1, u3, u5} B (fun (x : B) => E₁ x) (fun (x : B) => E₂ x) _inst_3 _inst_5) (fun (b : B) => instTopologicalSpaceProd.{u3, u5} (E₁ b) (E₂ b) (_inst_8 b) (_inst_9 b))
-Case conversion may be inaccurate. Consider using '#align fiber_bundle.prod FiberBundle.prodₓ'. -/
 /-- The product of two fiber bundles is a fiber bundle. -/
 noncomputable instance FiberBundle.prod : FiberBundle (F₁ × F₂) (E₁ ×ᵇ E₂)
     where
@@ -422,12 +362,6 @@ theorem Pullback.continuous_lift (f : B' → B) : Continuous (@Pullback.lift B E
 #align pullback.continuous_lift Pullback.continuous_lift
 -/
 
-/- warning: inducing_pullback_total_space_embedding -> inducing_pullbackTotalSpaceEmbedding is a dubious translation:
-lean 3 declaration is
-  forall {B : Type.{u1}} (E : B -> Type.{u2}) {B' : Type.{u3}} [_inst_1 : TopologicalSpace.{u3} B'] [_inst_2 : TopologicalSpace.{max u1 u2} (Bundle.TotalSpace.{u1, u2} B E)] (f : B' -> B), Inducing.{max u3 u2, max u3 u1 u2} (Bundle.TotalSpace.{u3, u2} B' (Bundle.Pullback.{u1, u3, u2} B B' f E)) (Prod.{u3, max u1 u2} B' (Bundle.TotalSpace.{u1, u2} B E)) (Pullback.TotalSpace.topologicalSpace.{u1, u2, u3} B E B' f _inst_1 _inst_2) (Prod.topologicalSpace.{u3, max u1 u2} B' (Bundle.TotalSpace.{u1, u2} B E) _inst_1 _inst_2) (Bundle.pullbackTotalSpaceEmbedding.{u1, u2, u3} B E B' f)
-but is expected to have type
-  forall {B : Type.{u1}} (E : B -> Type.{u2}) {B' : Type.{u3}} [_inst_1 : TopologicalSpace.{u3} B'] [_inst_2 : TopologicalSpace.{max u2 u1} (Bundle.TotalSpace.{u1, u2} B E)] (f : B' -> B), Inducing.{max u2 u3, max (max u1 u2) u3} (Bundle.TotalSpace.{u3, u2} B' (Bundle.Pullback.{u1, u3, u2} B B' f E)) (Prod.{u3, max u2 u1} B' (Bundle.TotalSpace.{u1, u2} B E)) (Pullback.TotalSpace.topologicalSpace.{u1, u2, u3} B E B' f _inst_1 _inst_2) (instTopologicalSpaceProd.{u3, max u1 u2} B' (Bundle.TotalSpace.{u1, u2} B E) _inst_1 _inst_2) (Bundle.pullbackTotalSpaceEmbedding.{u1, u2, u3} B E B' f)
-Case conversion may be inaccurate. Consider using '#align inducing_pullback_total_space_embedding inducing_pullbackTotalSpaceEmbeddingₓ'. -/
 theorem inducing_pullbackTotalSpaceEmbedding (f : B' → B) :
     Inducing (@pullbackTotalSpaceEmbedding B E B' f) :=
   by

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -72,8 +72,7 @@ def trivialization : Trivialization F (π (Bundle.Trivial B F))
   continuous_toFun :=
     by
     rw [← continuous_iff_continuousOn_univ, continuous_iff_le_induced]
-    simp only [Prod.topologicalSpace, induced_inf, induced_compose]
-    exact le_rfl
+    simp only [Prod.topologicalSpace, induced_inf, induced_compose]; exact le_rfl
   continuous_invFun :=
     by
     rw [← continuous_iff_continuousOn_univ, continuous_iff_le_induced]
@@ -119,10 +118,7 @@ instance fiberBundle : FiberBundle F (Bundle.Trivial B F)
   trivialization_mem_atlas x := mem_singleton _
   totalSpaceMk_inducing b :=
     ⟨by
-      have : (fun x : trivial B F b => x) = @id F :=
-        by
-        ext x
-        rfl
+      have : (fun x : trivial B F b => x) = @id F := by ext x; rfl
       simp only [total_space.topological_space, induced_inf, induced_compose, Function.comp,
         total_space.proj, induced_const, top_inf_eq, trivial.proj_snd, id.def,
         trivial.topological_space, this, induced_id]⟩
@@ -482,8 +478,7 @@ noncomputable def Trivialization.pullback (e : Trivialization F (π E)) (f : K)
   right_inv' x h := by
     simp_rw [mem_prod, mem_preimage, mem_univ, and_true_iff] at h
     simp_rw [total_space.proj_mk, pullback.lift_mk, e.apply_mk_symm h, Prod.mk.eta]
-  open_source := by
-    simp_rw [e.source_eq, ← preimage_comp]
+  open_source := by simp_rw [e.source_eq, ← preimage_comp];
     exact
       ((map_continuous f).comp <| Pullback.continuous_proj E f).isOpen_preimage _ e.open_base_set
   open_target := ((map_continuous f).isOpen_preimage _ e.open_baseSet).Prod isOpen_univ
@@ -501,10 +496,7 @@ noncomputable def Trivialization.pullback (e : Trivialization F (π E)) (f : K)
       continuous_on_fst.prod
         (e.continuous_on_symm.comp ((map_continuous f).Prod_map continuous_id).ContinuousOn
           subset.rfl)
-  source_eq := by
-    dsimp only
-    rw [e.source_eq]
-    rfl
+  source_eq := by dsimp only; rw [e.source_eq]; rfl
   target_eq := rfl
   proj_toFun y h := rfl
 #align trivialization.pullback Trivialization.pullback

bump to nightly-2023-05-28-03

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

6c6011cf

Diff

@@ -249,10 +249,7 @@ noncomputable def Prod.invFun' (p : B × F₁ × F₂) : TotalSpace (E₁ ×ᵇ
 variable {e₁ e₂}
 
 /- warning: trivialization.prod.left_inv -> Trivialization.Prod.left_inv is a dubious translation:
-lean 3 declaration is
-  forall {B : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} B] {F₁ : Type.{u2}} [_inst_2 : TopologicalSpace.{u2} F₁] {E₁ : B -> Type.{u3}} [_inst_3 : TopologicalSpace.{max u1 u3} (Bundle.TotalSpace.{u1, u3} B E₁)] {F₂ : Type.{u4}} [_inst_4 : TopologicalSpace.{u4} F₂] {E₂ : B -> Type.{u5}} [_inst_5 : TopologicalSpace.{max u1 u5} (Bundle.TotalSpace.{u1, u5} B E₂)] {e₁ : Trivialization.{u1, u2, max u1 u3} B F₁ (Bundle.TotalSpace.{u1, u3} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u1, u3} B E₁)} {e₂ : Trivialization.{u1, u4, max u1 u5} B F₂ (Bundle.TotalSpace.{u1, u5} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u1, u5} B E₂)} [_inst_6 : forall (x : B), Zero.{u3} (E₁ x)] [_inst_7 : forall (x : B), Zero.{u5} (E₂ x)] {x : Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))}, (Membership.Mem.{max u1 u3 u5, max u1 u3 u5} (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))) (Set.{max u1 u3 u5} (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x)))) (Set.hasMem.{max u1 u3 u5} (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x)))) x (Set.preimage.{max u1 u3 u5, u1} (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))) B (Bundle.TotalSpace.proj.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))) (Inter.inter.{u1} (Set.{u1} B) (Set.hasInter.{u1} B) (Trivialization.baseSet.{u1, u2, max u1 u3} B F₁ (Bundle.TotalSpace.{u1, u3} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u1, u3} B E₁) e₁) (Trivialization.baseSet.{u1, u4, max u1 u5} B F₂ (Bundle.TotalSpace.{u1, u5} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u1, u5} B E₂) e₂)))) -> (Eq.{max (succ u1) (succ (max u3 u5))} (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))) (Trivialization.Prod.invFun'.{u1, u2, u3, u4, u5} B _inst_1 F₁ _inst_2 E₁ _inst_3 F₂ _inst_4 E₂ _inst_5 e₁ e₂ (fun (x : B) => _inst_6 x) (fun (x : B) => _inst_7 x) (Trivialization.Prod.toFun'.{u1, u2, u3, u4, u5} B _inst_1 F₁ _inst_2 E₁ _inst_3 F₂ _inst_4 E₂ _inst_5 e₁ e₂ x)) x)
-but is expected to have type
-  forall {B : Type.{u5}} [_inst_1 : TopologicalSpace.{u5} B] {F₁ : Type.{u2}} [_inst_2 : TopologicalSpace.{u2} F₁] {E₁ : B -> Type.{u3}} [_inst_3 : TopologicalSpace.{max u3 u5} (Bundle.TotalSpace.{u5, u3} B E₁)] {F₂ : Type.{u1}} [_inst_4 : TopologicalSpace.{u1} F₂] {E₂ : B -> Type.{u4}} [_inst_5 : TopologicalSpace.{max u4 u5} (Bundle.TotalSpace.{u5, u4} B E₂)] {e₁ : Trivialization.{u5, u2, max u5 u3} B F₁ (Bundle.TotalSpace.{u5, u3} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u5, u3} B E₁)} {e₂ : Trivialization.{u5, u1, max u5 u4} B F₂ (Bundle.TotalSpace.{u5, u4} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u5, u4} B E₂)} [_inst_6 : forall (x : B), Zero.{u3} (E₁ x)] [_inst_7 : forall (x : B), Zero.{u4} (E₂ x)] {x : Bundle.TotalSpace.{u5, max u4 u3} B (fun (x : B) => Prod.{u3, u4} (E₁ x) (E₂ x))}, (Membership.mem.{max (max u5 u3) u4, max (max u5 u3) u4} (Bundle.TotalSpace.{u5, max u4 u3} B (fun (x : B) => Prod.{u3, u4} (E₁ x) (E₂ x))) (Set.{max (max u5 u3) u4} (Bundle.TotalSpace.{u5, max u4 u3} B (fun (x : B) => Prod.{u3, u4} (E₁ x) (E₂ x)))) (Set.instMembershipSet.{max (max u5 u3) u4} (Bundle.TotalSpace.{u5, max u4 u3} B (fun (x : B) => Prod.{u3, u4} (E₁ x) (E₂ x)))) x (Set.preimage.{max (max u5 u3) u4, u5} (Bundle.TotalSpace.{u5, max u4 u3} B (fun (x : B) => Prod.{u3, u4} (E₁ x) (E₂ x))) B (Bundle.TotalSpace.proj.{u5, max u4 u3} B (fun (x : B) => Prod.{u3, u4} (E₁ x) (E₂ x))) (Inter.inter.{u5} (Set.{u5} B) (Set.instInterSet.{u5} B) (Trivialization.baseSet.{u5, u2, max u5 u3} B F₁ (Bundle.TotalSpace.{u5, u3} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u5, u3} B E₁) e₁) (Trivialization.baseSet.{u5, u1, max u5 u4} B F₂ (Bundle.TotalSpace.{u5, u4} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u5, u4} B E₂) e₂)))) -> (Eq.{max (max (succ u5) (succ u3)) (succ u4)} (Bundle.TotalSpace.{u5, max u4 u3} B (fun (x : B) => Prod.{u3, u4} (E₁ x) (E₂ x))) (Trivialization.Prod.invFun'.{u5, u2, u3, u1, u4} B _inst_1 F₁ _inst_2 E₁ _inst_3 F₂ _inst_4 E₂ _inst_5 e₁ e₂ (fun (x : B) => _inst_6 x) (fun (x : B) => _inst_7 x) (Trivialization.Prod.toFun'.{u5, u2, u3, u1, u4} B _inst_1 F₁ _inst_2 E₁ _inst_3 F₂ _inst_4 E₂ _inst_5 e₁ e₂ x)) x)
+<too large>
 Case conversion may be inaccurate. Consider using '#align trivialization.prod.left_inv Trivialization.Prod.left_invₓ'. -/
 theorem Prod.left_inv {x : TotalSpace (E₁ ×ᵇ E₂)}
     (h : x ∈ @TotalSpace.proj B (E₁ ×ᵇ E₂) ⁻¹' (e₁.baseSet ∩ e₂.baseSet)) :
@@ -264,10 +261,7 @@ theorem Prod.left_inv {x : TotalSpace (E₁ ×ᵇ E₂)}
 #align trivialization.prod.left_inv Trivialization.Prod.left_inv
 
 /- warning: trivialization.prod.right_inv -> Trivialization.Prod.right_inv is a dubious translation:
-lean 3 declaration is
-  forall {B : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} B] {F₁ : Type.{u2}} [_inst_2 : TopologicalSpace.{u2} F₁] {E₁ : B -> Type.{u3}} [_inst_3 : TopologicalSpace.{max u1 u3} (Bundle.TotalSpace.{u1, u3} B E₁)] {F₂ : Type.{u4}} [_inst_4 : TopologicalSpace.{u4} F₂] {E₂ : B -> Type.{u5}} [_inst_5 : TopologicalSpace.{max u1 u5} (Bundle.TotalSpace.{u1, u5} B E₂)] {e₁ : Trivialization.{u1, u2, max u1 u3} B F₁ (Bundle.TotalSpace.{u1, u3} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u1, u3} B E₁)} {e₂ : Trivialization.{u1, u4, max u1 u5} B F₂ (Bundle.TotalSpace.{u1, u5} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u1, u5} B E₂)} [_inst_6 : forall (x : B), Zero.{u3} (E₁ x)] [_inst_7 : forall (x : B), Zero.{u5} (E₂ x)] {x : Prod.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂)}, (Membership.Mem.{max u1 u2 u4, max u1 u2 u4} (Prod.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂)) (Set.{max u1 u2 u4} (Prod.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂))) (Set.hasMem.{max u1 u2 u4} (Prod.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂))) x (Set.prod.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂) (Inter.inter.{u1} (Set.{u1} B) (Set.hasInter.{u1} B) (Trivialization.baseSet.{u1, u2, max u1 u3} B F₁ (Bundle.TotalSpace.{u1, u3} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u1, u3} B E₁) e₁) (Trivialization.baseSet.{u1, u4, max u1 u5} B F₂ (Bundle.TotalSpace.{u1, u5} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u1, u5} B E₂) e₂)) (Set.univ.{max u2 u4} (Prod.{u2, u4} F₁ F₂)))) -> (Eq.{max (succ u1) (succ (max u2 u4))} (Prod.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂)) (Trivialization.Prod.toFun'.{u1, u2, u3, u4, u5} B _inst_1 F₁ _inst_2 E₁ _inst_3 F₂ _inst_4 E₂ _inst_5 e₁ e₂ (Trivialization.Prod.invFun'.{u1, u2, u3, u4, u5} B _inst_1 F₁ _inst_2 (fun (x : B) => E₁ x) _inst_3 F₂ _inst_4 (fun (x : B) => E₂ x) _inst_5 e₁ e₂ (fun (x : B) => _inst_6 x) (fun (x : B) => _inst_7 x) x)) x)
-but is expected to have type
-  forall {B : Type.{u5}} [_inst_1 : TopologicalSpace.{u5} B] {F₁ : Type.{u3}} [_inst_2 : TopologicalSpace.{u3} F₁] {E₁ : B -> Type.{u2}} [_inst_3 : TopologicalSpace.{max u2 u5} (Bundle.TotalSpace.{u5, u2} B E₁)] {F₂ : Type.{u4}} [_inst_4 : TopologicalSpace.{u4} F₂] {E₂ : B -> Type.{u1}} [_inst_5 : TopologicalSpace.{max u1 u5} (Bundle.TotalSpace.{u5, u1} B E₂)] {e₁ : Trivialization.{u5, u3, max u5 u2} B F₁ (Bundle.TotalSpace.{u5, u2} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u5, u2} B E₁)} {e₂ : Trivialization.{u5, u4, max u5 u1} B F₂ (Bundle.TotalSpace.{u5, u1} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u5, u1} B E₂)} [_inst_6 : forall (x : B), Zero.{u2} (E₁ x)] [_inst_7 : forall (x : B), Zero.{u1} (E₂ x)] {x : Prod.{u5, max u4 u3} B (Prod.{u3, u4} F₁ F₂)}, (Membership.mem.{max (max u5 u3) u4, max (max u3 u4) u5} (Prod.{u5, max u4 u3} B (Prod.{u3, u4} F₁ F₂)) (Set.{max (max u3 u4) u5} (Prod.{u5, max u3 u4} B (Prod.{u3, u4} F₁ F₂))) (Set.instMembershipSet.{max (max u5 u3) u4} (Prod.{u5, max u3 u4} B (Prod.{u3, u4} F₁ F₂))) x (Set.prod.{u5, max u3 u4} B (Prod.{u3, u4} F₁ F₂) (Inter.inter.{u5} (Set.{u5} B) (Set.instInterSet.{u5} B) (Trivialization.baseSet.{u5, u3, max u5 u2} B F₁ (Bundle.TotalSpace.{u5, u2} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u5, u2} B E₁) e₁) (Trivialization.baseSet.{u5, u4, max u5 u1} B F₂ (Bundle.TotalSpace.{u5, u1} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u5, u1} B E₂) e₂)) (Set.univ.{max u3 u4} (Prod.{u3, u4} F₁ F₂)))) -> (Eq.{max (max (succ u5) (succ u3)) (succ u4)} (Prod.{u5, max u4 u3} B (Prod.{u3, u4} F₁ F₂)) (Trivialization.Prod.toFun'.{u5, u3, u2, u4, u1} B _inst_1 F₁ _inst_2 E₁ _inst_3 F₂ _inst_4 E₂ _inst_5 e₁ e₂ (Trivialization.Prod.invFun'.{u5, u3, u2, u4, u1} B _inst_1 F₁ _inst_2 (fun (x : B) => E₁ x) _inst_3 F₂ _inst_4 (fun (x : B) => E₂ x) _inst_5 e₁ e₂ (fun (x : B) => _inst_6 x) (fun (x : B) => _inst_7 x) x)) x)
+<too large>
 Case conversion may be inaccurate. Consider using '#align trivialization.prod.right_inv Trivialization.Prod.right_invₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem Prod.right_inv {x : B × F₁ × F₂}
@@ -335,10 +329,7 @@ noncomputable def prod : Trivialization (F₁ × F₂) (π (E₁ ×ᵇ E₂))
 #align trivialization.prod Trivialization.prod
 
 /- warning: trivialization.base_set_prod -> Trivialization.baseSet_prod is a dubious translation:
-lean 3 declaration is
-  forall {B : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} B] {F₁ : Type.{u2}} [_inst_2 : TopologicalSpace.{u2} F₁] {E₁ : B -> Type.{u3}} [_inst_3 : TopologicalSpace.{max u1 u3} (Bundle.TotalSpace.{u1, u3} B E₁)] {F₂ : Type.{u4}} [_inst_4 : TopologicalSpace.{u4} F₂] {E₂ : B -> Type.{u5}} [_inst_5 : TopologicalSpace.{max u1 u5} (Bundle.TotalSpace.{u1, u5} B E₂)] (e₁ : Trivialization.{u1, u2, max u1 u3} B F₁ (Bundle.TotalSpace.{u1, u3} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u1, u3} B E₁)) (e₂ : Trivialization.{u1, u4, max u1 u5} B F₂ (Bundle.TotalSpace.{u1, u5} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u1, u5} B E₂)) [_inst_6 : forall (x : B), Zero.{u3} (E₁ x)] [_inst_7 : forall (x : B), Zero.{u5} (E₂ x)], Eq.{succ u1} (Set.{u1} B) (Trivialization.baseSet.{u1, max u2 u4, max u1 u3 u5} B (Prod.{u2, u4} F₁ F₂) (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))) _inst_1 (Prod.topologicalSpace.{u2, u4} F₁ F₂ _inst_2 _inst_4) (FiberBundle.Prod.topologicalSpace.{u1, u3, u5} B (fun (x : B) => E₁ x) (fun (x : B) => E₂ x) _inst_3 _inst_5) (Bundle.TotalSpace.proj.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))) (Trivialization.prod.{u1, u2, u3, u4, u5} B _inst_1 F₁ _inst_2 E₁ _inst_3 F₂ _inst_4 E₂ _inst_5 e₁ e₂ (fun (x : B) => _inst_6 x) (fun (x : B) => _inst_7 x))) (Inter.inter.{u1} (Set.{u1} B) (Set.hasInter.{u1} B) (Trivialization.baseSet.{u1, u2, max u1 u3} B F₁ (Bundle.TotalSpace.{u1, u3} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u1, u3} B E₁) e₁) (Trivialization.baseSet.{u1, u4, max u1 u5} B F₂ (Bundle.TotalSpace.{u1, u5} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u1, u5} B E₂) e₂))
-but is expected to have type
-  forall {B : Type.{u5}} [_inst_1 : TopologicalSpace.{u5} B] {F₁ : Type.{u4}} [_inst_2 : TopologicalSpace.{u4} F₁] {E₁ : B -> Type.{u2}} [_inst_3 : TopologicalSpace.{max u2 u5} (Bundle.TotalSpace.{u5, u2} B E₁)] {F₂ : Type.{u3}} [_inst_4 : TopologicalSpace.{u3} F₂] {E₂ : B -> Type.{u1}} [_inst_5 : TopologicalSpace.{max u1 u5} (Bundle.TotalSpace.{u5, u1} B E₂)] (e₁ : Trivialization.{u5, u4, max u5 u2} B F₁ (Bundle.TotalSpace.{u5, u2} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u5, u2} B E₁)) (e₂ : Trivialization.{u5, u3, max u5 u1} B F₂ (Bundle.TotalSpace.{u5, u1} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u5, u1} B E₂)) [_inst_6 : forall (x : B), Zero.{u2} (E₁ x)] [_inst_7 : forall (x : B), Zero.{u1} (E₂ x)], Eq.{succ u5} (Set.{u5} B) (Trivialization.baseSet.{u5, max u4 u3, max (max u5 u2) u1} B (Prod.{u4, u3} F₁ F₂) (Bundle.TotalSpace.{u5, max u1 u2} B (fun (x : B) => Prod.{u2, u1} (E₁ x) (E₂ x))) _inst_1 (instTopologicalSpaceProd.{u4, u3} F₁ F₂ _inst_2 _inst_4) (FiberBundle.Prod.topologicalSpace.{u5, u2, u1} B (fun (x : B) => E₁ x) (fun (x : B) => E₂ x) _inst_3 _inst_5) (Bundle.TotalSpace.proj.{u5, max u1 u2} B (fun (x : B) => Prod.{u2, u1} (E₁ x) (E₂ x))) (Trivialization.prod.{u5, u4, u2, u3, u1} B _inst_1 F₁ _inst_2 E₁ _inst_3 F₂ _inst_4 E₂ _inst_5 e₁ e₂ (fun (x : B) => _inst_6 x) (fun (x : B) => _inst_7 x))) (Inter.inter.{u5} (Set.{u5} B) (Set.instInterSet.{u5} B) (Trivialization.baseSet.{u5, u4, max u5 u2} B F₁ (Bundle.TotalSpace.{u5, u2} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u5, u2} B E₁) e₁) (Trivialization.baseSet.{u5, u3, max u5 u1} B F₂ (Bundle.TotalSpace.{u5, u1} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u5, u1} B E₂) e₂))
+<too large>
 Case conversion may be inaccurate. Consider using '#align trivialization.base_set_prod Trivialization.baseSet_prodₓ'. -/
 @[simp]
 theorem baseSet_prod : (prod e₁ e₂).baseSet = e₁.baseSet ∩ e₂.baseSet :=
@@ -346,10 +337,7 @@ theorem baseSet_prod : (prod e₁ e₂).baseSet = e₁.baseSet ∩ e₂.baseSet
 #align trivialization.base_set_prod Trivialization.baseSet_prod
 
 /- warning: trivialization.prod_symm_apply -> Trivialization.prod_symm_apply is a dubious translation:
-lean 3 declaration is
-  forall {B : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} B] {F₁ : Type.{u2}} [_inst_2 : TopologicalSpace.{u2} F₁] {E₁ : B -> Type.{u3}} [_inst_3 : TopologicalSpace.{max u1 u3} (Bundle.TotalSpace.{u1, u3} B E₁)] {F₂ : Type.{u4}} [_inst_4 : TopologicalSpace.{u4} F₂] {E₂ : B -> Type.{u5}} [_inst_5 : TopologicalSpace.{max u1 u5} (Bundle.TotalSpace.{u1, u5} B E₂)] (e₁ : Trivialization.{u1, u2, max u1 u3} B F₁ (Bundle.TotalSpace.{u1, u3} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u1, u3} B E₁)) (e₂ : Trivialization.{u1, u4, max u1 u5} B F₂ (Bundle.TotalSpace.{u1, u5} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u1, u5} B E₂)) [_inst_6 : forall (x : B), Zero.{u3} (E₁ x)] [_inst_7 : forall (x : B), Zero.{u5} (E₂ x)] (x : B) (w₁ : F₁) (w₂ : F₂), Eq.{max (succ u1) (succ (max u3 u5))} (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))) (coeFn.{max (succ (max u1 u2 u4)) (succ (max u1 u3 u5)), max (succ (max u1 u2 u4)) (succ (max u1 u3 u5))} (LocalEquiv.{max u1 u2 u4, max u1 u3 u5} (Prod.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂)) (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x)))) (fun (_x : LocalEquiv.{max u1 u2 u4, max u1 u3 u5} (Prod.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂)) (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x)))) => (Prod.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂)) -> (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x)))) (LocalEquiv.hasCoeToFun.{max u1 u2 u4, max u1 u3 u5} (Prod.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂)) (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x)))) (LocalEquiv.symm.{max u1 u3 u5, max u1 u2 u4} (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))) (Prod.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂)) (LocalHomeomorph.toLocalEquiv.{max u1 u3 u5, max u1 u2 u4} (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))) (Prod.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂)) (FiberBundle.Prod.topologicalSpace.{u1, u3, u5} B (fun (x : B) => E₁ x) (fun (x : B) => E₂ x) _inst_3 _inst_5) (Prod.topologicalSpace.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂) _inst_1 (Prod.topologicalSpace.{u2, u4} F₁ F₂ _inst_2 _inst_4)) (Trivialization.toLocalHomeomorph.{u1, max u2 u4, max u1 u3 u5} B (Prod.{u2, u4} F₁ F₂) (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))) _inst_1 (Prod.topologicalSpace.{u2, u4} F₁ F₂ _inst_2 _inst_4) (FiberBundle.Prod.topologicalSpace.{u1, u3, u5} B (fun (x : B) => E₁ x) (fun (x : B) => E₂ x) _inst_3 _inst_5) (Bundle.TotalSpace.proj.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))) (Trivialization.prod.{u1, u2, u3, u4, u5} B _inst_1 F₁ _inst_2 E₁ _inst_3 F₂ _inst_4 E₂ _inst_5 e₁ e₂ (fun (x : B) => _inst_6 x) (fun (x : B) => _inst_7 x))))) (Prod.mk.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂) x (Prod.mk.{u2, u4} F₁ F₂ w₁ w₂))) (Sigma.mk.{u1, max u3 u5} B (fun (x : B) => (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x)) x) x (Prod.mk.{u3, u5} (E₁ x) (E₂ x) (Trivialization.symm.{u1, u2, u3} B F₁ E₁ _inst_1 _inst_2 _inst_3 (fun (x : B) => _inst_6 x) e₁ x w₁) (Trivialization.symm.{u1, u4, u5} B F₂ E₂ _inst_1 _inst_4 _inst_5 (fun (x : B) => _inst_7 x) e₂ x w₂)))
-but is expected to have type
-  forall {B : Type.{u5}} [_inst_1 : TopologicalSpace.{u5} B] {F₁ : Type.{u2}} [_inst_2 : TopologicalSpace.{u2} F₁] {E₁ : B -> Type.{u4}} [_inst_3 : TopologicalSpace.{max u4 u5} (Bundle.TotalSpace.{u5, u4} B E₁)] {F₂ : Type.{u1}} [_inst_4 : TopologicalSpace.{u1} F₂] {E₂ : B -> Type.{u3}} [_inst_5 : TopologicalSpace.{max u3 u5} (Bundle.TotalSpace.{u5, u3} B E₂)] (e₁ : Trivialization.{u5, u2, max u5 u4} B F₁ (Bundle.TotalSpace.{u5, u4} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u5, u4} B E₁)) (e₂ : Trivialization.{u5, u1, max u5 u3} B F₂ (Bundle.TotalSpace.{u5, u3} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u5, u3} B E₂)) [_inst_6 : forall (x : B), Zero.{u4} (E₁ x)] [_inst_7 : forall (x : B), Zero.{u3} (E₂ x)] (x : B) (w₁ : F₁) (w₂ : F₂), Eq.{max (max (succ u5) (succ u4)) (succ u3)} (Bundle.TotalSpace.{u5, max u3 u4} B (fun (x : B) => Prod.{u4, u3} (E₁ x) (E₂ x))) (LocalEquiv.toFun.{max (max u5 u2) u1, max (max u5 u4) u3} (Prod.{u5, max u2 u1} B (Prod.{u2, u1} F₁ F₂)) (Bundle.TotalSpace.{u5, max u3 u4} B (fun (x._@.Mathlib.Topology.FiberBundle.Constructions._hyg.2275 : B) => Prod.{u4, u3} (E₁ x._@.Mathlib.Topology.FiberBundle.Constructions._hyg.2275) (E₂ x._@.Mathlib.Topology.FiberBundle.Constructions._hyg.2275))) (LocalEquiv.symm.{max (max u5 u4) u3, max (max u5 u2) u1} (Bundle.TotalSpace.{u5, max u3 u4} B (fun (x : B) => Prod.{u4, u3} (E₁ x) (E₂ x))) (Prod.{u5, max u2 u1} B (Prod.{u2, u1} F₁ F₂)) (LocalHomeomorph.toLocalEquiv.{max (max u5 u4) u3, max (max u5 u2) u1} (Bundle.TotalSpace.{u5, max u3 u4} B (fun (x : B) => Prod.{u4, u3} (E₁ x) (E₂ x))) (Prod.{u5, max u2 u1} B (Prod.{u2, u1} F₁ F₂)) (FiberBundle.Prod.topologicalSpace.{u5, u4, u3} B (fun (x : B) => E₁ x) (fun (x : B) => E₂ x) _inst_3 _inst_5) (instTopologicalSpaceProd.{u5, max u2 u1} B (Prod.{u2, u1} F₁ F₂) _inst_1 (instTopologicalSpaceProd.{u2, u1} F₁ F₂ _inst_2 _inst_4)) (Trivialization.toLocalHomeomorph.{u5, max u2 u1, max (max u5 u4) u3} B (Prod.{u2, u1} F₁ F₂) (Bundle.TotalSpace.{u5, max u3 u4} B (fun (x : B) => Prod.{u4, u3} (E₁ x) (E₂ x))) _inst_1 (instTopologicalSpaceProd.{u2, u1} F₁ F₂ _inst_2 _inst_4) (FiberBundle.Prod.topologicalSpace.{u5, u4, u3} B (fun (x : B) => E₁ x) (fun (x : B) => E₂ x) _inst_3 _inst_5) (Bundle.TotalSpace.proj.{u5, max u3 u4} B (fun (x : B) => Prod.{u4, u3} (E₁ x) (E₂ x))) (Trivialization.prod.{u5, u2, u4, u1, u3} B _inst_1 F₁ _inst_2 E₁ _inst_3 F₂ _inst_4 E₂ _inst_5 e₁ e₂ (fun (x : B) => _inst_6 x) (fun (x : B) => _inst_7 x))))) (Prod.mk.{u5, max u2 u1} B (Prod.{u2, u1} F₁ F₂) x (Prod.mk.{u2, u1} F₁ F₂ w₁ w₂))) (Sigma.mk.{u5, max u4 u3} B (fun (x : B) => (fun (x : B) => Prod.{u4, u3} (E₁ x) (E₂ x)) x) x (Prod.mk.{u4, u3} (E₁ x) (E₂ x) (Trivialization.symm.{u5, u2, u4} B F₁ E₁ _inst_1 _inst_2 _inst_3 (fun (x : B) => _inst_6 x) e₁ x w₁) (Trivialization.symm.{u5, u1, u3} B F₂ E₂ _inst_1 _inst_4 _inst_5 (fun (x : B) => _inst_7 x) e₂ x w₂)))
+<too large>
 Case conversion may be inaccurate. Consider using '#align trivialization.prod_symm_apply Trivialization.prod_symm_applyₓ'. -/
 theorem prod_symm_apply (x : B) (w₁ : F₁) (w₂ : F₂) :
     (prod e₁ e₂).toLocalEquiv.symm (x, w₁, w₂) = ⟨x, e₁.symm x w₁, e₂.symm x w₂⟩ :=

bump to nightly-2023-05-21-03

mathlib commit https://github.com/leanprover-community/mathlib/commit/33c67ae661dd8988516ff7f247b0be3018cdd952

7b1466d5

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Nicolò Cavalleri, Sébastien Gouëzel, Heather Macbeth, Floris van Doorn
 
 ! This file was ported from Lean 3 source module topology.fiber_bundle.constructions
-! leanprover-community/mathlib commit be2c24f56783935652cefffb4bfca7e4b25d167e
+! leanprover-community/mathlib commit 33c67ae661dd8988516ff7f247b0be3018cdd952
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -13,6 +13,9 @@ import Mathbin.Topology.FiberBundle.Basic
 /-!
 # Standard constructions on fiber bundles
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 This file contains several standard constructions on fiber bundles:
 
 * `bundle.trivial.fiber_bundle 𝕜 B F`: the trivial fiber bundle with model fiber `F` over the base

bump to nightly-2023-05-18-10

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

ad9cea1f

Diff

@@ -52,6 +52,7 @@ instance [t₁ : TopologicalSpace B] [t₂ : TopologicalSpace F] :
 
 variable [TopologicalSpace B] [TopologicalSpace F]
 
+#print Bundle.Trivial.trivialization /-
 /-- Local trivialization for trivial bundle. -/
 def trivialization : Trivialization F (π (Bundle.Trivial B F))
     where
@@ -81,17 +82,31 @@ def trivialization : Trivialization F (π (Bundle.Trivial B F))
   target_eq := by simp only [univ_prod_univ]
   proj_toFun y hy := rfl
 #align bundle.trivial.trivialization Bundle.Trivial.trivialization
+-/
 
+/- warning: bundle.trivial.trivialization_source -> Bundle.Trivial.trivialization_source is a dubious translation:
+lean 3 declaration is
+  forall (B : Type.{u1}) (F : Type.{u2}) [_inst_1 : TopologicalSpace.{u1} B] [_inst_2 : TopologicalSpace.{u2} F], Eq.{succ (max u1 u2)} (Set.{max u1 u2} (Bundle.TotalSpace.{u1, u2} B (Bundle.Trivial.{u1, u2} B F))) (LocalEquiv.source.{max u1 u2, max u1 u2} (Bundle.TotalSpace.{u1, u2} B (Bundle.Trivial.{u1, u2} B F)) (Prod.{u1, u2} B F) (LocalHomeomorph.toLocalEquiv.{max u1 u2, max u1 u2} (Bundle.TotalSpace.{u1, u2} B (Bundle.Trivial.{u1, u2} B F)) (Prod.{u1, u2} B F) (Bundle.Trivial.Bundle.TotalSpace.topologicalSpace.{u1, u2} B F _inst_1 _inst_2) (Prod.topologicalSpace.{u1, u2} B F _inst_1 _inst_2) (Trivialization.toLocalHomeomorph.{u1, u2, max u1 u2} B F (Bundle.TotalSpace.{u1, u2} B (Bundle.Trivial.{u1, u2} B F)) _inst_1 _inst_2 (Bundle.Trivial.Bundle.TotalSpace.topologicalSpace.{u1, u2} B F _inst_1 _inst_2) (Bundle.TotalSpace.proj.{u1, u2} B (Bundle.Trivial.{u1, u2} B F)) (Bundle.Trivial.trivialization.{u1, u2} B F _inst_1 _inst_2)))) (Set.univ.{max u1 u2} (Bundle.TotalSpace.{u1, u2} B (Bundle.Trivial.{u1, u2} B F)))
+but is expected to have type
+  forall (B : Type.{u2}) (F : Type.{u1}) [_inst_1 : TopologicalSpace.{u2} B] [_inst_2 : TopologicalSpace.{u1} F], Eq.{max (succ u2) (succ u1)} (Set.{max u2 u1} (Bundle.TotalSpace.{u2, u1} B (Bundle.Trivial.{u2, u1} B F))) (LocalEquiv.source.{max u2 u1, max u2 u1} (Bundle.TotalSpace.{u2, u1} B (Bundle.Trivial.{u2, u1} B F)) (Prod.{u2, u1} B F) (LocalHomeomorph.toLocalEquiv.{max u2 u1, max u2 u1} (Bundle.TotalSpace.{u2, u1} B (Bundle.Trivial.{u2, u1} B F)) (Prod.{u2, u1} B F) (Bundle.Trivial.Bundle.TotalSpace.topologicalSpace.{u2, u1} B F _inst_1 _inst_2) (instTopologicalSpaceProd.{u2, u1} B F _inst_1 _inst_2) (Trivialization.toLocalHomeomorph.{u2, u1, max u2 u1} B F (Bundle.TotalSpace.{u2, u1} B (Bundle.Trivial.{u2, u1} B F)) _inst_1 _inst_2 (Bundle.Trivial.Bundle.TotalSpace.topologicalSpace.{u2, u1} B F _inst_1 _inst_2) (Bundle.TotalSpace.proj.{u2, u1} B (Bundle.Trivial.{u2, u1} B F)) (Bundle.Trivial.trivialization.{u2, u1} B F _inst_1 _inst_2)))) (Set.univ.{max u2 u1} (Bundle.TotalSpace.{u2, u1} B (Bundle.Trivial.{u2, u1} B F)))
+Case conversion may be inaccurate. Consider using '#align bundle.trivial.trivialization_source Bundle.Trivial.trivialization_sourceₓ'. -/
 @[simp]
 theorem trivialization_source : (trivialization B F).source = univ :=
   rfl
 #align bundle.trivial.trivialization_source Bundle.Trivial.trivialization_source
 
+/- warning: bundle.trivial.trivialization_target -> Bundle.Trivial.trivialization_target is a dubious translation:
+lean 3 declaration is
+  forall (B : Type.{u1}) (F : Type.{u2}) [_inst_1 : TopologicalSpace.{u1} B] [_inst_2 : TopologicalSpace.{u2} F], Eq.{succ (max u1 u2)} (Set.{max u1 u2} (Prod.{u1, u2} B F)) (LocalEquiv.target.{max u1 u2, max u1 u2} (Bundle.TotalSpace.{u1, u2} B (Bundle.Trivial.{u1, u2} B F)) (Prod.{u1, u2} B F) (LocalHomeomorph.toLocalEquiv.{max u1 u2, max u1 u2} (Bundle.TotalSpace.{u1, u2} B (Bundle.Trivial.{u1, u2} B F)) (Prod.{u1, u2} B F) (Bundle.Trivial.Bundle.TotalSpace.topologicalSpace.{u1, u2} B F _inst_1 _inst_2) (Prod.topologicalSpace.{u1, u2} B F _inst_1 _inst_2) (Trivialization.toLocalHomeomorph.{u1, u2, max u1 u2} B F (Bundle.TotalSpace.{u1, u2} B (Bundle.Trivial.{u1, u2} B F)) _inst_1 _inst_2 (Bundle.Trivial.Bundle.TotalSpace.topologicalSpace.{u1, u2} B F _inst_1 _inst_2) (Bundle.TotalSpace.proj.{u1, u2} B (Bundle.Trivial.{u1, u2} B F)) (Bundle.Trivial.trivialization.{u1, u2} B F _inst_1 _inst_2)))) (Set.univ.{max u1 u2} (Prod.{u1, u2} B F))
+but is expected to have type
+  forall (B : Type.{u2}) (F : Type.{u1}) [_inst_1 : TopologicalSpace.{u2} B] [_inst_2 : TopologicalSpace.{u1} F], Eq.{max (succ u2) (succ u1)} (Set.{max u2 u1} (Prod.{u2, u1} B F)) (LocalEquiv.target.{max u2 u1, max u2 u1} (Bundle.TotalSpace.{u2, u1} B (Bundle.Trivial.{u2, u1} B F)) (Prod.{u2, u1} B F) (LocalHomeomorph.toLocalEquiv.{max u2 u1, max u2 u1} (Bundle.TotalSpace.{u2, u1} B (Bundle.Trivial.{u2, u1} B F)) (Prod.{u2, u1} B F) (Bundle.Trivial.Bundle.TotalSpace.topologicalSpace.{u2, u1} B F _inst_1 _inst_2) (instTopologicalSpaceProd.{u2, u1} B F _inst_1 _inst_2) (Trivialization.toLocalHomeomorph.{u2, u1, max u2 u1} B F (Bundle.TotalSpace.{u2, u1} B (Bundle.Trivial.{u2, u1} B F)) _inst_1 _inst_2 (Bundle.Trivial.Bundle.TotalSpace.topologicalSpace.{u2, u1} B F _inst_1 _inst_2) (Bundle.TotalSpace.proj.{u2, u1} B (Bundle.Trivial.{u2, u1} B F)) (Bundle.Trivial.trivialization.{u2, u1} B F _inst_1 _inst_2)))) (Set.univ.{max u2 u1} (Prod.{u2, u1} B F))
+Case conversion may be inaccurate. Consider using '#align bundle.trivial.trivialization_target Bundle.Trivial.trivialization_targetₓ'. -/
 @[simp]
 theorem trivialization_target : (trivialization B F).target = univ :=
   rfl
 #align bundle.trivial.trivialization_target Bundle.Trivial.trivialization_target
 
+#print Bundle.Trivial.fiberBundle /-
 /-- Fiber bundle instance on the trivial bundle. -/
 instance fiberBundle : FiberBundle F (Bundle.Trivial B F)
     where
@@ -109,7 +124,14 @@ instance fiberBundle : FiberBundle F (Bundle.Trivial B F)
         total_space.proj, induced_const, top_inf_eq, trivial.proj_snd, id.def,
         trivial.topological_space, this, induced_id]⟩
 #align bundle.trivial.fiber_bundle Bundle.Trivial.fiberBundle
+-/
 
+/- warning: bundle.trivial.eq_trivialization -> Bundle.Trivial.eq_trivialization is a dubious translation:
+lean 3 declaration is
+  forall (B : Type.{u1}) (F : Type.{u2}) [_inst_1 : TopologicalSpace.{u1} B] [_inst_2 : TopologicalSpace.{u2} F] (e : Trivialization.{u1, u2, max u1 u2} B F (Bundle.TotalSpace.{u1, u2} B (Bundle.Trivial.{u1, u2} B F)) _inst_1 _inst_2 (Bundle.Trivial.Bundle.TotalSpace.topologicalSpace.{u1, u2} B F _inst_1 _inst_2) (Bundle.TotalSpace.proj.{u1, u2} B (Bundle.Trivial.{u1, u2} B F))) [i : MemTrivializationAtlas.{u1, u2, u2} B F _inst_1 _inst_2 (Bundle.Trivial.{u1, u2} B F) (Bundle.Trivial.Bundle.TotalSpace.topologicalSpace.{u1, u2} B F _inst_1 _inst_2) (fun (b : B) => Bundle.Trivial.topologicalSpace.{u1, u2} B F _inst_2 b) (Bundle.Trivial.fiberBundle.{u1, u2} B F _inst_1 _inst_2) e], Eq.{max (succ u1) (succ u2) (succ (max u1 u2))} (Trivialization.{u1, u2, max u1 u2} B F (Bundle.TotalSpace.{u1, u2} B (Bundle.Trivial.{u1, u2} B F)) _inst_1 _inst_2 (Bundle.Trivial.Bundle.TotalSpace.topologicalSpace.{u1, u2} B F _inst_1 _inst_2) (Bundle.TotalSpace.proj.{u1, u2} B (Bundle.Trivial.{u1, u2} B F))) e (Bundle.Trivial.trivialization.{u1, u2} B F _inst_1 _inst_2)
+but is expected to have type
+  forall (B : Type.{u2}) (F : Type.{u1}) [_inst_1 : TopologicalSpace.{u2} B] [_inst_2 : TopologicalSpace.{u1} F] (e : Trivialization.{u2, u1, max u2 u1} B F (Bundle.TotalSpace.{u2, u1} B (Bundle.Trivial.{u2, u1} B F)) _inst_1 _inst_2 (Bundle.Trivial.Bundle.TotalSpace.topologicalSpace.{u2, u1} B F _inst_1 _inst_2) (Bundle.TotalSpace.proj.{u2, u1} B (Bundle.Trivial.{u2, u1} B F))) [i : MemTrivializationAtlas.{u2, u1, u1} B F _inst_1 _inst_2 (Bundle.Trivial.{u2, u1} B F) (Bundle.Trivial.Bundle.TotalSpace.topologicalSpace.{u2, u1} B F _inst_1 _inst_2) (fun (b : B) => Bundle.Trivial.topologicalSpace.{u2, u1} B F _inst_2 b) (Bundle.Trivial.fiberBundle.{u2, u1} B F _inst_1 _inst_2) e], Eq.{max (succ u2) (succ u1)} (Trivialization.{u2, u1, max u2 u1} B F (Bundle.TotalSpace.{u2, u1} B (Bundle.Trivial.{u2, u1} B F)) _inst_1 _inst_2 (Bundle.Trivial.Bundle.TotalSpace.topologicalSpace.{u2, u1} B F _inst_1 _inst_2) (Bundle.TotalSpace.proj.{u2, u1} B (Bundle.Trivial.{u2, u1} B F))) e (Bundle.Trivial.trivialization.{u2, u1} B F _inst_1 _inst_2)
+Case conversion may be inaccurate. Consider using '#align bundle.trivial.eq_trivialization Bundle.Trivial.eq_trivializationₓ'. -/
 theorem eq_trivialization (e : Trivialization F (π (Bundle.Trivial B F)))
     [i : MemTrivializationAtlas e] : e = trivialization B F :=
   i.out
@@ -132,6 +154,7 @@ variable (E₁ : B → Type _) (E₂ : B → Type _)
 
 variable [TopologicalSpace (TotalSpace E₁)] [TopologicalSpace (TotalSpace E₂)]
 
+#print FiberBundle.Prod.topologicalSpace /-
 /-- Equip the total space of the fiberwise product of two fiber bundles `E₁`, `E₂` with
 the induced topology from the diagonal embedding into `total_space E₁ × total_space E₂`. -/
 instance FiberBundle.Prod.topologicalSpace : TopologicalSpace (TotalSpace (E₁ ×ᵇ E₂)) :=
@@ -139,7 +162,14 @@ instance FiberBundle.Prod.topologicalSpace : TopologicalSpace (TotalSpace (E₁
     (fun p => ((⟨p.1, p.2.1⟩ : TotalSpace E₁), (⟨p.1, p.2.2⟩ : TotalSpace E₂)))
     (by infer_instance : TopologicalSpace (TotalSpace E₁ × TotalSpace E₂))
 #align fiber_bundle.prod.topological_space FiberBundle.Prod.topologicalSpace
+-/
 
+/- warning: fiber_bundle.prod.inducing_diag -> FiberBundle.Prod.inducing_diag is a dubious translation:
+lean 3 declaration is
+  forall {B : Type.{u1}} (E₁ : B -> Type.{u2}) (E₂ : B -> Type.{u3}) [_inst_1 : TopologicalSpace.{max u1 u2} (Bundle.TotalSpace.{u1, u2} B E₁)] [_inst_2 : TopologicalSpace.{max u1 u3} (Bundle.TotalSpace.{u1, u3} B E₂)], Inducing.{max u1 u2 u3, max (max u1 u2) u1 u3} (Bundle.TotalSpace.{u1, max u2 u3} B (fun (x : B) => Prod.{u2, u3} (E₁ x) (E₂ x))) (Prod.{max u1 u2, max u1 u3} (Bundle.TotalSpace.{u1, u2} B E₁) (Bundle.TotalSpace.{u1, u3} B E₂)) (FiberBundle.Prod.topologicalSpace.{u1, u2, u3} B (fun (x : B) => E₁ x) (fun (x : B) => E₂ x) _inst_1 _inst_2) (Prod.topologicalSpace.{max u1 u2, max u1 u3} (Bundle.TotalSpace.{u1, u2} B E₁) (Bundle.TotalSpace.{u1, u3} B E₂) _inst_1 _inst_2) (fun (p : Bundle.TotalSpace.{u1, max u2 u3} B (fun (x : B) => Prod.{u2, u3} (E₁ x) (E₂ x))) => Prod.mk.{max u1 u2, max u1 u3} (Bundle.TotalSpace.{u1, u2} B E₁) (Bundle.TotalSpace.{u1, u3} B E₂) (Sigma.mk.{u1, u2} B (fun (x : B) => E₁ x) (Sigma.fst.{u1, max u2 u3} B (fun (x : B) => (fun (x : B) => Prod.{u2, u3} (E₁ x) (E₂ x)) x) p) (Prod.fst.{u2, u3} (E₁ (Sigma.fst.{u1, max u2 u3} B (fun (x : B) => (fun (x : B) => Prod.{u2, u3} (E₁ x) (E₂ x)) x) p)) (E₂ (Sigma.fst.{u1, max u2 u3} B (fun (x : B) => (fun (x : B) => Prod.{u2, u3} (E₁ x) (E₂ x)) x) p)) (Sigma.snd.{u1, max u2 u3} B (fun (x : B) => (fun (x : B) => Prod.{u2, u3} (E₁ x) (E₂ x)) x) p))) (Sigma.mk.{u1, u3} B (fun (x : B) => E₂ x) (Sigma.fst.{u1, max u2 u3} B (fun (x : B) => (fun (x : B) => Prod.{u2, u3} (E₁ x) (E₂ x)) x) p) (Prod.snd.{u2, u3} (E₁ (Sigma.fst.{u1, max u2 u3} B (fun (x : B) => (fun (x : B) => Prod.{u2, u3} (E₁ x) (E₂ x)) x) p)) (E₂ (Sigma.fst.{u1, max u2 u3} B (fun (x : B) => (fun (x : B) => Prod.{u2, u3} (E₁ x) (E₂ x)) x) p)) (Sigma.snd.{u1, max u2 u3} B (fun (x : B) => (fun (x : B) => Prod.{u2, u3} (E₁ x) (E₂ x)) x) p))))
+but is expected to have type
+  forall {B : Type.{u3}} (E₁ : B -> Type.{u2}) (E₂ : B -> Type.{u1}) [_inst_1 : TopologicalSpace.{max u2 u3} (Bundle.TotalSpace.{u3, u2} B E₁)] [_inst_2 : TopologicalSpace.{max u1 u3} (Bundle.TotalSpace.{u3, u1} B E₂)], Inducing.{max (max u3 u2) u1, max (max u3 u2) u1} (Bundle.TotalSpace.{u3, max u1 u2} B (fun (x : B) => Prod.{u2, u1} (E₁ x) (E₂ x))) (Prod.{max u3 u2, max u3 u1} (Bundle.TotalSpace.{u3, u2} B E₁) (Bundle.TotalSpace.{u3, u1} B E₂)) (FiberBundle.Prod.topologicalSpace.{u3, u2, u1} B (fun (x : B) => E₁ x) (fun (x : B) => E₂ x) _inst_1 _inst_2) (instTopologicalSpaceProd.{max u3 u2, max u3 u1} (Bundle.TotalSpace.{u3, u2} B E₁) (Bundle.TotalSpace.{u3, u1} B E₂) _inst_1 _inst_2) (fun (p : Bundle.TotalSpace.{u3, max u1 u2} B (fun (x : B) => Prod.{u2, u1} (E₁ x) (E₂ x))) => Prod.mk.{max u3 u2, max u3 u1} (Bundle.TotalSpace.{u3, u2} B E₁) (Bundle.TotalSpace.{u3, u1} B E₂) (Sigma.mk.{u3, u2} B (fun (x : B) => E₁ x) (Sigma.fst.{u3, max u2 u1} B (fun (x : B) => (fun (x : B) => Prod.{u2, u1} (E₁ x) (E₂ x)) x) p) (Prod.fst.{u2, u1} (E₁ (Sigma.fst.{u3, max u2 u1} B (fun (x : B) => (fun (x : B) => Prod.{u2, u1} (E₁ x) (E₂ x)) x) p)) (E₂ (Sigma.fst.{u3, max u2 u1} B (fun (x : B) => (fun (x : B) => Prod.{u2, u1} (E₁ x) (E₂ x)) x) p)) (Sigma.snd.{u3, max u2 u1} B (fun (x : B) => (fun (x : B) => Prod.{u2, u1} (E₁ x) (E₂ x)) x) p))) (Sigma.mk.{u3, u1} B (fun (x : B) => E₂ x) (Sigma.fst.{u3, max u2 u1} B (fun (x : B) => (fun (x : B) => Prod.{u2, u1} (E₁ x) (E₂ x)) x) p) (Prod.snd.{u2, u1} (E₁ (Sigma.fst.{u3, max u2 u1} B (fun (x : B) => (fun (x : B) => Prod.{u2, u1} (E₁ x) (E₂ x)) x) p)) (E₂ (Sigma.fst.{u3, max u2 u1} B (fun (x : B) => (fun (x : B) => Prod.{u2, u1} (E₁ x) (E₂ x)) x) p)) (Sigma.snd.{u3, max u2 u1} B (fun (x : B) => (fun (x : B) => Prod.{u2, u1} (E₁ x) (E₂ x)) x) p))))
+Case conversion may be inaccurate. Consider using '#align fiber_bundle.prod.inducing_diag FiberBundle.Prod.inducing_diagₓ'. -/
 /-- The diagonal map from the total space of the fiberwise product of two fiber bundles
 `E₁`, `E₂` into `total_space E₁ × total_space E₂` is `inducing`. -/
 theorem FiberBundle.Prod.inducing_diag :
@@ -161,15 +191,23 @@ namespace Trivialization
 
 variable {F₁ E₁ F₂ E₂} (e₁ : Trivialization F₁ (π E₁)) (e₂ : Trivialization F₂ (π E₂))
 
+#print Trivialization.Prod.toFun' /-
 /-- Given trivializations `e₁`, `e₂` for fiber bundles `E₁`, `E₂` over a base `B`, the forward
 function for the construction `trivialization.prod`, the induced
 trivialization for the fiberwise product of `E₁` and `E₂`. -/
 def Prod.toFun' : TotalSpace (E₁ ×ᵇ E₂) → B × F₁ × F₂ := fun p =>
   ⟨p.1, (e₁ ⟨p.1, p.2.1⟩).2, (e₂ ⟨p.1, p.2.2⟩).2⟩
 #align trivialization.prod.to_fun' Trivialization.Prod.toFun'
+-/
 
 variable {e₁ e₂}
 
+/- warning: trivialization.prod.continuous_to_fun -> Trivialization.Prod.continuous_to_fun is a dubious translation:
+lean 3 declaration is
+  forall {B : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} B] {F₁ : Type.{u2}} [_inst_2 : TopologicalSpace.{u2} F₁] {E₁ : B -> Type.{u3}} [_inst_3 : TopologicalSpace.{max u1 u3} (Bundle.TotalSpace.{u1, u3} B E₁)] {F₂ : Type.{u4}} [_inst_4 : TopologicalSpace.{u4} F₂] {E₂ : B -> Type.{u5}} [_inst_5 : TopologicalSpace.{max u1 u5} (Bundle.TotalSpace.{u1, u5} B E₂)] {e₁ : Trivialization.{u1, u2, max u1 u3} B F₁ (Bundle.TotalSpace.{u1, u3} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u1, u3} B E₁)} {e₂ : Trivialization.{u1, u4, max u1 u5} B F₂ (Bundle.TotalSpace.{u1, u5} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u1, u5} B E₂)}, ContinuousOn.{max u1 u3 u5, max u1 u2 u4} (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))) (Prod.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂)) (FiberBundle.Prod.topologicalSpace.{u1, u3, u5} B (fun (x : B) => E₁ x) (fun (x : B) => E₂ x) _inst_3 _inst_5) (Prod.topologicalSpace.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂) _inst_1 (Prod.topologicalSpace.{u2, u4} F₁ F₂ _inst_2 _inst_4)) (Trivialization.Prod.toFun'.{u1, u2, u3, u4, u5} B _inst_1 F₁ _inst_2 E₁ _inst_3 F₂ _inst_4 E₂ _inst_5 e₁ e₂) (Set.preimage.{max u1 u3 u5, u1} (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))) B (Bundle.TotalSpace.proj.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))) (Inter.inter.{u1} (Set.{u1} B) (Set.hasInter.{u1} B) (Trivialization.baseSet.{u1, u2, max u1 u3} B F₁ (Bundle.TotalSpace.{u1, u3} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u1, u3} B E₁) e₁) (Trivialization.baseSet.{u1, u4, max u1 u5} B F₂ (Bundle.TotalSpace.{u1, u5} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u1, u5} B E₂) e₂)))
+but is expected to have type
+  forall {B : Type.{u3}} [_inst_1 : TopologicalSpace.{u3} B] {F₁ : Type.{u1}} [_inst_2 : TopologicalSpace.{u1} F₁] {E₁ : B -> Type.{u4}} [_inst_3 : TopologicalSpace.{max u4 u3} (Bundle.TotalSpace.{u3, u4} B E₁)] {F₂ : Type.{u2}} [_inst_4 : TopologicalSpace.{u2} F₂] {E₂ : B -> Type.{u5}} [_inst_5 : TopologicalSpace.{max u5 u3} (Bundle.TotalSpace.{u3, u5} B E₂)] {e₁ : Trivialization.{u3, u1, max u3 u4} B F₁ (Bundle.TotalSpace.{u3, u4} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u3, u4} B E₁)} {e₂ : Trivialization.{u3, u2, max u3 u5} B F₂ (Bundle.TotalSpace.{u3, u5} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u3, u5} B E₂)}, ContinuousOn.{max (max u5 u4) u3, max (max u2 u1) u3} (Bundle.TotalSpace.{u3, max u5 u4} B (fun (x : B) => Prod.{u4, u5} (E₁ x) (E₂ x))) (Prod.{u3, max u2 u1} B (Prod.{u1, u2} F₁ F₂)) (FiberBundle.Prod.topologicalSpace.{u3, u4, u5} B (fun (x : B) => E₁ x) (fun (x : B) => E₂ x) _inst_3 _inst_5) (instTopologicalSpaceProd.{u3, max u1 u2} B (Prod.{u1, u2} F₁ F₂) _inst_1 (instTopologicalSpaceProd.{u1, u2} F₁ F₂ _inst_2 _inst_4)) (Trivialization.Prod.toFun'.{u3, u1, u4, u2, u5} B _inst_1 F₁ _inst_2 E₁ _inst_3 F₂ _inst_4 E₂ _inst_5 e₁ e₂) (Set.preimage.{max (max u3 u4) u5, u3} (Bundle.TotalSpace.{u3, max u5 u4} B (fun (x : B) => Prod.{u4, u5} (E₁ x) (E₂ x))) B (Bundle.TotalSpace.proj.{u3, max u5 u4} B (fun (x : B) => Prod.{u4, u5} (E₁ x) (E₂ x))) (Inter.inter.{u3} (Set.{u3} B) (Set.instInterSet.{u3} B) (Trivialization.baseSet.{u3, u1, max u3 u4} B F₁ (Bundle.TotalSpace.{u3, u4} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u3, u4} B E₁) e₁) (Trivialization.baseSet.{u3, u2, max u3 u5} B F₂ (Bundle.TotalSpace.{u3, u5} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u3, u5} B E₂) e₂)))
+Case conversion may be inaccurate. Consider using '#align trivialization.prod.continuous_to_fun Trivialization.Prod.continuous_to_funₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem Prod.continuous_to_fun :
     ContinuousOn (Prod.toFun' e₁ e₂)
@@ -196,15 +234,23 @@ theorem Prod.continuous_to_fun :
 
 variable (e₁ e₂) [∀ x, Zero (E₁ x)] [∀ x, Zero (E₂ x)]
 
+#print Trivialization.Prod.invFun' /-
 /-- Given trivializations `e₁`, `e₂` for fiber bundles `E₁`, `E₂` over a base `B`, the inverse
 function for the construction `trivialization.prod`, the induced
 trivialization for the fiberwise product of `E₁` and `E₂`. -/
 noncomputable def Prod.invFun' (p : B × F₁ × F₂) : TotalSpace (E₁ ×ᵇ E₂) :=
   ⟨p.1, e₁.symm p.1 p.2.1, e₂.symm p.1 p.2.2⟩
 #align trivialization.prod.inv_fun' Trivialization.Prod.invFun'
+-/
 
 variable {e₁ e₂}
 
+/- warning: trivialization.prod.left_inv -> Trivialization.Prod.left_inv is a dubious translation:
+lean 3 declaration is
+  forall {B : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} B] {F₁ : Type.{u2}} [_inst_2 : TopologicalSpace.{u2} F₁] {E₁ : B -> Type.{u3}} [_inst_3 : TopologicalSpace.{max u1 u3} (Bundle.TotalSpace.{u1, u3} B E₁)] {F₂ : Type.{u4}} [_inst_4 : TopologicalSpace.{u4} F₂] {E₂ : B -> Type.{u5}} [_inst_5 : TopologicalSpace.{max u1 u5} (Bundle.TotalSpace.{u1, u5} B E₂)] {e₁ : Trivialization.{u1, u2, max u1 u3} B F₁ (Bundle.TotalSpace.{u1, u3} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u1, u3} B E₁)} {e₂ : Trivialization.{u1, u4, max u1 u5} B F₂ (Bundle.TotalSpace.{u1, u5} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u1, u5} B E₂)} [_inst_6 : forall (x : B), Zero.{u3} (E₁ x)] [_inst_7 : forall (x : B), Zero.{u5} (E₂ x)] {x : Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))}, (Membership.Mem.{max u1 u3 u5, max u1 u3 u5} (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))) (Set.{max u1 u3 u5} (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x)))) (Set.hasMem.{max u1 u3 u5} (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x)))) x (Set.preimage.{max u1 u3 u5, u1} (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))) B (Bundle.TotalSpace.proj.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))) (Inter.inter.{u1} (Set.{u1} B) (Set.hasInter.{u1} B) (Trivialization.baseSet.{u1, u2, max u1 u3} B F₁ (Bundle.TotalSpace.{u1, u3} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u1, u3} B E₁) e₁) (Trivialization.baseSet.{u1, u4, max u1 u5} B F₂ (Bundle.TotalSpace.{u1, u5} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u1, u5} B E₂) e₂)))) -> (Eq.{max (succ u1) (succ (max u3 u5))} (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))) (Trivialization.Prod.invFun'.{u1, u2, u3, u4, u5} B _inst_1 F₁ _inst_2 E₁ _inst_3 F₂ _inst_4 E₂ _inst_5 e₁ e₂ (fun (x : B) => _inst_6 x) (fun (x : B) => _inst_7 x) (Trivialization.Prod.toFun'.{u1, u2, u3, u4, u5} B _inst_1 F₁ _inst_2 E₁ _inst_3 F₂ _inst_4 E₂ _inst_5 e₁ e₂ x)) x)
+but is expected to have type
+  forall {B : Type.{u5}} [_inst_1 : TopologicalSpace.{u5} B] {F₁ : Type.{u2}} [_inst_2 : TopologicalSpace.{u2} F₁] {E₁ : B -> Type.{u3}} [_inst_3 : TopologicalSpace.{max u3 u5} (Bundle.TotalSpace.{u5, u3} B E₁)] {F₂ : Type.{u1}} [_inst_4 : TopologicalSpace.{u1} F₂] {E₂ : B -> Type.{u4}} [_inst_5 : TopologicalSpace.{max u4 u5} (Bundle.TotalSpace.{u5, u4} B E₂)] {e₁ : Trivialization.{u5, u2, max u5 u3} B F₁ (Bundle.TotalSpace.{u5, u3} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u5, u3} B E₁)} {e₂ : Trivialization.{u5, u1, max u5 u4} B F₂ (Bundle.TotalSpace.{u5, u4} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u5, u4} B E₂)} [_inst_6 : forall (x : B), Zero.{u3} (E₁ x)] [_inst_7 : forall (x : B), Zero.{u4} (E₂ x)] {x : Bundle.TotalSpace.{u5, max u4 u3} B (fun (x : B) => Prod.{u3, u4} (E₁ x) (E₂ x))}, (Membership.mem.{max (max u5 u3) u4, max (max u5 u3) u4} (Bundle.TotalSpace.{u5, max u4 u3} B (fun (x : B) => Prod.{u3, u4} (E₁ x) (E₂ x))) (Set.{max (max u5 u3) u4} (Bundle.TotalSpace.{u5, max u4 u3} B (fun (x : B) => Prod.{u3, u4} (E₁ x) (E₂ x)))) (Set.instMembershipSet.{max (max u5 u3) u4} (Bundle.TotalSpace.{u5, max u4 u3} B (fun (x : B) => Prod.{u3, u4} (E₁ x) (E₂ x)))) x (Set.preimage.{max (max u5 u3) u4, u5} (Bundle.TotalSpace.{u5, max u4 u3} B (fun (x : B) => Prod.{u3, u4} (E₁ x) (E₂ x))) B (Bundle.TotalSpace.proj.{u5, max u4 u3} B (fun (x : B) => Prod.{u3, u4} (E₁ x) (E₂ x))) (Inter.inter.{u5} (Set.{u5} B) (Set.instInterSet.{u5} B) (Trivialization.baseSet.{u5, u2, max u5 u3} B F₁ (Bundle.TotalSpace.{u5, u3} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u5, u3} B E₁) e₁) (Trivialization.baseSet.{u5, u1, max u5 u4} B F₂ (Bundle.TotalSpace.{u5, u4} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u5, u4} B E₂) e₂)))) -> (Eq.{max (max (succ u5) (succ u3)) (succ u4)} (Bundle.TotalSpace.{u5, max u4 u3} B (fun (x : B) => Prod.{u3, u4} (E₁ x) (E₂ x))) (Trivialization.Prod.invFun'.{u5, u2, u3, u1, u4} B _inst_1 F₁ _inst_2 E₁ _inst_3 F₂ _inst_4 E₂ _inst_5 e₁ e₂ (fun (x : B) => _inst_6 x) (fun (x : B) => _inst_7 x) (Trivialization.Prod.toFun'.{u5, u2, u3, u1, u4} B _inst_1 F₁ _inst_2 E₁ _inst_3 F₂ _inst_4 E₂ _inst_5 e₁ e₂ x)) x)
+Case conversion may be inaccurate. Consider using '#align trivialization.prod.left_inv Trivialization.Prod.left_invₓ'. -/
 theorem Prod.left_inv {x : TotalSpace (E₁ ×ᵇ E₂)}
     (h : x ∈ @TotalSpace.proj B (E₁ ×ᵇ E₂) ⁻¹' (e₁.baseSet ∩ e₂.baseSet)) :
     Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x :=
@@ -214,6 +260,12 @@ theorem Prod.left_inv {x : TotalSpace (E₁ ×ᵇ E₂)}
   simp only [prod.to_fun', prod.inv_fun', symm_apply_apply_mk, h₁, h₂]
 #align trivialization.prod.left_inv Trivialization.Prod.left_inv
 
+/- warning: trivialization.prod.right_inv -> Trivialization.Prod.right_inv is a dubious translation:
+lean 3 declaration is
+  forall {B : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} B] {F₁ : Type.{u2}} [_inst_2 : TopologicalSpace.{u2} F₁] {E₁ : B -> Type.{u3}} [_inst_3 : TopologicalSpace.{max u1 u3} (Bundle.TotalSpace.{u1, u3} B E₁)] {F₂ : Type.{u4}} [_inst_4 : TopologicalSpace.{u4} F₂] {E₂ : B -> Type.{u5}} [_inst_5 : TopologicalSpace.{max u1 u5} (Bundle.TotalSpace.{u1, u5} B E₂)] {e₁ : Trivialization.{u1, u2, max u1 u3} B F₁ (Bundle.TotalSpace.{u1, u3} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u1, u3} B E₁)} {e₂ : Trivialization.{u1, u4, max u1 u5} B F₂ (Bundle.TotalSpace.{u1, u5} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u1, u5} B E₂)} [_inst_6 : forall (x : B), Zero.{u3} (E₁ x)] [_inst_7 : forall (x : B), Zero.{u5} (E₂ x)] {x : Prod.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂)}, (Membership.Mem.{max u1 u2 u4, max u1 u2 u4} (Prod.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂)) (Set.{max u1 u2 u4} (Prod.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂))) (Set.hasMem.{max u1 u2 u4} (Prod.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂))) x (Set.prod.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂) (Inter.inter.{u1} (Set.{u1} B) (Set.hasInter.{u1} B) (Trivialization.baseSet.{u1, u2, max u1 u3} B F₁ (Bundle.TotalSpace.{u1, u3} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u1, u3} B E₁) e₁) (Trivialization.baseSet.{u1, u4, max u1 u5} B F₂ (Bundle.TotalSpace.{u1, u5} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u1, u5} B E₂) e₂)) (Set.univ.{max u2 u4} (Prod.{u2, u4} F₁ F₂)))) -> (Eq.{max (succ u1) (succ (max u2 u4))} (Prod.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂)) (Trivialization.Prod.toFun'.{u1, u2, u3, u4, u5} B _inst_1 F₁ _inst_2 E₁ _inst_3 F₂ _inst_4 E₂ _inst_5 e₁ e₂ (Trivialization.Prod.invFun'.{u1, u2, u3, u4, u5} B _inst_1 F₁ _inst_2 (fun (x : B) => E₁ x) _inst_3 F₂ _inst_4 (fun (x : B) => E₂ x) _inst_5 e₁ e₂ (fun (x : B) => _inst_6 x) (fun (x : B) => _inst_7 x) x)) x)
+but is expected to have type
+  forall {B : Type.{u5}} [_inst_1 : TopologicalSpace.{u5} B] {F₁ : Type.{u3}} [_inst_2 : TopologicalSpace.{u3} F₁] {E₁ : B -> Type.{u2}} [_inst_3 : TopologicalSpace.{max u2 u5} (Bundle.TotalSpace.{u5, u2} B E₁)] {F₂ : Type.{u4}} [_inst_4 : TopologicalSpace.{u4} F₂] {E₂ : B -> Type.{u1}} [_inst_5 : TopologicalSpace.{max u1 u5} (Bundle.TotalSpace.{u5, u1} B E₂)] {e₁ : Trivialization.{u5, u3, max u5 u2} B F₁ (Bundle.TotalSpace.{u5, u2} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u5, u2} B E₁)} {e₂ : Trivialization.{u5, u4, max u5 u1} B F₂ (Bundle.TotalSpace.{u5, u1} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u5, u1} B E₂)} [_inst_6 : forall (x : B), Zero.{u2} (E₁ x)] [_inst_7 : forall (x : B), Zero.{u1} (E₂ x)] {x : Prod.{u5, max u4 u3} B (Prod.{u3, u4} F₁ F₂)}, (Membership.mem.{max (max u5 u3) u4, max (max u3 u4) u5} (Prod.{u5, max u4 u3} B (Prod.{u3, u4} F₁ F₂)) (Set.{max (max u3 u4) u5} (Prod.{u5, max u3 u4} B (Prod.{u3, u4} F₁ F₂))) (Set.instMembershipSet.{max (max u5 u3) u4} (Prod.{u5, max u3 u4} B (Prod.{u3, u4} F₁ F₂))) x (Set.prod.{u5, max u3 u4} B (Prod.{u3, u4} F₁ F₂) (Inter.inter.{u5} (Set.{u5} B) (Set.instInterSet.{u5} B) (Trivialization.baseSet.{u5, u3, max u5 u2} B F₁ (Bundle.TotalSpace.{u5, u2} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u5, u2} B E₁) e₁) (Trivialization.baseSet.{u5, u4, max u5 u1} B F₂ (Bundle.TotalSpace.{u5, u1} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u5, u1} B E₂) e₂)) (Set.univ.{max u3 u4} (Prod.{u3, u4} F₁ F₂)))) -> (Eq.{max (max (succ u5) (succ u3)) (succ u4)} (Prod.{u5, max u4 u3} B (Prod.{u3, u4} F₁ F₂)) (Trivialization.Prod.toFun'.{u5, u3, u2, u4, u1} B _inst_1 F₁ _inst_2 E₁ _inst_3 F₂ _inst_4 E₂ _inst_5 e₁ e₂ (Trivialization.Prod.invFun'.{u5, u3, u2, u4, u1} B _inst_1 F₁ _inst_2 (fun (x : B) => E₁ x) _inst_3 F₂ _inst_4 (fun (x : B) => E₂ x) _inst_5 e₁ e₂ (fun (x : B) => _inst_6 x) (fun (x : B) => _inst_7 x) x)) x)
+Case conversion may be inaccurate. Consider using '#align trivialization.prod.right_inv Trivialization.Prod.right_invₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem Prod.right_inv {x : B × F₁ × F₂}
     (h : x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ (univ : Set (F₁ × F₂))) :
@@ -224,6 +276,12 @@ theorem Prod.right_inv {x : B × F₁ × F₂}
   simp only [prod.to_fun', prod.inv_fun', apply_mk_symm, h₁, h₂]
 #align trivialization.prod.right_inv Trivialization.Prod.right_inv
 
+/- warning: trivialization.prod.continuous_inv_fun -> Trivialization.Prod.continuous_inv_fun is a dubious translation:
+lean 3 declaration is
+  forall {B : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} B] {F₁ : Type.{u2}} [_inst_2 : TopologicalSpace.{u2} F₁] {E₁ : B -> Type.{u3}} [_inst_3 : TopologicalSpace.{max u1 u3} (Bundle.TotalSpace.{u1, u3} B E₁)] {F₂ : Type.{u4}} [_inst_4 : TopologicalSpace.{u4} F₂] {E₂ : B -> Type.{u5}} [_inst_5 : TopologicalSpace.{max u1 u5} (Bundle.TotalSpace.{u1, u5} B E₂)] {e₁ : Trivialization.{u1, u2, max u1 u3} B F₁ (Bundle.TotalSpace.{u1, u3} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u1, u3} B E₁)} {e₂ : Trivialization.{u1, u4, max u1 u5} B F₂ (Bundle.TotalSpace.{u1, u5} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u1, u5} B E₂)} [_inst_6 : forall (x : B), Zero.{u3} (E₁ x)] [_inst_7 : forall (x : B), Zero.{u5} (E₂ x)], ContinuousOn.{max u1 u2 u4, max u1 u3 u5} (Prod.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂)) (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))) (Prod.topologicalSpace.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂) _inst_1 (Prod.topologicalSpace.{u2, u4} F₁ F₂ _inst_2 _inst_4)) (FiberBundle.Prod.topologicalSpace.{u1, u3, u5} B (fun (x : B) => E₁ x) (fun (x : B) => E₂ x) _inst_3 _inst_5) (Trivialization.Prod.invFun'.{u1, u2, u3, u4, u5} B _inst_1 F₁ _inst_2 E₁ _inst_3 F₂ _inst_4 E₂ _inst_5 e₁ e₂ (fun (x : B) => _inst_6 x) (fun (x : B) => _inst_7 x)) (Set.prod.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂) (Inter.inter.{u1} (Set.{u1} B) (Set.hasInter.{u1} B) (Trivialization.baseSet.{u1, u2, max u1 u3} B F₁ (Bundle.TotalSpace.{u1, u3} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u1, u3} B E₁) e₁) (Trivialization.baseSet.{u1, u4, max u1 u5} B F₂ (Bundle.TotalSpace.{u1, u5} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u1, u5} B E₂) e₂)) (Set.univ.{max u2 u4} (Prod.{u2, u4} F₁ F₂)))
+but is expected to have type
+  forall {B : Type.{u3}} [_inst_1 : TopologicalSpace.{u3} B] {F₁ : Type.{u4}} [_inst_2 : TopologicalSpace.{u4} F₁] {E₁ : B -> Type.{u1}} [_inst_3 : TopologicalSpace.{max u1 u3} (Bundle.TotalSpace.{u3, u1} B E₁)] {F₂ : Type.{u5}} [_inst_4 : TopologicalSpace.{u5} F₂] {E₂ : B -> Type.{u2}} [_inst_5 : TopologicalSpace.{max u2 u3} (Bundle.TotalSpace.{u3, u2} B E₂)] {e₁ : Trivialization.{u3, u4, max u3 u1} B F₁ (Bundle.TotalSpace.{u3, u1} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u3, u1} B E₁)} {e₂ : Trivialization.{u3, u5, max u3 u2} B F₂ (Bundle.TotalSpace.{u3, u2} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u3, u2} B E₂)} [_inst_6 : forall (x : B), Zero.{u1} (E₁ x)] [_inst_7 : forall (x : B), Zero.{u2} (E₂ x)], ContinuousOn.{max (max u5 u4) u3, max (max u2 u1) u3} (Prod.{u3, max u5 u4} B (Prod.{u4, u5} F₁ F₂)) (Bundle.TotalSpace.{u3, max u2 u1} B (fun (x : B) => Prod.{u1, u2} (E₁ x) (E₂ x))) (instTopologicalSpaceProd.{u3, max u4 u5} B (Prod.{u4, u5} F₁ F₂) _inst_1 (instTopologicalSpaceProd.{u4, u5} F₁ F₂ _inst_2 _inst_4)) (FiberBundle.Prod.topologicalSpace.{u3, u1, u2} B (fun (x : B) => E₁ x) (fun (x : B) => E₂ x) _inst_3 _inst_5) (Trivialization.Prod.invFun'.{u3, u4, u1, u5, u2} B _inst_1 F₁ _inst_2 E₁ _inst_3 F₂ _inst_4 E₂ _inst_5 e₁ e₂ (fun (x : B) => _inst_6 x) (fun (x : B) => _inst_7 x)) (Set.prod.{u3, max u4 u5} B (Prod.{u4, u5} F₁ F₂) (Inter.inter.{u3} (Set.{u3} B) (Set.instInterSet.{u3} B) (Trivialization.baseSet.{u3, u4, max u3 u1} B F₁ (Bundle.TotalSpace.{u3, u1} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u3, u1} B E₁) e₁) (Trivialization.baseSet.{u3, u5, max u3 u2} B F₂ (Bundle.TotalSpace.{u3, u2} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u3, u2} B E₂) e₂)) (Set.univ.{max u4 u5} (Prod.{u4, u5} F₁ F₂)))
+Case conversion may be inaccurate. Consider using '#align trivialization.prod.continuous_inv_fun Trivialization.Prod.continuous_inv_funₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem Prod.continuous_inv_fun :
     ContinuousOn (Prod.invFun' e₁ e₂) ((e₁.baseSet ∩ e₂.baseSet) ×ˢ univ) :=
@@ -237,6 +295,12 @@ theorem Prod.continuous_inv_fun :
 
 variable (e₁ e₂ e₁ e₂)
 
+/- warning: trivialization.prod -> Trivialization.prod is a dubious translation:
+lean 3 declaration is
+  forall {B : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} B] {F₁ : Type.{u2}} [_inst_2 : TopologicalSpace.{u2} F₁] {E₁ : B -> Type.{u3}} [_inst_3 : TopologicalSpace.{max u1 u3} (Bundle.TotalSpace.{u1, u3} B E₁)] {F₂ : Type.{u4}} [_inst_4 : TopologicalSpace.{u4} F₂] {E₂ : B -> Type.{u5}} [_inst_5 : TopologicalSpace.{max u1 u5} (Bundle.TotalSpace.{u1, u5} B E₂)], (Trivialization.{u1, u2, max u1 u3} B F₁ (Bundle.TotalSpace.{u1, u3} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u1, u3} B E₁)) -> (Trivialization.{u1, u4, max u1 u5} B F₂ (Bundle.TotalSpace.{u1, u5} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u1, u5} B E₂)) -> (forall [_inst_6 : forall (x : B), Zero.{u3} (E₁ x)] [_inst_7 : forall (x : B), Zero.{u5} (E₂ x)], Trivialization.{u1, max u2 u4, max u1 u3 u5} B (Prod.{u2, u4} F₁ F₂) (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))) _inst_1 (Prod.topologicalSpace.{u2, u4} F₁ F₂ _inst_2 _inst_4) (FiberBundle.Prod.topologicalSpace.{u1, u3, u5} B (fun (x : B) => E₁ x) (fun (x : B) => E₂ x) _inst_3 _inst_5) (Bundle.TotalSpace.proj.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))))
+but is expected to have type
+  forall {B : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} B] {F₁ : Type.{u2}} [_inst_2 : TopologicalSpace.{u2} F₁] {E₁ : B -> Type.{u3}} [_inst_3 : TopologicalSpace.{max u3 u1} (Bundle.TotalSpace.{u1, u3} B E₁)] {F₂ : Type.{u4}} [_inst_4 : TopologicalSpace.{u4} F₂] {E₂ : B -> Type.{u5}} [_inst_5 : TopologicalSpace.{max u5 u1} (Bundle.TotalSpace.{u1, u5} B E₂)], (Trivialization.{u1, u2, max u1 u3} B F₁ (Bundle.TotalSpace.{u1, u3} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u1, u3} B E₁)) -> (Trivialization.{u1, u4, max u1 u5} B F₂ (Bundle.TotalSpace.{u1, u5} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u1, u5} B E₂)) -> (forall [_inst_6 : forall (x : B), Zero.{u3} (E₁ x)] [_inst_7 : forall (x : B), Zero.{u5} (E₂ x)], Trivialization.{u1, max u4 u2, max (max u1 u3) u5} B (Prod.{u2, u4} F₁ F₂) (Bundle.TotalSpace.{u1, max u5 u3} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))) _inst_1 (instTopologicalSpaceProd.{u2, u4} F₁ F₂ _inst_2 _inst_4) (FiberBundle.Prod.topologicalSpace.{u1, u3, u5} B (fun (x : B) => E₁ x) (fun (x : B) => E₂ x) _inst_3 _inst_5) (Bundle.TotalSpace.proj.{u1, max u5 u3} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))))
+Case conversion may be inaccurate. Consider using '#align trivialization.prod Trivialization.prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /-- Given trivializations `e₁`, `e₂` for bundle types `E₁`, `E₂` over a base `B`, the induced
 trivialization for the fiberwise product of `E₁` and `E₂`, whose base set is
@@ -267,11 +331,23 @@ noncomputable def prod : Trivialization (F₁ × F₂) (π (E₁ ×ᵇ E₂))
   proj_toFun x h := rfl
 #align trivialization.prod Trivialization.prod
 
+/- warning: trivialization.base_set_prod -> Trivialization.baseSet_prod is a dubious translation:
+lean 3 declaration is
+  forall {B : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} B] {F₁ : Type.{u2}} [_inst_2 : TopologicalSpace.{u2} F₁] {E₁ : B -> Type.{u3}} [_inst_3 : TopologicalSpace.{max u1 u3} (Bundle.TotalSpace.{u1, u3} B E₁)] {F₂ : Type.{u4}} [_inst_4 : TopologicalSpace.{u4} F₂] {E₂ : B -> Type.{u5}} [_inst_5 : TopologicalSpace.{max u1 u5} (Bundle.TotalSpace.{u1, u5} B E₂)] (e₁ : Trivialization.{u1, u2, max u1 u3} B F₁ (Bundle.TotalSpace.{u1, u3} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u1, u3} B E₁)) (e₂ : Trivialization.{u1, u4, max u1 u5} B F₂ (Bundle.TotalSpace.{u1, u5} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u1, u5} B E₂)) [_inst_6 : forall (x : B), Zero.{u3} (E₁ x)] [_inst_7 : forall (x : B), Zero.{u5} (E₂ x)], Eq.{succ u1} (Set.{u1} B) (Trivialization.baseSet.{u1, max u2 u4, max u1 u3 u5} B (Prod.{u2, u4} F₁ F₂) (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))) _inst_1 (Prod.topologicalSpace.{u2, u4} F₁ F₂ _inst_2 _inst_4) (FiberBundle.Prod.topologicalSpace.{u1, u3, u5} B (fun (x : B) => E₁ x) (fun (x : B) => E₂ x) _inst_3 _inst_5) (Bundle.TotalSpace.proj.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))) (Trivialization.prod.{u1, u2, u3, u4, u5} B _inst_1 F₁ _inst_2 E₁ _inst_3 F₂ _inst_4 E₂ _inst_5 e₁ e₂ (fun (x : B) => _inst_6 x) (fun (x : B) => _inst_7 x))) (Inter.inter.{u1} (Set.{u1} B) (Set.hasInter.{u1} B) (Trivialization.baseSet.{u1, u2, max u1 u3} B F₁ (Bundle.TotalSpace.{u1, u3} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u1, u3} B E₁) e₁) (Trivialization.baseSet.{u1, u4, max u1 u5} B F₂ (Bundle.TotalSpace.{u1, u5} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u1, u5} B E₂) e₂))
+but is expected to have type
+  forall {B : Type.{u5}} [_inst_1 : TopologicalSpace.{u5} B] {F₁ : Type.{u4}} [_inst_2 : TopologicalSpace.{u4} F₁] {E₁ : B -> Type.{u2}} [_inst_3 : TopologicalSpace.{max u2 u5} (Bundle.TotalSpace.{u5, u2} B E₁)] {F₂ : Type.{u3}} [_inst_4 : TopologicalSpace.{u3} F₂] {E₂ : B -> Type.{u1}} [_inst_5 : TopologicalSpace.{max u1 u5} (Bundle.TotalSpace.{u5, u1} B E₂)] (e₁ : Trivialization.{u5, u4, max u5 u2} B F₁ (Bundle.TotalSpace.{u5, u2} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u5, u2} B E₁)) (e₂ : Trivialization.{u5, u3, max u5 u1} B F₂ (Bundle.TotalSpace.{u5, u1} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u5, u1} B E₂)) [_inst_6 : forall (x : B), Zero.{u2} (E₁ x)] [_inst_7 : forall (x : B), Zero.{u1} (E₂ x)], Eq.{succ u5} (Set.{u5} B) (Trivialization.baseSet.{u5, max u4 u3, max (max u5 u2) u1} B (Prod.{u4, u3} F₁ F₂) (Bundle.TotalSpace.{u5, max u1 u2} B (fun (x : B) => Prod.{u2, u1} (E₁ x) (E₂ x))) _inst_1 (instTopologicalSpaceProd.{u4, u3} F₁ F₂ _inst_2 _inst_4) (FiberBundle.Prod.topologicalSpace.{u5, u2, u1} B (fun (x : B) => E₁ x) (fun (x : B) => E₂ x) _inst_3 _inst_5) (Bundle.TotalSpace.proj.{u5, max u1 u2} B (fun (x : B) => Prod.{u2, u1} (E₁ x) (E₂ x))) (Trivialization.prod.{u5, u4, u2, u3, u1} B _inst_1 F₁ _inst_2 E₁ _inst_3 F₂ _inst_4 E₂ _inst_5 e₁ e₂ (fun (x : B) => _inst_6 x) (fun (x : B) => _inst_7 x))) (Inter.inter.{u5} (Set.{u5} B) (Set.instInterSet.{u5} B) (Trivialization.baseSet.{u5, u4, max u5 u2} B F₁ (Bundle.TotalSpace.{u5, u2} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u5, u2} B E₁) e₁) (Trivialization.baseSet.{u5, u3, max u5 u1} B F₂ (Bundle.TotalSpace.{u5, u1} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u5, u1} B E₂) e₂))
+Case conversion may be inaccurate. Consider using '#align trivialization.base_set_prod Trivialization.baseSet_prodₓ'. -/
 @[simp]
 theorem baseSet_prod : (prod e₁ e₂).baseSet = e₁.baseSet ∩ e₂.baseSet :=
   rfl
 #align trivialization.base_set_prod Trivialization.baseSet_prod
 
+/- warning: trivialization.prod_symm_apply -> Trivialization.prod_symm_apply is a dubious translation:
+lean 3 declaration is
+  forall {B : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} B] {F₁ : Type.{u2}} [_inst_2 : TopologicalSpace.{u2} F₁] {E₁ : B -> Type.{u3}} [_inst_3 : TopologicalSpace.{max u1 u3} (Bundle.TotalSpace.{u1, u3} B E₁)] {F₂ : Type.{u4}} [_inst_4 : TopologicalSpace.{u4} F₂] {E₂ : B -> Type.{u5}} [_inst_5 : TopologicalSpace.{max u1 u5} (Bundle.TotalSpace.{u1, u5} B E₂)] (e₁ : Trivialization.{u1, u2, max u1 u3} B F₁ (Bundle.TotalSpace.{u1, u3} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u1, u3} B E₁)) (e₂ : Trivialization.{u1, u4, max u1 u5} B F₂ (Bundle.TotalSpace.{u1, u5} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u1, u5} B E₂)) [_inst_6 : forall (x : B), Zero.{u3} (E₁ x)] [_inst_7 : forall (x : B), Zero.{u5} (E₂ x)] (x : B) (w₁ : F₁) (w₂ : F₂), Eq.{max (succ u1) (succ (max u3 u5))} (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))) (coeFn.{max (succ (max u1 u2 u4)) (succ (max u1 u3 u5)), max (succ (max u1 u2 u4)) (succ (max u1 u3 u5))} (LocalEquiv.{max u1 u2 u4, max u1 u3 u5} (Prod.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂)) (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x)))) (fun (_x : LocalEquiv.{max u1 u2 u4, max u1 u3 u5} (Prod.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂)) (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x)))) => (Prod.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂)) -> (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x)))) (LocalEquiv.hasCoeToFun.{max u1 u2 u4, max u1 u3 u5} (Prod.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂)) (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x)))) (LocalEquiv.symm.{max u1 u3 u5, max u1 u2 u4} (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))) (Prod.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂)) (LocalHomeomorph.toLocalEquiv.{max u1 u3 u5, max u1 u2 u4} (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))) (Prod.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂)) (FiberBundle.Prod.topologicalSpace.{u1, u3, u5} B (fun (x : B) => E₁ x) (fun (x : B) => E₂ x) _inst_3 _inst_5) (Prod.topologicalSpace.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂) _inst_1 (Prod.topologicalSpace.{u2, u4} F₁ F₂ _inst_2 _inst_4)) (Trivialization.toLocalHomeomorph.{u1, max u2 u4, max u1 u3 u5} B (Prod.{u2, u4} F₁ F₂) (Bundle.TotalSpace.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))) _inst_1 (Prod.topologicalSpace.{u2, u4} F₁ F₂ _inst_2 _inst_4) (FiberBundle.Prod.topologicalSpace.{u1, u3, u5} B (fun (x : B) => E₁ x) (fun (x : B) => E₂ x) _inst_3 _inst_5) (Bundle.TotalSpace.proj.{u1, max u3 u5} B (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x))) (Trivialization.prod.{u1, u2, u3, u4, u5} B _inst_1 F₁ _inst_2 E₁ _inst_3 F₂ _inst_4 E₂ _inst_5 e₁ e₂ (fun (x : B) => _inst_6 x) (fun (x : B) => _inst_7 x))))) (Prod.mk.{u1, max u2 u4} B (Prod.{u2, u4} F₁ F₂) x (Prod.mk.{u2, u4} F₁ F₂ w₁ w₂))) (Sigma.mk.{u1, max u3 u5} B (fun (x : B) => (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x)) x) x (Prod.mk.{u3, u5} (E₁ x) (E₂ x) (Trivialization.symm.{u1, u2, u3} B F₁ E₁ _inst_1 _inst_2 _inst_3 (fun (x : B) => _inst_6 x) e₁ x w₁) (Trivialization.symm.{u1, u4, u5} B F₂ E₂ _inst_1 _inst_4 _inst_5 (fun (x : B) => _inst_7 x) e₂ x w₂)))
+but is expected to have type
+  forall {B : Type.{u5}} [_inst_1 : TopologicalSpace.{u5} B] {F₁ : Type.{u2}} [_inst_2 : TopologicalSpace.{u2} F₁] {E₁ : B -> Type.{u4}} [_inst_3 : TopologicalSpace.{max u4 u5} (Bundle.TotalSpace.{u5, u4} B E₁)] {F₂ : Type.{u1}} [_inst_4 : TopologicalSpace.{u1} F₂] {E₂ : B -> Type.{u3}} [_inst_5 : TopologicalSpace.{max u3 u5} (Bundle.TotalSpace.{u5, u3} B E₂)] (e₁ : Trivialization.{u5, u2, max u5 u4} B F₁ (Bundle.TotalSpace.{u5, u4} B E₁) _inst_1 _inst_2 _inst_3 (Bundle.TotalSpace.proj.{u5, u4} B E₁)) (e₂ : Trivialization.{u5, u1, max u5 u3} B F₂ (Bundle.TotalSpace.{u5, u3} B E₂) _inst_1 _inst_4 _inst_5 (Bundle.TotalSpace.proj.{u5, u3} B E₂)) [_inst_6 : forall (x : B), Zero.{u4} (E₁ x)] [_inst_7 : forall (x : B), Zero.{u3} (E₂ x)] (x : B) (w₁ : F₁) (w₂ : F₂), Eq.{max (max (succ u5) (succ u4)) (succ u3)} (Bundle.TotalSpace.{u5, max u3 u4} B (fun (x : B) => Prod.{u4, u3} (E₁ x) (E₂ x))) (LocalEquiv.toFun.{max (max u5 u2) u1, max (max u5 u4) u3} (Prod.{u5, max u2 u1} B (Prod.{u2, u1} F₁ F₂)) (Bundle.TotalSpace.{u5, max u3 u4} B (fun (x._@.Mathlib.Topology.FiberBundle.Constructions._hyg.2275 : B) => Prod.{u4, u3} (E₁ x._@.Mathlib.Topology.FiberBundle.Constructions._hyg.2275) (E₂ x._@.Mathlib.Topology.FiberBundle.Constructions._hyg.2275))) (LocalEquiv.symm.{max (max u5 u4) u3, max (max u5 u2) u1} (Bundle.TotalSpace.{u5, max u3 u4} B (fun (x : B) => Prod.{u4, u3} (E₁ x) (E₂ x))) (Prod.{u5, max u2 u1} B (Prod.{u2, u1} F₁ F₂)) (LocalHomeomorph.toLocalEquiv.{max (max u5 u4) u3, max (max u5 u2) u1} (Bundle.TotalSpace.{u5, max u3 u4} B (fun (x : B) => Prod.{u4, u3} (E₁ x) (E₂ x))) (Prod.{u5, max u2 u1} B (Prod.{u2, u1} F₁ F₂)) (FiberBundle.Prod.topologicalSpace.{u5, u4, u3} B (fun (x : B) => E₁ x) (fun (x : B) => E₂ x) _inst_3 _inst_5) (instTopologicalSpaceProd.{u5, max u2 u1} B (Prod.{u2, u1} F₁ F₂) _inst_1 (instTopologicalSpaceProd.{u2, u1} F₁ F₂ _inst_2 _inst_4)) (Trivialization.toLocalHomeomorph.{u5, max u2 u1, max (max u5 u4) u3} B (Prod.{u2, u1} F₁ F₂) (Bundle.TotalSpace.{u5, max u3 u4} B (fun (x : B) => Prod.{u4, u3} (E₁ x) (E₂ x))) _inst_1 (instTopologicalSpaceProd.{u2, u1} F₁ F₂ _inst_2 _inst_4) (FiberBundle.Prod.topologicalSpace.{u5, u4, u3} B (fun (x : B) => E₁ x) (fun (x : B) => E₂ x) _inst_3 _inst_5) (Bundle.TotalSpace.proj.{u5, max u3 u4} B (fun (x : B) => Prod.{u4, u3} (E₁ x) (E₂ x))) (Trivialization.prod.{u5, u2, u4, u1, u3} B _inst_1 F₁ _inst_2 E₁ _inst_3 F₂ _inst_4 E₂ _inst_5 e₁ e₂ (fun (x : B) => _inst_6 x) (fun (x : B) => _inst_7 x))))) (Prod.mk.{u5, max u2 u1} B (Prod.{u2, u1} F₁ F₂) x (Prod.mk.{u2, u1} F₁ F₂ w₁ w₂))) (Sigma.mk.{u5, max u4 u3} B (fun (x : B) => (fun (x : B) => Prod.{u4, u3} (E₁ x) (E₂ x)) x) x (Prod.mk.{u4, u3} (E₁ x) (E₂ x) (Trivialization.symm.{u5, u2, u4} B F₁ E₁ _inst_1 _inst_2 _inst_3 (fun (x : B) => _inst_6 x) e₁ x w₁) (Trivialization.symm.{u5, u1, u3} B F₂ E₂ _inst_1 _inst_4 _inst_5 (fun (x : B) => _inst_7 x) e₂ x w₂)))
+Case conversion may be inaccurate. Consider using '#align trivialization.prod_symm_apply Trivialization.prod_symm_applyₓ'. -/
 theorem prod_symm_apply (x : B) (w₁ : F₁) (w₂ : F₂) :
     (prod e₁ e₂).toLocalEquiv.symm (x, w₁, w₂) = ⟨x, e₁.symm x w₁, e₂.symm x w₂⟩ :=
   rfl
@@ -284,6 +360,12 @@ open Trivialization
 variable [∀ x, Zero (E₁ x)] [∀ x, Zero (E₂ x)] [∀ x : B, TopologicalSpace (E₁ x)]
   [∀ x : B, TopologicalSpace (E₂ x)] [FiberBundle F₁ E₁] [FiberBundle F₂ E₂]
 
+/- warning: fiber_bundle.prod -> FiberBundle.prod is a dubious translation:
+lean 3 declaration is
+  forall {B : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} B] (F₁ : Type.{u2}) [_inst_2 : TopologicalSpace.{u2} F₁] (E₁ : B -> Type.{u3}) [_inst_3 : TopologicalSpace.{max u1 u3} (Bundle.TotalSpace.{u1, u3} B E₁)] (F₂ : Type.{u4}) [_inst_4 : TopologicalSpace.{u4} F₂] (E₂ : B -> Type.{u5}) [_inst_5 : TopologicalSpace.{max u1 u5} (Bundle.TotalSpace.{u1, u5} B E₂)] [_inst_6 : forall (x : B), Zero.{u3} (E₁ x)] [_inst_7 : forall (x : B), Zero.{u5} (E₂ x)] [_inst_8 : forall (x : B), TopologicalSpace.{u3} (E₁ x)] [_inst_9 : forall (x : B), TopologicalSpace.{u5} (E₂ x)] [_inst_10 : FiberBundle.{u1, u2, u3} B F₁ _inst_1 _inst_2 E₁ _inst_3 (fun (b : B) => _inst_8 b)] [_inst_11 : FiberBundle.{u1, u4, u5} B F₂ _inst_1 _inst_4 E₂ _inst_5 (fun (b : B) => _inst_9 b)], FiberBundle.{u1, max u2 u4, max u3 u5} B (Prod.{u2, u4} F₁ F₂) _inst_1 (Prod.topologicalSpace.{u2, u4} F₁ F₂ _inst_2 _inst_4) (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x)) (FiberBundle.Prod.topologicalSpace.{u1, u3, u5} B (fun (x : B) => E₁ x) (fun (x : B) => E₂ x) _inst_3 _inst_5) (fun (b : B) => Prod.topologicalSpace.{u3, u5} (E₁ b) (E₂ b) (_inst_8 b) (_inst_9 b))
+but is expected to have type
+  forall {B : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} B] (F₁ : Type.{u2}) [_inst_2 : TopologicalSpace.{u2} F₁] (E₁ : B -> Type.{u3}) [_inst_3 : TopologicalSpace.{max u3 u1} (Bundle.TotalSpace.{u1, u3} B E₁)] (F₂ : Type.{u4}) [_inst_4 : TopologicalSpace.{u4} F₂] (E₂ : B -> Type.{u5}) [_inst_5 : TopologicalSpace.{max u5 u1} (Bundle.TotalSpace.{u1, u5} B E₂)] [_inst_6 : forall (x : B), Zero.{u3} (E₁ x)] [_inst_7 : forall (x : B), Zero.{u5} (E₂ x)] [_inst_8 : forall (x : B), TopologicalSpace.{u3} (E₁ x)] [_inst_9 : forall (x : B), TopologicalSpace.{u5} (E₂ x)] [_inst_10 : FiberBundle.{u1, u2, u3} B F₁ _inst_1 _inst_2 E₁ _inst_3 (fun (b : B) => _inst_8 b)] [_inst_11 : FiberBundle.{u1, u4, u5} B F₂ _inst_1 _inst_4 E₂ _inst_5 (fun (b : B) => _inst_9 b)], FiberBundle.{u1, max u4 u2, max u5 u3} B (Prod.{u2, u4} F₁ F₂) _inst_1 (instTopologicalSpaceProd.{u2, u4} F₁ F₂ _inst_2 _inst_4) (fun (x : B) => Prod.{u3, u5} (E₁ x) (E₂ x)) (FiberBundle.Prod.topologicalSpace.{u1, u3, u5} B (fun (x : B) => E₁ x) (fun (x : B) => E₂ x) _inst_3 _inst_5) (fun (b : B) => instTopologicalSpaceProd.{u3, u5} (E₁ b) (E₂ b) (_inst_8 b) (_inst_9 b))
+Case conversion may be inaccurate. Consider using '#align fiber_bundle.prod FiberBundle.prodₓ'. -/
 /-- The product of two fiber bundles is a fiber bundle. -/
 noncomputable instance FiberBundle.prod : FiberBundle (F₁ × F₂) (E₁ ×ᵇ E₂)
     where
@@ -321,30 +403,44 @@ instance [∀ x : B, TopologicalSpace (E x)] : ∀ x : B', TopologicalSpace ((f
 
 variable [TopologicalSpace B'] [TopologicalSpace (TotalSpace E)]
 
+#print pullbackTopology /-
 /-- Definition of `pullback.total_space.topological_space`, which we make irreducible. -/
 irreducible_def pullbackTopology : TopologicalSpace (TotalSpace (f *ᵖ E)) :=
   induced TotalSpace.proj ‹TopologicalSpace B'› ⊓
     induced (Pullback.lift f) ‹TopologicalSpace (TotalSpace E)›
 #align pullback_topology pullbackTopology
+-/
 
+#print Pullback.TotalSpace.topologicalSpace /-
 /-- The topology on the total space of a pullback bundle is the coarsest topology for which both
 the projections to the base and the map to the original bundle are continuous. -/
 instance Pullback.TotalSpace.topologicalSpace : TopologicalSpace (TotalSpace (f *ᵖ E)) :=
   pullbackTopology E f
 #align pullback.total_space.topological_space Pullback.TotalSpace.topologicalSpace
+-/
 
+#print Pullback.continuous_proj /-
 theorem Pullback.continuous_proj (f : B' → B) : Continuous (@TotalSpace.proj _ (f *ᵖ E)) :=
   by
   rw [continuous_iff_le_induced, Pullback.TotalSpace.topologicalSpace, pullbackTopology]
   exact inf_le_left
 #align pullback.continuous_proj Pullback.continuous_proj
+-/
 
+#print Pullback.continuous_lift /-
 theorem Pullback.continuous_lift (f : B' → B) : Continuous (@Pullback.lift B E B' f) :=
   by
   rw [continuous_iff_le_induced, Pullback.TotalSpace.topologicalSpace, pullbackTopology]
   exact inf_le_right
 #align pullback.continuous_lift Pullback.continuous_lift
+-/
 
+/- warning: inducing_pullback_total_space_embedding -> inducing_pullbackTotalSpaceEmbedding is a dubious translation:
+lean 3 declaration is
+  forall {B : Type.{u1}} (E : B -> Type.{u2}) {B' : Type.{u3}} [_inst_1 : TopologicalSpace.{u3} B'] [_inst_2 : TopologicalSpace.{max u1 u2} (Bundle.TotalSpace.{u1, u2} B E)] (f : B' -> B), Inducing.{max u3 u2, max u3 u1 u2} (Bundle.TotalSpace.{u3, u2} B' (Bundle.Pullback.{u1, u3, u2} B B' f E)) (Prod.{u3, max u1 u2} B' (Bundle.TotalSpace.{u1, u2} B E)) (Pullback.TotalSpace.topologicalSpace.{u1, u2, u3} B E B' f _inst_1 _inst_2) (Prod.topologicalSpace.{u3, max u1 u2} B' (Bundle.TotalSpace.{u1, u2} B E) _inst_1 _inst_2) (Bundle.pullbackTotalSpaceEmbedding.{u1, u2, u3} B E B' f)
+but is expected to have type
+  forall {B : Type.{u1}} (E : B -> Type.{u2}) {B' : Type.{u3}} [_inst_1 : TopologicalSpace.{u3} B'] [_inst_2 : TopologicalSpace.{max u2 u1} (Bundle.TotalSpace.{u1, u2} B E)] (f : B' -> B), Inducing.{max u2 u3, max (max u1 u2) u3} (Bundle.TotalSpace.{u3, u2} B' (Bundle.Pullback.{u1, u3, u2} B B' f E)) (Prod.{u3, max u2 u1} B' (Bundle.TotalSpace.{u1, u2} B E)) (Pullback.TotalSpace.topologicalSpace.{u1, u2, u3} B E B' f _inst_1 _inst_2) (instTopologicalSpaceProd.{u3, max u1 u2} B' (Bundle.TotalSpace.{u1, u2} B E) _inst_1 _inst_2) (Bundle.pullbackTotalSpaceEmbedding.{u1, u2, u3} B E B' f)
+Case conversion may be inaccurate. Consider using '#align inducing_pullback_total_space_embedding inducing_pullbackTotalSpaceEmbeddingₓ'. -/
 theorem inducing_pullbackTotalSpaceEmbedding (f : B' → B) :
     Inducing (@pullbackTotalSpaceEmbedding B E B' f) :=
   by
@@ -358,6 +454,7 @@ section FiberBundle
 
 variable (F) [TopologicalSpace F] [TopologicalSpace B]
 
+#print Pullback.continuous_totalSpaceMk /-
 theorem Pullback.continuous_totalSpaceMk [∀ x, TopologicalSpace (E x)] [FiberBundle F E]
     {f : B' → B} {x : B'} : Continuous (@totalSpaceMk _ (f *ᵖ E) x) :=
   by
@@ -366,10 +463,12 @@ theorem Pullback.continuous_totalSpaceMk [∀ x, TopologicalSpace (E x)] [FiberB
     pullbackTopology]
   exact le_of_eq (FiberBundle.totalSpaceMk_inducing F E (f x)).induced
 #align pullback.continuous_total_space_mk Pullback.continuous_totalSpaceMk
+-/
 
 variable {E F} [∀ b, Zero (E b)] {K : Type _} [ContinuousMapClass K B' B]
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Trivialization.pullback /-
 /-- A fiber bundle trivialization can be pulled back to a trivialization on the pullback bundle. -/
 noncomputable def Trivialization.pullback (e : Trivialization F (π E)) (f : K) :
     Trivialization F (π ((f : B' → B) *ᵖ E))
@@ -418,7 +517,9 @@ noncomputable def Trivialization.pullback (e : Trivialization F (π E)) (f : K)
   target_eq := rfl
   proj_toFun y h := rfl
 #align trivialization.pullback Trivialization.pullback
+-/
 
+#print FiberBundle.pullback /-
 noncomputable instance FiberBundle.pullback [∀ x, TopologicalSpace (E x)] [FiberBundle F E]
     (f : K) : FiberBundle F ((f : B' → B) *ᵖ E)
     where
@@ -431,6 +532,7 @@ noncomputable instance FiberBundle.pullback [∀ x, TopologicalSpace (E x)] [Fib
   mem_baseSet_trivializationAt x := mem_baseSet_trivializationAt F E (f x)
   trivialization_mem_atlas x := ⟨trivializationAt F E (f x), by infer_instance, rfl⟩
 #align fiber_bundle.pullback FiberBundle.pullback
+-/
 
 end FiberBundle

bump to nightly-2023-03-17-00

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

c85864d4

Diff

@@ -253,8 +253,7 @@ noncomputable def prod : Trivialization (F₁ × F₂) (π (E₁ ×ᵇ E₂))
   right_inv' x := Prod.right_inv
   open_source :=
     by
-    convert
-      (e₁.open_source.prod e₂.open_source).Preimage
+    convert(e₁.open_source.prod e₂.open_source).Preimage
         (FiberBundle.Prod.inducing_diag E₁ E₂).Continuous
     ext x
     simp only [Trivialization.source_eq, mfld_simps]

bump to nightly-2023-03-08-03

mathlib commit https://github.com/leanprover-community/mathlib/commit/38f16f960f5006c6c0c2bac7b0aba5273188f4e5

aa586d73

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Nicolò Cavalleri, Sébastien Gouëzel, Heather Macbeth, Floris van Doorn
 
 ! This file was ported from Lean 3 source module topology.fiber_bundle.constructions
-! leanprover-community/mathlib commit f2ce6086713c78a7f880485f7917ea547a215982
+! leanprover-community/mathlib commit be2c24f56783935652cefffb4bfca7e4b25d167e
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -15,11 +15,11 @@ import Mathbin.Topology.FiberBundle.Basic
 
 This file contains several standard constructions on fiber bundles:
 
-* `bundle.trivial.fiber_bundle 𝕜 B F`: the trivial fiber bundle with model fibre `F` over the base
+* `bundle.trivial.fiber_bundle 𝕜 B F`: the trivial fiber bundle with model fiber `F` over the base
   `B`
 
 * `fiber_bundle.prod`: for fiber bundles `E₁` and `E₂` over a common base, a fiber bundle structure
-  on their fibrewise product `E₁ ×ᵇ E₂` (the notation stands for `λ x, E₁ x × E₂ x`).
+  on their fiberwise product `E₁ ×ᵇ E₂` (the notation stands for `λ x, E₁ x × E₂ x`).
 
 * `fiber_bundle.pullback`: for a fiber bundle `E` over `B`, a fiber bundle structure on its
   pullback `f *ᵖ E` by a map `f : B' → B` (the notation is a type synonym for `E ∘ f`).
@@ -132,7 +132,7 @@ variable (E₁ : B → Type _) (E₂ : B → Type _)
 
 variable [TopologicalSpace (TotalSpace E₁)] [TopologicalSpace (TotalSpace E₂)]
 
-/-- Equip the total space of the fibrewise product of two fiber bundles `E₁`, `E₂` with
+/-- Equip the total space of the fiberwise product of two fiber bundles `E₁`, `E₂` with
 the induced topology from the diagonal embedding into `total_space E₁ × total_space E₂`. -/
 instance FiberBundle.Prod.topologicalSpace : TopologicalSpace (TotalSpace (E₁ ×ᵇ E₂)) :=
   TopologicalSpace.induced
@@ -140,7 +140,7 @@ instance FiberBundle.Prod.topologicalSpace : TopologicalSpace (TotalSpace (E₁
     (by infer_instance : TopologicalSpace (TotalSpace E₁ × TotalSpace E₂))
 #align fiber_bundle.prod.topological_space FiberBundle.Prod.topologicalSpace
 
-/-- The diagonal map from the total space of the fibrewise product of two fiber bundles
+/-- The diagonal map from the total space of the fiberwise product of two fiber bundles
 `E₁`, `E₂` into `total_space E₁ × total_space E₂` is `inducing`. -/
 theorem FiberBundle.Prod.inducing_diag :
     Inducing
@@ -163,7 +163,7 @@ variable {F₁ E₁ F₂ E₂} (e₁ : Trivialization F₁ (π E₁)) (e₂ : Tr
 
 /-- Given trivializations `e₁`, `e₂` for fiber bundles `E₁`, `E₂` over a base `B`, the forward
 function for the construction `trivialization.prod`, the induced
-trivialization for the fibrewise product of `E₁` and `E₂`. -/
+trivialization for the fiberwise product of `E₁` and `E₂`. -/
 def Prod.toFun' : TotalSpace (E₁ ×ᵇ E₂) → B × F₁ × F₂ := fun p =>
   ⟨p.1, (e₁ ⟨p.1, p.2.1⟩).2, (e₂ ⟨p.1, p.2.2⟩).2⟩
 #align trivialization.prod.to_fun' Trivialization.Prod.toFun'
@@ -198,7 +198,7 @@ variable (e₁ e₂) [∀ x, Zero (E₁ x)] [∀ x, Zero (E₂ x)]
 
 /-- Given trivializations `e₁`, `e₂` for fiber bundles `E₁`, `E₂` over a base `B`, the inverse
 function for the construction `trivialization.prod`, the induced
-trivialization for the fibrewise product of `E₁` and `E₂`. -/
+trivialization for the fiberwise product of `E₁` and `E₂`. -/
 noncomputable def Prod.invFun' (p : B × F₁ × F₂) : TotalSpace (E₁ ×ᵇ E₂) :=
   ⟨p.1, e₁.symm p.1 p.2.1, e₂.symm p.1 p.2.2⟩
 #align trivialization.prod.inv_fun' Trivialization.Prod.invFun'
@@ -239,7 +239,7 @@ variable (e₁ e₂ e₁ e₂)
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /-- Given trivializations `e₁`, `e₂` for bundle types `E₁`, `E₂` over a base `B`, the induced
-trivialization for the fibrewise product of `E₁` and `E₂`, whose base set is
+trivialization for the fiberwise product of `E₁` and `E₂`, whose base set is
 `e₁.base_set ∩ e₂.base_set`. -/
 noncomputable def prod : Trivialization (F₁ × F₂) (π (E₁ ×ᵇ E₂))
     where
@@ -310,7 +310,7 @@ instance {e₁ : Trivialization F₁ (π E₁)} {e₂ : Trivialization F₂ (π
 
 end Prod
 
-/-! ### Pullbacks of fibre bundles -/
+/-! ### Pullbacks of fiber bundles -/
 
 
 section

f2ce6086

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

chore(*): remove empty lines between variable statements (#11418)

Empty lines were removed by executing the following Python script twice

import os
import re


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

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

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

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

75c86f04

Diff

@@ -105,7 +105,6 @@ variable {B : Type*}
 section Defs
 
 variable (F₁ : Type*) (E₁ : B → Type*) (F₂ : Type*) (E₂ : B → Type*)
-
 variable [TopologicalSpace (TotalSpace F₁ E₁)] [TopologicalSpace (TotalSpace F₂ E₂)]
 
 /-- Equip the total space of the fiberwise product of two fiber bundles `E₁`, `E₂` with

chore: scope open Classical (#11199)

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.

c747be0a

Diff

@@ -30,7 +30,8 @@ fiber bundle, fibre bundle, fiberwise product, pullback
 
 open TopologicalSpace Filter Set Bundle
 
-open Topology Classical Bundle
+open scoped Classical
+open Topology Bundle
 
 /-! ### The trivial bundle -/

style: homogenise porting notes (#11145)

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".

8be0b69c

Diff

@@ -59,7 +59,7 @@ def homeomorphProd : TotalSpace F (Trivial B F) ≃ₜ B × F :=
 
 /-- Local trivialization for trivial bundle. -/
 def trivialization : Trivialization F (π F (Bundle.Trivial B F)) where
-  -- porting note: golfed
+  -- Porting note: golfed
   toPartialHomeomorph := (homeomorphProd B F).toPartialHomeomorph
   baseSet := univ
   open_baseSet := isOpen_univ

chore: more backporting of simp changes from #10995 (#11001)

Co-authored-by: Patrick Massot <patrickmassot@free.fr> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

d9589c14

Diff

@@ -160,7 +160,7 @@ theorem Prod.continuous_to_fun : ContinuousOn (Prod.toFun' e₁ e₂)
   · rw [e₁.source_eq, e₂.source_eq]
     exact mapsTo_preimage _ _
   rintro ⟨b, v₁, v₂⟩ ⟨hb₁, _⟩
-  simp only [Prod.toFun', Prod.mk.inj_iff, Function.comp_apply, and_true_iff]
+  simp only [f₃, Prod.toFun', Prod.mk.inj_iff, Function.comp_apply, and_true_iff]
   rw [e₁.coe_fst]
   rw [e₁.source_eq, mem_preimage]
   exact hb₁

chore: classify added instance porting notes (#10925)

Classifies by adding issue number (#10754) to porting notes claiming added instance.

1d96f991

Diff

@@ -41,7 +41,7 @@ namespace Trivial
 
 variable (B : Type*) (F : Type*)
 
--- Porting note: Added name for this instance.
+-- Porting note (#10754): Added name for this instance.
 -- TODO: use `TotalSpace.toProd`
 instance topologicalSpace [t₁ : TopologicalSpace B]
     [t₂ : TopologicalSpace F] : TopologicalSpace (TotalSpace F (Trivial B F)) :=

refactor(Data/FunLike): use unbundled inheritance from FunLike (#8386)

The FunLike hierarchy is very big and gets scanned through each time we need a coercion (via the CoeFun instance). It looks like unbundled inheritance suits Lean 4 better here. The only class that still extends FunLike is EquivLike, since that has a custom coe_injective' field that is easier to implement. All other classes should take FunLike or EquivLike as a parameter.

Zulip thread

Important changes

Previously, morphism classes would be Type-valued and extend FunLike:

/-- `MyHomClass F A B` states that `F` is a type of `MyClass.op`-preserving morphisms.
You should extend this class when you extend `MyHom`. -/
class MyHomClass (F : Type*) (A B : outParam <| Type*) [MyClass A] [MyClass B]
  extends FunLike F A B :=
(map_op : ∀ (f : F) (x y : A), f (MyClass.op x y) = MyClass.op (f x) (f y))

After this PR, they should be Prop-valued and take FunLike as a parameter:

/-- `MyHomClass F A B` states that `F` is a type of `MyClass.op`-preserving morphisms.
You should extend this class when you extend `MyHom`. -/
class MyHomClass (F : Type*) (A B : outParam <| Type*) [MyClass A] [MyClass B]
  [FunLike F A B] : Prop :=
(map_op : ∀ (f : F) (x y : A), f (MyClass.op x y) = MyClass.op (f x) (f y))

(Note that A B stay marked as outParam even though they are not purely required to be so due to the FunLike parameter already filling them in. This is required to see through type synonyms, which is important in the category theory library. Also, I think keeping them as outParam is slightly faster.)

Similarly, MyEquivClass should take EquivLike as a parameter.

As a result, every mention of [MyHomClass F A B] should become [FunLike F A B] [MyHomClass F A B].

Remaining issues

Slower (failing) search

While overall this gives some great speedups, there are some cases that are noticeably slower. In particular, a failing application of a lemma such as map_mul is more expensive. This is due to suboptimal processing of arguments. For example:

variable [FunLike F M N] [Mul M] [Mul N] (f : F) (x : M) (y : M)

theorem map_mul [MulHomClass F M N] : f (x * y) = f x * f y

example [AddHomClass F A B] : f (x * y) = f x * f y := map_mul f _ _

Before this PR, applying map_mul f gives the goals [Mul ?M] [Mul ?N] [MulHomClass F ?M ?N]. Since M and N are out_params, [MulHomClass F ?M ?N] is synthesized first, supplies values for ?M and ?N and then the Mul M and Mul N instances can be found.

After this PR, the goals become [FunLike F ?M ?N] [Mul ?M] [Mul ?N] [MulHomClass F ?M ?N]. Now [FunLike F ?M ?N] is synthesized first, supplies values for ?M and ?N and then the Mul M and Mul N instances can be found, before trying MulHomClass F M N which fails. Since the Mul hierarchy is very big, this can be slow to fail, especially when there is no such Mul instance.

A long-term but harder to achieve solution would be to specify the order in which instance goals get solved. For example, we'd like to change the arguments to map_mul to look like [FunLike F M N] [Mul M] [Mul N] [highPriority <| MulHomClass F M N] because MulHomClass fails or succeeds much faster than the others.

As a consequence, the simpNF linter is much slower since by design it tries and fails to apply many map_ lemmas. The same issue occurs a few times in existing calls to simp [map_mul], where map_mul is tried "too soon" and fails. Thanks to the speedup of leanprover/lean4#2478 the impact is very limited, only in files that already were close to the timeout.

`simp` not firing sometimes

This affects map_smulₛₗ and related definitions. For simp lemmas Lean apparently uses a slightly different mechanism to find instances, so that rw can find every argument to map_smulₛₗ successfully but simp can't: leanprover/lean4#3701.

Missing instances due to unification failing

Especially in the category theory library, we might sometimes have a type A which is also accessible as a synonym (Bundled A hA).1. Instance synthesis doesn't always work if we have f : A →* B but x * y : (Bundled A hA).1 or vice versa. This seems to be mostly fixed by keeping A B as outParams in MulHomClass F A B. (Presumably because Lean will do a definitional check A =?= (Bundled A hA).1 instead of using the syntax in the discrimination tree.)

Workaround for issues

The timeouts can be worked around for now by specifying which map_mul we mean, either as map_mul f for some explicit f, or as e.g. MonoidHomClass.map_mul.

map_smulₛₗ not firing as simp lemma can be worked around by going back to the pre-FunLike situation and making LinearMap.map_smulₛₗ a simp lemma instead of the generic map_smulₛₗ. Writing simp [map_smulₛₗ _] also works.

Co-authored-by: Matthew Ballard <matt@mrb.email> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Scott Morrison <scott@tqft.net> Co-authored-by: Anne Baanen <Vierkantor@users.noreply.github.com>

c6a73d4f

Diff

@@ -326,8 +326,7 @@ theorem Pullback.continuous_totalSpaceMk [∀ x, TopologicalSpace (E x)] [FiberB
   exact le_of_eq (FiberBundle.totalSpaceMk_inducing F E (f x)).induced
 #align pullback.continuous_total_space_mk Pullback.continuous_totalSpaceMk
 
-variable {E F}
-variable [∀ b, Zero (E b)] {K : Type U} [ContinuousMapClass K B' B]
+variable {E F} [∀ _b, Zero (E _b)] {K : Type U} [FunLike K B' B] [ContinuousMapClass K B' B]
 
 -- Porting note: universe levels are explicitly provided
 /-- A fiber bundle trivialization can be pulled back to a trivialization on the pullback bundle. -/

chore(*): use α → β instead of ∀ _ : α, β (#9529)

5618e431

Diff

@@ -326,7 +326,8 @@ theorem Pullback.continuous_totalSpaceMk [∀ x, TopologicalSpace (E x)] [FiberB
   exact le_of_eq (FiberBundle.totalSpaceMk_inducing F E (f x)).induced
 #align pullback.continuous_total_space_mk Pullback.continuous_totalSpaceMk
 
-variable {E F} [∀ _b, Zero (E _b)] {K : Type U} [ContinuousMapClass K B' B]
+variable {E F}
+variable [∀ b, Zero (E b)] {K : Type U} [ContinuousMapClass K B' B]
 
 -- Porting note: universe levels are explicitly provided
 /-- A fiber bundle trivialization can be pulled back to a trivialization on the pullback bundle. -/

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

@@ -236,7 +236,7 @@ theorem baseSet_prod : (prod e₁ e₂).baseSet = e₁.baseSet ∩ e₂.baseSet
 #align trivialization.base_set_prod Trivialization.baseSet_prod
 
 theorem prod_symm_apply (x : B) (w₁ : F₁) (w₂ : F₂) :
-    (prod e₁ e₂).toLocalEquiv.symm (x, w₁, w₂) = ⟨x, e₁.symm x w₁, e₂.symm x w₂⟩ := rfl
+    (prod e₁ e₂).toPartialEquiv.symm (x, w₁, w₂) = ⟨x, e₁.symm x w₁, e₂.symm x w₂⟩ := rfl
 #align trivialization.prod_symm_apply Trivialization.prod_symm_apply
 
 end Trivialization

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

@@ -60,7 +60,7 @@ def homeomorphProd : TotalSpace F (Trivial B F) ≃ₜ B × F :=
 /-- Local trivialization for trivial bundle. -/
 def trivialization : Trivialization F (π F (Bundle.Trivial B F)) where
   -- porting note: golfed
-  toLocalHomeomorph := (homeomorphProd B F).toLocalHomeomorph
+  toPartialHomeomorph := (homeomorphProd B F).toPartialHomeomorph
   baseSet := univ
   open_baseSet := isOpen_univ
   source_eq := rfl
@@ -153,7 +153,7 @@ theorem Prod.continuous_to_fun : ContinuousOn (Prod.toFun' e₁ e₂)
   let f₃ : (B × F₁) × B × F₂ → B × F₁ × F₂ := fun p ↦ ⟨p.1.1, p.1.2, p.2.2⟩
   have hf₁ : Continuous f₁ := (Prod.inducing_diag F₁ E₁ F₂ E₂).continuous
   have hf₂ : ContinuousOn f₂ (e₁.source ×ˢ e₂.source) :=
-    e₁.toLocalHomeomorph.continuousOn.prod_map e₂.toLocalHomeomorph.continuousOn
+    e₁.toPartialHomeomorph.continuousOn.prod_map e₂.toPartialHomeomorph.continuousOn
   have hf₃ : Continuous f₃ :=
     (continuous_fst.comp continuous_fst).prod_mk (continuous_snd.prod_map continuous_snd)
   refine' ((hf₃.comp_continuousOn hf₂).comp hf₁.continuousOn _).congr _

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

@@ -222,8 +222,8 @@ noncomputable def prod : Trivialization (F₁ × F₂) (π (F₁ × F₂) (E₁
     ext x
     simp only [Trivialization.source_eq, mfld_simps]
   open_target := (e₁.open_baseSet.inter e₂.open_baseSet).prod isOpen_univ
-  continuous_toFun := Prod.continuous_to_fun
-  continuous_invFun := Prod.continuous_inv_fun
+  continuousOn_toFun := Prod.continuous_to_fun
+  continuousOn_invFun := Prod.continuous_inv_fun
   baseSet := e₁.baseSet ∩ e₂.baseSet
   open_baseSet := e₁.open_baseSet.inter e₂.open_baseSet
   source_eq := rfl
@@ -354,11 +354,11 @@ noncomputable def Trivialization.pullback (e : Trivialization F (π F E)) (f : K
     exact e.open_baseSet.preimage ((map_continuous f).comp <| Pullback.continuous_proj F E f)
   open_target := ((map_continuous f).isOpen_preimage _ e.open_baseSet).prod isOpen_univ
   open_baseSet := (map_continuous f).isOpen_preimage _ e.open_baseSet
-  continuous_toFun :=
+  continuousOn_toFun :=
     (Pullback.continuous_proj F E f).continuousOn.prod
       (continuous_snd.comp_continuousOn <|
         e.continuousOn.comp (Pullback.continuous_lift F E f).continuousOn Subset.rfl)
-  continuous_invFun := by
+  continuousOn_invFun := by
     dsimp only
     simp_rw [(inducing_pullbackTotalSpaceEmbedding F E f).continuousOn_iff, Function.comp,
       pullbackTotalSpaceEmbedding]

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

@@ -39,7 +39,7 @@ namespace Bundle
 
 namespace Trivial
 
-variable (B : Type _) (F : Type _)
+variable (B : Type*) (F : Type*)
 
 -- Porting note: Added name for this instance.
 -- TODO: use `TotalSpace.toProd`
@@ -99,11 +99,11 @@ end Bundle
 
 section Prod
 
-variable {B : Type _}
+variable {B : Type*}
 
 section Defs
 
-variable (F₁ : Type _) (E₁ : B → Type _) (F₂ : Type _) (E₂ : B → Type _)
+variable (F₁ : Type*) (E₁ : B → Type*) (F₂ : Type*) (E₂ : B → Type*)
 
 variable [TopologicalSpace (TotalSpace F₁ E₁)] [TopologicalSpace (TotalSpace F₂ E₂)]
 
@@ -127,8 +127,8 @@ end Defs
 
 open FiberBundle
 
-variable [TopologicalSpace B] (F₁ : Type _) [TopologicalSpace F₁] (E₁ : B → Type _)
-  [TopologicalSpace (TotalSpace F₁ E₁)] (F₂ : Type _) [TopologicalSpace F₂] (E₂ : B → Type _)
+variable [TopologicalSpace B] (F₁ : Type*) [TopologicalSpace F₁] (E₁ : B → Type*)
+  [TopologicalSpace (TotalSpace F₁ E₁)] (F₂ : Type*) [TopologicalSpace F₂] (E₂ : B → Type*)
   [TopologicalSpace (TotalSpace F₂ E₂)]
 
 namespace Trivialization

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

depends on: #5966

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

89aa3a3b

Diff

@@ -2,14 +2,11 @@
 Copyright © 2022 Nicolò Cavalleri. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Nicolò Cavalleri, Sébastien Gouëzel, Heather Macbeth, Floris van Doorn
-
-! This file was ported from Lean 3 source module topology.fiber_bundle.constructions
-! 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.FiberBundle.Basic
 
+#align_import topology.fiber_bundle.constructions from "leanprover-community/mathlib"@"e473c3198bb41f68560cab68a0529c854b618833"
+
 /-!
 # Standard constructions on fiber bundles

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: Nicolò Cavalleri, Sébastien Gouëzel, Heather Macbeth, Floris van Doorn
 
 ! This file was ported from Lean 3 source module topology.fiber_bundle.constructions
-! leanprover-community/mathlib commit be2c24f56783935652cefffb4bfca7e4b25d167e
+! leanprover-community/mathlib commit e473c3198bb41f68560cab68a0529c854b618833
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -45,43 +45,30 @@ namespace Trivial
 variable (B : Type _) (F : Type _)
 
 -- Porting note: Added name for this instance.
-instance topologicalSpace [I : TopologicalSpace F] : ∀ x : B, TopologicalSpace (Trivial B F x) :=
-  fun _ ↦ I
-#align bundle.trivial.topological_space Bundle.Trivial.topologicalSpace
-
--- Porting note: Added name for this instance.
-instance Bundle.TotalSpace.topologicalSpace [t₁ : TopologicalSpace B]
-    [t₂ : TopologicalSpace F] : TopologicalSpace (TotalSpace (Trivial B F)) :=
-  induced TotalSpace.proj t₁ ⊓ induced (Trivial.projSnd B F) t₂
-#align bundle.trivial.bundle.total_space.topological_space Bundle.Trivial.Bundle.TotalSpace.topologicalSpace
+-- TODO: use `TotalSpace.toProd`
+instance topologicalSpace [t₁ : TopologicalSpace B]
+    [t₂ : TopologicalSpace F] : TopologicalSpace (TotalSpace F (Trivial B F)) :=
+  induced TotalSpace.proj t₁ ⊓ induced (TotalSpace.trivialSnd B F) t₂
+#align bundle.trivial.bundle.total_space.topological_space Bundle.Trivial.topologicalSpace
 
 variable [TopologicalSpace B] [TopologicalSpace F]
 
+theorem inducing_toProd : Inducing (TotalSpace.toProd B F) :=
+  ⟨by simp only [instTopologicalSpaceProd, induced_inf, induced_compose]; rfl⟩
+
+/-- Homeomorphism between the total space of the trivial bundle and the Cartesian product. -/
+def homeomorphProd : TotalSpace F (Trivial B F) ≃ₜ B × F :=
+  (TotalSpace.toProd _ _).toHomeomorphOfInducing (inducing_toProd B F)
+
 /-- Local trivialization for trivial bundle. -/
-def trivialization : Trivialization F (π (Bundle.Trivial B F)) where
-  toFun x := (x.fst, x.snd)
-  invFun y := ⟨y.fst, y.snd⟩
-  source := univ
-  target := univ
-  map_source' x _ := mem_univ (x.fst, x.snd)
-  map_target' y _ := mem_univ (y.fst, y.snd)
-  left_inv' x _ := Sigma.eq rfl rfl
-  right_inv' x _ := Prod.ext rfl rfl
-  open_source := isOpen_univ
-  open_target := isOpen_univ
-  continuous_toFun := by
-    rw [← continuous_iff_continuousOn_univ, continuous_iff_le_induced]
-    simp only [instTopologicalSpaceProd, induced_inf, induced_compose]
-    exact le_rfl
-  continuous_invFun := by
-    rw [← continuous_iff_continuousOn_univ, continuous_iff_le_induced]
-    simp only [Bundle.TotalSpace.topologicalSpace, induced_inf, induced_compose]
-    exact le_rfl
+def trivialization : Trivialization F (π F (Bundle.Trivial B F)) where
+  -- porting note: golfed
+  toLocalHomeomorph := (homeomorphProd B F).toLocalHomeomorph
   baseSet := univ
   open_baseSet := isOpen_univ
   source_eq := rfl
-  target_eq := by simp only [univ_prod_univ]
-  proj_toFun y _ := rfl
+  target_eq := univ_prod_univ.symm
+  proj_toFun _ _ := rfl
 #align bundle.trivial.trivialization Bundle.Trivial.trivialization
 
 @[simp]
@@ -94,19 +81,15 @@ theorem trivialization_target : (trivialization B F).target = univ := rfl
 
 /-- Fiber bundle instance on the trivial bundle. -/
 instance fiberBundle : FiberBundle F (Bundle.Trivial B F) where
-  trivializationAtlas' := {Bundle.Trivial.trivialization B F}
-  trivializationAt' _ := Bundle.Trivial.trivialization B F
+  trivializationAtlas' := {trivialization B F}
+  trivializationAt' _ := trivialization B F
   mem_baseSet_trivializationAt' := mem_univ
-  trivialization_mem_atlas' x := mem_singleton _
-  totalSpaceMk_inducing' b := ⟨by
-    have : (fun x : Trivial B F b ↦ x) = @id F := by
-      ext x
-      rfl
-    simp only [Bundle.TotalSpace.topologicalSpace, induced_inf, induced_compose, Function.comp,
-      induced_const, top_inf_eq, Trivial.projSnd, Trivial.topologicalSpace, this, induced_id]⟩
+  trivialization_mem_atlas' _ := mem_singleton _
+  totalSpaceMk_inducing' _ := (homeomorphProd B F).symm.inducing.comp
+    (inducing_const_prod.2 inducing_id)
 #align bundle.trivial.fiber_bundle Bundle.Trivial.fiberBundle
 
-theorem eq_trivialization (e : Trivialization F (π (Bundle.Trivial B F)))
+theorem eq_trivialization (e : Trivialization F (π F (Bundle.Trivial B F)))
     [i : MemTrivializationAtlas e] : e = trivialization B F := i.out
 #align bundle.trivial.eq_trivialization Bundle.Trivial.eq_trivialization
 
@@ -123,23 +106,23 @@ variable {B : Type _}
 
 section Defs
 
-variable (E₁ : B → Type _) (E₂ : B → Type _)
+variable (F₁ : Type _) (E₁ : B → Type _) (F₂ : Type _) (E₂ : B → Type _)
 
-variable [TopologicalSpace (TotalSpace E₁)] [TopologicalSpace (TotalSpace E₂)]
+variable [TopologicalSpace (TotalSpace F₁ E₁)] [TopologicalSpace (TotalSpace F₂ E₂)]
 
 /-- Equip the total space of the fiberwise product of two fiber bundles `E₁`, `E₂` with
-the induced topology from the diagonal embedding into `TotalSpace E₁ × TotalSpace E₂`. -/
-instance FiberBundle.Prod.topologicalSpace : TopologicalSpace (TotalSpace (E₁ ×ᵇ E₂)) :=
+the induced topology from the diagonal embedding into `TotalSpace F₁ E₁ × TotalSpace F₂ E₂`. -/
+instance FiberBundle.Prod.topologicalSpace : TopologicalSpace (TotalSpace (F₁ × F₂) (E₁ ×ᵇ E₂)) :=
   TopologicalSpace.induced
-    (fun p ↦ ((⟨p.1, p.2.1⟩ : TotalSpace E₁), (⟨p.1, p.2.2⟩ : TotalSpace E₂)))
-    (inferInstance : TopologicalSpace (TotalSpace E₁ × TotalSpace E₂))
+    (fun p ↦ ((⟨p.1, p.2.1⟩ : TotalSpace F₁ E₁), (⟨p.1, p.2.2⟩ : TotalSpace F₂ E₂)))
+    inferInstance
 #align fiber_bundle.prod.topological_space FiberBundle.Prod.topologicalSpace
 
 /-- The diagonal map from the total space of the fiberwise product of two fiber bundles
-`E₁`, `E₂` into `TotalSpace E₁ × TotalSpace E₂` is `Inducing`. -/
+`E₁`, `E₂` into `TotalSpace F₁ E₁ × TotalSpace F₂ E₂` is `Inducing`. -/
 theorem FiberBundle.Prod.inducing_diag :
     Inducing (fun p ↦ (⟨p.1, p.2.1⟩, ⟨p.1, p.2.2⟩) :
-      TotalSpace (E₁ ×ᵇ E₂) → TotalSpace E₁ × TotalSpace E₂) :=
+      TotalSpace (F₁ × F₂) (E₁ ×ᵇ E₂) → TotalSpace F₁ E₁ × TotalSpace F₂ E₂) :=
   ⟨rfl⟩
 #align fiber_bundle.prod.inducing_diag FiberBundle.Prod.inducing_diag
 
@@ -148,30 +131,30 @@ end Defs
 open FiberBundle
 
 variable [TopologicalSpace B] (F₁ : Type _) [TopologicalSpace F₁] (E₁ : B → Type _)
-  [TopologicalSpace (TotalSpace E₁)] (F₂ : Type _) [TopologicalSpace F₂] (E₂ : B → Type _)
-  [TopologicalSpace (TotalSpace E₂)]
+  [TopologicalSpace (TotalSpace F₁ E₁)] (F₂ : Type _) [TopologicalSpace F₂] (E₂ : B → Type _)
+  [TopologicalSpace (TotalSpace F₂ E₂)]
 
 namespace Trivialization
 
 variable {F₁ E₁ F₂ E₂}
-variable (e₁ : Trivialization F₁ (π E₁)) (e₂ : Trivialization F₂ (π E₂))
+variable (e₁ : Trivialization F₁ (π F₁ E₁)) (e₂ : Trivialization F₂ (π F₂ E₂))
 
 /-- Given trivializations `e₁`, `e₂` for fiber bundles `E₁`, `E₂` over a base `B`, the forward
 function for the construction `Trivialization.prod`, the induced
 trivialization for the fiberwise product of `E₁` and `E₂`. -/
-def Prod.toFun' : TotalSpace (E₁ ×ᵇ E₂) → B × F₁ × F₂ :=
+def Prod.toFun' : TotalSpace (F₁ × F₂) (E₁ ×ᵇ E₂) → B × F₁ × F₂ :=
   fun p ↦ ⟨p.1, (e₁ ⟨p.1, p.2.1⟩).2, (e₂ ⟨p.1, p.2.2⟩).2⟩
 #align trivialization.prod.to_fun' Trivialization.Prod.toFun'
 
 variable {e₁ e₂}
 
 theorem Prod.continuous_to_fun : ContinuousOn (Prod.toFun' e₁ e₂)
-    (@TotalSpace.proj B (E₁ ×ᵇ E₂) ⁻¹' (e₁.baseSet ∩ e₂.baseSet)) := by
-  let f₁ : TotalSpace (E₁ ×ᵇ E₂) → TotalSpace E₁ × TotalSpace E₂ :=
-    fun p ↦ ((⟨p.1, p.2.1⟩ : TotalSpace E₁), (⟨p.1, p.2.2⟩ : TotalSpace E₂))
-  let f₂ : TotalSpace E₁ × TotalSpace E₂ → (B × F₁) × B × F₂ := fun p ↦ ⟨e₁ p.1, e₂ p.2⟩
+    (π (F₁ × F₂) (E₁ ×ᵇ E₂) ⁻¹' (e₁.baseSet ∩ e₂.baseSet)) := by
+  let f₁ : TotalSpace (F₁ × F₂) (E₁ ×ᵇ E₂) → TotalSpace F₁ E₁ × TotalSpace F₂ E₂ :=
+    fun p ↦ ((⟨p.1, p.2.1⟩ : TotalSpace F₁ E₁), (⟨p.1, p.2.2⟩ : TotalSpace F₂ E₂))
+  let f₂ : TotalSpace F₁ E₁ × TotalSpace F₂ E₂ → (B × F₁) × B × F₂ := fun p ↦ ⟨e₁ p.1, e₂ p.2⟩
   let f₃ : (B × F₁) × B × F₂ → B × F₁ × F₂ := fun p ↦ ⟨p.1.1, p.1.2, p.2.2⟩
-  have hf₁ : Continuous f₁ := (Prod.inducing_diag E₁ E₂).continuous
+  have hf₁ : Continuous f₁ := (Prod.inducing_diag F₁ E₁ F₂ E₂).continuous
   have hf₂ : ContinuousOn f₂ (e₁.source ×ˢ e₂.source) :=
     e₁.toLocalHomeomorph.continuousOn.prod_map e₂.toLocalHomeomorph.continuousOn
   have hf₃ : Continuous f₃ :=
@@ -191,14 +174,14 @@ variable (e₁ e₂) [∀ x, Zero (E₁ x)] [∀ x, Zero (E₂ x)]
 /-- Given trivializations `e₁`, `e₂` for fiber bundles `E₁`, `E₂` over a base `B`, the inverse
 function for the construction `Trivialization.prod`, the induced
 trivialization for the fiberwise product of `E₁` and `E₂`. -/
-noncomputable def Prod.invFun' (p : B × F₁ × F₂) : TotalSpace (E₁ ×ᵇ E₂) :=
+noncomputable def Prod.invFun' (p : B × F₁ × F₂) : TotalSpace (F₁ × F₂) (E₁ ×ᵇ E₂) :=
   ⟨p.1, e₁.symm p.1 p.2.1, e₂.symm p.1 p.2.2⟩
 #align trivialization.prod.inv_fun' Trivialization.Prod.invFun'
 
 variable {e₁ e₂}
 
-theorem Prod.left_inv {x : TotalSpace (E₁ ×ᵇ E₂)}
-    (h : x ∈ @TotalSpace.proj B (E₁ ×ᵇ E₂) ⁻¹' (e₁.baseSet ∩ e₂.baseSet)) :
+theorem Prod.left_inv {x : TotalSpace (F₁ × F₂) (E₁ ×ᵇ E₂)}
+    (h : x ∈ π (F₁ × F₂) (E₁ ×ᵇ E₂) ⁻¹' (e₁.baseSet ∩ e₂.baseSet)) :
     Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x := by
   obtain ⟨x, v₁, v₂⟩ := x
   obtain ⟨h₁ : x ∈ e₁.baseSet, h₂ : x ∈ e₂.baseSet⟩ := h
@@ -215,7 +198,7 @@ theorem Prod.right_inv {x : B × F₁ × F₂}
 
 theorem Prod.continuous_inv_fun :
     ContinuousOn (Prod.invFun' e₁ e₂) ((e₁.baseSet ∩ e₂.baseSet) ×ˢ univ) := by
-  rw [(Prod.inducing_diag E₁ E₂).continuousOn_iff]
+  rw [(Prod.inducing_diag F₁ E₁ F₂ E₂).continuousOn_iff]
   have H₁ : Continuous fun p : B × F₁ × F₂ ↦ ((p.1, p.2.1), (p.1, p.2.2)) :=
     (continuous_id.prod_map continuous_fst).prod_mk (continuous_id.prod_map continuous_snd)
   refine' (e₁.continuousOn_symm.prod_map e₂.continuousOn_symm).comp H₁.continuousOn _
@@ -227,10 +210,10 @@ variable (e₁ e₂)
 /-- Given trivializations `e₁`, `e₂` for bundle types `E₁`, `E₂` over a base `B`, the induced
 trivialization for the fiberwise product of `E₁` and `E₂`, whose base set is
 `e₁.baseSet ∩ e₂.baseSet`. -/
-noncomputable def prod : Trivialization (F₁ × F₂) (π (E₁ ×ᵇ E₂)) where
+noncomputable def prod : Trivialization (F₁ × F₂) (π (F₁ × F₂) (E₁ ×ᵇ E₂)) where
   toFun := Prod.toFun' e₁ e₂
   invFun := Prod.invFun' e₁ e₂
-  source := @TotalSpace.proj B (E₁ ×ᵇ E₂) ⁻¹' (e₁.baseSet ∩ e₂.baseSet)
+  source := π (F₁ × F₂) (E₁ ×ᵇ E₂) ⁻¹' (e₁.baseSet ∩ e₂.baseSet)
   target := (e₁.baseSet ∩ e₂.baseSet) ×ˢ Set.univ
   map_source' x h := ⟨h, Set.mem_univ _⟩
   map_target' x h := h.1
@@ -238,7 +221,7 @@ noncomputable def prod : Trivialization (F₁ × F₂) (π (E₁ ×ᵇ E₂)) wh
   right_inv' x := Prod.right_inv
   open_source := by
     convert (e₁.open_source.prod e₂.open_source).preimage
-        (FiberBundle.Prod.inducing_diag E₁ E₂).continuous
+        (FiberBundle.Prod.inducing_diag F₁ E₁ F₂ E₂).continuous
     ext x
     simp only [Trivialization.source_eq, mfld_simps]
   open_target := (e₁.open_baseSet.inter e₂.open_baseSet).prod isOpen_univ
@@ -269,9 +252,10 @@ variable [∀ x, Zero (E₁ x)] [∀ x, Zero (E₂ x)] [∀ x : B, TopologicalSp
 /-- The product of two fiber bundles is a fiber bundle. -/
 noncomputable instance FiberBundle.prod : FiberBundle (F₁ × F₂) (E₁ ×ᵇ E₂) where
   totalSpaceMk_inducing' b := by
-    rw [(Prod.inducing_diag E₁ E₂).inducing_iff]
+    rw [(Prod.inducing_diag F₁ E₁ F₂ E₂).inducing_iff]
     exact (totalSpaceMk_inducing F₁ E₁ b).prod_map (totalSpaceMk_inducing F₂ E₂ b)
-  trivializationAtlas' := { e | ∃ (e₁ : Trivialization F₁ (π E₁)) (e₂ : Trivialization F₂ (π E₂))
+  trivializationAtlas' := { e |
+    ∃ (e₁ : Trivialization F₁ (π F₁ E₁)) (e₂ : Trivialization F₂ (π F₂ E₂))
       (_ : MemTrivializationAtlas e₁) (_ : MemTrivializationAtlas e₂),
       e = Trivialization.prod e₁ e₂ }
   trivializationAt' b := (trivializationAt F₁ E₁ b).prod (trivializationAt F₂ E₂ b)
@@ -281,16 +265,15 @@ noncomputable instance FiberBundle.prod : FiberBundle (F₁ × F₂) (E₁ ×ᵇ
     ⟨trivializationAt F₁ E₁ b, trivializationAt F₂ E₂ b, inferInstance, inferInstance, rfl⟩
 #align fiber_bundle.prod FiberBundle.prod
 
-instance {e₁ : Trivialization F₁ (π E₁)} {e₂ : Trivialization F₂ (π E₂)} [MemTrivializationAtlas e₁]
-    [MemTrivializationAtlas e₂] :
-    MemTrivializationAtlas (e₁.prod e₂ : Trivialization (F₁ × F₂) (π (E₁ ×ᵇ E₂))) where
+instance {e₁ : Trivialization F₁ (π F₁ E₁)} {e₂ : Trivialization F₂ (π F₂ E₂)}
+    [MemTrivializationAtlas e₁] [MemTrivializationAtlas e₂] :
+    MemTrivializationAtlas (e₁.prod e₂ : Trivialization (F₁ × F₂) (π (F₁ × F₂) (E₁ ×ᵇ E₂))) where
   out := ⟨e₁, e₂, inferInstance, inferInstance, rfl⟩
 
 end Prod
 
 /-! ### Pullbacks of fiber bundles -/
 
-
 section
 
 universe u v w₁ w₂ U
@@ -303,32 +286,32 @@ instance [∀ x : B, TopologicalSpace (E x)] : ∀ x : B', TopologicalSpace ((f
   rw [Bundle.Pullback]
   infer_instance
 
-variable [TopologicalSpace B'] [TopologicalSpace (TotalSpace E)]
+variable [TopologicalSpace B'] [TopologicalSpace (TotalSpace F E)]
 
 /-- Definition of `Pullback.TotalSpace.topologicalSpace`, which we make irreducible. -/
-irreducible_def pullbackTopology : TopologicalSpace (TotalSpace (f *ᵖ E)) :=
+irreducible_def pullbackTopology : TopologicalSpace (TotalSpace F (f *ᵖ E)) :=
   induced TotalSpace.proj ‹TopologicalSpace B'› ⊓
-    induced (Pullback.lift f) ‹TopologicalSpace (TotalSpace E)›
+    induced (Pullback.lift f) ‹TopologicalSpace (TotalSpace F E)›
 #align pullback_topology pullbackTopology
 
 /-- The topology on the total space of a pullback bundle is the coarsest topology for which both
 the projections to the base and the map to the original bundle are continuous. -/
-instance Pullback.TotalSpace.topologicalSpace : TopologicalSpace (TotalSpace (f *ᵖ E)) :=
-  pullbackTopology E f
+instance Pullback.TotalSpace.topologicalSpace : TopologicalSpace (TotalSpace F (f *ᵖ E)) :=
+  pullbackTopology F E f
 #align pullback.total_space.topological_space Pullback.TotalSpace.topologicalSpace
 
-theorem Pullback.continuous_proj (f : B' → B) : Continuous (@TotalSpace.proj _ (f *ᵖ E)) := by
+theorem Pullback.continuous_proj (f : B' → B) : Continuous (π F (f *ᵖ E)) := by
   rw [continuous_iff_le_induced, Pullback.TotalSpace.topologicalSpace, pullbackTopology_def]
   exact inf_le_left
 #align pullback.continuous_proj Pullback.continuous_proj
 
-theorem Pullback.continuous_lift (f : B' → B) : Continuous (@Pullback.lift B E B' f) := by
+theorem Pullback.continuous_lift (f : B' → B) : Continuous (@Pullback.lift B F E B' f) := by
   rw [continuous_iff_le_induced, Pullback.TotalSpace.topologicalSpace, pullbackTopology_def]
   exact inf_le_right
 #align pullback.continuous_lift Pullback.continuous_lift
 
 theorem inducing_pullbackTotalSpaceEmbedding (f : B' → B) :
-    Inducing (@pullbackTotalSpaceEmbedding B E B' f) := by
+    Inducing (@pullbackTotalSpaceEmbedding B F E B' f) := by
   constructor
   simp_rw [instTopologicalSpaceProd, induced_inf, induced_compose,
     Pullback.TotalSpace.topologicalSpace, pullbackTopology_def]
@@ -340,10 +323,9 @@ section FiberBundle
 variable [TopologicalSpace F] [TopologicalSpace B]
 
 theorem Pullback.continuous_totalSpaceMk [∀ x, TopologicalSpace (E x)] [FiberBundle F E]
-    {f : B' → B} {x : B'} : Continuous (@totalSpaceMk _ (f *ᵖ E) x) := by
+    {f : B' → B} {x : B'} : Continuous (@TotalSpace.mk _ F (f *ᵖ E) x) := by
   simp only [continuous_iff_le_induced, Pullback.TotalSpace.topologicalSpace, induced_compose,
-    induced_inf, Function.comp, totalSpaceMk, TotalSpace.proj, induced_const, top_inf_eq,
-    pullbackTopology_def]
+    induced_inf, Function.comp, induced_const, top_inf_eq, pullbackTopology_def]
   exact le_of_eq (FiberBundle.totalSpaceMk_inducing F E (f x)).induced
 #align pullback.continuous_total_space_mk Pullback.continuous_totalSpaceMk
 
@@ -351,40 +333,38 @@ variable {E F} [∀ _b, Zero (E _b)] {K : Type U} [ContinuousMapClass K B' B]
 
 -- Porting note: universe levels are explicitly provided
 /-- A fiber bundle trivialization can be pulled back to a trivialization on the pullback bundle. -/
-noncomputable def Trivialization.pullback (e : Trivialization F (π E)) (f : K) :
-    Trivialization F (π ((f : B' → B) *ᵖ E)) where
+noncomputable def Trivialization.pullback (e : Trivialization F (π F E)) (f : K) :
+    Trivialization F (π F ((f : B' → B) *ᵖ E)) where
   toFun z := (z.proj, (e (Pullback.lift f z)).2)
-  invFun y := @totalSpaceMk _ (f *ᵖ E) y.1 (e.symm (f y.1) y.2)
+  invFun y := @TotalSpace.mk _ F (f *ᵖ E) y.1 (e.symm (f y.1) y.2)
   source := Pullback.lift f ⁻¹' e.source
   baseSet := f ⁻¹' e.baseSet
   target := (f ⁻¹' e.baseSet) ×ˢ univ
   map_source' x h := by
-    simp_rw [e.source_eq, mem_preimage, Pullback.proj_lift] at h
+    simp_rw [e.source_eq, mem_preimage, Pullback.lift_proj] at h
     simp_rw [prod_mk_mem_set_prod_eq, mem_univ, and_true_iff, mem_preimage, h]
   map_target' y h := by
     rw [mem_prod, mem_preimage] at h
-    simp_rw [e.source_eq, mem_preimage, Pullback.proj_lift, h.1]
+    simp_rw [e.source_eq, mem_preimage, Pullback.lift_proj, h.1]
   left_inv' x h := by
-    simp_rw [mem_preimage, e.mem_source, Pullback.proj_lift] at h
-    simp_rw [Pullback.lift, e.symm_apply_apply_mk h, TotalSpace.eta]
+    simp_rw [mem_preimage, e.mem_source, Pullback.lift_proj] at h
+    simp_rw [Pullback.lift, e.symm_apply_apply_mk h]
   right_inv' x h := by
     simp_rw [mem_prod, mem_preimage, mem_univ, and_true_iff] at h
-    simp_rw [TotalSpace.proj_mk, Pullback.lift_mk, e.apply_mk_symm h]
+    simp_rw [Pullback.lift_mk, e.apply_mk_symm h]
   open_source := by
     simp_rw [e.source_eq, ← preimage_comp]
-    exact
-      ((map_continuous f).comp <| Pullback.continuous_proj E f).isOpen_preimage _ e.open_baseSet
+    exact e.open_baseSet.preimage ((map_continuous f).comp <| Pullback.continuous_proj F E f)
   open_target := ((map_continuous f).isOpen_preimage _ e.open_baseSet).prod isOpen_univ
   open_baseSet := (map_continuous f).isOpen_preimage _ e.open_baseSet
   continuous_toFun :=
-    (Pullback.continuous_proj E f).continuousOn.prod
+    (Pullback.continuous_proj F E f).continuousOn.prod
       (continuous_snd.comp_continuousOn <|
-        e.continuousOn.comp (Pullback.continuous_lift E f).continuousOn Subset.rfl)
+        e.continuousOn.comp (Pullback.continuous_lift F E f).continuousOn Subset.rfl)
   continuous_invFun := by
     dsimp only
-    simp_rw [(inducing_pullbackTotalSpaceEmbedding E f).continuousOn_iff, Function.comp,
-      pullbackTotalSpaceEmbedding, TotalSpace.proj_mk]
-    dsimp only [TotalSpace.proj_mk]
+    simp_rw [(inducing_pullbackTotalSpaceEmbedding F E f).continuousOn_iff, Function.comp,
+      pullbackTotalSpaceEmbedding]
     refine'
       continuousOn_fst.prod
         (e.continuousOn_symm.comp ((map_continuous f).prod_map continuous_id).continuousOn
@@ -401,9 +381,9 @@ noncomputable instance FiberBundle.pullback [∀ x, TopologicalSpace (E x)] [Fib
     (f : K) : FiberBundle F ((f : B' → B) *ᵖ E) where
   totalSpaceMk_inducing' x :=
     inducing_of_inducing_compose (Pullback.continuous_totalSpaceMk F E)
-      (Pullback.continuous_lift E f) (totalSpaceMk_inducing F E (f x))
+      (Pullback.continuous_lift F E f) (totalSpaceMk_inducing F E (f x))
   trivializationAtlas' :=
-    { ef | ∃ (e : Trivialization F (π E)) (_ : MemTrivializationAtlas e), ef = e.pullback f }
+    { ef | ∃ (e : Trivialization F (π F E)) (_ : MemTrivializationAtlas e), ef = e.pullback f }
   trivializationAt' x := (trivializationAt F E (f x)).pullback f
   mem_baseSet_trivializationAt' x := mem_baseSet_trivializationAt F E (f x)
   trivialization_mem_atlas' x := ⟨trivializationAt F E (f x), inferInstance, rfl⟩

chore: fix upper/lowercase in comments (#4360)

Run a non-interactive version of fix-comments.py on all files.
Go through the diff and manually add/discard/edit chunks.

27d257fc

Diff

@@ -136,7 +136,7 @@ instance FiberBundle.Prod.topologicalSpace : TopologicalSpace (TotalSpace (E₁
 #align fiber_bundle.prod.topological_space FiberBundle.Prod.topologicalSpace
 
 /-- The diagonal map from the total space of the fiberwise product of two fiber bundles
-`E₁`, `E₂` into `TotalSpace E₁ × TotalSpace E₂` is `inducing`. -/
+`E₁`, `E₂` into `TotalSpace E₁ × TotalSpace E₂` is `Inducing`. -/
 theorem FiberBundle.Prod.inducing_diag :
     Inducing (fun p ↦ (⟨p.1, p.2.1⟩, ⟨p.1, p.2.2⟩) :
       TotalSpace (E₁ ×ᵇ E₂) → TotalSpace E₁ × TotalSpace E₂) :=