@[simp] -- porting note: changed arguments to make `simpNF` happy: merged `hx₁` and `hx₂` into `hx`
theorem Trivialization.continuousLinearEquivAt_prod {e₁ : Trivialization F₁ (π F₁ E₁)}
    {e₂ : Trivialization F₂ (π F₂ E₂)} [e₁.IsLinear 𝕜] [e₂.IsLinear 𝕜] {x : B}
    (hx : x ∈ (e₁.prod e₂).baseSet) :
    (e₁.prod e₂).continuousLinearEquivAt 𝕜 x hx =
      (e₁.continuousLinearEquivAt 𝕜 x hx.1).prod (e₂.continuousLinearEquivAt 𝕜 x hx.2) := by
  ext v : 2
  obtain ⟨v₁, v₂⟩ := v
  rw [(e₁.prod e₂).continuousLinearEquivAt_apply 𝕜, Trivialization.prod]
  

Proof state:
case h.h.mk
𝕜 : Type u_1
B : Type u_2
inst✝¹⁷ : NontriviallyNormedField 𝕜
inst✝¹⁶ : TopologicalSpace B
F₁ : Type u_3
inst✝¹⁵ : NormedAddCommGroup F₁
inst✝¹⁴ : NormedSpace 𝕜 F₁
E₁ : B → Type u_4
inst✝¹³ : TopologicalSpace (TotalSpace F₁ E₁)
F₂ : Type u_5
inst✝¹² : NormedAddCommGroup F₂
inst✝¹¹ : NormedSpace 𝕜 F₂
E₂ : B → Type u_6
inst✝¹⁰ : TopologicalSpace (TotalSpace F₂ 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 =>
        (↑{
                toPartialHomeomorph :=
                  {
                    toPartialEquiv :=
                      { 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.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                              (Prod.toFun' e₁ e₂ x).1 ∈ e₁.baseSet ∩ e₂.baseSet ∧ (Prod.toFun' e₁ e₂ x).2 ∈ univ),
                        map_target' := (_ : ∀ x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ, x.1 ∈ e₁.baseSet ∩ e₂.baseSet),
                        left_inv' :=
                          (_ :
                            ∀ x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                              Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x),
                        right_inv' :=
                          (_ : ∀ 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.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                    (Prod.toFun' e₁ e₂ x).1 ∈ e₁.baseSet ∩ e₂.baseSet ∧ (Prod.toFun' e₁ e₂ x).2 ∈ univ),
                              map_target' :=
                                (_ : ∀ x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ, x.1 ∈ e₁.baseSet ∩ e₂.baseSet),
                              left_inv' :=
                                (_ :
                                  ∀ x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                    Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x),
                              right_inv' :=
                                (_ :
                                  ∀ 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)),
                    continuousOn_toFun :=
                      (_ : ContinuousOn (Prod.toFun' e₁ e₂) (TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet))),
                    continuousOn_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 :=
                  (_ :
                    {
                            toPartialEquiv :=
                              { 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.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                      (Prod.toFun' e₁ e₂ x).1 ∈ e₁.baseSet ∩ e₂.baseSet ∧
                                        (Prod.toFun' e₁ e₂ x).2 ∈ univ),
                                map_target' :=
                                  (_ : ∀ x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ, x.1 ∈ e₁.baseSet ∩ e₂.baseSet),
                                left_inv' :=
                                  (_ :
                                    ∀ x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                      Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x),
                                right_inv' :=
                                  (_ :
                                    ∀ 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.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                            (Prod.toFun' e₁ e₂ x).1 ∈ e₁.baseSet ∩ e₂.baseSet ∧
                                              (Prod.toFun' e₁ e₂ x).2 ∈ univ),
                                      map_target' :=
                                        (_ : ∀ x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ, x.1 ∈ e₁.baseSet ∩ e₂.baseSet),
                                      left_inv' :=
                                        (_ :
                                          ∀ x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                            Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x),
                                      right_inv' :=
                                        (_ :
                                          ∀ 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)),
                            continuousOn_toFun :=
                              (_ : ContinuousOn (Prod.toFun' e₁ e₂) (TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet))),
                            continuousOn_invFun :=
                              (_ :
                                ContinuousOn (Prod.invFun' e₁ e₂)
                                  ((e₁.baseSet ∩ e₂.baseSet) ×ˢ univ)) }.toPartialEquiv.source =
                      {
                            toPartialEquiv :=
                              { 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.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                      (Prod.toFun' e₁ e₂ x).1 ∈ e₁.baseSet ∩ e₂.baseSet ∧
                                        (Prod.toFun' e₁ e₂ x).2 ∈ univ),
                                map_target' :=
                                  (_ : ∀ x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ, x.1 ∈ e₁.baseSet ∩ e₂.baseSet),
                                left_inv' :=
                                  (_ :
                                    ∀ x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                      Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x),
                                right_inv' :=
                                  (_ :
                                    ∀ 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.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                            (Prod.toFun' e₁ e₂ x).1 ∈ e₁.baseSet ∩ e₂.baseSet ∧
                                              (Prod.toFun' e₁ e₂ x).2 ∈ univ),
                                      map_target' :=
                                        (_ : ∀ x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ, x.1 ∈ e₁.baseSet ∩ e₂.baseSet),
                                      left_inv' :=
                                        (_ :
                                          ∀ x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                            Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x),
                                      right_inv' :=
                                        (_ :
                                          ∀ 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)),
                            continuousOn_toFun :=
                              (_ : ContinuousOn (Prod.toFun' e₁ e₂) (TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet))),
                            continuousOn_invFun :=
                              (_ :
                                ContinuousOn (Prod.invFun' e₁ e₂)
                                  ((e₁.baseSet ∩ e₂.baseSet) ×ˢ univ)) }.toPartialEquiv.source),
                target_eq :=
                  (_ :
                    {
                            toPartialEquiv :=
                              { 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.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                      (Prod.toFun' e₁ e₂ x).1 ∈ e₁.baseSet ∩ e₂.baseSet ∧
                                        (Prod.toFun' e₁ e₂ x).2 ∈ univ),
                                map_target' :=
                                  (_ : ∀ x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ, x.1 ∈ e₁.baseSet ∩ e₂.baseSet),
                                left_inv' :=
                                  (_ :
                                    ∀ x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                      Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x),
                                right_inv' :=
                                  (_ :
                                    ∀ 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.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                            (Prod.toFun' e₁ e₂ x).1 ∈ e₁.baseSet ∩ e₂.baseSet ∧
                                              (Prod.toFun' e₁ e₂ x).2 ∈ univ),
                                      map_target' :=
                                        (_ : ∀ x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ, x.1 ∈ e₁.baseSet ∩ e₂.baseSet),
                                      left_inv' :=
                                        (_ :
                                          ∀ x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                            Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x),
                                      right_inv' :=
                                        (_ :
                                          ∀ 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)),
                            continuousOn_toFun :=
                              (_ : ContinuousOn (Prod.toFun' e₁ e₂) (TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet))),
                            continuousOn_invFun :=
                              (_ :
                                ContinuousOn (Prod.invFun' e₁ e₂)
                                  ((e₁.baseSet ∩ e₂.baseSet) ×ˢ univ)) }.toPartialEquiv.target =
                      {
                            toPartialEquiv :=
                              { 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.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                      (Prod.toFun' e₁ e₂ x).1 ∈ e₁.baseSet ∩ e₂.baseSet ∧
                                        (Prod.toFun' e₁ e₂ x).2 ∈ univ),
                                map_target' :=
                                  (_ : ∀ x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ, x.1 ∈ e₁.baseSet ∩ e₂.baseSet),
                                left_inv' :=
                                  (_ :
                                    ∀ x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                      Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x),
                                right_inv' :=
                                  (_ :
                                    ∀ 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.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                            (Prod.toFun' e₁ e₂ x).1 ∈ e₁.baseSet ∩ e₂.baseSet ∧
                                              (Prod.toFun' e₁ e₂ x).2 ∈ univ),
                                      map_target' :=
                                        (_ : ∀ x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ, x.1 ∈ e₁.baseSet ∩ e₂.baseSet),
                                      left_inv' :=
                                        (_ :
                                          ∀ x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                            Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x),
                                      right_inv' :=
                                        (_ :
                                          ∀ 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)),
                            continuousOn_toFun :=
                              (_ : ContinuousOn (Prod.toFun' e₁ e₂) (TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet))),
                            continuousOn_invFun :=
                              (_ :
                                ContinuousOn (Prod.invFun' e₁ e₂)
                                  ((e₁.baseSet ∩ e₂.baseSet) ×ˢ univ)) }.toPartialEquiv.target),
                proj_toFun :=
                  (_ :
                    ∀
                      x ∈
                        {
                              toPartialEquiv :=
                                { 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.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                        (Prod.toFun' e₁ e₂ x).1 ∈ e₁.baseSet ∩ e₂.baseSet ∧
                                          (Prod.toFun' e₁ e₂ x).2 ∈ univ),
                                  map_target' :=
                                    (_ : ∀ x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ, x.1 ∈ e₁.baseSet ∩ e₂.baseSet),
                                  left_inv' :=
                                    (_ :
                                      ∀ x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                        Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x),
                                  right_inv' :=
                                    (_ :
                                      ∀ 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.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                              (Prod.toFun' e₁ e₂ x).1 ∈ e₁.baseSet ∩ e₂.baseSet ∧
                                                (Prod.toFun' e₁ e₂ x).2 ∈ univ),
                                        map_target' :=
                                          (_ : ∀ x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ, x.1 ∈ e₁.baseSet ∩ e₂.baseSet),
                                        left_inv' :=
                                          (_ :
                                            ∀ x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                              Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x),
                                        right_inv' :=
                                          (_ :
                                            ∀ 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)),
                              continuousOn_toFun :=
                                (_ : ContinuousOn (Prod.toFun' e₁ e₂) (TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet))),
                              continuousOn_invFun :=
                                (_ :
                                  ContinuousOn (Prod.invFun' e₁ e₂)
                                    ((e₁.baseSet ∩ e₂.baseSet) ×ˢ univ)) }.toPartialEquiv.source,
                      (↑{
                                toPartialEquiv :=
                                  { 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.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                          (Prod.toFun' e₁ e₂ x).1 ∈ e₁.baseSet ∩ e₂.baseSet ∧
                                            (Prod.toFun' e₁ e₂ x).2 ∈ univ),
                                    map_target' :=
                                      (_ : ∀ x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ, x.1 ∈ e₁.baseSet ∩ e₂.baseSet),
                                    left_inv' :=
                                      (_ :
                                        ∀ x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                          Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x),
                                    right_inv' :=
                                      (_ :
                                        ∀ 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.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                                (Prod.toFun' e₁ e₂ x).1 ∈ e₁.baseSet ∩ e₂.baseSet ∧
                                                  (Prod.toFun' e₁ e₂ x).2 ∈ univ),
                                          map_target' :=
                                            (_ :
                                              ∀ x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ, x.1 ∈ e₁.baseSet ∩ e₂.baseSet),
                                          left_inv' :=
                                            (_ :
                                              ∀ x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                                Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x),
                                          right_inv' :=
                                            (_ :
                                              ∀ 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)),
                                continuousOn_toFun :=
                                  (_ :
                                    ContinuousOn (Prod.toFun' e₁ e₂) (TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet))),
                                continuousOn_invFun :=
                                  (_ : ContinuousOn (Prod.invFun' e₁ e₂) ((e₁.baseSet ∩ e₂.baseSet) ×ˢ univ)) }
                            x).1 =
                        (↑{
                                toPartialEquiv :=
                                  { 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.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                          (Prod.toFun' e₁ e₂ x).1 ∈ e₁.baseSet ∩ e₂.baseSet ∧
                                            (Prod.toFun' e₁ e₂ x).2 ∈ univ),
                                    map_target' :=
                                      (_ : ∀ x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ, x.1 ∈ e₁.baseSet ∩ e₂.baseSet),
                                    left_inv' :=
                                      (_ :
                                        ∀ x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                          Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x),
                                    right_inv' :=
                                      (_ :
                                        ∀ 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.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                                (Prod.toFun' e₁ e₂ x).1 ∈ e₁.baseSet ∩ e₂.baseSet ∧
                                                  (Prod.toFun' e₁ e₂ x).2 ∈ univ),
                                          map_target' :=
                                            (_ :
                                              ∀ x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ univ, x.1 ∈ e₁.baseSet ∩ e₂.baseSet),
                                          left_inv' :=
                                            (_ :
                                              ∀ x ∈ TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet),
                                                Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x),
                                          right_inv' :=
                                            (_ :
                                              ∀ 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)),
                                continuousOn_toFun :=
                                  (_ :
                                    ContinuousOn (Prod.toFun' e₁ e₂) (TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet))),
                                continuousOn_invFun :=
                                  (_ : ContinuousOn (Prod.invFun' e₁ e₂) ((e₁.baseSet ∩ e₂.baseSet) ×ˢ univ)) }
                            x).1) }
            { proj := x, snd := y }).2)
      (v₁, v₂) =
    (ContinuousLinearEquiv.prod (continuousLinearEquivAt 𝕜 e₁ x (_ : x ∈ e₁.baseSet))
        (continuousLinearEquivAt 𝕜 e₂ x (_ : x ∈ e₂.baseSet)))
      (v₁, v₂)

Next tactic:
exact (congr_arg Prod.snd (prod_apply 𝕜 hx.1 hx.2 v₁ v₂) : _)