File: Mathlib/Analysis/Analytic/Linear.lean

full_name: ContinuousLinearMap.fpowerSeries_radius
code: @[simp]
theorem fpowerSeries_radius (f : E →L[𝕜] F) (x : E) : (f.fpowerSeries x).radius = ∞ 
goal: (f.fpowerSeries x).radius = ⊤

full_name: ContinuousLinearMap.hasFPowerSeriesOnBall
code: protected theorem hasFPowerSeriesOnBall (f : E →L[𝕜] F) (x : E) :
    HasFPowerSeriesOnBall f (f.fpowerSeries x) x ∞ 
goal: HasFPowerSeriesOnBall (⇑f) (f.fpowerSeries x) x ⊤

full_name: ContinuousLinearMap.hasFPowerSeriesAt
code: protected theorem hasFPowerSeriesAt (f : E →L[𝕜] F) (x : E) :
    HasFPowerSeriesAt f (f.fpowerSeries x) x 
goal: HasFPowerSeriesAt (⇑f) (f.fpowerSeries x) x

full_name: ContinuousLinearMap.analyticAt
code: protected theorem analyticAt (f : E →L[𝕜] F) (x : E) : AnalyticAt 𝕜 f x 
goal: AnalyticAt 𝕜 (⇑f) x

full_name: ContinuousLinearMap.uncurryBilinear
code: /-- Reinterpret a bilinear map `f : E →L[𝕜] F →L[𝕜] G` as a multilinear map
`(E × F) [×2]→L[𝕜] G`. This multilinear map is the second term in the formal
multilinear series expansion of `uncurry f`. It is given by
`f.uncurryBilinear ![(x, y), (x', y')] = f x y'`. -/
def uncurryBilinear (f : E →L[𝕜] F →L[𝕜] G) : E × F[×2]→L[𝕜] G 
goal: ContinuousMultilinearMap 𝕜 (fun i => E × F) G

full_name: ContinuousLinearMap.uncurryBilinear_apply
code: @[simp]
theorem uncurryBilinear_apply (f : E →L[𝕜] F →L[𝕜] G) (m : Fin 2 → E × F) :
    f.uncurryBilinear m = f (m 0).1 (m 1).2 
goal: f.uncurryBilinear m = (f (m 0).1) (m 1).2

full_name: ContinuousLinearMap.fpowerSeriesBilinear
code: /-- Formal multilinear series expansion of a bilinear function `f : E →L[𝕜] F →L[𝕜] G`. -/
def fpowerSeriesBilinear (f : E →L[𝕜] F →L[𝕜] G) (x : E × F) : FormalMultilinearSeries 𝕜 (E × F) G
  
goal: FormalMultilinearSeries 𝕜 (E × F) G

full_name: ContinuousLinearMap.fpowerSeriesBilinear_apply_zero
code: theorem fpowerSeriesBilinear_apply_zero (f : E →L[𝕜] F →L[𝕜] G) (x : E × F) :
    fpowerSeriesBilinear f x 0 = ContinuousMultilinearMap.curry0 𝕜 _ (f x.1 x.2) 
goal: f.fpowerSeriesBilinear x 0 = ContinuousMultilinearMap.curry0 𝕜 (E × F) ((f x.1) x.2)

full_name: ContinuousLinearMap.fpowerSeriesBilinear_apply_one
code: theorem fpowerSeriesBilinear_apply_one (f : E →L[𝕜] F →L[𝕜] G) (x : E × F) :
    fpowerSeriesBilinear f x 1 = (continuousMultilinearCurryFin1 𝕜 (E × F) G).symm (f.deriv₂ x) 
goal: f.fpowerSeriesBilinear x 1 = (continuousMultilinearCurryFin1 𝕜 (E × F) G).symm (f.deriv₂ x)

full_name: ContinuousLinearMap.fpowerSeriesBilinear_apply_two
code: theorem fpowerSeriesBilinear_apply_two (f : E →L[𝕜] F →L[𝕜] G) (x : E × F) :
    fpowerSeriesBilinear f x 2 = f.uncurryBilinear 
goal: f.fpowerSeriesBilinear x 2 = f.uncurryBilinear

full_name: ContinuousLinearMap.fpowerSeriesBilinear_apply_add_three
code: theorem fpowerSeriesBilinear_apply_add_three (f : E →L[𝕜] F →L[𝕜] G) (x : E × F) (n) :
    fpowerSeriesBilinear f x (n + 3) = 0 
goal: f.fpowerSeriesBilinear x (n + 3) = 0

full_name: ContinuousLinearMap.fpowerSeriesBilinear_radius
code: @[simp]
theorem fpowerSeriesBilinear_radius (f : E →L[𝕜] F →L[𝕜] G) (x : E × F) :
    (f.fpowerSeriesBilinear x).radius = ∞ 
goal: (f.fpowerSeriesBilinear x).radius = ⊤

full_name: ContinuousLinearMap.hasFPowerSeriesOnBall_bilinear
code: protected theorem hasFPowerSeriesOnBall_bilinear (f : E →L[𝕜] F →L[𝕜] G) (x : E × F) :
    HasFPowerSeriesOnBall (fun x : E × F => f x.1 x.2) (f.fpowerSeriesBilinear x) x ∞ 
goal: HasFPowerSeriesOnBall (fun x => (f x.1) x.2) (f.fpowerSeriesBilinear x) x ⊤

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

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

full_name: analyticAt_id
code: lemma analyticAt_id (z : E) : AnalyticAt 𝕜 (id : E → E) z 
goal: AnalyticAt 𝕜 id z

full_name: analyticOn_id
code: /-- `id` is entire -/
theorem analyticOn_id {s : Set E} : AnalyticOn 𝕜 (fun x : E ↦ x) s 
goal: AnalyticOn 𝕜 (fun x => x) s

full_name: analyticAt_fst
code: /-- `fst` is analytic -/
theorem analyticAt_fst {p : E × F} : AnalyticAt 𝕜 (fun p : E × F ↦ p.fst) p 
goal: AnalyticAt 𝕜 (fun p => p.1) p

full_name: analyticAt_snd
code: /-- `snd` is analytic -/
theorem analyticAt_snd {p : E × F} : AnalyticAt 𝕜 (fun p : E × F ↦ p.snd) p 
goal: AnalyticAt 𝕜 (fun p => p.2) p

full_name: analyticOn_fst
code: /-- `fst` is entire -/
theorem analyticOn_fst {s : Set (E × F)} : AnalyticOn 𝕜 (fun p : E × F ↦ p.fst) s 
goal: AnalyticOn 𝕜 (fun p => p.1) s

full_name: analyticOn_snd
code: /-- `snd` is entire -/
theorem analyticOn_snd {s : Set (E × F)} : AnalyticOn 𝕜 (fun p : E × F ↦ p.snd) s 
goal: AnalyticOn 𝕜 (fun p => p.2) s