l3lab/ntp-mathlib huggingface dataset:
/-- Promotion from a `Pretrivialization` to a `Trivialization`. -/
def trivializationOfMemPretrivializationAtlas (he : e ∈ a.pretrivializationAtlas) :
    @Trivialization B F _ _ _ a.totalSpaceTopology (π F E) :=
  let _ := a.totalSpaceTopology
  { e with
    open_source := a.isOpen_source e,
    continuousOn_toFun := by
      refine continuousOn_iff'.mpr fun s hs => ⟨e ⁻¹' s ∩ e.source,
        isOpen_iSup_iff.mpr fun e' => ?_, by rw [inter_assoc, inter_self]; rfl⟩
      refine isOpen_iSup_iff.mpr fun he' => ?_
      rw [isOpen_coinduced, isOpen_induced_iff]
      obtain ⟨u, hu1, hu2⟩ := continuousOn_iff'.mp (a.continuous_trivChange _ he _ he') s hs
      have hu3 := congr_arg (fun s => (fun x : e'.target => (x : B × F)) ⁻¹' s) hu2
      simp only [Subtype.coe_preimage_self, preimage_inter, univ_inter] at hu3
      

Proof state:
case intro.intro
ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝³ : TopologicalSpace X
E : B → Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e : Pretrivialization F TotalSpace.proj
he : e ∈ a.pretrivializationAtlas
x✝ : TopologicalSpace (TotalSpace F E) := totalSpaceTopology a
s : Set (B × F)
hs : IsOpen s
e' : Pretrivialization F TotalSpace.proj
he' : e' ∈ a.pretrivializationAtlas
u : Set (B × F)
hu1 : IsOpen u
hu2 :
  ↑e ∘ ↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' s ∩
      (e'.target ∩ ↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' e.source) =
    u ∩ (e'.target ∩ ↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' e.source)
hu3 :
  (fun x => ↑x) ⁻¹' (↑e ∘ ↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' s) ∩
      (fun x => ↑x) ⁻¹' (↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' e.source) =
    (fun x => ↑x) ⁻¹' u ∩ (fun x => ↑x) ⁻¹' (↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' e.source)
⊢ ∃ t, IsOpen t ∧ Subtype.val ⁻¹' t = Pretrivialization.setSymm e' ⁻¹' (↑e ⁻¹' s ∩ e.source)

Next tactic:
refine ⟨u ∩ e'.toPartialEquiv.target ∩ e'.toPartialEquiv.symm ⁻¹' e.source, ?_, by
        simp only [preimage_inter, inter_univ, Subtype.coe_preimage_self, hu3.symm]; rfl⟩
/-- Promotion from a `Pretrivialization` to a `Trivialization`. -/
def trivializationOfMemPretrivializationAtlas (he : e ∈ a.pretrivializationAtlas) :
    @Trivialization B F _ _ _ a.totalSpaceTopology (π F E) :=
  let _ := a.totalSpaceTopology
  { e with
    open_source := a.isOpen_source e,
    continuousOn_toFun := by
      refine continuousOn_iff'.mpr fun s hs => ⟨e ⁻¹' s ∩ e.source,
        isOpen_iSup_iff.mpr fun e' => ?_, by rw [inter_assoc, inter_self]; rfl⟩
      refine isOpen_iSup_iff.mpr fun he' => ?_
      rw [isOpen_coinduced, isOpen_induced_iff]
      obtain ⟨u, hu1, hu2⟩ := continuousOn_iff'.mp (a.continuous_trivChange _ he _ he') s hs
      have hu3 := congr_arg (fun s => (fun x : e'.target => (x : B × F)) ⁻¹' s) hu2
      simp only [Subtype.coe_preimage_self, preimage_inter, univ_inter] at hu3
      refine ⟨u ∩ e'.toPartialEquiv.target ∩ e'.toPartialEquiv.symm ⁻¹' e.source, ?_, by
        

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝³ : TopologicalSpace X
E : B → Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e : Pretrivialization F TotalSpace.proj
he : e ∈ a.pretrivializationAtlas
x✝ : TopologicalSpace (TotalSpace F E) := totalSpaceTopology a
s : Set (B × F)
hs : IsOpen s
e' : Pretrivialization F TotalSpace.proj
he' : e' ∈ a.pretrivializationAtlas
u : Set (B × F)
hu1 : IsOpen u
hu2 :
  ↑e ∘ ↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' s ∩
      (e'.target ∩ ↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' e.source) =
    u ∩ (e'.target ∩ ↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' e.source)
hu3 :
  (fun x => ↑x) ⁻¹' (↑e ∘ ↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' s) ∩
      (fun x => ↑x) ⁻¹' (↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' e.source) =
    (fun x => ↑x) ⁻¹' u ∩ (fun x => ↑x) ⁻¹' (↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' e.source)
⊢ Subtype.val ⁻¹' (u ∩ e'.target ∩ ↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' e.source) =
    Pretrivialization.setSymm e' ⁻¹' (↑e ⁻¹' s ∩ e.source)

Next tactic:
simp only [preimage_inter, inter_univ, Subtype.coe_preimage_self, hu3.symm]
/-- Promotion from a `Pretrivialization` to a `Trivialization`. -/
def trivializationOfMemPretrivializationAtlas (he : e ∈ a.pretrivializationAtlas) :
    @Trivialization B F _ _ _ a.totalSpaceTopology (π F E) :=
  let _ := a.totalSpaceTopology
  { e with
    open_source := a.isOpen_source e,
    continuousOn_toFun := by
      refine continuousOn_iff'.mpr fun s hs => ⟨e ⁻¹' s ∩ e.source,
        isOpen_iSup_iff.mpr fun e' => ?_, by rw [inter_assoc, inter_self]; rfl⟩
      refine isOpen_iSup_iff.mpr fun he' => ?_
      rw [isOpen_coinduced, isOpen_induced_iff]
      obtain ⟨u, hu1, hu2⟩ := continuousOn_iff'.mp (a.continuous_trivChange _ he _ he') s hs
      have hu3 := congr_arg (fun s => (fun x : e'.target => (x : B × F)) ⁻¹' s) hu2
      simp only [Subtype.coe_preimage_self, preimage_inter, univ_inter] at hu3
      refine ⟨u ∩ e'.toPartialEquiv.target ∩ e'.toPartialEquiv.symm ⁻¹' e.source, ?_, by
        simp only [preimage_inter, inter_univ, Subtype.coe_preimage_self, hu3.symm]; 

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝³ : TopologicalSpace X
E : B → Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e : Pretrivialization F TotalSpace.proj
he : e ∈ a.pretrivializationAtlas
x✝ : TopologicalSpace (TotalSpace F E) := totalSpaceTopology a
s : Set (B × F)
hs : IsOpen s
e' : Pretrivialization F TotalSpace.proj
he' : e' ∈ a.pretrivializationAtlas
u : Set (B × F)
hu1 : IsOpen u
hu2 :
  ↑e ∘ ↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' s ∩
      (e'.target ∩ ↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' e.source) =
    u ∩ (e'.target ∩ ↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' e.source)
hu3 :
  (fun x => ↑x) ⁻¹' (↑e ∘ ↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' s) ∩
      (fun x => ↑x) ⁻¹' (↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' e.source) =
    (fun x => ↑x) ⁻¹' u ∩ (fun x => ↑x) ⁻¹' (↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' e.source)
⊢ (fun x => ↑x) ⁻¹' (↑e ∘ ↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' s) ∩
      (fun x => ↑x) ⁻¹' (↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' e.source) =
    Pretrivialization.setSymm e' ⁻¹' (↑e ⁻¹' s) ∩ Pretrivialization.setSymm e' ⁻¹' e.source

Next tactic:
rfl
/-- Promotion from a `Pretrivialization` to a `Trivialization`. -/
def trivializationOfMemPretrivializationAtlas (he : e ∈ a.pretrivializationAtlas) :
    @Trivialization B F _ _ _ a.totalSpaceTopology (π F E) :=
  let _ := a.totalSpaceTopology
  { e with
    open_source := a.isOpen_source e,
    continuousOn_toFun := by
      refine continuousOn_iff'.mpr fun s hs => ⟨e ⁻¹' s ∩ e.source,
        isOpen_iSup_iff.mpr fun e' => ?_, by rw [inter_assoc, inter_self]; rfl⟩
      refine isOpen_iSup_iff.mpr fun he' => ?_
      rw [isOpen_coinduced, isOpen_induced_iff]
      obtain ⟨u, hu1, hu2⟩ := continuousOn_iff'.mp (a.continuous_trivChange _ he _ he') s hs
      have hu3 := congr_arg (fun s => (fun x : e'.target => (x : B × F)) ⁻¹' s) hu2
      simp only [Subtype.coe_preimage_self, preimage_inter, univ_inter] at hu3
      refine ⟨u ∩ e'.toPartialEquiv.target ∩ e'.toPartialEquiv.symm ⁻¹' e.source, ?_, by
        simp only [preimage_inter, inter_univ, Subtype.coe_preimage_self, hu3.symm]; rfl⟩
      

Proof state:
case intro.intro
ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝³ : TopologicalSpace X
E : B → Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e : Pretrivialization F TotalSpace.proj
he : e ∈ a.pretrivializationAtlas
x✝ : TopologicalSpace (TotalSpace F E) := totalSpaceTopology a
s : Set (B × F)
hs : IsOpen s
e' : Pretrivialization F TotalSpace.proj
he' : e' ∈ a.pretrivializationAtlas
u : Set (B × F)
hu1 : IsOpen u
hu2 :
  ↑e ∘ ↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' s ∩
      (e'.target ∩ ↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' e.source) =
    u ∩ (e'.target ∩ ↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' e.source)
hu3 :
  (fun x => ↑x) ⁻¹' (↑e ∘ ↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' s) ∩
      (fun x => ↑x) ⁻¹' (↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' e.source) =
    (fun x => ↑x) ⁻¹' u ∩ (fun x => ↑x) ⁻¹' (↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' e.source)
⊢ IsOpen (u ∩ e'.target ∩ ↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' e.source)

Next tactic:
rw [inter_assoc]
/-- Promotion from a `Pretrivialization` to a `Trivialization`. -/
def trivializationOfMemPretrivializationAtlas (he : e ∈ a.pretrivializationAtlas) :
    @Trivialization B F _ _ _ a.totalSpaceTopology (π F E) :=
  let _ := a.totalSpaceTopology
  { e with
    open_source := a.isOpen_source e,
    continuousOn_toFun := by
      refine continuousOn_iff'.mpr fun s hs => ⟨e ⁻¹' s ∩ e.source,
        isOpen_iSup_iff.mpr fun e' => ?_, by rw [inter_assoc, inter_self]; rfl⟩
      refine isOpen_iSup_iff.mpr fun he' => ?_
      rw [isOpen_coinduced, isOpen_induced_iff]
      obtain ⟨u, hu1, hu2⟩ := continuousOn_iff'.mp (a.continuous_trivChange _ he _ he') s hs
      have hu3 := congr_arg (fun s => (fun x : e'.target => (x : B × F)) ⁻¹' s) hu2
      simp only [Subtype.coe_preimage_self, preimage_inter, univ_inter] at hu3
      refine ⟨u ∩ e'.toPartialEquiv.target ∩ e'.toPartialEquiv.symm ⁻¹' e.source, ?_, by
        simp only [preimage_inter, inter_univ, Subtype.coe_preimage_self, hu3.symm]; rfl⟩
      rw [inter_assoc]
      

Proof state:
case intro.intro
ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝³ : TopologicalSpace X
E : B → Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e : Pretrivialization F TotalSpace.proj
he : e ∈ a.pretrivializationAtlas
x✝ : TopologicalSpace (TotalSpace F E) := totalSpaceTopology a
s : Set (B × F)
hs : IsOpen s
e' : Pretrivialization F TotalSpace.proj
he' : e' ∈ a.pretrivializationAtlas
u : Set (B × F)
hu1 : IsOpen u
hu2 :
  ↑e ∘ ↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' s ∩
      (e'.target ∩ ↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' e.source) =
    u ∩ (e'.target ∩ ↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' e.source)
hu3 :
  (fun x => ↑x) ⁻¹' (↑e ∘ ↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' s) ∩
      (fun x => ↑x) ⁻¹' (↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' e.source) =
    (fun x => ↑x) ⁻¹' u ∩ (fun x => ↑x) ⁻¹' (↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' e.source)
⊢ IsOpen (u ∩ (e'.target ∩ ↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' e.source))

Next tactic:
exact hu1.inter (a.isOpen_target_of_mem_pretrivializationAtlas_inter e e' he')
theorem mem_pretrivializationAt_source (b : B) (x : E b) :
    ⟨b, x⟩ ∈ (a.pretrivializationAt b).source := by
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝³ : TopologicalSpace X
E : B → Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e : Pretrivialization F TotalSpace.proj
b : B
x : E b
⊢ { proj := b, snd := x } ∈ (pretrivializationAt a b).source

Next tactic:
simp only [(a.pretrivializationAt b).source_eq, mem_preimage, TotalSpace.proj]
theorem mem_pretrivializationAt_source (b : B) (x : E b) :
    ⟨b, x⟩ ∈ (a.pretrivializationAt b).source := by
  simp only [(a.pretrivializationAt b).source_eq, mem_preimage, TotalSpace.proj]
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝³ : TopologicalSpace X
E : B → Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e : Pretrivialization F TotalSpace.proj
b : B
x : E b
⊢ b ∈ (pretrivializationAt a b).baseSet

Next tactic:
exact a.mem_base_pretrivializationAt b
@[continuity]
theorem continuous_totalSpaceMk (b : B) :
    Continuous[_, a.totalSpaceTopology] (TotalSpace.mk b) := by
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝³ : TopologicalSpace X
E : B → Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e : Pretrivialization F TotalSpace.proj
b : B
⊢ Continuous (TotalSpace.mk b)

Next tactic:
letI := a.totalSpaceTopology
@[continuity]
theorem continuous_totalSpaceMk (b : B) :
    Continuous[_, a.totalSpaceTopology] (TotalSpace.mk b) := by
  letI := a.totalSpaceTopology
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝³ : TopologicalSpace X
E : B → Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e : Pretrivialization F TotalSpace.proj
b : B
this : TopologicalSpace (TotalSpace F E) := totalSpaceTopology a
⊢ Continuous (TotalSpace.mk b)

Next tactic:
let e := a.trivializationOfMemPretrivializationAtlas (a.pretrivialization_mem_atlas b)
@[continuity]
theorem continuous_totalSpaceMk (b : B) :
    Continuous[_, a.totalSpaceTopology] (TotalSpace.mk b) := by
  letI := a.totalSpaceTopology
  let e := a.trivializationOfMemPretrivializationAtlas (a.pretrivialization_mem_atlas b)
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝³ : TopologicalSpace X
E : B → Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e✝ : Pretrivialization F TotalSpace.proj
b : B
this : TopologicalSpace (TotalSpace F E) := totalSpaceTopology a
e : Trivialization F TotalSpace.proj :=
  trivializationOfMemPretrivializationAtlas a (_ : pretrivializationAt a b ∈ a.pretrivializationAtlas)
⊢ Continuous (TotalSpace.mk b)

Next tactic:
rw [e.toPartialHomeomorph.continuous_iff_continuous_comp_left
      (a.totalSpaceMk_preimage_source b)]
@[continuity]
theorem continuous_totalSpaceMk (b : B) :
    Continuous[_, a.totalSpaceTopology] (TotalSpace.mk b) := by
  letI := a.totalSpaceTopology
  let e := a.trivializationOfMemPretrivializationAtlas (a.pretrivialization_mem_atlas b)
  rw [e.toPartialHomeomorph.continuous_iff_continuous_comp_left
      (a.totalSpaceMk_preimage_source b)]
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝³ : TopologicalSpace X
E : B → Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e✝ : Pretrivialization F TotalSpace.proj
b : B
this : TopologicalSpace (TotalSpace F E) := totalSpaceTopology a
e : Trivialization F TotalSpace.proj :=
  trivializationOfMemPretrivializationAtlas a (_ : pretrivializationAt a b ∈ a.pretrivializationAtlas)
⊢ Continuous (↑e.toPartialHomeomorph ∘ TotalSpace.mk b)

Next tactic:
exact continuous_iff_le_induced.mpr (le_antisymm_iff.mp (a.totalSpaceMk_inducing b).induced).1
theorem inducing_totalSpaceMk_of_inducing_comp (b : B)
    (h : Inducing (a.pretrivializationAt b ∘ TotalSpace.mk b)) :
    @Inducing _ _ _ a.totalSpaceTopology (TotalSpace.mk b) := by
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝³ : TopologicalSpace X
E : B → Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e : Pretrivialization F TotalSpace.proj
b : B
h : Inducing (↑(pretrivializationAt a b) ∘ TotalSpace.mk b)
⊢ Inducing (TotalSpace.mk b)

Next tactic:
letI := a.totalSpaceTopology
theorem inducing_totalSpaceMk_of_inducing_comp (b : B)
    (h : Inducing (a.pretrivializationAt b ∘ TotalSpace.mk b)) :
    @Inducing _ _ _ a.totalSpaceTopology (TotalSpace.mk b) := by
  letI := a.totalSpaceTopology
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝³ : TopologicalSpace X
E : B → Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e : Pretrivialization F TotalSpace.proj
b : B
h : Inducing (↑(pretrivializationAt a b) ∘ TotalSpace.mk b)
this : TopologicalSpace (TotalSpace F E) := totalSpaceTopology a
⊢ Inducing (TotalSpace.mk b)

Next tactic:
rw [← restrict_comp_codRestrict (a.mem_pretrivializationAt_source b)] at h
theorem inducing_totalSpaceMk_of_inducing_comp (b : B)
    (h : Inducing (a.pretrivializationAt b ∘ TotalSpace.mk b)) :
    @Inducing _ _ _ a.totalSpaceTopology (TotalSpace.mk b) := by
  letI := a.totalSpaceTopology
  rw [← restrict_comp_codRestrict (a.mem_pretrivializationAt_source b)] at h
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝³ : TopologicalSpace X
E : B → Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e : Pretrivialization F TotalSpace.proj
b : B
h :
  Inducing
    (restrict (pretrivializationAt a b).source ↑(pretrivializationAt a b) ∘
      codRestrict (fun x => { proj := b, snd := x }) (pretrivializationAt a b).source
        (_ : ∀ (x : E b), { proj := b, snd := x } ∈ (pretrivializationAt a b).source))
this : TopologicalSpace (TotalSpace F E) := totalSpaceTopology a
⊢ Inducing (TotalSpace.mk b)

Next tactic:
apply Inducing.of_codRestrict (a.mem_pretrivializationAt_source b)
theorem inducing_totalSpaceMk_of_inducing_comp (b : B)
    (h : Inducing (a.pretrivializationAt b ∘ TotalSpace.mk b)) :
    @Inducing _ _ _ a.totalSpaceTopology (TotalSpace.mk b) := by
  letI := a.totalSpaceTopology
  rw [← restrict_comp_codRestrict (a.mem_pretrivializationAt_source b)] at h
  apply Inducing.of_codRestrict (a.mem_pretrivializationAt_source b)
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝³ : TopologicalSpace X
E : B → Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e : Pretrivialization F TotalSpace.proj
b : B
h :
  Inducing
    (restrict (pretrivializationAt a b).source ↑(pretrivializationAt a b) ∘
      codRestrict (fun x => { proj := b, snd := x }) (pretrivializationAt a b).source
        (_ : ∀ (x : E b), { proj := b, snd := x } ∈ (pretrivializationAt a b).source))
this : TopologicalSpace (TotalSpace F E) := totalSpaceTopology a
⊢ Inducing
    (codRestrict (fun a => { proj := b, snd := a }) (pretrivializationAt a b).source
      (_ : ∀ (x : E b), { proj := b, snd := x } ∈ (pretrivializationAt a b).source))

Next tactic:
refine inducing_of_inducing_compose ?_ (continuousOn_iff_continuous_restrict.mp
    (a.trivializationOfMemPretrivializationAtlas
      (a.pretrivialization_mem_atlas b)).continuousOn_toFun) h
theorem inducing_totalSpaceMk_of_inducing_comp (b : B)
    (h : Inducing (a.pretrivializationAt b ∘ TotalSpace.mk b)) :
    @Inducing _ _ _ a.totalSpaceTopology (TotalSpace.mk b) := by
  letI := a.totalSpaceTopology
  rw [← restrict_comp_codRestrict (a.mem_pretrivializationAt_source b)] at h
  apply Inducing.of_codRestrict (a.mem_pretrivializationAt_source b)
  refine inducing_of_inducing_compose ?_ (continuousOn_iff_continuous_restrict.mp
    (a.trivializationOfMemPretrivializationAtlas
      (a.pretrivialization_mem_atlas b)).continuousOn_toFun) h
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝³ : TopologicalSpace X
E : B → Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e : Pretrivialization F TotalSpace.proj
b : B
h :
  Inducing
    (restrict (pretrivializationAt a b).source ↑(pretrivializationAt a b) ∘
      codRestrict (fun x => { proj := b, snd := x }) (pretrivializationAt a b).source
        (_ : ∀ (x : E b), { proj := b, snd := x } ∈ (pretrivializationAt a b).source))
this : TopologicalSpace (TotalSpace F E) := totalSpaceTopology a
⊢ Continuous
    (codRestrict (fun a => { proj := b, snd := a }) (pretrivializationAt a b).source
      (_ : ∀ (x : E b), { proj := b, snd := x } ∈ (pretrivializationAt a b).source))

Next tactic:
exact (a.continuous_totalSpaceMk b).codRestrict (a.mem_pretrivializationAt_source b)
theorem continuous_proj : @Continuous _ _ a.totalSpaceTopology _ (π F E) := by
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝³ : TopologicalSpace X
E : B → Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e : Pretrivialization F TotalSpace.proj
⊢ Continuous TotalSpace.proj

Next tactic:
letI := a.totalSpaceTopology
theorem continuous_proj : @Continuous _ _ a.totalSpaceTopology _ (π F E) := by
  letI := a.totalSpaceTopology
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝³ : TopologicalSpace X
E : B → Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e : Pretrivialization F TotalSpace.proj
this : TopologicalSpace (TotalSpace F E) := totalSpaceTopology a
⊢ Continuous TotalSpace.proj

Next tactic:
letI := a.toFiberBundle
theorem continuous_proj : @Continuous _ _ a.totalSpaceTopology _ (π F E) := by
  letI := a.totalSpaceTopology
  letI := a.toFiberBundle
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝³ : TopologicalSpace X
E : B → Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e : Pretrivialization F TotalSpace.proj
this✝ : TopologicalSpace (TotalSpace F E) := totalSpaceTopology a
this : FiberBundle F E := toFiberBundle a
⊢ Continuous TotalSpace.proj

Next tactic:
exact FiberBundle.continuous_proj F E
/-- For a fiber bundle `E` over `B` constructed using the `FiberPrebundle` mechanism,
continuity of a function `TotalSpace F E → X` on an open set `s` can be checked by precomposing at
each point with the pretrivialization used for the construction at that point. -/
theorem continuousOn_of_comp_right {X : Type*} [TopologicalSpace X] {f : TotalSpace F E → X}
    {s : Set B} (hs : IsOpen s) (hf : ∀ b ∈ s,
      ContinuousOn (f ∘ (a.pretrivializationAt b).toPartialEquiv.symm)
        ((s ∩ (a.pretrivializationAt b).baseSet) ×ˢ (Set.univ : Set F))) :
    @ContinuousOn _ _ a.totalSpaceTopology _ f (π F E ⁻¹' s) := by
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
X✝ : Type u_4
inst✝⁴ : TopologicalSpace X✝
E : B → Type u_5
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace F
inst✝¹ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e : Pretrivialization F TotalSpace.proj
X : Type u_6
inst✝ : TopologicalSpace X
f : TotalSpace F E → X
s : Set B
hs : IsOpen s
hf :
  ∀ b ∈ s,
    ContinuousOn (f ∘ ↑(PartialEquiv.symm (pretrivializationAt a b).toPartialEquiv))
      ((s ∩ (pretrivializationAt a b).baseSet) ×ˢ univ)
⊢ ContinuousOn f (TotalSpace.proj ⁻¹' s)

Next tactic:
letI := a.totalSpaceTopology
/-- For a fiber bundle `E` over `B` constructed using the `FiberPrebundle` mechanism,
continuity of a function `TotalSpace F E → X` on an open set `s` can be checked by precomposing at
each point with the pretrivialization used for the construction at that point. -/
theorem continuousOn_of_comp_right {X : Type*} [TopologicalSpace X] {f : TotalSpace F E → X}
    {s : Set B} (hs : IsOpen s) (hf : ∀ b ∈ s,
      ContinuousOn (f ∘ (a.pretrivializationAt b).toPartialEquiv.symm)
        ((s ∩ (a.pretrivializationAt b).baseSet) ×ˢ (Set.univ : Set F))) :
    @ContinuousOn _ _ a.totalSpaceTopology _ f (π F E ⁻¹' s) := by
  letI := a.totalSpaceTopology
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
X✝ : Type u_4
inst✝⁴ : TopologicalSpace X✝
E : B → Type u_5
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace F
inst✝¹ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e : Pretrivialization F TotalSpace.proj
X : Type u_6
inst✝ : TopologicalSpace X
f : TotalSpace F E → X
s : Set B
hs : IsOpen s
hf :
  ∀ b ∈ s,
    ContinuousOn (f ∘ ↑(PartialEquiv.symm (pretrivializationAt a b).toPartialEquiv))
      ((s ∩ (pretrivializationAt a b).baseSet) ×ˢ univ)
this : TopologicalSpace (TotalSpace F E) := totalSpaceTopology a
⊢ ContinuousOn f (TotalSpace.proj ⁻¹' s)

Next tactic:
intro z hz