File: Mathlib/Topology/Algebra/Module/StrongTopology.lean

full_name: UniformConvergenceCLM
code: /-- Given `E` and `F` two topological vector spaces and `𝔖 : Set (Set E)`, then
`UniformConvergenceCLM σ F 𝔖` is a type synonym of `E →SL[σ] F` equipped with the "topology of
uniform convergence on the elements of `𝔖`".

If the continuous linear image of any element of `𝔖` is bounded, this makes `E →SL[σ] F` a
topological vector space. -/
@[nolint unusedArguments]
def UniformConvergenceCLM [TopologicalSpace F] [TopologicalAddGroup F] (_ : Set (Set E)) 
goal: Set (Set E) → Type (max u_3 u_4)

full_name: UniformConvergenceCLM.instFunLike
code: instance instFunLike [TopologicalSpace F] [TopologicalAddGroup F]
    (𝔖 : Set (Set E)) : FunLike (UniformConvergenceCLM σ F 𝔖) E F 
goal: FunLike (UniformConvergenceCLM σ F 𝔖) E F

full_name: UniformConvergenceCLM.instContinuousSemilinearMapClass
code: instance instContinuousSemilinearMapClass [TopologicalSpace F] [TopologicalAddGroup F]
    (𝔖 : Set (Set E)) : ContinuousSemilinearMapClass (UniformConvergenceCLM σ F 𝔖) σ E F 
goal: ContinuousSemilinearMapClass (UniformConvergenceCLM σ F 𝔖) σ E F

full_name: UniformConvergenceCLM.instTopologicalSpace
code: instance instTopologicalSpace [TopologicalSpace F] [TopologicalAddGroup F] (𝔖 : Set (Set E)) :
    TopologicalSpace (UniformConvergenceCLM σ F 𝔖) 
goal: TopologicalSpace (UniformConvergenceCLM σ F 𝔖)

full_name: UniformConvergenceCLM.topologicalSpace_eq
code: theorem topologicalSpace_eq [UniformSpace F] [UniformAddGroup F] (𝔖 : Set (Set E)) :
    instTopologicalSpace σ F 𝔖 = TopologicalSpace.induced DFunLike.coe
      (UniformOnFun.topologicalSpace E F 𝔖) 
goal: UniformConvergenceCLM.instTopologicalSpace σ F 𝔖 =
  TopologicalSpace.induced DFunLike.coe (UniformOnFun.topologicalSpace E F 𝔖)

full_name: UniformConvergenceCLM.instUniformSpace
code: /-- The uniform structure associated with `ContinuousLinearMap.strongTopology`. We make sure
that this has nice definitional properties. -/
instance instUniformSpace [UniformSpace F] [UniformAddGroup F]
    (𝔖 : Set (Set E)) : UniformSpace (UniformConvergenceCLM σ F 𝔖) 
goal: UniformSpace (UniformConvergenceCLM σ F 𝔖)

full_name: UniformConvergenceCLM.uniformSpace_eq
code: theorem uniformSpace_eq [UniformSpace F] [UniformAddGroup F] (𝔖 : Set (Set E)) :
    instUniformSpace σ F 𝔖 = UniformSpace.comap DFunLike.coe (UniformOnFun.uniformSpace E F 𝔖) 
goal: UniformConvergenceCLM.instUniformSpace σ F 𝔖 = UniformSpace.comap DFunLike.coe (UniformOnFun.uniformSpace E F 𝔖)

full_name: UniformConvergenceCLM.uniformity_toTopologicalSpace_eq
code: @[simp]
theorem uniformity_toTopologicalSpace_eq [UniformSpace F] [UniformAddGroup F] (𝔖 : Set (Set E)) :
    (UniformConvergenceCLM.instUniformSpace σ F 𝔖).toTopologicalSpace =
      UniformConvergenceCLM.instTopologicalSpace σ F 𝔖 
goal: UniformSpace.toTopologicalSpace = UniformConvergenceCLM.instTopologicalSpace σ F 𝔖

full_name: UniformConvergenceCLM.uniformEmbedding_coeFn
code: theorem uniformEmbedding_coeFn [UniformSpace F] [UniformAddGroup F] (𝔖 : Set (Set E)) :
    UniformEmbedding (α := UniformConvergenceCLM σ F 𝔖) (β := E →ᵤ[𝔖] F) DFunLike.coe 
goal: UniformEmbedding DFunLike.coe

full_name: UniformConvergenceCLM.embedding_coeFn
code: theorem embedding_coeFn [UniformSpace F] [UniformAddGroup F] (𝔖 : Set (Set E)) :
    Embedding (X := UniformConvergenceCLM σ F 𝔖) (Y := E →ᵤ[𝔖] F)
      (UniformOnFun.ofFun 𝔖 ∘ DFunLike.coe) 
goal: Embedding (⇑(UniformOnFun.ofFun 𝔖) ∘ DFunLike.coe)

full_name: UniformConvergenceCLM.instAddCommGroup
code: instance instAddCommGroup [TopologicalSpace F] [TopologicalAddGroup F] (𝔖 : Set (Set E)) :
    AddCommGroup (UniformConvergenceCLM σ F 𝔖) 
goal: AddCommGroup (UniformConvergenceCLM σ F 𝔖)

full_name: UniformConvergenceCLM.instUniformAddGroup
code: instance instUniformAddGroup [UniformSpace F] [UniformAddGroup F] (𝔖 : Set (Set E)) :
    UniformAddGroup (UniformConvergenceCLM σ F 𝔖) 
goal: UniformAddGroup (UniformConvergenceCLM σ F 𝔖)

full_name: UniformConvergenceCLM.instTopologicalAddGroup
code: instance instTopologicalAddGroup [TopologicalSpace F] [TopologicalAddGroup F]
    (𝔖 : Set (Set E)) : TopologicalAddGroup (UniformConvergenceCLM σ F 𝔖) 
goal: TopologicalAddGroup (UniformConvergenceCLM σ F 𝔖)

full_name: UniformConvergenceCLM.t2Space
code: theorem t2Space [TopologicalSpace F] [TopologicalAddGroup F] [T2Space F]
    (𝔖 : Set (Set E)) (h𝔖 : ⋃₀ 𝔖 = Set.univ) : T2Space (UniformConvergenceCLM σ F 𝔖) 
goal: T2Space (UniformConvergenceCLM σ F 𝔖)

full_name: UniformConvergenceCLM.instDistribMulAction
code: instance instDistribMulAction (M : Type*) [Monoid M] [DistribMulAction M F] [SMulCommClass 𝕜₂ M F]
    [TopologicalSpace F] [TopologicalAddGroup F] [ContinuousConstSMul M F] (𝔖 : Set (Set E)) :
    DistribMulAction M (UniformConvergenceCLM σ F 𝔖) 
goal: DistribMulAction M (UniformConvergenceCLM σ F 𝔖)

full_name: UniformConvergenceCLM.instModule
code: instance instModule (R : Type*) [Semiring R] [Module R F] [SMulCommClass 𝕜₂ R F]
    [TopologicalSpace F] [ContinuousConstSMul R F] [TopologicalAddGroup F] (𝔖 : Set (Set E)) :
    Module R (UniformConvergenceCLM σ F 𝔖) 
goal: Module R (UniformConvergenceCLM σ F 𝔖)

full_name: UniformConvergenceCLM.continuousSMul
code: theorem continuousSMul [RingHomSurjective σ] [RingHomIsometric σ]
    [TopologicalSpace F] [TopologicalAddGroup F] [ContinuousSMul 𝕜₂ F] (𝔖 : Set (Set E))
    (h𝔖₃ : ∀ S ∈ 𝔖, Bornology.IsVonNBounded 𝕜₁ S) :
    ContinuousSMul 𝕜₂ (UniformConvergenceCLM σ F 𝔖) 
goal: ContinuousSMul 𝕜₂ (UniformConvergenceCLM σ F 𝔖)

full_name: UniformConvergenceCLM.hasBasis_nhds_zero_of_basis
code: theorem hasBasis_nhds_zero_of_basis [TopologicalSpace F] [TopologicalAddGroup F]
    {ι : Type*} (𝔖 : Set (Set E)) (h𝔖₁ : 𝔖.Nonempty) (h𝔖₂ : DirectedOn (· ⊆ ·) 𝔖) {p : ι → Prop}
    {b : ι → Set F} (h : (𝓝 0 : Filter F).HasBasis p b) :
    (𝓝 (0 : UniformConvergenceCLM σ F 𝔖)).HasBasis
      (fun Si : Set E × ι => Si.1 ∈ 𝔖 ∧ p Si.2)
      fun Si => { f : E →SL[σ] F | ∀ x ∈ Si.1, f x ∈ b Si.2 } 
goal: (𝓝 0).HasBasis (fun Si => Si.1 ∈ 𝔖 ∧ p Si.2) fun Si => {f | ∀ x ∈ Si.1, f x ∈ b Si.2}

full_name: UniformConvergenceCLM.hasBasis_nhds_zero
code: theorem hasBasis_nhds_zero [TopologicalSpace F] [TopologicalAddGroup F]
    (𝔖 : Set (Set E)) (h𝔖₁ : 𝔖.Nonempty) (h𝔖₂ : DirectedOn (· ⊆ ·) 𝔖) :
    (𝓝 (0 : UniformConvergenceCLM σ F 𝔖)).HasBasis
      (fun SV : Set E × Set F => SV.1 ∈ 𝔖 ∧ SV.2 ∈ (𝓝 0 : Filter F)) fun SV =>
      { f : UniformConvergenceCLM σ F 𝔖 | ∀ x ∈ SV.1, f x ∈ SV.2 } 
goal: (𝓝 0).HasBasis (fun SV => SV.1 ∈ 𝔖 ∧ SV.2 ∈ 𝓝 0) fun SV => {f | ∀ x ∈ SV.1, f x ∈ SV.2}

full_name: UniformConvergenceCLM.instUniformContinuousConstSMul
code: instance instUniformContinuousConstSMul (M : Type*)
    [Monoid M] [DistribMulAction M F] [SMulCommClass 𝕜₂ M F]
    [UniformSpace F] [UniformAddGroup F] [UniformContinuousConstSMul M F] (𝔖 : Set (Set E)) :
    UniformContinuousConstSMul M (UniformConvergenceCLM σ F 𝔖) 
goal: UniformContinuousConstSMul M (UniformConvergenceCLM σ F 𝔖)

full_name: UniformConvergenceCLM.instContinuousConstSMul
code: instance instContinuousConstSMul (M : Type*)
    [Monoid M] [DistribMulAction M F] [SMulCommClass 𝕜₂ M F]
    [TopologicalSpace F] [TopologicalAddGroup F] [ContinuousConstSMul M F] (𝔖 : Set (Set E)) :
    ContinuousConstSMul M (UniformConvergenceCLM σ F 𝔖) 
goal: ContinuousConstSMul M (UniformConvergenceCLM σ F 𝔖)

full_name: UniformConvergenceCLM.tendsto_iff_tendstoUniformlyOn
code: theorem tendsto_iff_tendstoUniformlyOn {ι : Type*} {p : Filter ι} [UniformSpace F]
    [UniformAddGroup F] (𝔖 : Set (Set E)) {a : ι → UniformConvergenceCLM σ F 𝔖}
    {a₀ : UniformConvergenceCLM σ F 𝔖} :
    Filter.Tendsto a p (𝓝 a₀) ↔ ∀ s ∈ 𝔖, TendstoUniformlyOn (a · ·) a₀ p s 
goal: Filter.Tendsto a p (𝓝 a₀) ↔ ∀ s ∈ 𝔖, TendstoUniformlyOn (fun x x_1 => (a x) x_1) (⇑a₀) p s

full_name: UniformConvergenceCLM.uniformSpace_mono
code: theorem uniformSpace_mono [UniformSpace F] [UniformAddGroup F] (h : 𝔖₂ ⊆ 𝔖₁) :
    instUniformSpace σ F 𝔖₁ ≤ instUniformSpace σ F 𝔖₂ 
goal: UniformConvergenceCLM.instUniformSpace σ F 𝔖₁ ≤ UniformConvergenceCLM.instUniformSpace σ F 𝔖₂

full_name: UniformConvergenceCLM.topologicalSpace_mono
code: theorem topologicalSpace_mono [TopologicalSpace F] [TopologicalAddGroup F] (h : 𝔖₂ ⊆ 𝔖₁) :
    instTopologicalSpace σ F 𝔖₁ ≤ instTopologicalSpace σ F 𝔖₂ 
goal: UniformConvergenceCLM.instTopologicalSpace σ F 𝔖₁ ≤ UniformConvergenceCLM.instTopologicalSpace σ F 𝔖₂

full_name: ContinuousLinearMap.topologicalSpace
code: /-- The topology of bounded convergence on `E →L[𝕜] F`. This coincides with the topology induced by
the operator norm when `E` and `F` are normed spaces. -/
instance topologicalSpace [TopologicalSpace F] [TopologicalAddGroup F] :
    TopologicalSpace (E →SL[σ] F) 
goal: TopologicalSpace (E →SL[σ] F)

full_name: ContinuousLinearMap.topologicalAddGroup
code: instance topologicalAddGroup [TopologicalSpace F] [TopologicalAddGroup F] :
    TopologicalAddGroup (E →SL[σ] F) 
goal: TopologicalAddGroup (E →SL[σ] F)

full_name: ContinuousLinearMap.continuousSMul
code: instance continuousSMul [RingHomSurjective σ] [RingHomIsometric σ] [TopologicalSpace F]
    [TopologicalAddGroup F] [ContinuousSMul 𝕜₂ F] : ContinuousSMul 𝕜₂ (E →SL[σ] F) 
goal: ContinuousSMul 𝕜₂ (E →SL[σ] F)

full_name: ContinuousLinearMap.uniformSpace
code: instance uniformSpace [UniformSpace F] [UniformAddGroup F] : UniformSpace (E →SL[σ] F) 
goal: UniformSpace (E →SL[σ] F)

full_name: ContinuousLinearMap.uniformAddGroup
code: instance uniformAddGroup [UniformSpace F] [UniformAddGroup F] : UniformAddGroup (E →SL[σ] F) 
goal: UniformAddGroup (E →SL[σ] F)

full_name: ContinuousLinearMap.instT2SpaceOfContinuousSMul
code: instance [TopologicalSpace F] [TopologicalAddGroup F] [ContinuousSMul 𝕜₁ E] [T2Space F] :
    T2Space (E →SL[σ] F) 
goal: T2Space (E →SL[σ] F)

full_name: ContinuousLinearMap.hasBasis_nhds_zero_of_basis
code: protected theorem hasBasis_nhds_zero_of_basis [TopologicalSpace F] [TopologicalAddGroup F]
    {ι : Type*} {p : ι → Prop} {b : ι → Set F} (h : (𝓝 0 : Filter F).HasBasis p b) :
    (𝓝 (0 : E →SL[σ] F)).HasBasis (fun Si : Set E × ι => Bornology.IsVonNBounded 𝕜₁ Si.1 ∧ p Si.2)
      fun Si => { f : E →SL[σ] F | ∀ x ∈ Si.1, f x ∈ b Si.2 } 
goal: (𝓝 0).HasBasis (fun Si => Bornology.IsVonNBounded 𝕜₁ Si.1 ∧ p Si.2) fun Si => {f | ∀ x ∈ Si.1, f x ∈ b Si.2}

full_name: ContinuousLinearMap.hasBasis_nhds_zero
code: protected theorem hasBasis_nhds_zero [TopologicalSpace F] [TopologicalAddGroup F] :
    (𝓝 (0 : E →SL[σ] F)).HasBasis
      (fun SV : Set E × Set F => Bornology.IsVonNBounded 𝕜₁ SV.1 ∧ SV.2 ∈ (𝓝 0 : Filter F))
      fun SV => { f : E →SL[σ] F | ∀ x ∈ SV.1, f x ∈ SV.2 } 
goal: (𝓝 0).HasBasis (fun SV => Bornology.IsVonNBounded 𝕜₁ SV.1 ∧ SV.2 ∈ 𝓝 0) fun SV => {f | ∀ x ∈ SV.1, f x ∈ SV.2}

full_name: ContinuousLinearMap.uniformContinuousConstSMul
code: instance uniformContinuousConstSMul
    {M : Type*} [Monoid M] [DistribMulAction M F] [SMulCommClass 𝕜₂ M F]
    [UniformSpace F] [UniformAddGroup F] [UniformContinuousConstSMul M F] :
    UniformContinuousConstSMul M (E →SL[σ] F) 
goal: UniformContinuousConstSMul M (E →SL[σ] F)

full_name: ContinuousLinearMap.continuousConstSMul
code: instance continuousConstSMul {M : Type*} [Monoid M] [DistribMulAction M F] [SMulCommClass 𝕜₂ M F]
    [TopologicalSpace F] [TopologicalAddGroup F] [ContinuousConstSMul M F] :
    ContinuousConstSMul M (E →SL[σ] F) 
goal: ContinuousConstSMul M (E →SL[σ] F)

full_name: ContinuousLinearMap.precomp_toFun
code: /-- Pre-composition by a *fixed* continuous linear map as a continuous linear map.
Note that in non-normed space it is not always true that composition is continuous
in both variables, so we have to fix one of them. -/
@[simps]
def precomp [TopologicalAddGroup G] [ContinuousConstSMul 𝕜₃ G] [RingHomSurjective σ]
    [RingHomIsometric σ] (L : E →SL[σ] F) : (F →SL[τ] G) →L[𝕜₃] E →SL[ρ] G 
goal: (ContinuousLinearMap.precomp G L) f = f.comp L

full_name: ContinuousLinearMap.precomp
code: /-- Pre-composition by a *fixed* continuous linear map as a continuous linear map.
Note that in non-normed space it is not always true that composition is continuous
in both variables, so we have to fix one of them. -/
@[simps]
def precomp [TopologicalAddGroup G] [ContinuousConstSMul 𝕜₃ G] [RingHomSurjective σ]
    [RingHomIsometric σ] (L : E →SL[σ] F) : (F →SL[τ] G) →L[𝕜₃] E →SL[ρ] G 
goal: (F →SL[τ] G) →L[𝕜₃] E →SL[ρ] G

full_name: ContinuousLinearMap.precomp_apply
code: /-- Pre-composition by a *fixed* continuous linear map as a continuous linear map.
Note that in non-normed space it is not always true that composition is continuous
in both variables, so we have to fix one of them. -/
@[simps]
def precomp [TopologicalAddGroup G] [ContinuousConstSMul 𝕜₃ G] [RingHomSurjective σ]
    [RingHomIsometric σ] (L : E →SL[σ] F) : (F →SL[τ] G) →L[𝕜₃] E →SL[ρ] G 
goal: (ContinuousLinearMap.precomp G L) f = f.comp L

full_name: ContinuousLinearMap.postcomp_toFun
code: /-- Post-composition by a *fixed* continuous linear map as a continuous linear map.
Note that in non-normed space it is not always true that composition is continuous
in both variables, so we have to fix one of them. -/
@[simps]
def postcomp [TopologicalAddGroup F] [TopologicalAddGroup G] [ContinuousConstSMul 𝕜₃ G]
    [ContinuousConstSMul 𝕜₂ F] (L : F →SL[τ] G) : (E →SL[σ] F) →SL[τ] E →SL[ρ] G 
goal: (ContinuousLinearMap.postcomp E L) f = L.comp f

full_name: ContinuousLinearMap.postcomp
code: /-- Post-composition by a *fixed* continuous linear map as a continuous linear map.
Note that in non-normed space it is not always true that composition is continuous
in both variables, so we have to fix one of them. -/
@[simps]
def postcomp [TopologicalAddGroup F] [TopologicalAddGroup G] [ContinuousConstSMul 𝕜₃ G]
    [ContinuousConstSMul 𝕜₂ F] (L : F →SL[τ] G) : (E →SL[σ] F) →SL[τ] E →SL[ρ] G 
goal: (E →SL[σ] F) →SL[τ] E →SL[ρ] G

full_name: ContinuousLinearMap.postcomp_apply
code: /-- Post-composition by a *fixed* continuous linear map as a continuous linear map.
Note that in non-normed space it is not always true that composition is continuous
in both variables, so we have to fix one of them. -/
@[simps]
def postcomp [TopologicalAddGroup F] [TopologicalAddGroup G] [ContinuousConstSMul 𝕜₃ G]
    [ContinuousConstSMul 𝕜₂ F] (L : F →SL[τ] G) : (E →SL[σ] F) →SL[τ] E →SL[ρ] G 
goal: (ContinuousLinearMap.postcomp E L) f = L.comp f

full_name: ContinuousLinearMap.toLinearMap₂
code: /-- Send a continuous bilinear map to an abstract bilinear map (forgetting continuity). -/
def toLinearMap₂ (L : E →L[𝕜] F →L[𝕜] G) : E →ₗ[𝕜] F →ₗ[𝕜] G 
goal: E →ₗ[𝕜] F →ₗ[𝕜] G

full_name: ContinuousLinearMap.toLinearMap₂_apply
code: @[simp] lemma toLinearMap₂_apply (L : E →L[𝕜] F →L[𝕜] G) (v : E) (w : F) :
    L.toLinearMap₂ v w = L v w 
goal: (L.toLinearMap₂ v) w = (L v) w

full_name: ContinuousLinearEquiv.arrowCongrSL_symm_apply
code: /-- A pair of continuous (semi)linear equivalences generates a (semi)linear equivalence between the
spaces of continuous (semi)linear maps. -/
@[simps]
def arrowCongrSL (e₁₂ : E ≃SL[σ₁₂] F) (e₄₃ : H ≃SL[σ₄₃] G) :
    (E →SL[σ₁₄] H) ≃SL[σ₄₃] F →SL[σ₂₃] G 
goal: (e₁₂.arrowCongrSL e₄₃).symm L = (↑e₄₃.symm).comp (L.comp ↑e₁₂)

full_name: ContinuousLinearEquiv.arrowCongrSL
code: /-- A pair of continuous (semi)linear equivalences generates a (semi)linear equivalence between the
spaces of continuous (semi)linear maps. -/
@[simps]
def arrowCongrSL (e₁₂ : E ≃SL[σ₁₂] F) (e₄₃ : H ≃SL[σ₄₃] G) :
    (E →SL[σ₁₄] H) ≃SL[σ₄₃] F →SL[σ₂₃] G 
goal: (E →SL[σ₁₄] H) ≃SL[σ₄₃] F →SL[σ₂₃] G

full_name: ContinuousLinearEquiv.arrowCongrSL_apply
code: /-- A pair of continuous (semi)linear equivalences generates a (semi)linear equivalence between the
spaces of continuous (semi)linear maps. -/
@[simps]
def arrowCongrSL (e₁₂ : E ≃SL[σ₁₂] F) (e₄₃ : H ≃SL[σ₄₃] G) :
    (E →SL[σ₁₄] H) ≃SL[σ₄₃] F →SL[σ₂₃] G 
goal: (e₁₂.arrowCongrSL e₄₃) L = (↑e₄₃).comp (L.comp ↑e₁₂.symm)

full_name: ContinuousLinearEquiv.arrowCongrSL_toLinearEquiv_apply
code: theorem arrowCongrSL_toLinearEquiv_apply (e₁₂ : E ≃SL[σ₁₂] F) (e₄₃ : H ≃SL[σ₄₃] G)
    (L : E →SL[σ₁₄] H) : (e₁₂.arrowCongrSL e₄₃).toLinearEquiv L =
      (e₄₃ : H →SL[σ₄₃] G).comp (L.comp (e₁₂.symm : F →SL[σ₂₁] E)) 
goal: (e₁₂.arrowCongrSL e₄₃).toLinearEquiv L = (↑e₄₃).comp (L.comp ↑e₁₂.symm)

full_name: ContinuousLinearEquiv.arrowCongrSL_toLinearEquiv_symm_apply
code: @[simp]
theorem arrowCongrSL_toLinearEquiv_symm_apply (e₁₂ : E ≃SL[σ₁₂] F) (e₄₃ : H ≃SL[σ₄₃] G)
    (L : F →SL[σ₂₃] G) : (e₁₂.arrowCongrSL e₄₃).toLinearEquiv.symm L =
      (e₄₃.symm : G →SL[σ₃₄] H).comp (L.comp (e₁₂ : E →SL[σ₁₂] F)) 
goal: (e₁₂.arrowCongrSL e₄₃).symm L = (↑e₄₃.symm).comp (L.comp ↑e₁₂)

full_name: ContinuousLinearEquiv.arrowCongr
code: /-- A pair of continuous linear equivalences generates a continuous linear equivalence between
the spaces of continuous linear maps. -/
def arrowCongr (e₁ : E ≃L[𝕜] F) (e₂ : H ≃L[𝕜] G) : (E →L[𝕜] H) ≃L[𝕜] F →L[𝕜] G 
goal: (E →L[𝕜] H) ≃L[𝕜] F →L[𝕜] G

full_name: ContinuousLinearEquiv.arrowCongr_apply
code: @[simp] lemma arrowCongr_apply (e₁ : E ≃L[𝕜] F) (e₂ : H ≃L[𝕜] G) (f : E →L[𝕜] H) (x : F) :
    e₁.arrowCongr e₂ f x = e₂ (f (e₁.symm x)) 
goal: ((e₁.arrowCongr e₂) f) x = e₂ (f (e₁.symm x))

full_name: ContinuousLinearEquiv.arrowCongr_symm
code: @[simp] lemma arrowCongr_symm (e₁ : E ≃L[𝕜] F) (e₂ : H ≃L[𝕜] G) :
    (e₁.arrowCongr e₂).symm = e₁.symm.arrowCongr e₂.symm 
goal: (e₁.arrowCongr e₂).symm = e₁.symm.arrowCongr e₂.symm