/-- 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
    

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
⊢ 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

Next tactic:
dsimp only