l3lab/ntp-mathlib huggingface dataset:
theorem mk_coordChange (a : VectorPrebundle R F E) {e e' : Pretrivialization F (π F E)}
    (he : e ∈ a.pretrivializationAtlas) (he' : e' ∈ a.pretrivializationAtlas) {b : B}
    (hb : b ∈ e.baseSet ∩ e'.baseSet) (v : F) :
    (b, a.coordChange he he' b v) = e' ⟨b, e.symm b v⟩ := by
  ext
  · rw [e.mk_symm hb.1 v, e'.coe_fst', e.proj_symm_apply' hb.1]
    rw [e.proj_symm_apply' hb.1]
    

Proof state:
case a
R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁶ : NontriviallyNormedField R
inst✝⁵ : (x : B) → AddCommMonoid (E x)
inst✝⁴ : (x : B) → Module R (E x)
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace R F
inst✝¹ : TopologicalSpace B
inst✝ : (x : B) → TopologicalSpace (E x)
a : VectorPrebundle R F E
e e' : Pretrivialization F TotalSpace.proj
he : e ∈ a.pretrivializationAtlas
he' : e' ∈ a.pretrivializationAtlas
b : B
hb : b ∈ e.baseSet ∩ e'.baseSet
v : F
⊢ b ∈ e'.baseSet

Next tactic:
exact hb.2
theorem mk_coordChange (a : VectorPrebundle R F E) {e e' : Pretrivialization F (π F E)}
    (he : e ∈ a.pretrivializationAtlas) (he' : e' ∈ a.pretrivializationAtlas) {b : B}
    (hb : b ∈ e.baseSet ∩ e'.baseSet) (v : F) :
    (b, a.coordChange he he' b v) = e' ⟨b, e.symm b v⟩ := by
  ext
  · rw [e.mk_symm hb.1 v, e'.coe_fst', e.proj_symm_apply' hb.1]
    rw [e.proj_symm_apply' hb.1]
    exact hb.2
  · 

Proof state:
case a
R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁶ : NontriviallyNormedField R
inst✝⁵ : (x : B) → AddCommMonoid (E x)
inst✝⁴ : (x : B) → Module R (E x)
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace R F
inst✝¹ : TopologicalSpace B
inst✝ : (x : B) → TopologicalSpace (E x)
a : VectorPrebundle R F E
e e' : Pretrivialization F TotalSpace.proj
he : e ∈ a.pretrivializationAtlas
he' : e' ∈ a.pretrivializationAtlas
b : B
hb : b ∈ e.baseSet ∩ e'.baseSet
v : F
⊢ (b, (coordChange a he he' b) v).2 = (↑e' { proj := b, snd := Pretrivialization.symm e b v }).2

Next tactic:
exact a.coordChange_apply he he' hb v
/-- Natural identification of `VectorPrebundle` as a `FiberPrebundle`. -/
def toFiberPrebundle (a : VectorPrebundle R F E) : FiberPrebundle F E :=
  { a with
    continuous_trivChange := fun e he e' he' ↦ by
      

Proof state:
R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁶ : NontriviallyNormedField R
inst✝⁵ : (x : B) → AddCommMonoid (E x)
inst✝⁴ : (x : B) → Module R (E x)
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace R F
inst✝¹ : TopologicalSpace B
inst✝ : (x : B) → TopologicalSpace (E x)
a : VectorPrebundle R F E
e : Pretrivialization F TotalSpace.proj
he : e ∈ a.pretrivializationAtlas
e' : Pretrivialization F TotalSpace.proj
he' : e' ∈ a.pretrivializationAtlas
⊢ ContinuousOn (↑e ∘ ↑(PartialEquiv.symm e'.toPartialEquiv))
    (e'.target ∩ ↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' e.source)

Next tactic:
have : ContinuousOn (fun x : B × F ↦ a.coordChange he' he x.1 x.2)
          ((e'.baseSet ∩ e.baseSet) ×ˢ univ) :=
        isBoundedBilinearMap_apply.continuous.comp_continuousOn
          ((a.continuousOn_coordChange he' he).prod_map continuousOn_id)
/-- Natural identification of `VectorPrebundle` as a `FiberPrebundle`. -/
def toFiberPrebundle (a : VectorPrebundle R F E) : FiberPrebundle F E :=
  { a with
    continuous_trivChange := fun e he e' he' ↦ by
      have : ContinuousOn (fun x : B × F ↦ a.coordChange he' he x.1 x.2)
          ((e'.baseSet ∩ e.baseSet) ×ˢ univ) :=
        isBoundedBilinearMap_apply.continuous.comp_continuousOn
          ((a.continuousOn_coordChange he' he).prod_map continuousOn_id)
      

Proof state:
R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁶ : NontriviallyNormedField R
inst✝⁵ : (x : B) → AddCommMonoid (E x)
inst✝⁴ : (x : B) → Module R (E x)
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace R F
inst✝¹ : TopologicalSpace B
inst✝ : (x : B) → TopologicalSpace (E x)
a : VectorPrebundle R F E
e : Pretrivialization F TotalSpace.proj
he : e ∈ a.pretrivializationAtlas
e' : Pretrivialization F TotalSpace.proj
he' : e' ∈ a.pretrivializationAtlas
this : ContinuousOn (fun x => (coordChange a he' he x.1) x.2) ((e'.baseSet ∩ e.baseSet) ×ˢ univ)
⊢ ContinuousOn (↑e ∘ ↑(PartialEquiv.symm e'.toPartialEquiv))
    (e'.target ∩ ↑(PartialEquiv.symm e'.toPartialEquiv) ⁻¹' e.source)

Next tactic:
rw [e.target_inter_preimage_symm_source_eq e', inter_comm]
/-- Natural identification of `VectorPrebundle` as a `FiberPrebundle`. -/
def toFiberPrebundle (a : VectorPrebundle R F E) : FiberPrebundle F E :=
  { a with
    continuous_trivChange := fun e he e' he' ↦ by
      have : ContinuousOn (fun x : B × F ↦ a.coordChange he' he x.1 x.2)
          ((e'.baseSet ∩ e.baseSet) ×ˢ univ) :=
        isBoundedBilinearMap_apply.continuous.comp_continuousOn
          ((a.continuousOn_coordChange he' he).prod_map continuousOn_id)
      rw [e.target_inter_preimage_symm_source_eq e', inter_comm]
      

Proof state:
R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁶ : NontriviallyNormedField R
inst✝⁵ : (x : B) → AddCommMonoid (E x)
inst✝⁴ : (x : B) → Module R (E x)
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace R F
inst✝¹ : TopologicalSpace B
inst✝ : (x : B) → TopologicalSpace (E x)
a : VectorPrebundle R F E
e : Pretrivialization F TotalSpace.proj
he : e ∈ a.pretrivializationAtlas
e' : Pretrivialization F TotalSpace.proj
he' : e' ∈ a.pretrivializationAtlas
this : ContinuousOn (fun x => (coordChange a he' he x.1) x.2) ((e'.baseSet ∩ e.baseSet) ×ˢ univ)
⊢ ContinuousOn (↑e ∘ ↑(PartialEquiv.symm e'.toPartialEquiv)) ((e'.baseSet ∩ e.baseSet) ×ˢ univ)

Next tactic:
refine' (continuousOn_fst.prod this).congr _
/-- Natural identification of `VectorPrebundle` as a `FiberPrebundle`. -/
def toFiberPrebundle (a : VectorPrebundle R F E) : FiberPrebundle F E :=
  { a with
    continuous_trivChange := fun e he e' he' ↦ by
      have : ContinuousOn (fun x : B × F ↦ a.coordChange he' he x.1 x.2)
          ((e'.baseSet ∩ e.baseSet) ×ˢ univ) :=
        isBoundedBilinearMap_apply.continuous.comp_continuousOn
          ((a.continuousOn_coordChange he' he).prod_map continuousOn_id)
      rw [e.target_inter_preimage_symm_source_eq e', inter_comm]
      refine' (continuousOn_fst.prod this).congr _
      

Proof state:
R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁶ : NontriviallyNormedField R
inst✝⁵ : (x : B) → AddCommMonoid (E x)
inst✝⁴ : (x : B) → Module R (E x)
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace R F
inst✝¹ : TopologicalSpace B
inst✝ : (x : B) → TopologicalSpace (E x)
a : VectorPrebundle R F E
e : Pretrivialization F TotalSpace.proj
he : e ∈ a.pretrivializationAtlas
e' : Pretrivialization F TotalSpace.proj
he' : e' ∈ a.pretrivializationAtlas
this : ContinuousOn (fun x => (coordChange a he' he x.1) x.2) ((e'.baseSet ∩ e.baseSet) ×ˢ univ)
⊢ EqOn (↑e ∘ ↑(PartialEquiv.symm e'.toPartialEquiv)) (fun x => (x.1, (coordChange a he' he x.1) x.2))
    ((e'.baseSet ∩ e.baseSet) ×ˢ univ)

Next tactic:
rintro ⟨b, f⟩ ⟨hb, -⟩
/-- Natural identification of `VectorPrebundle` as a `FiberPrebundle`. -/
def toFiberPrebundle (a : VectorPrebundle R F E) : FiberPrebundle F E :=
  { a with
    continuous_trivChange := fun e he e' he' ↦ by
      have : ContinuousOn (fun x : B × F ↦ a.coordChange he' he x.1 x.2)
          ((e'.baseSet ∩ e.baseSet) ×ˢ univ) :=
        isBoundedBilinearMap_apply.continuous.comp_continuousOn
          ((a.continuousOn_coordChange he' he).prod_map continuousOn_id)
      rw [e.target_inter_preimage_symm_source_eq e', inter_comm]
      refine' (continuousOn_fst.prod this).congr _
      rintro ⟨b, f⟩ ⟨hb, -⟩
      

Proof state:
case mk.intro
R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁶ : NontriviallyNormedField R
inst✝⁵ : (x : B) → AddCommMonoid (E x)
inst✝⁴ : (x : B) → Module R (E x)
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace R F
inst✝¹ : TopologicalSpace B
inst✝ : (x : B) → TopologicalSpace (E x)
a : VectorPrebundle R F E
e : Pretrivialization F TotalSpace.proj
he : e ∈ a.pretrivializationAtlas
e' : Pretrivialization F TotalSpace.proj
he' : e' ∈ a.pretrivializationAtlas
this : ContinuousOn (fun x => (coordChange a he' he x.1) x.2) ((e'.baseSet ∩ e.baseSet) ×ˢ univ)
b : B
f : F
hb : (b, f).1 ∈ e'.baseSet ∩ e.baseSet
⊢ (↑e ∘ ↑(PartialEquiv.symm e'.toPartialEquiv)) (b, f) = (fun x => (x.1, (coordChange a he' he x.1) x.2)) (b, f)

Next tactic:
dsimp only [Function.comp_def, Prod.map]
/-- Natural identification of `VectorPrebundle` as a `FiberPrebundle`. -/
def toFiberPrebundle (a : VectorPrebundle R F E) : FiberPrebundle F E :=
  { a with
    continuous_trivChange := fun e he e' he' ↦ by
      have : ContinuousOn (fun x : B × F ↦ a.coordChange he' he x.1 x.2)
          ((e'.baseSet ∩ e.baseSet) ×ˢ univ) :=
        isBoundedBilinearMap_apply.continuous.comp_continuousOn
          ((a.continuousOn_coordChange he' he).prod_map continuousOn_id)
      rw [e.target_inter_preimage_symm_source_eq e', inter_comm]
      refine' (continuousOn_fst.prod this).congr _
      rintro ⟨b, f⟩ ⟨hb, -⟩
      dsimp only [Function.comp_def, Prod.map]
      

Proof state:
case mk.intro
R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁶ : NontriviallyNormedField R
inst✝⁵ : (x : B) → AddCommMonoid (E x)
inst✝⁴ : (x : B) → Module R (E x)
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace R F
inst✝¹ : TopologicalSpace B
inst✝ : (x : B) → TopologicalSpace (E x)
a : VectorPrebundle R F E
e : Pretrivialization F TotalSpace.proj
he : e ∈ a.pretrivializationAtlas
e' : Pretrivialization F TotalSpace.proj
he' : e' ∈ a.pretrivializationAtlas
this : ContinuousOn (fun x => (coordChange a he' he x.1) x.2) ((e'.baseSet ∩ e.baseSet) ×ˢ univ)
b : B
f : F
hb : (b, f).1 ∈ e'.baseSet ∩ e.baseSet
⊢ ↑e (↑(PartialEquiv.symm e'.toPartialEquiv) (b, f)) = (b, (coordChange a he' he b) f)

Next tactic:
rw [a.mk_coordChange _ _ hb, e'.mk_symm hb.1]
/-- Make a `VectorBundle` from a `VectorPrebundle`.  Concretely this means
that, given a `VectorPrebundle` structure for a sigma-type `E` -- which consists of a
number of "pretrivializations" identifying parts of `E` with product spaces `U × F` -- one
establishes that for the topology constructed on the sigma-type using
`VectorPrebundle.totalSpaceTopology`, these "pretrivializations" are actually
"trivializations" (i.e., homeomorphisms with respect to the constructed topology). -/
theorem toVectorBundle : @VectorBundle R _ F E _ _ _ _ _ _ a.totalSpaceTopology _ a.toFiberBundle :=
  letI := a.totalSpaceTopology; letI := a.toFiberBundle
  { trivialization_linear' := by
      

Proof state:
R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁶ : NontriviallyNormedField R
inst✝⁵ : (x : B) → AddCommMonoid (E x)
inst✝⁴ : (x : B) → Module R (E x)
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace R F
inst✝¹ : TopologicalSpace B
inst✝ : (x : B) → TopologicalSpace (E x)
a : VectorPrebundle R F E
this✝ : TopologicalSpace (TotalSpace F E) := totalSpaceTopology a
this : FiberBundle F E := toFiberBundle a
⊢ ∀ (e : Trivialization F TotalSpace.proj) [inst : MemTrivializationAtlas e], Trivialization.IsLinear R e

Next tactic:
rintro _ ⟨e, he, rfl⟩
/-- Make a `VectorBundle` from a `VectorPrebundle`.  Concretely this means
that, given a `VectorPrebundle` structure for a sigma-type `E` -- which consists of a
number of "pretrivializations" identifying parts of `E` with product spaces `U × F` -- one
establishes that for the topology constructed on the sigma-type using
`VectorPrebundle.totalSpaceTopology`, these "pretrivializations" are actually
"trivializations" (i.e., homeomorphisms with respect to the constructed topology). -/
theorem toVectorBundle : @VectorBundle R _ F E _ _ _ _ _ _ a.totalSpaceTopology _ a.toFiberBundle :=
  letI := a.totalSpaceTopology; letI := a.toFiberBundle
  { trivialization_linear' := by
      rintro _ ⟨e, he, rfl⟩
      

Proof state:
case mk.intro.intro
R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁶ : NontriviallyNormedField R
inst✝⁵ : (x : B) → AddCommMonoid (E x)
inst✝⁴ : (x : B) → Module R (E x)
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace R F
inst✝¹ : TopologicalSpace B
inst✝ : (x : B) → TopologicalSpace (E x)
a : VectorPrebundle R F E
this✝ : TopologicalSpace (TotalSpace F E) := totalSpaceTopology a
this : FiberBundle F E := toFiberBundle a
e : Pretrivialization F TotalSpace.proj
he : e ∈ (toFiberPrebundle a).pretrivializationAtlas
⊢ Trivialization.IsLinear R (FiberPrebundle.trivializationOfMemPretrivializationAtlas (toFiberPrebundle a) he)

Next tactic:
apply linear_trivializationOfMemPretrivializationAtlas
/-- Make a `VectorBundle` from a `VectorPrebundle`.  Concretely this means
that, given a `VectorPrebundle` structure for a sigma-type `E` -- which consists of a
number of "pretrivializations" identifying parts of `E` with product spaces `U × F` -- one
establishes that for the topology constructed on the sigma-type using
`VectorPrebundle.totalSpaceTopology`, these "pretrivializations" are actually
"trivializations" (i.e., homeomorphisms with respect to the constructed topology). -/
theorem toVectorBundle : @VectorBundle R _ F E _ _ _ _ _ _ a.totalSpaceTopology _ a.toFiberBundle :=
  letI := a.totalSpaceTopology; letI := a.toFiberBundle
  { trivialization_linear' := by
      rintro _ ⟨e, he, rfl⟩
      apply linear_trivializationOfMemPretrivializationAtlas
    continuousOn_coordChange' := by
      

Proof state:
R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁶ : NontriviallyNormedField R
inst✝⁵ : (x : B) → AddCommMonoid (E x)
inst✝⁴ : (x : B) → Module R (E x)
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace R F
inst✝¹ : TopologicalSpace B
inst✝ : (x : B) → TopologicalSpace (E x)
a : VectorPrebundle R F E
this✝ : TopologicalSpace (TotalSpace F E) := totalSpaceTopology a
this : FiberBundle F E := toFiberBundle a
⊢ ∀ (e e' : Trivialization F TotalSpace.proj) [inst : MemTrivializationAtlas e] [inst_1 : MemTrivializationAtlas e'],
    ContinuousOn (fun b => ↑(Trivialization.coordChangeL R e e' b)) (e.baseSet ∩ e'.baseSet)

Next tactic:
rintro _ _ ⟨e, he, rfl⟩ ⟨e', he', rfl⟩
/-- Make a `VectorBundle` from a `VectorPrebundle`.  Concretely this means
that, given a `VectorPrebundle` structure for a sigma-type `E` -- which consists of a
number of "pretrivializations" identifying parts of `E` with product spaces `U × F` -- one
establishes that for the topology constructed on the sigma-type using
`VectorPrebundle.totalSpaceTopology`, these "pretrivializations" are actually
"trivializations" (i.e., homeomorphisms with respect to the constructed topology). -/
theorem toVectorBundle : @VectorBundle R _ F E _ _ _ _ _ _ a.totalSpaceTopology _ a.toFiberBundle :=
  letI := a.totalSpaceTopology; letI := a.toFiberBundle
  { trivialization_linear' := by
      rintro _ ⟨e, he, rfl⟩
      apply linear_trivializationOfMemPretrivializationAtlas
    continuousOn_coordChange' := by
      rintro _ _ ⟨e, he, rfl⟩ ⟨e', he', rfl⟩
      

Proof state:
case mk.intro.intro.mk.intro.intro
R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁶ : NontriviallyNormedField R
inst✝⁵ : (x : B) → AddCommMonoid (E x)
inst✝⁴ : (x : B) → Module R (E x)
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace R F
inst✝¹ : TopologicalSpace B
inst✝ : (x : B) → TopologicalSpace (E x)
a : VectorPrebundle R F E
this✝ : TopologicalSpace (TotalSpace F E) := totalSpaceTopology a
this : FiberBundle F E := toFiberBundle a
e : Pretrivialization F TotalSpace.proj
he : e ∈ (toFiberPrebundle a).pretrivializationAtlas
e' : Pretrivialization F TotalSpace.proj
he' : e' ∈ (toFiberPrebundle a).pretrivializationAtlas
⊢ ContinuousOn
    (fun b =>
      ↑(Trivialization.coordChangeL R (FiberPrebundle.trivializationOfMemPretrivializationAtlas (toFiberPrebundle a) he)
          (FiberPrebundle.trivializationOfMemPretrivializationAtlas (toFiberPrebundle a) he') b))
    ((FiberPrebundle.trivializationOfMemPretrivializationAtlas (toFiberPrebundle a) he).baseSet ∩
      (FiberPrebundle.trivializationOfMemPretrivializationAtlas (toFiberPrebundle a) he').baseSet)

Next tactic:
refine (a.continuousOn_coordChange he he').congr fun b hb ↦ ?_
/-- Make a `VectorBundle` from a `VectorPrebundle`.  Concretely this means
that, given a `VectorPrebundle` structure for a sigma-type `E` -- which consists of a
number of "pretrivializations" identifying parts of `E` with product spaces `U × F` -- one
establishes that for the topology constructed on the sigma-type using
`VectorPrebundle.totalSpaceTopology`, these "pretrivializations" are actually
"trivializations" (i.e., homeomorphisms with respect to the constructed topology). -/
theorem toVectorBundle : @VectorBundle R _ F E _ _ _ _ _ _ a.totalSpaceTopology _ a.toFiberBundle :=
  letI := a.totalSpaceTopology; letI := a.toFiberBundle
  { trivialization_linear' := by
      rintro _ ⟨e, he, rfl⟩
      apply linear_trivializationOfMemPretrivializationAtlas
    continuousOn_coordChange' := by
      rintro _ _ ⟨e, he, rfl⟩ ⟨e', he', rfl⟩
      refine (a.continuousOn_coordChange he he').congr fun b hb ↦ ?_
      

Proof state:
case mk.intro.intro.mk.intro.intro
R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁶ : NontriviallyNormedField R
inst✝⁵ : (x : B) → AddCommMonoid (E x)
inst✝⁴ : (x : B) → Module R (E x)
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace R F
inst✝¹ : TopologicalSpace B
inst✝ : (x : B) → TopologicalSpace (E x)
a : VectorPrebundle R F E
this✝ : TopologicalSpace (TotalSpace F E) := totalSpaceTopology a
this : FiberBundle F E := toFiberBundle a
e : Pretrivialization F TotalSpace.proj
he : e ∈ (toFiberPrebundle a).pretrivializationAtlas
e' : Pretrivialization F TotalSpace.proj
he' : e' ∈ (toFiberPrebundle a).pretrivializationAtlas
b : B
hb : b ∈ e.baseSet ∩ e'.baseSet
⊢ ↑(Trivialization.coordChangeL R (FiberPrebundle.trivializationOfMemPretrivializationAtlas (toFiberPrebundle a) he)
        (FiberPrebundle.trivializationOfMemPretrivializationAtlas (toFiberPrebundle a) he') b) =
    coordChange a he he' b

Next tactic:
ext v
/-- Make a `VectorBundle` from a `VectorPrebundle`.  Concretely this means
that, given a `VectorPrebundle` structure for a sigma-type `E` -- which consists of a
number of "pretrivializations" identifying parts of `E` with product spaces `U × F` -- one
establishes that for the topology constructed on the sigma-type using
`VectorPrebundle.totalSpaceTopology`, these "pretrivializations" are actually
"trivializations" (i.e., homeomorphisms with respect to the constructed topology). -/
theorem toVectorBundle : @VectorBundle R _ F E _ _ _ _ _ _ a.totalSpaceTopology _ a.toFiberBundle :=
  letI := a.totalSpaceTopology; letI := a.toFiberBundle
  { trivialization_linear' := by
      rintro _ ⟨e, he, rfl⟩
      apply linear_trivializationOfMemPretrivializationAtlas
    continuousOn_coordChange' := by
      rintro _ _ ⟨e, he, rfl⟩ ⟨e', he', rfl⟩
      refine (a.continuousOn_coordChange he he').congr fun b hb ↦ ?_
      ext v
      -- porting note: help `rw` find instances
      

Proof state:
case mk.intro.intro.mk.intro.intro.h
R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁶ : NontriviallyNormedField R
inst✝⁵ : (x : B) → AddCommMonoid (E x)
inst✝⁴ : (x : B) → Module R (E x)
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace R F
inst✝¹ : TopologicalSpace B
inst✝ : (x : B) → TopologicalSpace (E x)
a : VectorPrebundle R F E
this✝ : TopologicalSpace (TotalSpace F E) := totalSpaceTopology a
this : FiberBundle F E := toFiberBundle a
e : Pretrivialization F TotalSpace.proj
he : e ∈ (toFiberPrebundle a).pretrivializationAtlas
e' : Pretrivialization F TotalSpace.proj
he' : e' ∈ (toFiberPrebundle a).pretrivializationAtlas
b : B
hb : b ∈ e.baseSet ∩ e'.baseSet
v : F
⊢ ↑(Trivialization.coordChangeL R (FiberPrebundle.trivializationOfMemPretrivializationAtlas (toFiberPrebundle a) he)
          (FiberPrebundle.trivializationOfMemPretrivializationAtlas (toFiberPrebundle a) he') b)
      v =
    (coordChange a he he' b) v

Next tactic:
haveI h₁ := a.linear_trivializationOfMemPretrivializationAtlas he
/-- Make a `VectorBundle` from a `VectorPrebundle`.  Concretely this means
that, given a `VectorPrebundle` structure for a sigma-type `E` -- which consists of a
number of "pretrivializations" identifying parts of `E` with product spaces `U × F` -- one
establishes that for the topology constructed on the sigma-type using
`VectorPrebundle.totalSpaceTopology`, these "pretrivializations" are actually
"trivializations" (i.e., homeomorphisms with respect to the constructed topology). -/
theorem toVectorBundle : @VectorBundle R _ F E _ _ _ _ _ _ a.totalSpaceTopology _ a.toFiberBundle :=
  letI := a.totalSpaceTopology; letI := a.toFiberBundle
  { trivialization_linear' := by
      rintro _ ⟨e, he, rfl⟩
      apply linear_trivializationOfMemPretrivializationAtlas
    continuousOn_coordChange' := by
      rintro _ _ ⟨e, he, rfl⟩ ⟨e', he', rfl⟩
      refine (a.continuousOn_coordChange he he').congr fun b hb ↦ ?_
      ext v
      -- porting note: help `rw` find instances
      haveI h₁ := a.linear_trivializationOfMemPretrivializationAtlas he
      

Proof state:
case mk.intro.intro.mk.intro.intro.h
R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁶ : NontriviallyNormedField R
inst✝⁵ : (x : B) → AddCommMonoid (E x)
inst✝⁴ : (x : B) → Module R (E x)
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace R F
inst✝¹ : TopologicalSpace B
inst✝ : (x : B) → TopologicalSpace (E x)
a : VectorPrebundle R F E
this✝ : TopologicalSpace (TotalSpace F E) := totalSpaceTopology a
this : FiberBundle F E := toFiberBundle a
e : Pretrivialization F TotalSpace.proj
he : e ∈ (toFiberPrebundle a).pretrivializationAtlas
e' : Pretrivialization F TotalSpace.proj
he' : e' ∈ (toFiberPrebundle a).pretrivializationAtlas
b : B
hb : b ∈ e.baseSet ∩ e'.baseSet
v : F
h₁ : Trivialization.IsLinear R (trivializationOfMemPretrivializationAtlas a he)
⊢ ↑(Trivialization.coordChangeL R (FiberPrebundle.trivializationOfMemPretrivializationAtlas (toFiberPrebundle a) he)
          (FiberPrebundle.trivializationOfMemPretrivializationAtlas (toFiberPrebundle a) he') b)
      v =
    (coordChange a he he' b) v

Next tactic:
haveI h₂ := a.linear_trivializationOfMemPretrivializationAtlas he'
/-- Make a `VectorBundle` from a `VectorPrebundle`.  Concretely this means
that, given a `VectorPrebundle` structure for a sigma-type `E` -- which consists of a
number of "pretrivializations" identifying parts of `E` with product spaces `U × F` -- one
establishes that for the topology constructed on the sigma-type using
`VectorPrebundle.totalSpaceTopology`, these "pretrivializations" are actually
"trivializations" (i.e., homeomorphisms with respect to the constructed topology). -/
theorem toVectorBundle : @VectorBundle R _ F E _ _ _ _ _ _ a.totalSpaceTopology _ a.toFiberBundle :=
  letI := a.totalSpaceTopology; letI := a.toFiberBundle
  { trivialization_linear' := by
      rintro _ ⟨e, he, rfl⟩
      apply linear_trivializationOfMemPretrivializationAtlas
    continuousOn_coordChange' := by
      rintro _ _ ⟨e, he, rfl⟩ ⟨e', he', rfl⟩
      refine (a.continuousOn_coordChange he he').congr fun b hb ↦ ?_
      ext v
      -- porting note: help `rw` find instances
      haveI h₁ := a.linear_trivializationOfMemPretrivializationAtlas he
      haveI h₂ := a.linear_trivializationOfMemPretrivializationAtlas he'
      

Proof state:
case mk.intro.intro.mk.intro.intro.h
R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁶ : NontriviallyNormedField R
inst✝⁵ : (x : B) → AddCommMonoid (E x)
inst✝⁴ : (x : B) → Module R (E x)
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace R F
inst✝¹ : TopologicalSpace B
inst✝ : (x : B) → TopologicalSpace (E x)
a : VectorPrebundle R F E
this✝ : TopologicalSpace (TotalSpace F E) := totalSpaceTopology a
this : FiberBundle F E := toFiberBundle a
e : Pretrivialization F TotalSpace.proj
he : e ∈ (toFiberPrebundle a).pretrivializationAtlas
e' : Pretrivialization F TotalSpace.proj
he' : e' ∈ (toFiberPrebundle a).pretrivializationAtlas
b : B
hb : b ∈ e.baseSet ∩ e'.baseSet
v : F
h₁ : Trivialization.IsLinear R (trivializationOfMemPretrivializationAtlas a he)
h₂ : Trivialization.IsLinear R (trivializationOfMemPretrivializationAtlas a he')
⊢ ↑(Trivialization.coordChangeL R (FiberPrebundle.trivializationOfMemPretrivializationAtlas (toFiberPrebundle a) he)
          (FiberPrebundle.trivializationOfMemPretrivializationAtlas (toFiberPrebundle a) he') b)
      v =
    (coordChange a he he' b) v

Next tactic:
rw [trivializationOfMemPretrivializationAtlas] at h₁ h₂