File: Mathlib/Analysis/NormedSpace/OperatorNorm/Bilinear.lean

full_name: ContinuousLinearMap.opNorm_ext
code: theorem opNorm_ext [RingHomIsometric σ₁₃] (f : E →SL[σ₁₂] F) (g : E →SL[σ₁₃] G)
    (h : ∀ x, ‖f x‖ = ‖g x‖) : ‖f‖ = ‖g‖ 
goal: ‖f‖ = ‖g‖

full_name: ContinuousLinearMap.opNorm_le_bound₂
code: theorem opNorm_le_bound₂ (f : E →SL[σ₁₃] F →SL[σ₂₃] G) {C : ℝ} (h0 : 0 ≤ C)
    (hC : ∀ x y, ‖f x y‖ ≤ C * ‖x‖ * ‖y‖) : ‖f‖ ≤ C 
goal: ‖f‖ ≤ C

full_name: ContinuousLinearMap.le_opNorm₂
code: theorem le_opNorm₂ [RingHomIsometric σ₁₃] (f : E →SL[σ₁₃] F →SL[σ₂₃] G) (x : E) (y : F) :
    ‖f x y‖ ≤ ‖f‖ * ‖x‖ * ‖y‖ 
goal: ‖(f x) y‖ ≤ ‖f‖ * ‖x‖ * ‖y‖

full_name: ContinuousLinearMap.le_of_opNorm₂_le_of_le
code: theorem le_of_opNorm₂_le_of_le [RingHomIsometric σ₁₃] (f : E →SL[σ₁₃] F →SL[σ₂₃] G) {x : E} {y : F}
    {a b c : ℝ} (hf : ‖f‖ ≤ a) (hx : ‖x‖ ≤ b) (hy : ‖y‖ ≤ c) :
    ‖f x y‖ ≤ a * b * c 
goal: ‖(f x) y‖ ≤ a * b * c

full_name: LinearMap.norm_mkContinuous₂_aux
code: lemma norm_mkContinuous₂_aux (f : E →ₛₗ[σ₁₃] F →ₛₗ[σ₂₃] G) (C : ℝ)
    (h : ∀ x y, ‖f x y‖ ≤ C * ‖x‖ * ‖y‖) (x : E) :
    ‖(f x).mkContinuous (C * ‖x‖) (h x)‖ ≤ max C 0 * ‖x‖ 
goal: ‖(f x).mkContinuous (C * ‖x‖) ⋯‖ ≤ max C 0 * ‖x‖

full_name: LinearMap.mkContinuousOfExistsBound₂
code: /-- Create a bilinear map (represented as a map `E →L[𝕜] F →L[𝕜] G`) from the corresponding linear
map and existence of a bound on the norm of the image. The linear map can be constructed using
`LinearMap.mk₂`.

If you have an explicit bound, use `LinearMap.mkContinuous₂` instead, as a norm estimate will
follow automatically in `LinearMap.mkContinuous₂_norm_le`. -/
def mkContinuousOfExistsBound₂ (f : E →ₛₗ[σ₁₃] F →ₛₗ[σ₂₃] G)
    (h : ∃ C, ∀ x y, ‖f x y‖ ≤ C * ‖x‖ * ‖y‖) : E →SL[σ₁₃] F →SL[σ₂₃] G 
goal: E →SL[σ₁₃] F →SL[σ₂₃] G

full_name: LinearMap.mkContinuous₂
code: /-- Create a bilinear map (represented as a map `E →L[𝕜] F →L[𝕜] G`) from the corresponding linear
map and a bound on the norm of the image. The linear map can be constructed using
`LinearMap.mk₂`. Lemmas `LinearMap.mkContinuous₂_norm_le'` and `LinearMap.mkContinuous₂_norm_le`
provide estimates on the norm of an operator constructed using this function. -/
def mkContinuous₂ (f : E →ₛₗ[σ₁₃] F →ₛₗ[σ₂₃] G) (C : ℝ) (hC : ∀ x y, ‖f x y‖ ≤ C * ‖x‖ * ‖y‖) :
    E →SL[σ₁₃] F →SL[σ₂₃] G 
goal: E →SL[σ₁₃] F →SL[σ₂₃] G

full_name: LinearMap.mkContinuous₂_apply
code: @[simp]
theorem mkContinuous₂_apply (f : E →ₛₗ[σ₁₃] F →ₛₗ[σ₂₃] G) {C : ℝ}
    (hC : ∀ x y, ‖f x y‖ ≤ C * ‖x‖ * ‖y‖) (x : E) (y : F) : f.mkContinuous₂ C hC x y = f x y 
goal: ((f.mkContinuous₂ C hC) x) y = (f x) y

full_name: LinearMap.mkContinuous₂_norm_le'
code: theorem mkContinuous₂_norm_le' (f : E →ₛₗ[σ₁₃] F →ₛₗ[σ₂₃] G) {C : ℝ}
    (hC : ∀ x y, ‖f x y‖ ≤ C * ‖x‖ * ‖y‖) : ‖f.mkContinuous₂ C hC‖ ≤ max C 0 
goal: ‖f.mkContinuous₂ C hC‖ ≤ max C 0

full_name: LinearMap.mkContinuous₂_norm_le
code: theorem mkContinuous₂_norm_le (f : E →ₛₗ[σ₁₃] F →ₛₗ[σ₂₃] G) {C : ℝ} (h0 : 0 ≤ C)
    (hC : ∀ x y, ‖f x y‖ ≤ C * ‖x‖ * ‖y‖) : ‖f.mkContinuous₂ C hC‖ ≤ C 
goal: ‖f.mkContinuous₂ C hC‖ ≤ C

full_name: ContinuousLinearMap.flip
code: /-- Flip the order of arguments of a continuous bilinear map.
For a version bundled as `LinearIsometryEquiv`, see
`ContinuousLinearMap.flipL`. -/
def flip (f : E →SL[σ₁₃] F →SL[σ₂₃] G) : F →SL[σ₂₃] E →SL[σ₁₃] G 
goal: F →SL[σ₂₃] E →SL[σ₁₃] G

full_name: _private.Mathlib.Analysis.NormedSpace.OperatorNorm.Bilinear.0.ContinuousLinearMap.le_norm_flip
code: private theorem le_norm_flip (f : E →SL[σ₁₃] F →SL[σ₂₃] G) : ‖f‖ ≤ ‖flip f‖ 
goal: ‖f‖ ≤ ‖f.flip‖

full_name: ContinuousLinearMap.flip_apply
code: @[simp]
theorem flip_apply (f : E →SL[σ₁₃] F →SL[σ₂₃] G) (x : E) (y : F) : f.flip y x = f x y 
goal: (f.flip y) x = (f x) y

full_name: ContinuousLinearMap.flip_flip
code: @[simp]
theorem flip_flip (f : E →SL[σ₁₃] F →SL[σ₂₃] G) : f.flip.flip = f 
goal: f.flip.flip = f

full_name: ContinuousLinearMap.opNorm_flip
code: @[simp]
theorem opNorm_flip (f : E →SL[σ₁₃] F →SL[σ₂₃] G) : ‖f.flip‖ = ‖f‖ 
goal: ‖f.flip‖ = ‖f‖

full_name: ContinuousLinearMap.flip_add
code: @[simp]
theorem flip_add (f g : E →SL[σ₁₃] F →SL[σ₂₃] G) : (f + g).flip = f.flip + g.flip 
goal: (f + g).flip = f.flip + g.flip

full_name: ContinuousLinearMap.flip_smul
code: @[simp]
theorem flip_smul (c : 𝕜₃) (f : E →SL[σ₁₃] F →SL[σ₂₃] G) : (c • f).flip = c • f.flip 
goal: (c • f).flip = c • f.flip

full_name: ContinuousLinearMap.flipₗᵢ'
code: /-- Flip the order of arguments of a continuous bilinear map.
This is a version bundled as a `LinearIsometryEquiv`.
For an unbundled version see `ContinuousLinearMap.flip`. -/
def flipₗᵢ' : (E →SL[σ₁₃] F →SL[σ₂₃] G) ≃ₗᵢ[𝕜₃] F →SL[σ₂₃] E →SL[σ₁₃] G 
goal: (E →SL[σ₁₃] F →SL[σ₂₃] G) ≃ₗᵢ[𝕜₃] F →SL[σ₂₃] E →SL[σ₁₃] G

full_name: ContinuousLinearMap.flipₗᵢ'_symm
code: @[simp]
theorem flipₗᵢ'_symm : (flipₗᵢ' E F G σ₂₃ σ₁₃).symm = flipₗᵢ' F E G σ₁₃ σ₂₃ 
goal: (ContinuousLinearMap.flipₗᵢ' E F G σ₂₃ σ₁₃).symm = ContinuousLinearMap.flipₗᵢ' F E G σ₁₃ σ₂₃

full_name: ContinuousLinearMap.coe_flipₗᵢ'
code: @[simp]
theorem coe_flipₗᵢ' : ⇑(flipₗᵢ' E F G σ₂₃ σ₁₃) = flip 
goal: ⇑(ContinuousLinearMap.flipₗᵢ' E F G σ₂₃ σ₁₃) = ContinuousLinearMap.flip

full_name: ContinuousLinearMap.flipₗᵢ
code: /-- Flip the order of arguments of a continuous bilinear map.
This is a version bundled as a `LinearIsometryEquiv`.
For an unbundled version see `ContinuousLinearMap.flip`. -/
def flipₗᵢ : (E →L[𝕜] Fₗ →L[𝕜] Gₗ) ≃ₗᵢ[𝕜] Fₗ →L[𝕜] E →L[𝕜] Gₗ 
goal: (E →L[𝕜] Fₗ →L[𝕜] Gₗ) ≃ₗᵢ[𝕜] Fₗ →L[𝕜] E →L[𝕜] Gₗ

full_name: ContinuousLinearMap.flipₗᵢ_symm
code: @[simp]
theorem flipₗᵢ_symm : (flipₗᵢ 𝕜 E Fₗ Gₗ).symm = flipₗᵢ 𝕜 Fₗ E Gₗ 
goal: (ContinuousLinearMap.flipₗᵢ 𝕜 E Fₗ Gₗ).symm = ContinuousLinearMap.flipₗᵢ 𝕜 Fₗ E Gₗ

full_name: ContinuousLinearMap.coe_flipₗᵢ
code: @[simp]
theorem coe_flipₗᵢ : ⇑(flipₗᵢ 𝕜 E Fₗ Gₗ) = flip 
goal: ⇑(ContinuousLinearMap.flipₗᵢ 𝕜 E Fₗ Gₗ) = ContinuousLinearMap.flip

full_name: ContinuousLinearMap.apply'
code: /-- The continuous semilinear map obtained by applying a continuous semilinear map at a given
vector.

This is the continuous version of `LinearMap.applyₗ`. -/
def apply' : E →SL[σ₁₂] (E →SL[σ₁₂] F) →L[𝕜₂] F 
goal: E →SL[σ₁₂] (E →SL[σ₁₂] F) →L[𝕜₂] F

full_name: ContinuousLinearMap.apply_apply'
code: @[simp]
theorem apply_apply' (v : E) (f : E →SL[σ₁₂] F) : apply' F σ₁₂ v f = f v 
goal: ((ContinuousLinearMap.apply' F σ₁₂) v) f = f v

full_name: ContinuousLinearMap.apply
code: /-- The continuous semilinear map obtained by applying a continuous semilinear map at a given
vector.

This is the continuous version of `LinearMap.applyₗ`. -/
def apply : E →L[𝕜] (E →L[𝕜] Fₗ) →L[𝕜] Fₗ 
goal: E →L[𝕜] (E →L[𝕜] Fₗ) →L[𝕜] Fₗ

full_name: ContinuousLinearMap.apply_apply
code: @[simp]
theorem apply_apply (v : E) (f : E →L[𝕜] Fₗ) : apply 𝕜 Fₗ v f = f v 
goal: ((ContinuousLinearMap.apply 𝕜 Fₗ) v) f = f v

full_name: ContinuousLinearMap.compSL
code: /-- Composition of continuous semilinear maps as a continuous semibilinear map. -/
def compSL : (F →SL[σ₂₃] G) →L[𝕜₃] (E →SL[σ₁₂] F) →SL[σ₂₃] E →SL[σ₁₃] G 
goal: (F →SL[σ₂₃] G) →L[𝕜₃] (E →SL[σ₁₂] F) →SL[σ₂₃] E →SL[σ₁₃] G

full_name: ContinuousLinearMap.norm_compSL_le
code: theorem norm_compSL_le : ‖compSL E F G σ₁₂ σ₂₃‖ ≤ 1 
goal: ‖ContinuousLinearMap.compSL E F G σ₁₂ σ₂₃‖ ≤ 1

full_name: ContinuousLinearMap.compSL_apply
code: @[simp]
theorem compSL_apply (f : F →SL[σ₂₃] G) (g : E →SL[σ₁₂] F) : compSL E F G σ₁₂ σ₂₃ f g = f.comp g 
goal: ((ContinuousLinearMap.compSL E F G σ₁₂ σ₂₃) f) g = f.comp g

full_name: Continuous.const_clm_comp
code: theorem _root_.Continuous.const_clm_comp {X} [TopologicalSpace X] {f : X → E →SL[σ₁₂] F}
    (hf : Continuous f) (g : F →SL[σ₂₃] G) :
    Continuous (fun x => g.comp (f x) : X → E →SL[σ₁₃] G) 
goal: Continuous fun x => g.comp (f x)

full_name: Continuous.clm_comp_const
code: theorem _root_.Continuous.clm_comp_const {X} [TopologicalSpace X] {g : X → F →SL[σ₂₃] G}
    (hg : Continuous g) (f : E →SL[σ₁₂] F) :
    Continuous (fun x => (g x).comp f : X → E →SL[σ₁₃] G) 
goal: Continuous fun x => (g x).comp f

full_name: ContinuousLinearMap.compL
code: /-- Composition of continuous linear maps as a continuous bilinear map. -/
def compL : (Fₗ →L[𝕜] Gₗ) →L[𝕜] (E →L[𝕜] Fₗ) →L[𝕜] E →L[𝕜] Gₗ 
goal: (Fₗ →L[𝕜] Gₗ) →L[𝕜] (E →L[𝕜] Fₗ) →L[𝕜] E →L[𝕜] Gₗ

full_name: ContinuousLinearMap.norm_compL_le
code: theorem norm_compL_le : ‖compL 𝕜 E Fₗ Gₗ‖ ≤ 1 
goal: ‖ContinuousLinearMap.compL 𝕜 E Fₗ Gₗ‖ ≤ 1

full_name: ContinuousLinearMap.compL_apply
code: @[simp]
theorem compL_apply (f : Fₗ →L[𝕜] Gₗ) (g : E →L[𝕜] Fₗ) : compL 𝕜 E Fₗ Gₗ f g = f.comp g 
goal: ((ContinuousLinearMap.compL 𝕜 E Fₗ Gₗ) f) g = f.comp g

full_name: ContinuousLinearMap.precompR
code: /-- Apply `L(x,-)` pointwise to bilinear maps, as a continuous bilinear map -/
@[simps! apply]
def precompR (L : E →L[𝕜] Fₗ →L[𝕜] Gₗ) : E →L[𝕜] (Eₗ →L[𝕜] Fₗ) →L[𝕜] Eₗ →L[𝕜] Gₗ 
goal: E →L[𝕜] (Eₗ →L[𝕜] Fₗ) →L[𝕜] Eₗ →L[𝕜] Gₗ

full_name: ContinuousLinearMap.precompR_apply
code: /-- Apply `L(x,-)` pointwise to bilinear maps, as a continuous bilinear map -/
@[simps! apply]
def precompR (L : E →L[𝕜] Fₗ →L[𝕜] Gₗ) : E →L[𝕜] (Eₗ →L[𝕜] Fₗ) →L[𝕜] Eₗ →L[𝕜] Gₗ 
goal: ∀ (a : E), (ContinuousLinearMap.precompR Eₗ L) a = (ContinuousLinearMap.compL 𝕜 Eₗ Fₗ Gₗ) (L a)

full_name: ContinuousLinearMap.precompL
code: /-- Apply `L(-,y)` pointwise to bilinear maps, as a continuous bilinear map -/
def precompL (L : E →L[𝕜] Fₗ →L[𝕜] Gₗ) : (Eₗ →L[𝕜] E) →L[𝕜] Fₗ →L[𝕜] Eₗ →L[𝕜] Gₗ 
goal: (Eₗ →L[𝕜] E) →L[𝕜] Fₗ →L[𝕜] Eₗ →L[𝕜] Gₗ

full_name: ContinuousLinearMap.precompL_apply
code: @[simp] lemma precompL_apply (L : E →L[𝕜] Fₗ →L[𝕜] Gₗ) (u : Eₗ →L[𝕜] E) (f : Fₗ) (g : Eₗ) :
    precompL Eₗ L u f g = L (u g) f 
goal: (((ContinuousLinearMap.precompL Eₗ L) u) f) g = (L (u g)) f

full_name: ContinuousLinearMap.norm_precompR_le
code: theorem norm_precompR_le (L : E →L[𝕜] Fₗ →L[𝕜] Gₗ) : ‖precompR Eₗ L‖ ≤ ‖L‖ 
goal: ‖ContinuousLinearMap.precompR Eₗ L‖ ≤ ‖L‖

full_name: ContinuousLinearMap.norm_precompL_le
code: theorem norm_precompL_le (L : E →L[𝕜] Fₗ →L[𝕜] Gₗ) : ‖precompL Eₗ L‖ ≤ ‖L‖ 
goal: ‖ContinuousLinearMap.precompL Eₗ L‖ ≤ ‖L‖

full_name: ContinuousLinearMap.bilinearComp
code: /-- Compose a bilinear map `E →SL[σ₁₃] F →SL[σ₂₃] G` with two linear maps
`E' →SL[σ₁'] E` and `F' →SL[σ₂'] F`.  -/
def bilinearComp (f : E →SL[σ₁₃] F →SL[σ₂₃] G) (gE : E' →SL[σ₁'] E) (gF : F' →SL[σ₂'] F) :
    E' →SL[σ₁₃'] F' →SL[σ₂₃'] G 
goal: E' →SL[σ₁₃'] F' →SL[σ₂₃'] G

full_name: ContinuousLinearMap.bilinearComp_apply
code: @[simp]
theorem bilinearComp_apply (f : E →SL[σ₁₃] F →SL[σ₂₃] G) (gE : E' →SL[σ₁'] E) (gF : F' →SL[σ₂'] F)
    (x : E') (y : F') : f.bilinearComp gE gF x y = f (gE x) (gF y) 
goal: ((f.bilinearComp gE gF) x) y = (f (gE x)) (gF y)

full_name: ContinuousLinearMap.deriv₂
code: /-- Derivative of a continuous bilinear map `f : E →L[𝕜] F →L[𝕜] G` interpreted as a map `E × F → G`
at point `p : E × F` evaluated at `q : E × F`, as a continuous bilinear map. -/
def deriv₂ (f : E →L[𝕜] Fₗ →L[𝕜] Gₗ) : E × Fₗ →L[𝕜] E × Fₗ →L[𝕜] Gₗ 
goal: E × Fₗ →L[𝕜] E × Fₗ →L[𝕜] Gₗ

full_name: ContinuousLinearMap.coe_deriv₂
code: @[simp]
theorem coe_deriv₂ (f : E →L[𝕜] Fₗ →L[𝕜] Gₗ) (p : E × Fₗ) :
    ⇑(f.deriv₂ p) = fun q : E × Fₗ => f p.1 q.2 + f q.1 p.2 
goal: ⇑(f.deriv₂ p) = fun q => (f p.1) q.2 + (f q.1) p.2

full_name: ContinuousLinearMap.map_add_add
code: theorem map_add_add (f : E →L[𝕜] Fₗ →L[𝕜] Gₗ) (x x' : E) (y y' : Fₗ) :
    f (x + x') (y + y') = f x y + f.deriv₂ (x, y) (x', y') + f x' y' 
goal: (f (x + x')) (y + y') = (f x) y + (f.deriv₂ (x, y)) (x', y') + (f x') y'