File: Mathlib/Analysis/NormedSpace/ContinuousAffineMap.lean

full_name: ContinuousAffineMap.contLinear
code: /-- The linear map underlying a continuous affine map is continuous. -/
def contLinear (f : P →ᴬ[R] Q) : V →L[R] W 
goal: V →L[R] W

full_name: ContinuousAffineMap.coe_contLinear
code: @[simp]
theorem coe_contLinear (f : P →ᴬ[R] Q) : (f.contLinear : V → W) = f.linear 
goal: ⇑f.contLinear = ⇑f.linear

full_name: ContinuousAffineMap.coe_contLinear_eq_linear
code: @[simp]
theorem coe_contLinear_eq_linear (f : P →ᴬ[R] Q) :
    (f.contLinear : V →ₗ[R] W) = (f : P →ᵃ[R] Q).linear 
goal: ↑f.contLinear = f.linear

full_name: ContinuousAffineMap.coe_mk_const_linear_eq_linear
code: @[simp]
theorem coe_mk_const_linear_eq_linear (f : P →ᵃ[R] Q) (h) :
    ((⟨f, h⟩ : P →ᴬ[R] Q).contLinear : V → W) = f.linear 
goal: ⇑{ toAffineMap := f, cont := h }.contLinear = ⇑f.linear

full_name: ContinuousAffineMap.coe_linear_eq_coe_contLinear
code: theorem coe_linear_eq_coe_contLinear (f : P →ᴬ[R] Q) :
    ((f : P →ᵃ[R] Q).linear : V → W) = (⇑f.contLinear : V → W) 
goal: ⇑f.linear = ⇑f.contLinear

full_name: ContinuousAffineMap.comp_contLinear
code: @[simp]
theorem comp_contLinear (f : P →ᴬ[R] Q) (g : Q →ᴬ[R] Q₂) :
    (g.comp f).contLinear = g.contLinear.comp f.contLinear 
goal: (g.comp f).contLinear = g.contLinear.comp f.contLinear

full_name: ContinuousAffineMap.map_vadd
code: @[simp]
theorem map_vadd (f : P →ᴬ[R] Q) (p : P) (v : V) : f (v +ᵥ p) = f.contLinear v +ᵥ f p 
goal: f (v +ᵥ p) = f.contLinear v +ᵥ f p

full_name: ContinuousAffineMap.contLinear_map_vsub
code: @[simp]
theorem contLinear_map_vsub (f : P →ᴬ[R] Q) (p₁ p₂ : P) : f.contLinear (p₁ -ᵥ p₂) = f p₁ -ᵥ f p₂ 
goal: f.contLinear (p₁ -ᵥ p₂) = f p₁ -ᵥ f p₂

full_name: ContinuousAffineMap.const_contLinear
code: @[simp]
theorem const_contLinear (q : Q) : (const R P q).contLinear = 0 
goal: (ContinuousAffineMap.const R P q).contLinear = 0

full_name: ContinuousAffineMap.contLinear_eq_zero_iff_exists_const
code: theorem contLinear_eq_zero_iff_exists_const (f : P →ᴬ[R] Q) :
    f.contLinear = 0 ↔ ∃ q, f = const R P q 
goal: f.contLinear = 0 ↔ ∃ q, f = ContinuousAffineMap.const R P q

full_name: ContinuousAffineMap.to_affine_map_contLinear
code: @[simp]
theorem to_affine_map_contLinear (f : V →L[R] W) : f.toContinuousAffineMap.contLinear = f 
goal: f.toContinuousAffineMap.contLinear = f

full_name: ContinuousAffineMap.zero_contLinear
code: @[simp]
theorem zero_contLinear : (0 : P →ᴬ[R] W).contLinear = 0 
goal: ContinuousAffineMap.contLinear 0 = 0

full_name: ContinuousAffineMap.add_contLinear
code: @[simp]
theorem add_contLinear (f g : P →ᴬ[R] W) : (f + g).contLinear = f.contLinear + g.contLinear 
goal: (f + g).contLinear = f.contLinear + g.contLinear

full_name: ContinuousAffineMap.sub_contLinear
code: @[simp]
theorem sub_contLinear (f g : P →ᴬ[R] W) : (f - g).contLinear = f.contLinear - g.contLinear 
goal: (f - g).contLinear = f.contLinear - g.contLinear

full_name: ContinuousAffineMap.neg_contLinear
code: @[simp]
theorem neg_contLinear (f : P →ᴬ[R] W) : (-f).contLinear = -f.contLinear 
goal: (-f).contLinear = -f.contLinear

full_name: ContinuousAffineMap.smul_contLinear
code: @[simp]
theorem smul_contLinear (t : R) (f : P →ᴬ[R] W) : (t • f).contLinear = t • f.contLinear 
goal: (t • f).contLinear = t • f.contLinear

full_name: ContinuousAffineMap.decomp
code: theorem decomp (f : V →ᴬ[R] W) : (f : V → W) = f.contLinear + Function.const V (f 0) 
goal: ⇑f = ⇑f.contLinear + Function.const V (f 0)

full_name: ContinuousAffineMap.hasNorm
code: /-- Note that unlike the operator norm for linear maps, this norm is _not_ submultiplicative:
we do _not_ necessarily have `‖f.comp g‖ ≤ ‖f‖ * ‖g‖`. See `norm_comp_le` for what we can say. -/
noncomputable instance hasNorm : Norm (V →ᴬ[𝕜] W) 
goal: Norm (V →ᴬ[𝕜] W)

full_name: ContinuousAffineMap.norm_def
code: theorem norm_def : ‖f‖ = max ‖f 0‖ ‖f.contLinear‖ 
goal: ‖f‖ = max ‖f 0‖ ‖f.contLinear‖

full_name: ContinuousAffineMap.norm_contLinear_le
code: theorem norm_contLinear_le : ‖f.contLinear‖ ≤ ‖f‖ 
goal: ‖f.contLinear‖ ≤ ‖f‖

full_name: ContinuousAffineMap.norm_image_zero_le
code: theorem norm_image_zero_le : ‖f 0‖ ≤ ‖f‖ 
goal: ‖f 0‖ ≤ ‖f‖

full_name: ContinuousAffineMap.norm_eq
code: @[simp]
theorem norm_eq (h : f 0 = 0) : ‖f‖ = ‖f.contLinear‖ 
goal: ‖f‖ = ‖f.contLinear‖

full_name: ContinuousAffineMap.instNormedAddCommGroup
code: noncomputable instance : NormedAddCommGroup (V →ᴬ[𝕜] W) 
goal: NormedAddCommGroup (V →ᴬ[𝕜] W)

full_name: ContinuousAffineMap.instNormedSpace
code: instance : NormedSpace 𝕜 (V →ᴬ[𝕜] W) 
goal: NormedSpace 𝕜 (V →ᴬ[𝕜] W)

full_name: ContinuousAffineMap.norm_comp_le
code: theorem norm_comp_le (g : W₂ →ᴬ[𝕜] V) : ‖f.comp g‖ ≤ ‖f‖ * ‖g‖ + ‖f 0‖ 
goal: ‖f.comp g‖ ≤ ‖f‖ * ‖g‖ + ‖f 0‖

full_name: ContinuousAffineMap.toConstProdContinuousLinearMap
code: /-- The space of affine maps between two normed spaces is linearly isometric to the product of the
codomain with the space of linear maps, by taking the value of the affine map at `(0 : V)` and the
linear part. -/
def toConstProdContinuousLinearMap : (V →ᴬ[𝕜] W) ≃ₗᵢ[𝕜] W × (V →L[𝕜] W) 
goal: (V →ᴬ[𝕜] W) ≃ₗᵢ[𝕜] W × (V →L[𝕜] W)

full_name: ContinuousAffineMap.toConstProdContinuousLinearMap_fst
code: @[simp]
theorem toConstProdContinuousLinearMap_fst (f : V →ᴬ[𝕜] W) :
    (toConstProdContinuousLinearMap 𝕜 V W f).fst = f 0 
goal: ((ContinuousAffineMap.toConstProdContinuousLinearMap 𝕜 V W) f).1 = f 0

full_name: ContinuousAffineMap.toConstProdContinuousLinearMap_snd
code: @[simp]
theorem toConstProdContinuousLinearMap_snd (f : V →ᴬ[𝕜] W) :
    (toConstProdContinuousLinearMap 𝕜 V W f).snd = f.contLinear 
goal: ((ContinuousAffineMap.toConstProdContinuousLinearMap 𝕜 V W) f).2 = f.contLinear