Theorem: Trivialization.continuousLinearEquivAt_prod
File: Mathlib/Topology/VectorBundle/Constructions.lean

tactic: ext v : 2
state_before: 𝕜 : Type u_6
B : Type u_1
inst✝¹⁷ : NontriviallyNormedField 𝕜
inst✝¹⁶ : TopologicalSpace B
F₁ : Type u_2
inst✝¹⁵ : NormedAddCommGroup F₁
inst✝¹⁴ : NormedSpace 𝕜 F₁
E₁ : B → Type u_3
inst✝¹³ : TopologicalSpace (TotalSpace E₁)
F₂ : Type u_4
inst✝¹² : NormedAddCommGroup F₂
inst✝¹¹ : NormedSpace 𝕜 F₂
E₂ : B → Type u_5
inst✝¹⁰ : TopologicalSpace (TotalSpace E₂)
inst✝⁹ : (x : B) → AddCommMonoid (E₁ x)
inst✝⁸ : (x : B) → Module 𝕜 (E₁ x)
inst✝⁷ : (x : B) → AddCommMonoid (E₂ x)
inst✝⁶ : (x : B) → Module 𝕜 (E₂ x)
inst✝⁵ : (x : B) → TopologicalSpace (E₁ x)
inst✝⁴ : (x : B) → TopologicalSpace (E₂ x)
inst✝³ : FiberBundle F₁ E₁
inst✝² : FiberBundle F₂ E₂
e₁ : Trivialization F₁ TotalSpace.proj
e₂ : Trivialization F₂ TotalSpace.proj
inst✝¹ : Trivialization.IsLinear 𝕜 e₁
inst✝ : Trivialization.IsLinear 𝕜 e₂
x : B
hx : x ∈ (prod e₁ e₂).baseSet
⊢ continuousLinearEquivAt 𝕜 (prod e₁ e₂) x hx =
    ContinuousLinearEquiv.prod (continuousLinearEquivAt 𝕜 e₁ x (_ : x ∈ e₁.baseSet))
      (continuousLinearEquivAt 𝕜 e₂ x (_ : x ∈ e₂.baseSet))

tactic: obtain ⟨v₁, v₂⟩ := v
state_before: case h.h
𝕜 : Type u_6
B : Type u_1
inst✝¹⁷ : NontriviallyNormedField 𝕜
inst✝¹⁶ : TopologicalSpace B
F₁ : Type u_2
inst✝¹⁵ : NormedAddCommGroup F₁
inst✝¹⁴ : NormedSpace 𝕜 F₁
E₁ : B → Type u_3
inst✝¹³ : TopologicalSpace (TotalSpace E₁)
F₂ : Type u_4
inst✝¹² : NormedAddCommGroup F₂
inst✝¹¹ : NormedSpace 𝕜 F₂
E₂ : B → Type u_5
inst✝¹⁰ : TopologicalSpace (TotalSpace E₂)
inst✝⁹ : (x : B) → AddCommMonoid (E₁ x)
inst✝⁸ : (x : B) → Module 𝕜 (E₁ x)
inst✝⁷ : (x : B) → AddCommMonoid (E₂ x)
inst✝⁶ : (x : B) → Module 𝕜 (E₂ x)
inst✝⁵ : (x : B) → TopologicalSpace (E₁ x)
inst✝⁴ : (x : B) → TopologicalSpace (E₂ x)
inst✝³ : FiberBundle F₁ E₁
inst✝² : FiberBundle F₂ E₂
e₁ : Trivialization F₁ TotalSpace.proj
e₂ : Trivialization F₂ TotalSpace.proj
inst✝¹ : Trivialization.IsLinear 𝕜 e₁
inst✝ : Trivialization.IsLinear 𝕜 e₂
x : B
hx : x ∈ (prod e₁ e₂).baseSet
v : E₁ x × E₂ x
⊢ ↑(continuousLinearEquivAt 𝕜 (prod e₁ e₂) x hx) v =
    ↑(ContinuousLinearEquiv.prod (continuousLinearEquivAt 𝕜 e₁ x (_ : x ∈ e₁.baseSet))
          (continuousLinearEquivAt 𝕜 e₂ x (_ : x ∈ e₂.baseSet)))
      v

tactic: rw [(e₁.prod e₂).continuousLinearEquivAt_apply 𝕜, Trivialization.prod]
state_before: case h.h.mk
𝕜 : Type u_6
B : Type u_1
inst✝¹⁷ : NontriviallyNormedField 𝕜
inst✝¹⁶ : TopologicalSpace B
F₁ : Type u_2
inst✝¹⁵ : NormedAddCommGroup F₁
inst✝¹⁴ : NormedSpace 𝕜 F₁
E₁ : B → Type u_3
inst✝¹³ : TopologicalSpace (TotalSpace E₁)
F₂ : Type u_4
inst✝¹² : NormedAddCommGroup F₂
inst✝¹¹ : NormedSpace 𝕜 F₂
E₂ : B → Type u_5
inst✝¹⁰ : TopologicalSpace (TotalSpace E₂)
inst✝⁹ : (x : B) → AddCommMonoid (E₁ x)
inst✝⁸ : (x : B) → Module 𝕜 (E₁ x)
inst✝⁷ : (x : B) → AddCommMonoid (E₂ x)
inst✝⁶ : (x : B) → Module 𝕜 (E₂ x)
inst✝⁵ : (x : B) → TopologicalSpace (E₁ x)
inst✝⁴ : (x : B) → TopologicalSpace (E₂ x)
inst✝³ : FiberBundle F₁ E₁
inst✝² : FiberBundle F₂ E₂
e₁ : Trivialization F₁ TotalSpace.proj
e₂ : Trivialization F₂ TotalSpace.proj
inst✝¹ : Trivialization.IsLinear 𝕜 e₁
inst✝ : Trivialization.IsLinear 𝕜 e₂
x : B
hx : x ∈ (prod e₁ e₂).baseSet
v₁ : E₁ x
v₂ : E₂ x
⊢ ↑(continuousLinearEquivAt 𝕜 (prod e₁ e₂) x hx) (v₁, v₂) =
    ↑(ContinuousLinearEquiv.prod (continuousLinearEquivAt 𝕜 e₁ x (_ : x ∈ e₁.baseSet))
          (continuousLinearEquivAt 𝕜 e₂ x (_ : x ∈ e₂.baseSet)))
      (v₁, v₂)

tactic: exact (congr_arg Prod.snd (prod_apply 𝕜 hx.1 hx.2 v₁ v₂) : _)
state_before: case h.h.mk
𝕜 : Type u_6
B : Type u_1
inst✝¹⁷ : NontriviallyNormedField 𝕜
inst✝¹⁶ : TopologicalSpace B
F₁ : Type u_2
inst✝¹⁵ : NormedAddCommGroup F₁
inst✝¹⁴ : NormedSpace 𝕜 F₁
E₁ : B → Type u_3
inst✝¹³ : TopologicalSpace (TotalSpace E₁)
F₂ : Type u_4
inst✝¹² : NormedAddCommGroup F₂
inst✝¹¹ : NormedSpace 𝕜 F₂
E₂ : B → Type u_5
inst✝¹⁰ : TopologicalSpace (TotalSpace E₂)
inst✝⁹ : (x : B) → AddCommMonoid (E₁ x)
inst✝⁸ : (x : B) → Module 𝕜 (E₁ x)
inst✝⁷ : (x : B) → AddCommMonoid (E₂ x)
inst✝⁶ : (x : B) → Module 𝕜 (E₂ x)
inst✝⁵ : (x : B) → TopologicalSpace (E₁ x)
inst✝⁴ : (x : B) → TopologicalSpace (E₂ x)
inst✝³ : FiberBundle F₁ E₁
inst✝² : FiberBundle F₂ E₂
e₁ : Trivialization F₁ TotalSpace.proj
e₂ : Trivialization F₂ TotalSpace.proj
inst✝¹ : Trivialization.IsLinear 𝕜 e₁
inst✝ : Trivialization.IsLinear 𝕜 e₂
x : B
hx : x ∈ (prod e₁ e₂).baseSet
v₁ : E₁ x
v₂ : E₂ x
⊢ (fun y =>
        (↑{
                toLocalHomeomorph :=
                  {
                    toLocalEquiv :=
                      { toFun := Prod.toFun' e₁ e₂, invFun := Prod.invFun' e₁ e₂,
                        source := TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                        target := (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ,
                        map_source' :=
                          (_ :
                            ∀ (x : TotalSpace fun x => E₁ x × E₂ x),
                              x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet) →
                                (Prod.toFun' e₁ e₂ x).fst ∈ e₁.baseSet ∩ e₂.baseSet ∧ (Prod.toFun' e₁ e₂ x).snd ∈ univ),
                        map_target' :=
                          (_ :
                            ∀ (x : B × F₁ × F₂),
                              x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ → x.fst ∈ e₁.baseSet ∩ e₂.baseSet),
                        left_inv' :=
                          (_ :
                            ∀ (x : TotalSpace fun x => E₁ x × E₂ x),
                              x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet) →
                                Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x),
                        right_inv' :=
                          (_ :
                            ∀ (x : B × F₁ × F₂),
                              x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ → Prod.toFun' e₁ e₂ (Prod.invFun' e₁ e₂ x) = x) },
                    open_source :=
                      (_ :
                        IsOpen
                          { toFun := Prod.toFun' e₁ e₂, invFun := Prod.invFun' e₁ e₂,
                              source := TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                              target := (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ,
                              map_source' :=
                                (_ :
                                  ∀ (x : TotalSpace fun x => E₁ x × E₂ x),
                                    x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet) →
                                      (Prod.toFun' e₁ e₂ x).fst ∈ e₁.baseSet ∩ e₂.baseSet ∧
                                        (Prod.toFun' e₁ e₂ x).snd ∈ univ),
                              map_target' :=
                                (_ :
                                  ∀ (x : B × F₁ × F₂),
                                    x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ → x.fst ∈ e₁.baseSet ∩ e₂.baseSet),
                              left_inv' :=
                                (_ :
                                  ∀ (x : TotalSpace fun x => E₁ x × E₂ x),
                                    x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet) →
                                      Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x),
                              right_inv' :=
                                (_ :
                                  ∀ (x : B × F₁ × F₂),
                                    x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ →
                                      Prod.toFun' e₁ e₂ (Prod.invFun' e₁ e₂ x) = x) }.source),
                    open_target := (_ : IsOpen ((e₁.baseSet ∩ e₂.baseSet) ×ˢ univ)),
                    continuous_toFun :=
                      (_ : ContinuousOn (Prod.toFun' e₁ e₂) (TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet))),
                    continuous_invFun := (_ : ContinuousOn (Prod.invFun' e₁ e₂) ((e₁.baseSet ∩ e₂.baseSet) ×ˢ univ)) },
                baseSet := e₁.baseSet ∩ e₂.baseSet, open_baseSet := (_ : IsOpen (e₁.baseSet ∩ e₂.baseSet)),
                source_eq :=
                  (_ :
                    {
                            toLocalEquiv :=
                              { toFun := Prod.toFun' e₁ e₂, invFun := Prod.invFun' e₁ e₂,
                                source := TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                target := (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ,
                                map_source' :=
                                  (_ :
                                    ∀ (x : TotalSpace fun x => E₁ x × E₂ x),
                                      x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet) →
                                        (Prod.toFun' e₁ e₂ x).fst ∈ e₁.baseSet ∩ e₂.baseSet ∧
                                          (Prod.toFun' e₁ e₂ x).snd ∈ univ),
                                map_target' :=
                                  (_ :
                                    ∀ (x : B × F₁ × F₂),
                                      x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ → x.fst ∈ e₁.baseSet ∩ e₂.baseSet),
                                left_inv' :=
                                  (_ :
                                    ∀ (x : TotalSpace fun x => E₁ x × E₂ x),
                                      x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet) →
                                        Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x),
                                right_inv' :=
                                  (_ :
                                    ∀ (x : B × F₁ × F₂),
                                      x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ →
                                        Prod.toFun' e₁ e₂ (Prod.invFun' e₁ e₂ x) = x) },
                            open_source :=
                              (_ :
                                IsOpen
                                  { toFun := Prod.toFun' e₁ e₂, invFun := Prod.invFun' e₁ e₂,
                                      source := TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                      target := (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ,
                                      map_source' :=
                                        (_ :
                                          ∀ (x : TotalSpace fun x => E₁ x × E₂ x),
                                            x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet) →
                                              (Prod.toFun' e₁ e₂ x).fst ∈ e₁.baseSet ∩ e₂.baseSet ∧
                                                (Prod.toFun' e₁ e₂ x).snd ∈ univ),
                                      map_target' :=
                                        (_ :
                                          ∀ (x : B × F₁ × F₂),
                                            x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ → x.fst ∈ e₁.baseSet ∩ e₂.baseSet),
                                      left_inv' :=
                                        (_ :
                                          ∀ (x : TotalSpace fun x => E₁ x × E₂ x),
                                            x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet) →
                                              Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x),
                                      right_inv' :=
                                        (_ :
                                          ∀ (x : B × F₁ × F₂),
                                            x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ →
                                              Prod.toFun' e₁ e₂ (Prod.invFun' e₁ e₂ x) = x) }.source),
                            open_target := (_ : IsOpen ((e₁.baseSet ∩ e₂.baseSet) ×ˢ univ)),
                            continuous_toFun :=
                              (_ : ContinuousOn (Prod.toFun' e₁ e₂) (TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet))),
                            continuous_invFun :=
                              (_ :
                                ContinuousOn (Prod.invFun' e₁ e₂)
                                  ((e₁.baseSet ∩ e₂.baseSet) ×ˢ univ)) }.toLocalEquiv.source =
                      {
                            toLocalEquiv :=
                              { toFun := Prod.toFun' e₁ e₂, invFun := Prod.invFun' e₁ e₂,
                                source := TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                target := (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ,
                                map_source' :=
                                  (_ :
                                    ∀ (x : TotalSpace fun x => E₁ x × E₂ x),
                                      x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet) →
                                        (Prod.toFun' e₁ e₂ x).fst ∈ e₁.baseSet ∩ e₂.baseSet ∧
                                          (Prod.toFun' e₁ e₂ x).snd ∈ univ),
                                map_target' :=
                                  (_ :
                                    ∀ (x : B × F₁ × F₂),
                                      x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ → x.fst ∈ e₁.baseSet ∩ e₂.baseSet),
                                left_inv' :=
                                  (_ :
                                    ∀ (x : TotalSpace fun x => E₁ x × E₂ x),
                                      x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet) →
                                        Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x),
                                right_inv' :=
                                  (_ :
                                    ∀ (x : B × F₁ × F₂),
                                      x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ →
                                        Prod.toFun' e₁ e₂ (Prod.invFun' e₁ e₂ x) = x) },
                            open_source :=
                              (_ :
                                IsOpen
                                  { toFun := Prod.toFun' e₁ e₂, invFun := Prod.invFun' e₁ e₂,
                                      source := TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                      target := (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ,
                                      map_source' :=
                                        (_ :
                                          ∀ (x : TotalSpace fun x => E₁ x × E₂ x),
                                            x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet) →
                                              (Prod.toFun' e₁ e₂ x).fst ∈ e₁.baseSet ∩ e₂.baseSet ∧
                                                (Prod.toFun' e₁ e₂ x).snd ∈ univ),
                                      map_target' :=
                                        (_ :
                                          ∀ (x : B × F₁ × F₂),
                                            x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ → x.fst ∈ e₁.baseSet ∩ e₂.baseSet),
                                      left_inv' :=
                                        (_ :
                                          ∀ (x : TotalSpace fun x => E₁ x × E₂ x),
                                            x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet) →
                                              Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x),
                                      right_inv' :=
                                        (_ :
                                          ∀ (x : B × F₁ × F₂),
                                            x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ →
                                              Prod.toFun' e₁ e₂ (Prod.invFun' e₁ e₂ x) = x) }.source),
                            open_target := (_ : IsOpen ((e₁.baseSet ∩ e₂.baseSet) ×ˢ univ)),
                            continuous_toFun :=
                              (_ : ContinuousOn (Prod.toFun' e₁ e₂) (TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet))),
                            continuous_invFun :=
                              (_ :
                                ContinuousOn (Prod.invFun' e₁ e₂)
                                  ((e₁.baseSet ∩ e₂.baseSet) ×ˢ univ)) }.toLocalEquiv.source),
                target_eq :=
                  (_ :
                    {
                            toLocalEquiv :=
                              { toFun := Prod.toFun' e₁ e₂, invFun := Prod.invFun' e₁ e₂,
                                source := TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                target := (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ,
                                map_source' :=
                                  (_ :
                                    ∀ (x : TotalSpace fun x => E₁ x × E₂ x),
                                      x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet) →
                                        (Prod.toFun' e₁ e₂ x).fst ∈ e₁.baseSet ∩ e₂.baseSet ∧
                                          (Prod.toFun' e₁ e₂ x).snd ∈ univ),
                                map_target' :=
                                  (_ :
                                    ∀ (x : B × F₁ × F₂),
                                      x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ → x.fst ∈ e₁.baseSet ∩ e₂.baseSet),
                                left_inv' :=
                                  (_ :
                                    ∀ (x : TotalSpace fun x => E₁ x × E₂ x),
                                      x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet) →
                                        Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x),
                                right_inv' :=
                                  (_ :
                                    ∀ (x : B × F₁ × F₂),
                                      x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ →
                                        Prod.toFun' e₁ e₂ (Prod.invFun' e₁ e₂ x) = x) },
                            open_source :=
                              (_ :
                                IsOpen
                                  { toFun := Prod.toFun' e₁ e₂, invFun := Prod.invFun' e₁ e₂,
                                      source := TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                      target := (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ,
                                      map_source' :=
                                        (_ :
                                          ∀ (x : TotalSpace fun x => E₁ x × E₂ x),
                                            x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet) →
                                              (Prod.toFun' e₁ e₂ x).fst ∈ e₁.baseSet ∩ e₂.baseSet ∧
                                                (Prod.toFun' e₁ e₂ x).snd ∈ univ),
                                      map_target' :=
                                        (_ :
                                          ∀ (x : B × F₁ × F₂),
                                            x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ → x.fst ∈ e₁.baseSet ∩ e₂.baseSet),
                                      left_inv' :=
                                        (_ :
                                          ∀ (x : TotalSpace fun x => E₁ x × E₂ x),
                                            x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet) →
                                              Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x),
                                      right_inv' :=
                                        (_ :
                                          ∀ (x : B × F₁ × F₂),
                                            x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ →
                                              Prod.toFun' e₁ e₂ (Prod.invFun' e₁ e₂ x) = x) }.source),
                            open_target := (_ : IsOpen ((e₁.baseSet ∩ e₂.baseSet) ×ˢ univ)),
                            continuous_toFun :=
                              (_ : ContinuousOn (Prod.toFun' e₁ e₂) (TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet))),
                            continuous_invFun :=
                              (_ :
                                ContinuousOn (Prod.invFun' e₁ e₂)
                                  ((e₁.baseSet ∩ e₂.baseSet) ×ˢ univ)) }.toLocalEquiv.target =
                      {
                            toLocalEquiv :=
                              { toFun := Prod.toFun' e₁ e₂, invFun := Prod.invFun' e₁ e₂,
                                source := TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                target := (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ,
                                map_source' :=
                                  (_ :
                                    ∀ (x : TotalSpace fun x => E₁ x × E₂ x),
                                      x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet) →
                                        (Prod.toFun' e₁ e₂ x).fst ∈ e₁.baseSet ∩ e₂.baseSet ∧
                                          (Prod.toFun' e₁ e₂ x).snd ∈ univ),
                                map_target' :=
                                  (_ :
                                    ∀ (x : B × F₁ × F₂),
                                      x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ → x.fst ∈ e₁.baseSet ∩ e₂.baseSet),
                                left_inv' :=
                                  (_ :
                                    ∀ (x : TotalSpace fun x => E₁ x × E₂ x),
                                      x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet) →
                                        Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x),
                                right_inv' :=
                                  (_ :
                                    ∀ (x : B × F₁ × F₂),
                                      x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ →
                                        Prod.toFun' e₁ e₂ (Prod.invFun' e₁ e₂ x) = x) },
                            open_source :=
                              (_ :
                                IsOpen
                                  { toFun := Prod.toFun' e₁ e₂, invFun := Prod.invFun' e₁ e₂,
                                      source := TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                      target := (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ,
                                      map_source' :=
                                        (_ :
                                          ∀ (x : TotalSpace fun x => E₁ x × E₂ x),
                                            x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet) →
                                              (Prod.toFun' e₁ e₂ x).fst ∈ e₁.baseSet ∩ e₂.baseSet ∧
                                                (Prod.toFun' e₁ e₂ x).snd ∈ univ),
                                      map_target' :=
                                        (_ :
                                          ∀ (x : B × F₁ × F₂),
                                            x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ → x.fst ∈ e₁.baseSet ∩ e₂.baseSet),
                                      left_inv' :=
                                        (_ :
                                          ∀ (x : TotalSpace fun x => E₁ x × E₂ x),
                                            x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet) →
                                              Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x),
                                      right_inv' :=
                                        (_ :
                                          ∀ (x : B × F₁ × F₂),
                                            x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ →
                                              Prod.toFun' e₁ e₂ (Prod.invFun' e₁ e₂ x) = x) }.source),
                            open_target := (_ : IsOpen ((e₁.baseSet ∩ e₂.baseSet) ×ˢ univ)),
                            continuous_toFun :=
                              (_ : ContinuousOn (Prod.toFun' e₁ e₂) (TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet))),
                            continuous_invFun :=
                              (_ :
                                ContinuousOn (Prod.invFun' e₁ e₂)
                                  ((e₁.baseSet ∩ e₂.baseSet) ×ˢ univ)) }.toLocalEquiv.target),
                proj_toFun :=
                  (_ :
                    ∀ (x : TotalSpace fun x => E₁ x × E₂ x),
                      x ∈
                          {
                                toLocalEquiv :=
                                  { toFun := Prod.toFun' e₁ e₂, invFun := Prod.invFun' e₁ e₂,
                                    source := TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                    target := (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ,
                                    map_source' :=
                                      (_ :
                                        ∀ (x : TotalSpace fun x => E₁ x × E₂ x),
                                          x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet) →
                                            (Prod.toFun' e₁ e₂ x).fst ∈ e₁.baseSet ∩ e₂.baseSet ∧
                                              (Prod.toFun' e₁ e₂ x).snd ∈ univ),
                                    map_target' :=
                                      (_ :
                                        ∀ (x : B × F₁ × F₂),
                                          x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ → x.fst ∈ e₁.baseSet ∩ e₂.baseSet),
                                    left_inv' :=
                                      (_ :
                                        ∀ (x : TotalSpace fun x => E₁ x × E₂ x),
                                          x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet) →
                                            Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x),
                                    right_inv' :=
                                      (_ :
                                        ∀ (x : B × F₁ × F₂),
                                          x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ →
                                            Prod.toFun' e₁ e₂ (Prod.invFun' e₁ e₂ x) = x) },
                                open_source :=
                                  (_ :
                                    IsOpen
                                      { toFun := Prod.toFun' e₁ e₂, invFun := Prod.invFun' e₁ e₂,
                                          source := TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                          target := (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ,
                                          map_source' :=
                                            (_ :
                                              ∀ (x : TotalSpace fun x => E₁ x × E₂ x),
                                                x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet) →
                                                  (Prod.toFun' e₁ e₂ x).fst ∈ e₁.baseSet ∩ e₂.baseSet ∧
                                                    (Prod.toFun' e₁ e₂ x).snd ∈ univ),
                                          map_target' :=
                                            (_ :
                                              ∀ (x : B × F₁ × F₂),
                                                x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ →
                                                  x.fst ∈ e₁.baseSet ∩ e₂.baseSet),
                                          left_inv' :=
                                            (_ :
                                              ∀ (x : TotalSpace fun x => E₁ x × E₂ x),
                                                x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet) →
                                                  Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x),
                                          right_inv' :=
                                            (_ :
                                              ∀ (x : B × F₁ × F₂),
                                                x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ →
                                                  Prod.toFun' e₁ e₂ (Prod.invFun' e₁ e₂ x) = x) }.source),
                                open_target := (_ : IsOpen ((e₁.baseSet ∩ e₂.baseSet) ×ˢ univ)),
                                continuous_toFun :=
                                  (_ :
                                    ContinuousOn (Prod.toFun' e₁ e₂) (TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet))),
                                continuous_invFun :=
                                  (_ :
                                    ContinuousOn (Prod.invFun' e₁ e₂)
                                      ((e₁.baseSet ∩ e₂.baseSet) ×ˢ univ)) }.toLocalEquiv.source →
                        (↑{
                                  toLocalEquiv :=
                                    { toFun := Prod.toFun' e₁ e₂, invFun := Prod.invFun' e₁ e₂,
                                      source := TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                      target := (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ,
                                      map_source' :=
                                        (_ :
                                          ∀ (x : TotalSpace fun x => E₁ x × E₂ x),
                                            x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet) →
                                              (Prod.toFun' e₁ e₂ x).fst ∈ e₁.baseSet ∩ e₂.baseSet ∧
                                                (Prod.toFun' e₁ e₂ x).snd ∈ univ),
                                      map_target' :=
                                        (_ :
                                          ∀ (x : B × F₁ × F₂),
                                            x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ → x.fst ∈ e₁.baseSet ∩ e₂.baseSet),
                                      left_inv' :=
                                        (_ :
                                          ∀ (x : TotalSpace fun x => E₁ x × E₂ x),
                                            x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet) →
                                              Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x),
                                      right_inv' :=
                                        (_ :
                                          ∀ (x : B × F₁ × F₂),
                                            x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ →
                                              Prod.toFun' e₁ e₂ (Prod.invFun' e₁ e₂ x) = x) },
                                  open_source :=
                                    (_ :
                                      IsOpen
                                        { toFun := Prod.toFun' e₁ e₂, invFun := Prod.invFun' e₁ e₂,
                                            source := TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                            target := (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ,
                                            map_source' :=
                                              (_ :
                                                ∀ (x : TotalSpace fun x => E₁ x × E₂ x),
                                                  x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet) →
                                                    (Prod.toFun' e₁ e₂ x).fst ∈ e₁.baseSet ∩ e₂.baseSet ∧
                                                      (Prod.toFun' e₁ e₂ x).snd ∈ univ),
                                            map_target' :=
                                              (_ :
                                                ∀ (x : B × F₁ × F₂),
                                                  x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ →
                                                    x.fst ∈ e₁.baseSet ∩ e₂.baseSet),
                                            left_inv' :=
                                              (_ :
                                                ∀ (x : TotalSpace fun x => E₁ x × E₂ x),
                                                  x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet) →
                                                    Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x),
                                            right_inv' :=
                                              (_ :
                                                ∀ (x : B × F₁ × F₂),
                                                  x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ →
                                                    Prod.toFun' e₁ e₂ (Prod.invFun' e₁ e₂ x) = x) }.source),
                                  open_target := (_ : IsOpen ((e₁.baseSet ∩ e₂.baseSet) ×ˢ univ)),
                                  continuous_toFun :=
                                    (_ :
                                      ContinuousOn (Prod.toFun' e₁ e₂) (TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet))),
                                  continuous_invFun :=
                                    (_ : ContinuousOn (Prod.invFun' e₁ e₂) ((e₁.baseSet ∩ e₂.baseSet) ×ˢ univ)) }
                              x).fst =
                          (↑{
                                  toLocalEquiv :=
                                    { toFun := Prod.toFun' e₁ e₂, invFun := Prod.invFun' e₁ e₂,
                                      source := TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                      target := (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ,
                                      map_source' :=
                                        (_ :
                                          ∀ (x : TotalSpace fun x => E₁ x × E₂ x),
                                            x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet) →
                                              (Prod.toFun' e₁ e₂ x).fst ∈ e₁.baseSet ∩ e₂.baseSet ∧
                                                (Prod.toFun' e₁ e₂ x).snd ∈ univ),
                                      map_target' :=
                                        (_ :
                                          ∀ (x : B × F₁ × F₂),
                                            x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ → x.fst ∈ e₁.baseSet ∩ e₂.baseSet),
                                      left_inv' :=
                                        (_ :
                                          ∀ (x : TotalSpace fun x => E₁ x × E₂ x),
                                            x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet) →
                                              Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x),
                                      right_inv' :=
                                        (_ :
                                          ∀ (x : B × F₁ × F₂),
                                            x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ →
                                              Prod.toFun' e₁ e₂ (Prod.invFun' e₁ e₂ x) = x) },
                                  open_source :=
                                    (_ :
                                      IsOpen
                                        { toFun := Prod.toFun' e₁ e₂, invFun := Prod.invFun' e₁ e₂,
                                            source := TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                            target := (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ,
                                            map_source' :=
                                              (_ :
                                                ∀ (x : TotalSpace fun x => E₁ x × E₂ x),
                                                  x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet) →
                                                    (Prod.toFun' e₁ e₂ x).fst ∈ e₁.baseSet ∩ e₂.baseSet ∧
                                                      (Prod.toFun' e₁ e₂ x).snd ∈ univ),
                                            map_target' :=
                                              (_ :
                                                ∀ (x : B × F₁ × F₂),
                                                  x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ →
                                                    x.fst ∈ e₁.baseSet ∩ e₂.baseSet),
                                            left_inv' :=
                                              (_ :
                                                ∀ (x : TotalSpace fun x => E₁ x × E₂ x),
                                                  x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet) →
                                                    Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x),
                                            right_inv' :=
                                              (_ :
                                                ∀ (x : B × F₁ × F₂),
                                                  x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ →
                                                    Prod.toFun' e₁ e₂ (Prod.invFun' e₁ e₂ x) = x) }.source),
                                  open_target := (_ : IsOpen ((e₁.baseSet ∩ e₂.baseSet) ×ˢ univ)),
                                  continuous_toFun :=
                                    (_ :
                                      ContinuousOn (Prod.toFun' e₁ e₂) (TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet))),
                                  continuous_invFun :=
                                    (_ : ContinuousOn (Prod.invFun' e₁ e₂) ((e₁.baseSet ∩ e₂.baseSet) ×ˢ univ)) }
                              x).fst) }
            (totalSpaceMk x y)).snd)
      (v₁, v₂) =
    ↑(ContinuousLinearEquiv.prod (continuousLinearEquivAt 𝕜 e₁ x (_ : x ∈ e₁.baseSet))
          (continuousLinearEquivAt 𝕜 e₂ x (_ : x ∈ e₂.baseSet)))
      (v₁, v₂)