/-- A fiber bundle trivialization can be pulled back to a trivialization on the pullback bundle. -/
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 := @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.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.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]
  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]
  open_source := by
    simp_rw [e.source_eq, ← preimage_comp]
    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
  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)
  continuousOn_invFun := by
    dsimp only
    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
          Subset.rfl)
  source_eq := by
    

Proof state:
B : Type u
F : Type v
E : B → Type w₁
B' : Type w₂
f✝ : B' → B
inst✝⁵ : TopologicalSpace B'
inst✝⁴ : TopologicalSpace (TotalSpace F E)
inst✝³ : TopologicalSpace F
inst✝² : TopologicalSpace B
inst✝¹ : (_b : B) → Zero (E _b)
K : Type U
inst✝ : ContinuousMapClass K B' B
e : Trivialization F TotalSpace.proj
f : K
⊢ {
          toPartialEquiv :=
            { toFun := fun z => (z.proj, (↑e (Pullback.lift (⇑f) z)).2),
              invFun := fun y => { proj := y.1, snd := Trivialization.symm e (f y.1) y.2 },
              source := Pullback.lift ⇑f ⁻¹' e.source, target := (⇑f ⁻¹' e.baseSet) ×ˢ univ,
              map_source' :=
                (_ :
                  ∀ x ∈ Pullback.lift ⇑f ⁻¹' e.source,
                    (fun z => (z.proj, (↑e (Pullback.lift (⇑f) z)).2)) x ∈ (⇑f ⁻¹' e.baseSet) ×ˢ univ),
              map_target' :=
                (_ :
                  ∀ y ∈ (⇑f ⁻¹' e.baseSet) ×ˢ univ,
                    (fun y => { proj := y.1, snd := Trivialization.symm e (f y.1) y.2 }) y ∈
                      Pullback.lift ⇑f ⁻¹' e.source),
              left_inv' :=
                (_ :
                  ∀ x ∈ Pullback.lift ⇑f ⁻¹' e.source,
                    (fun y => { proj := y.1, snd := Trivialization.symm e (f y.1) y.2 })
                        ((fun z => (z.proj, (↑e (Pullback.lift (⇑f) z)).2)) x) =
                      x),
              right_inv' :=
                (_ :
                  ∀ x ∈ (⇑f ⁻¹' e.baseSet) ×ˢ univ,
                    (fun z => (z.proj, (↑e (Pullback.lift (⇑f) z)).2))
                        ((fun y => { proj := y.1, snd := Trivialization.symm e (f y.1) y.2 }) x) =
                      x) },
          open_source :=
            (_ :
              IsOpen
                { toFun := fun z => (z.proj, (↑e (Pullback.lift (⇑f) z)).2),
                    invFun := fun y => { proj := y.1, snd := Trivialization.symm e (f y.1) y.2 },
                    source := Pullback.lift ⇑f ⁻¹' e.source, target := (⇑f ⁻¹' e.baseSet) ×ˢ univ,
                    map_source' :=
                      (_ :
                        ∀ x ∈ Pullback.lift ⇑f ⁻¹' e.source,
                          (fun z => (z.proj, (↑e (Pullback.lift (⇑f) z)).2)) x ∈ (⇑f ⁻¹' e.baseSet) ×ˢ univ),
                    map_target' :=
                      (_ :
                        ∀ y ∈ (⇑f ⁻¹' e.baseSet) ×ˢ univ,
                          (fun y => { proj := y.1, snd := Trivialization.symm e (f y.1) y.2 }) y ∈
                            Pullback.lift ⇑f ⁻¹' e.source),
                    left_inv' :=
                      (_ :
                        ∀ x ∈ Pullback.lift ⇑f ⁻¹' e.source,
                          (fun y => { proj := y.1, snd := Trivialization.symm e (f y.1) y.2 })
                              ((fun z => (z.proj, (↑e (Pullback.lift (⇑f) z)).2)) x) =
                            x),
                    right_inv' :=
                      (_ :
                        ∀ x ∈ (⇑f ⁻¹' e.baseSet) ×ˢ univ,
                          (fun z => (z.proj, (↑e (Pullback.lift (⇑f) z)).2))
                              ((fun y => { proj := y.1, snd := Trivialization.symm e (f y.1) y.2 }) x) =
                            x) }.source),
          open_target := (_ : IsOpen ((⇑f ⁻¹' e.baseSet) ×ˢ univ)),
          continuousOn_toFun :=
            (_ :
              ContinuousOn (fun x => (x.proj, (↑e (Pullback.lift (⇑f) x)).2))
                { toFun := fun z => (z.proj, (↑e (Pullback.lift (⇑f) z)).2),
                    invFun := fun y => { proj := y.1, snd := Trivialization.symm e (f y.1) y.2 },
                    source := Pullback.lift ⇑f ⁻¹' e.source, target := (⇑f ⁻¹' e.baseSet) ×ˢ univ,
                    map_source' :=
                      (_ :
                        ∀ x ∈ Pullback.lift ⇑f ⁻¹' e.source,
                          (fun z => (z.proj, (↑e (Pullback.lift (⇑f) z)).2)) x ∈ (⇑f ⁻¹' e.baseSet) ×ˢ univ),
                    map_target' :=
                      (_ :
                        ∀ y ∈ (⇑f ⁻¹' e.baseSet) ×ˢ univ,
                          (fun y => { proj := y.1, snd := Trivialization.symm e (f y.1) y.2 }) y ∈
                            Pullback.lift ⇑f ⁻¹' e.source),
                    left_inv' :=
                      (_ :
                        ∀ x ∈ Pullback.lift ⇑f ⁻¹' e.source,
                          (fun y => { proj := y.1, snd := Trivialization.symm e (f y.1) y.2 })
                              ((fun z => (z.proj, (↑e (Pullback.lift (⇑f) z)).2)) x) =
                            x),
                    right_inv' :=
                      (_ :
                        ∀ x ∈ (⇑f ⁻¹' e.baseSet) ×ˢ univ,
                          (fun z => (z.proj, (↑e (Pullback.lift (⇑f) z)).2))
                              ((fun y => { proj := y.1, snd := Trivialization.symm e (f y.1) y.2 }) x) =
                            x) }.source),
          continuousOn_invFun :=
            (_ :
              ContinuousOn
                { toFun := fun z => (z.proj, (↑e (Pullback.lift (⇑f) z)).2),
                    invFun := fun y => { proj := y.1, snd := Trivialization.symm e (f y.1) y.2 },
                    source := Pullback.lift ⇑f ⁻¹' e.source, target := (⇑f ⁻¹' e.baseSet) ×ˢ univ,
                    map_source' :=
                      (_ :
                        ∀ x ∈ Pullback.lift ⇑f ⁻¹' e.source,
                          (fun z => (z.proj, (↑e (Pullback.lift (⇑f) z)).2)) x ∈ (⇑f ⁻¹' e.baseSet) ×ˢ univ),
                    map_target' :=
                      (_ :
                        ∀ y ∈ (⇑f ⁻¹' e.baseSet) ×ˢ univ,
                          (fun y => { proj := y.1, snd := Trivialization.symm e (f y.1) y.2 }) y ∈
                            Pullback.lift ⇑f ⁻¹' e.source),
                    left_inv' :=
                      (_ :
                        ∀ x ∈ Pullback.lift ⇑f ⁻¹' e.source,
                          (fun y => { proj := y.1, snd := Trivialization.symm e (f y.1) y.2 })
                              ((fun z => (z.proj, (↑e (Pullback.lift (⇑f) z)).2)) x) =
                            x),
                    right_inv' :=
                      (_ :
                        ∀ x ∈ (⇑f ⁻¹' e.baseSet) ×ˢ univ,
                          (fun z => (z.proj, (↑e (Pullback.lift (⇑f) z)).2))
                              ((fun y => { proj := y.1, snd := Trivialization.symm e (f y.1) y.2 }) x) =
                            x) }.invFun
                { toFun := fun z => (z.proj, (↑e (Pullback.lift (⇑f) z)).2),
                    invFun := fun y => { proj := y.1, snd := Trivialization.symm e (f y.1) y.2 },
                    source := Pullback.lift ⇑f ⁻¹' e.source, target := (⇑f ⁻¹' e.baseSet) ×ˢ univ,
                    map_source' :=
                      (_ :
                        ∀ x ∈ Pullback.lift ⇑f ⁻¹' e.source,
                          (fun z => (z.proj, (↑e (Pullback.lift (⇑f) z)).2)) x ∈ (⇑f ⁻¹' e.baseSet) ×ˢ univ),
                    map_target' :=
                      (_ :
                        ∀ y ∈ (⇑f ⁻¹' e.baseSet) ×ˢ univ,
                          (fun y => { proj := y.1, snd := Trivialization.symm e (f y.1) y.2 }) y ∈
                            Pullback.lift ⇑f ⁻¹' e.source),
                    left_inv' :=
                      (_ :
                        ∀ x ∈ Pullback.lift ⇑f ⁻¹' e.source,
                          (fun y => { proj := y.1, snd := Trivialization.symm e (f y.1) y.2 })
                              ((fun z => (z.proj, (↑e (Pullback.lift (⇑f) z)).2)) x) =
                            x),
                    right_inv' :=
                      (_ :
                        ∀ x ∈ (⇑f ⁻¹' e.baseSet) ×ˢ univ,
                          (fun z => (z.proj, (↑e (Pullback.lift (⇑f) z)).2))
                              ((fun y => { proj := y.1, snd := Trivialization.symm e (f y.1) y.2 }) x) =
                            x) }.target) }.toPartialEquiv.source =
    TotalSpace.proj ⁻¹' (⇑f ⁻¹' e.baseSet)

Next tactic:
dsimp only