File: Mathlib/Analysis/Normed/Operator/BoundedLinearMaps.lean

full_name: IsBoundedLinearMap.bound
code: /-- A function `f` satisfies `IsBoundedLinearMap 𝕜 f` if it is linear and satisfies the
inequality `‖f x‖ ≤ M * ‖x‖` for some positive constant `M`. -/
structure IsBoundedLinearMap (𝕜 : Type*) [NormedField 𝕜] {E : Type*} [NormedAddCommGroup E]
  [NormedSpace 𝕜 E] {F : Type*} [NormedAddCommGroup F] [NormedSpace 𝕜 F] (f : E → F) extends
  IsLinearMap 𝕜 f : Prop where
  bound : ∃ M, 0 < M ∧ ∀ x : E, ‖f x‖ ≤ M * ‖x‖
goal: ∃ M, 0 < M ∧ ∀ (x : E), ‖f x‖ ≤ M * ‖x‖

full_name: IsBoundedLinearMap
code: /-- A function `f` satisfies `IsBoundedLinearMap 𝕜 f` if it is linear and satisfies the
inequality `‖f x‖ ≤ M * ‖x‖` for some positive constant `M`. -/
structure IsBoundedLinearMap (𝕜 : Type*) [NormedField 𝕜] {E : Type*} [NormedAddCommGroup E]
  [NormedSpace 𝕜 E] {F : Type*} [NormedAddCommGroup F] [NormedSpace 𝕜 F] (f : E → F) extends
  IsLinearMap 𝕜 f : Prop where
  bound : ∃ M, 0 < M ∧ ∀ x : E, ‖f x‖ ≤ M * ‖x‖
goal: Prop

full_name: IsLinearMap.with_bound
code: theorem IsLinearMap.with_bound {f : E → F} (hf : IsLinearMap 𝕜 f) (M : ℝ)
    (h : ∀ x : E, ‖f x‖ ≤ M * ‖x‖) : IsBoundedLinearMap 𝕜 f 
goal: IsBoundedLinearMap 𝕜 f

full_name: ContinuousLinearMap.isBoundedLinearMap
code: /-- A continuous linear map satisfies `IsBoundedLinearMap` -/
theorem ContinuousLinearMap.isBoundedLinearMap (f : E →L[𝕜] F) : IsBoundedLinearMap 𝕜 f 
goal: IsBoundedLinearMap 𝕜 ⇑f

full_name: IsBoundedLinearMap.toLinearMap
code: /-- Construct a linear map from a function `f` satisfying `IsBoundedLinearMap 𝕜 f`. -/
def toLinearMap (f : E → F) (h : IsBoundedLinearMap 𝕜 f) : E →ₗ[𝕜] F 
goal: E →ₗ[𝕜] F

full_name: IsBoundedLinearMap.toContinuousLinearMap
code: /-- Construct a continuous linear map from `IsBoundedLinearMap`. -/
def toContinuousLinearMap {f : E → F} (hf : IsBoundedLinearMap 𝕜 f) : E →L[𝕜] F 
goal: E →L[𝕜] F

full_name: IsBoundedLinearMap.zero
code: theorem zero : IsBoundedLinearMap 𝕜 fun _ : E => (0 : F) 
goal: IsBoundedLinearMap 𝕜 fun x => 0

full_name: IsBoundedLinearMap.id
code: theorem id : IsBoundedLinearMap 𝕜 fun x : E => x 
goal: IsBoundedLinearMap 𝕜 fun x => x

full_name: IsBoundedLinearMap.fst
code: theorem fst : IsBoundedLinearMap 𝕜 fun x : E × F => x.1 
goal: IsBoundedLinearMap 𝕜 fun x => x.1

full_name: IsBoundedLinearMap.snd
code: theorem snd : IsBoundedLinearMap 𝕜 fun x : E × F => x.2 
goal: IsBoundedLinearMap 𝕜 fun x => x.2

full_name: IsBoundedLinearMap.smul
code: theorem smul (c : 𝕜) (hf : IsBoundedLinearMap 𝕜 f) : IsBoundedLinearMap 𝕜 (c • f) 
goal: IsBoundedLinearMap 𝕜 (c • f)

full_name: IsBoundedLinearMap.neg
code: theorem neg (hf : IsBoundedLinearMap 𝕜 f) : IsBoundedLinearMap 𝕜 fun e => -f e 
goal: IsBoundedLinearMap 𝕜 fun e => -f e

full_name: IsBoundedLinearMap.add
code: theorem add (hf : IsBoundedLinearMap 𝕜 f) (hg : IsBoundedLinearMap 𝕜 g) :
    IsBoundedLinearMap 𝕜 fun e => f e + g e 
goal: IsBoundedLinearMap 𝕜 fun e => f e + g e

full_name: IsBoundedLinearMap.sub
code: theorem sub (hf : IsBoundedLinearMap 𝕜 f) (hg : IsBoundedLinearMap 𝕜 g) :
    IsBoundedLinearMap 𝕜 fun e => f e - g e 
goal: IsBoundedLinearMap 𝕜 fun e => f e - g e

full_name: IsBoundedLinearMap.comp
code: theorem comp {g : F → G} (hg : IsBoundedLinearMap 𝕜 g) (hf : IsBoundedLinearMap 𝕜 f) :
    IsBoundedLinearMap 𝕜 (g ∘ f) 
goal: IsBoundedLinearMap 𝕜 (g ∘ f)

full_name: IsBoundedLinearMap.tendsto
code: protected theorem tendsto (x : E) (hf : IsBoundedLinearMap 𝕜 f) : Tendsto f (𝓝 x) (𝓝 (f x)) 
goal: Filter.Tendsto f (𝓝 x) (𝓝 (f x))

full_name: IsBoundedLinearMap.continuous
code: theorem continuous (hf : IsBoundedLinearMap 𝕜 f) : Continuous f 
goal: Continuous f

full_name: IsBoundedLinearMap.lim_zero_bounded_linear_map
code: theorem lim_zero_bounded_linear_map (hf : IsBoundedLinearMap 𝕜 f) : Tendsto f (𝓝 0) (𝓝 0) 
goal: Filter.Tendsto f (𝓝 0) (𝓝 0)

full_name: IsBoundedLinearMap.isBigO_id
code: theorem isBigO_id {f : E → F} (h : IsBoundedLinearMap 𝕜 f) (l : Filter E) : f =O[l] fun x => x 
goal: f =O[l] fun x => x

full_name: IsBoundedLinearMap.isBigO_comp
code: theorem isBigO_comp {E : Type*} {g : F → G} (hg : IsBoundedLinearMap 𝕜 g) {f : E → F}
    (l : Filter E) : (fun x' => g (f x')) =O[l] f 
goal: (fun x' => g (f x')) =O[l] f

full_name: IsBoundedLinearMap.isBigO_sub
code: theorem isBigO_sub {f : E → F} (h : IsBoundedLinearMap 𝕜 f) (l : Filter E) (x : E) :
    (fun x' => f (x' - x)) =O[l] fun x' => x' - x 
goal: (fun x' => f (x' - x)) =O[l] fun x' => x' - x

full_name: isBoundedLinearMap_prod_multilinear
code: /-- Taking the cartesian product of two continuous multilinear maps is a bounded linear
operation. -/
theorem isBoundedLinearMap_prod_multilinear {E : ι → Type*} [∀ i, NormedAddCommGroup (E i)]
    [∀ i, NormedSpace 𝕜 (E i)] :
    IsBoundedLinearMap 𝕜 fun p : ContinuousMultilinearMap 𝕜 E F × ContinuousMultilinearMap 𝕜 E G =>
      p.1.prod p.2 
goal: IsBoundedLinearMap 𝕜 fun p => p.1.prod p.2

full_name: isBoundedLinearMap_continuousMultilinearMap_comp_linear
code: /-- Given a fixed continuous linear map `g`, associating to a continuous multilinear map `f` the
continuous multilinear map `f (g m₁, ..., g mₙ)` is a bounded linear operation. -/
theorem isBoundedLinearMap_continuousMultilinearMap_comp_linear (g : G →L[𝕜] E) :
    IsBoundedLinearMap 𝕜 fun f : ContinuousMultilinearMap 𝕜 (fun _ : ι => E) F =>
      f.compContinuousLinearMap fun _ => g 
goal: IsBoundedLinearMap 𝕜 fun f => f.compContinuousLinearMap fun x => g

full_name: ContinuousLinearMap.map_add₂
code: theorem map_add₂ (f : M →SL[ρ₁₂] F →SL[σ₁₂] G') (x x' : M) (y : F) :
    f (x + x') y = f x y + f x' y 
goal: (f (x + x')) y = (f x) y + (f x') y

full_name: ContinuousLinearMap.map_zero₂
code: theorem map_zero₂ (f : M →SL[ρ₁₂] F →SL[σ₁₂] G') (y : F) : f 0 y = 0 
goal: (f 0) y = 0

full_name: ContinuousLinearMap.map_smulₛₗ₂
code: theorem map_smulₛₗ₂ (f : M →SL[ρ₁₂] F →SL[σ₁₂] G') (c : R) (x : M) (y : F) :
    f (c • x) y = ρ₁₂ c • f x y 
goal: (f (c • x)) y = ρ₁₂ c • (f x) y

full_name: ContinuousLinearMap.map_sub₂
code: theorem map_sub₂ (f : M →SL[ρ₁₂] F →SL[σ₁₂] G') (x x' : M) (y : F) :
    f (x - x') y = f x y - f x' y 
goal: (f (x - x')) y = (f x) y - (f x') y

full_name: ContinuousLinearMap.map_neg₂
code: theorem map_neg₂ (f : M →SL[ρ₁₂] F →SL[σ₁₂] G') (x : M) (y : F) : f (-x) y = -f x y 
goal: (f (-x)) y = -(f x) y

full_name: ContinuousLinearMap.map_smul₂
code: theorem map_smul₂ (f : E →L[𝕜] F →L[𝕜] G) (c : 𝕜) (x : E) (y : F) : f (c • x) y = c • f x y 
goal: (f (c • x)) y = c • (f x) y

full_name: IsBoundedBilinearMap.add_right
code: /-- A map `f : E × F → G` satisfies `IsBoundedBilinearMap 𝕜 f` if it is bilinear and
continuous. -/
structure IsBoundedBilinearMap (f : E × F → G) : Prop where
  add_left : ∀ (x₁ x₂ : E) (y : F), f (x₁ + x₂, y) = f (x₁, y) + f (x₂, y)
  smul_left : ∀ (c : 𝕜) (x : E) (y : F), f (c • x, y) = c • f (x, y)
  add_right : ∀ (x : E) (y₁ y₂ : F), f (x, y₁ + y₂) = f (x, y₁) + f (x, y₂)
  smul_right : ∀ (c : 𝕜) (x : E) (y : F), f (x, c • y) = c • f (x, y)
  bound : ∃ C > 0, ∀ (x : E) (y : F), ‖f (x, y)‖ ≤ C * ‖x‖ * ‖y‖
goal: f (x, y₁ + y₂) = f (x, y₁) + f (x, y₂)

full_name: IsBoundedBilinearMap.smul_left
code: /-- A map `f : E × F → G` satisfies `IsBoundedBilinearMap 𝕜 f` if it is bilinear and
continuous. -/
structure IsBoundedBilinearMap (f : E × F → G) : Prop where
  add_left : ∀ (x₁ x₂ : E) (y : F), f (x₁ + x₂, y) = f (x₁, y) + f (x₂, y)
  smul_left : ∀ (c : 𝕜) (x : E) (y : F), f (c • x, y) = c • f (x, y)
  add_right : ∀ (x : E) (y₁ y₂ : F), f (x, y₁ + y₂) = f (x, y₁) + f (x, y₂)
  smul_right : ∀ (c : 𝕜) (x : E) (y : F), f (x, c • y) = c • f (x, y)
  bound : ∃ C > 0, ∀ (x : E) (y : F), ‖f (x, y)‖ ≤ C * ‖x‖ * ‖y‖
goal: f (c • x, y) = c • f (x, y)

full_name: IsBoundedBilinearMap
code: /-- A map `f : E × F → G` satisfies `IsBoundedBilinearMap 𝕜 f` if it is bilinear and
continuous. -/
structure IsBoundedBilinearMap (f : E × F → G) : Prop where
  add_left : ∀ (x₁ x₂ : E) (y : F), f (x₁ + x₂, y) = f (x₁, y) + f (x₂, y)
  smul_left : ∀ (c : 𝕜) (x : E) (y : F), f (c • x, y) = c • f (x, y)
  add_right : ∀ (x : E) (y₁ y₂ : F), f (x, y₁ + y₂) = f (x, y₁) + f (x, y₂)
  smul_right : ∀ (c : 𝕜) (x : E) (y : F), f (x, c • y) = c • f (x, y)
  bound : ∃ C > 0, ∀ (x : E) (y : F), ‖f (x, y)‖ ≤ C * ‖x‖ * ‖y‖
goal: Prop

full_name: IsBoundedBilinearMap.smul_right
code: /-- A map `f : E × F → G` satisfies `IsBoundedBilinearMap 𝕜 f` if it is bilinear and
continuous. -/
structure IsBoundedBilinearMap (f : E × F → G) : Prop where
  add_left : ∀ (x₁ x₂ : E) (y : F), f (x₁ + x₂, y) = f (x₁, y) + f (x₂, y)
  smul_left : ∀ (c : 𝕜) (x : E) (y : F), f (c • x, y) = c • f (x, y)
  add_right : ∀ (x : E) (y₁ y₂ : F), f (x, y₁ + y₂) = f (x, y₁) + f (x, y₂)
  smul_right : ∀ (c : 𝕜) (x : E) (y : F), f (x, c • y) = c • f (x, y)
  bound : ∃ C > 0, ∀ (x : E) (y : F), ‖f (x, y)‖ ≤ C * ‖x‖ * ‖y‖
goal: f (x, c • y) = c • f (x, y)

full_name: IsBoundedBilinearMap.bound
code: /-- A map `f : E × F → G` satisfies `IsBoundedBilinearMap 𝕜 f` if it is bilinear and
continuous. -/
structure IsBoundedBilinearMap (f : E × F → G) : Prop where
  add_left : ∀ (x₁ x₂ : E) (y : F), f (x₁ + x₂, y) = f (x₁, y) + f (x₂, y)
  smul_left : ∀ (c : 𝕜) (x : E) (y : F), f (c • x, y) = c • f (x, y)
  add_right : ∀ (x : E) (y₁ y₂ : F), f (x, y₁ + y₂) = f (x, y₁) + f (x, y₂)
  smul_right : ∀ (c : 𝕜) (x : E) (y : F), f (x, c • y) = c • f (x, y)
  bound : ∃ C > 0, ∀ (x : E) (y : F), ‖f (x, y)‖ ≤ C * ‖x‖ * ‖y‖
goal: ∃ C > 0, ∀ (x : E) (y : F), ‖f (x, y)‖ ≤ C * ‖x‖ * ‖y‖

full_name: IsBoundedBilinearMap.add_left
code: /-- A map `f : E × F → G` satisfies `IsBoundedBilinearMap 𝕜 f` if it is bilinear and
continuous. -/
structure IsBoundedBilinearMap (f : E × F → G) : Prop where
  add_left : ∀ (x₁ x₂ : E) (y : F), f (x₁ + x₂, y) = f (x₁, y) + f (x₂, y)
  smul_left : ∀ (c : 𝕜) (x : E) (y : F), f (c • x, y) = c • f (x, y)
  add_right : ∀ (x : E) (y₁ y₂ : F), f (x, y₁ + y₂) = f (x, y₁) + f (x, y₂)
  smul_right : ∀ (c : 𝕜) (x : E) (y : F), f (x, c • y) = c • f (x, y)
  bound : ∃ C > 0, ∀ (x : E) (y : F), ‖f (x, y)‖ ≤ C * ‖x‖ * ‖y‖
goal: f (x₁ + x₂, y) = f (x₁, y) + f (x₂, y)

full_name: ContinuousLinearMap.isBoundedBilinearMap
code: theorem ContinuousLinearMap.isBoundedBilinearMap (f : E →L[𝕜] F →L[𝕜] G) :
    IsBoundedBilinearMap 𝕜 fun x : E × F => f x.1 x.2 
goal: IsBoundedBilinearMap 𝕜 fun x => (f x.1) x.2

full_name: IsBoundedBilinearMap.toContinuousLinearMap
code: /-- A bounded bilinear map `f : E × F → G` defines a continuous linear map
`f : E →L[𝕜] F →L[𝕜] G`. -/
def IsBoundedBilinearMap.toContinuousLinearMap (hf : IsBoundedBilinearMap 𝕜 f) :
    E →L[𝕜] F →L[𝕜] G 
goal: E →L[𝕜] F →L[𝕜] G

full_name: IsBoundedBilinearMap.isBigO
code: protected theorem IsBoundedBilinearMap.isBigO (h : IsBoundedBilinearMap 𝕜 f) :
    f =O[⊤] fun p : E × F => ‖p.1‖ * ‖p.2‖ 
goal: f =O[⊤] fun p => ‖p.1‖ * ‖p.2‖

full_name: IsBoundedBilinearMap.isBigO_comp
code: theorem IsBoundedBilinearMap.isBigO_comp {α : Type*} (H : IsBoundedBilinearMap 𝕜 f) {g : α → E}
    {h : α → F} {l : Filter α} : (fun x => f (g x, h x)) =O[l] fun x => ‖g x‖ * ‖h x‖ 
goal: (fun x => f (g x, h x)) =O[l] fun x => ‖g x‖ * ‖h x‖

full_name: IsBoundedBilinearMap.isBigO'
code: protected theorem IsBoundedBilinearMap.isBigO' (h : IsBoundedBilinearMap 𝕜 f) :
    f =O[⊤] fun p : E × F => ‖p‖ * ‖p‖ 
goal: f =O[⊤] fun p => ‖p‖ * ‖p‖

full_name: IsBoundedBilinearMap.map_sub_left
code: theorem IsBoundedBilinearMap.map_sub_left (h : IsBoundedBilinearMap 𝕜 f) {x y : E} {z : F} :
    f (x - y, z) = f (x, z) - f (y, z) 
goal: f (x - y, z) = f (x, z) - f (y, z)

full_name: IsBoundedBilinearMap.map_sub_right
code: theorem IsBoundedBilinearMap.map_sub_right (h : IsBoundedBilinearMap 𝕜 f) {x : E} {y z : F} :
    f (x, y - z) = f (x, y) - f (x, z) 
goal: f (x, y - z) = f (x, y) - f (x, z)

full_name: IsBoundedBilinearMap.continuous
code: /-- Useful to use together with `Continuous.comp₂`. -/
theorem IsBoundedBilinearMap.continuous (h : IsBoundedBilinearMap 𝕜 f) : Continuous f 
goal: Continuous f

full_name: IsBoundedBilinearMap.continuous_left
code: theorem IsBoundedBilinearMap.continuous_left (h : IsBoundedBilinearMap 𝕜 f) {e₂ : F} :
    Continuous fun e₁ => f (e₁, e₂) 
goal: Continuous fun e₁ => f (e₁, e₂)

full_name: IsBoundedBilinearMap.continuous_right
code: theorem IsBoundedBilinearMap.continuous_right (h : IsBoundedBilinearMap 𝕜 f) {e₁ : E} :
    Continuous fun e₂ => f (e₁, e₂) 
goal: Continuous fun e₂ => f (e₁, e₂)

full_name: ContinuousLinearMap.continuous₂
code: /-- Useful to use together with `Continuous.comp₂`. -/
theorem ContinuousLinearMap.continuous₂ (f : E →L[𝕜] F →L[𝕜] G) :
    Continuous (Function.uncurry fun x y => f x y) 
goal: Continuous (Function.uncurry fun x y => (f x) y)

full_name: IsBoundedBilinearMap.isBoundedLinearMap_left
code: theorem IsBoundedBilinearMap.isBoundedLinearMap_left (h : IsBoundedBilinearMap 𝕜 f) (y : F) :
    IsBoundedLinearMap 𝕜 fun x => f (x, y) 
goal: IsBoundedLinearMap 𝕜 fun x => f (x, y)

full_name: IsBoundedBilinearMap.isBoundedLinearMap_right
code: theorem IsBoundedBilinearMap.isBoundedLinearMap_right (h : IsBoundedBilinearMap 𝕜 f) (x : E) :
    IsBoundedLinearMap 𝕜 fun y => f (x, y) 
goal: IsBoundedLinearMap 𝕜 fun y => f (x, y)

full_name: isBoundedBilinearMap_smul
code: theorem isBoundedBilinearMap_smul {𝕜' : Type*} [NormedField 𝕜'] [NormedAlgebra 𝕜 𝕜'] {E : Type*}
    [NormedAddCommGroup E] [NormedSpace 𝕜 E] [NormedSpace 𝕜' E] [IsScalarTower 𝕜 𝕜' E] :
    IsBoundedBilinearMap 𝕜 fun p : 𝕜' × E => p.1 • p.2 
goal: IsBoundedBilinearMap 𝕜 fun p => p.1 • p.2

full_name: isBoundedBilinearMap_mul
code: theorem isBoundedBilinearMap_mul : IsBoundedBilinearMap 𝕜 fun p : 𝕜 × 𝕜 => p.1 * p.2 
goal: IsBoundedBilinearMap 𝕜 fun p => p.1 * p.2

full_name: isBoundedBilinearMap_comp
code: theorem isBoundedBilinearMap_comp :
    IsBoundedBilinearMap 𝕜 fun p : (F →L[𝕜] G) × (E →L[𝕜] F) => p.1.comp p.2 
goal: IsBoundedBilinearMap 𝕜 fun p => p.1.comp p.2

full_name: ContinuousLinearMap.isBoundedLinearMap_comp_left
code: theorem ContinuousLinearMap.isBoundedLinearMap_comp_left (g : F →L[𝕜] G) :
    IsBoundedLinearMap 𝕜 fun f : E →L[𝕜] F => ContinuousLinearMap.comp g f 
goal: IsBoundedLinearMap 𝕜 fun f => g.comp f

full_name: ContinuousLinearMap.isBoundedLinearMap_comp_right
code: theorem ContinuousLinearMap.isBoundedLinearMap_comp_right (f : E →L[𝕜] F) :
    IsBoundedLinearMap 𝕜 fun g : F →L[𝕜] G => ContinuousLinearMap.comp g f 
goal: IsBoundedLinearMap 𝕜 fun g => g.comp f

full_name: isBoundedBilinearMap_apply
code: theorem isBoundedBilinearMap_apply : IsBoundedBilinearMap 𝕜 fun p : (E →L[𝕜] F) × E => p.1 p.2 
goal: IsBoundedBilinearMap 𝕜 fun p => p.1 p.2

full_name: isBoundedBilinearMap_smulRight
code: /-- The function `ContinuousLinearMap.smulRight`, associating to a continuous linear map
`f : E → 𝕜` and a scalar `c : F` the tensor product `f ⊗ c` as a continuous linear map from `E` to
`F`, is a bounded bilinear map. -/
theorem isBoundedBilinearMap_smulRight :
    IsBoundedBilinearMap 𝕜 fun p =>
      (ContinuousLinearMap.smulRight : (E →L[𝕜] 𝕜) → F → E →L[𝕜] F) p.1 p.2 
goal: IsBoundedBilinearMap 𝕜 fun p => p.1.smulRight p.2

full_name: isBoundedBilinearMap_compMultilinear
code: /-- The composition of a continuous linear map with a continuous multilinear map is a bounded
bilinear operation. -/
theorem isBoundedBilinearMap_compMultilinear {ι : Type*} {E : ι → Type*} [Fintype ι]
    [∀ i, NormedAddCommGroup (E i)] [∀ i, NormedSpace 𝕜 (E i)] :
    IsBoundedBilinearMap 𝕜 fun p : (F →L[𝕜] G) × ContinuousMultilinearMap 𝕜 E F =>
      p.1.compContinuousMultilinearMap p.2 
goal: IsBoundedBilinearMap 𝕜 fun p => p.1.compContinuousMultilinearMap p.2

full_name: IsBoundedBilinearMap.linearDeriv
code: /-- Definition of the derivative of a bilinear map `f`, given at a point `p` by
`q ↦ f(p.1, q.2) + f(q.1, p.2)` as in the standard formula for the derivative of a product.
We define this function here as a linear map `E × F →ₗ[𝕜] G`, then `IsBoundedBilinearMap.deriv`
strengthens it to a continuous linear map `E × F →L[𝕜] G`.
-/
def IsBoundedBilinearMap.linearDeriv (h : IsBoundedBilinearMap 𝕜 f) (p : E × F) : E × F →ₗ[𝕜] G 
goal: E × F →ₗ[𝕜] G

full_name: IsBoundedBilinearMap.deriv
code: /-- The derivative of a bounded bilinear map at a point `p : E × F`, as a continuous linear map
from `E × F` to `G`. The statement that this is indeed the derivative of `f` is
`IsBoundedBilinearMap.hasFDerivAt` in `Analysis.Calculus.FDeriv`. -/
def IsBoundedBilinearMap.deriv (h : IsBoundedBilinearMap 𝕜 f) (p : E × F) : E × F →L[𝕜] G 
goal: E × F →L[𝕜] G

full_name: IsBoundedBilinearMap.deriv_apply
code: @[simp]
theorem IsBoundedBilinearMap.deriv_apply (h : IsBoundedBilinearMap 𝕜 f) (p q : E × F) :
    h.deriv p q = f (p.1, q.2) + f (q.1, p.2) 
goal: (h.deriv p) q = f (p.1, q.2) + f (q.1, p.2)

full_name: ContinuousLinearMap.mulLeftRight_isBoundedBilinear
code: /-- The function `ContinuousLinearMap.mulLeftRight : 𝕜' × 𝕜' → (𝕜' →L[𝕜] 𝕜')` is a bounded
bilinear map. -/
theorem ContinuousLinearMap.mulLeftRight_isBoundedBilinear (𝕜' : Type*) [NormedRing 𝕜']
    [NormedAlgebra 𝕜 𝕜'] :
    IsBoundedBilinearMap 𝕜 fun p : 𝕜' × 𝕜' => ContinuousLinearMap.mulLeftRight 𝕜 𝕜' p.1 p.2 
goal: IsBoundedBilinearMap 𝕜 fun p => ((ContinuousLinearMap.mulLeftRight 𝕜 𝕜') p.1) p.2

full_name: IsBoundedBilinearMap.isBoundedLinearMap_deriv
code: /-- Given a bounded bilinear map `f`, the map associating to a point `p` the derivative of `f` at
`p` is itself a bounded linear map. -/
theorem IsBoundedBilinearMap.isBoundedLinearMap_deriv (h : IsBoundedBilinearMap 𝕜 f) :
    IsBoundedLinearMap 𝕜 fun p : E × F => h.deriv p 
goal: IsBoundedLinearMap 𝕜 fun p => h.deriv p

full_name: Continuous.clm_comp
code: @[continuity, fun_prop]
theorem Continuous.clm_comp {X} [TopologicalSpace X] {g : X → F →L[𝕜] G} {f : X → E →L[𝕜] F}
    (hg : Continuous g) (hf : Continuous f) : Continuous fun x => (g x).comp (f x) 
goal: Continuous fun x => (g x).comp (f x)

full_name: ContinuousOn.clm_comp
code: theorem ContinuousOn.clm_comp {X} [TopologicalSpace X] {g : X → F →L[𝕜] G} {f : X → E →L[𝕜] F}
    {s : Set X} (hg : ContinuousOn g s) (hf : ContinuousOn f s) :
    ContinuousOn (fun x => (g x).comp (f x)) s 
goal: ContinuousOn (fun x => (g x).comp (f x)) s

full_name: Continuous.clm_apply
code: @[continuity, fun_prop]
theorem Continuous.clm_apply {X} [TopologicalSpace X] {f : X → (E →L[𝕜] F)} {g : X → E}
    (hf : Continuous f) (hg : Continuous g) : Continuous (fun x ↦ (f x) (g x)) 
goal: Continuous fun x => (f x) (g x)

full_name: ContinuousOn.clm_apply
code: theorem ContinuousOn.clm_apply {X} [TopologicalSpace X] {f : X → (E →L[𝕜] F)} {g : X → E}
    {s : Set X} (hf : ContinuousOn f s) (hg : ContinuousOn g s) :
    ContinuousOn (fun x ↦ f x (g x)) s 
goal: ContinuousOn (fun x => (f x) (g x)) s

full_name: ContinuousLinearEquiv.isOpen
code: protected theorem isOpen [CompleteSpace E] : IsOpen (range ((↑) : (E ≃L[𝕜] F) → E →L[𝕜] F)) 
goal: IsOpen (Set.range ContinuousLinearEquiv.toContinuousLinearMap)

full_name: ContinuousLinearEquiv.nhds
code: protected theorem nhds [CompleteSpace E] (e : E ≃L[𝕜] F) :
    range ((↑) : (E ≃L[𝕜] F) → E →L[𝕜] F) ∈ 𝓝 (e : E →L[𝕜] F) 
goal: Set.range ContinuousLinearEquiv.toContinuousLinearMap ∈ 𝓝 ↑e