File: Mathlib/Analysis/NormedSpace/Exponential.lean

full_name: NormedSpace.expSeries
code: /-- `expSeries 𝕂 𝔸` is the `FormalMultilinearSeries` whose `n`-th term is the map
`(xᵢ) : 𝔸ⁿ ↦ (1/n! : 𝕂) • ∏ xᵢ`. Its sum is the exponential map `exp 𝕂 : 𝔸 → 𝔸`. -/
def expSeries : FormalMultilinearSeries 𝕂 𝔸 𝔸 
goal: FormalMultilinearSeries 𝕂 𝔸 𝔸

full_name: NormedSpace.exp
code: /-- `exp 𝕂 : 𝔸 → 𝔸` is the exponential map determined by the action of `𝕂` on `𝔸`.
It is defined as the sum of the `FormalMultilinearSeries` `expSeries 𝕂 𝔸`.

Note that when `𝔸 = Matrix n n 𝕂`, this is the **Matrix Exponential**; see
[`Analysis.NormedSpace.MatrixExponential`](./MatrixExponential) for lemmas specific to that
case. -/
noncomputable def exp (x : 𝔸) : 𝔸 
goal: 𝔸

full_name: NormedSpace.expSeries_apply_eq
code: theorem expSeries_apply_eq (x : 𝔸) (n : ℕ) :
    (expSeries 𝕂 𝔸 n fun _ => x) = (n !⁻¹ : 𝕂) • x ^ n 
goal: ((NormedSpace.expSeries 𝕂 𝔸 n) fun x_1 => x) = (↑n.factorial)⁻¹ • x ^ n

full_name: NormedSpace.expSeries_apply_eq'
code: theorem expSeries_apply_eq' (x : 𝔸) :
    (fun n => expSeries 𝕂 𝔸 n fun _ => x) = fun n => (n !⁻¹ : 𝕂) • x ^ n 
goal: (fun n => (NormedSpace.expSeries 𝕂 𝔸 n) fun x_1 => x) = fun n => (↑n.factorial)⁻¹ • x ^ n

full_name: NormedSpace.expSeries_sum_eq
code: theorem expSeries_sum_eq (x : 𝔸) : (expSeries 𝕂 𝔸).sum x = ∑' n : ℕ, (n !⁻¹ : 𝕂) • x ^ n 
goal: (NormedSpace.expSeries 𝕂 𝔸).sum x = ∑' (n : ℕ), (↑n.factorial)⁻¹ • x ^ n

full_name: NormedSpace.exp_eq_tsum
code: theorem exp_eq_tsum : exp 𝕂 = fun x : 𝔸 => ∑' n : ℕ, (n !⁻¹ : 𝕂) • x ^ n 
goal: NormedSpace.exp 𝕂 = fun x => ∑' (n : ℕ), (↑n.factorial)⁻¹ • x ^ n

full_name: NormedSpace.expSeries_apply_zero
code: theorem expSeries_apply_zero (n : ℕ) :
    (expSeries 𝕂 𝔸 n fun _ => (0 : 𝔸)) = Pi.single (f := fun _ => 𝔸) 0 1 n 
goal: ((NormedSpace.expSeries 𝕂 𝔸 n) fun x => 0) = Pi.single 0 1 n

full_name: NormedSpace.exp_zero
code: @[simp]
theorem exp_zero : exp 𝕂 (0 : 𝔸) = 1 
goal: NormedSpace.exp 𝕂 0 = 1

full_name: NormedSpace.exp_op
code: @[simp]
theorem exp_op [T2Space 𝔸] (x : 𝔸) : exp 𝕂 (MulOpposite.op x) = MulOpposite.op (exp 𝕂 x) 
goal: NormedSpace.exp 𝕂 (MulOpposite.op x) = MulOpposite.op (NormedSpace.exp 𝕂 x)

full_name: NormedSpace.exp_unop
code: @[simp]
theorem exp_unop [T2Space 𝔸] (x : 𝔸ᵐᵒᵖ) :
    exp 𝕂 (MulOpposite.unop x) = MulOpposite.unop (exp 𝕂 x) 
goal: NormedSpace.exp 𝕂 (MulOpposite.unop x) = MulOpposite.unop (NormedSpace.exp 𝕂 x)

full_name: NormedSpace.star_exp
code: theorem star_exp [T2Space 𝔸] [StarRing 𝔸] [ContinuousStar 𝔸] (x : 𝔸) :
    star (exp 𝕂 x) = exp 𝕂 (star x) 
goal: star (NormedSpace.exp 𝕂 x) = NormedSpace.exp 𝕂 (star x)

full_name: IsSelfAdjoint.exp
code: theorem _root_.IsSelfAdjoint.exp [T2Space 𝔸] [StarRing 𝔸] [ContinuousStar 𝔸] {x : 𝔸}
    (h : IsSelfAdjoint x) : IsSelfAdjoint (exp 𝕂 x) 
goal: IsSelfAdjoint (NormedSpace.exp 𝕂 x)

full_name: Commute.exp_right
code: theorem _root_.Commute.exp_right [T2Space 𝔸] {x y : 𝔸} (h : Commute x y) :
    Commute x (exp 𝕂 y) 
goal: Commute x (NormedSpace.exp 𝕂 y)

full_name: Commute.exp_left
code: theorem _root_.Commute.exp_left [T2Space 𝔸] {x y : 𝔸} (h : Commute x y) : Commute (exp 𝕂 x) y 
goal: Commute (NormedSpace.exp 𝕂 x) y

full_name: Commute.exp
code: theorem _root_.Commute.exp [T2Space 𝔸] {x y : 𝔸} (h : Commute x y) : Commute (exp 𝕂 x) (exp 𝕂 y) 
goal: Commute (NormedSpace.exp 𝕂 x) (NormedSpace.exp 𝕂 y)

full_name: NormedSpace.expSeries_apply_eq_div
code: theorem expSeries_apply_eq_div (x : 𝔸) (n : ℕ) : (expSeries 𝕂 𝔸 n fun _ => x) = x ^ n / n ! 
goal: ((NormedSpace.expSeries 𝕂 𝔸 n) fun x_1 => x) = x ^ n / ↑n.factorial

full_name: NormedSpace.expSeries_apply_eq_div'
code: theorem expSeries_apply_eq_div' (x : 𝔸) :
    (fun n => expSeries 𝕂 𝔸 n fun _ => x) = fun n => x ^ n / n ! 
goal: (fun n => (NormedSpace.expSeries 𝕂 𝔸 n) fun x_1 => x) = fun n => x ^ n / ↑n.factorial

full_name: NormedSpace.expSeries_sum_eq_div
code: theorem expSeries_sum_eq_div (x : 𝔸) : (expSeries 𝕂 𝔸).sum x = ∑' n : ℕ, x ^ n / n ! 
goal: (NormedSpace.expSeries 𝕂 𝔸).sum x = ∑' (n : ℕ), x ^ n / ↑n.factorial

full_name: NormedSpace.exp_eq_tsum_div
code: theorem exp_eq_tsum_div : exp 𝕂 = fun x : 𝔸 => ∑' n : ℕ, x ^ n / n ! 
goal: NormedSpace.exp 𝕂 = fun x => ∑' (n : ℕ), x ^ n / ↑n.factorial

full_name: NormedSpace.norm_expSeries_summable_of_mem_ball
code: theorem norm_expSeries_summable_of_mem_ball (x : 𝔸)
    (hx : x ∈ EMetric.ball (0 : 𝔸) (expSeries 𝕂 𝔸).radius) :
    Summable fun n => ‖expSeries 𝕂 𝔸 n fun _ => x‖ 
goal: Summable fun n => ‖(NormedSpace.expSeries 𝕂 𝔸 n) fun x_1 => x‖

full_name: NormedSpace.norm_expSeries_summable_of_mem_ball'
code: theorem norm_expSeries_summable_of_mem_ball' (x : 𝔸)
    (hx : x ∈ EMetric.ball (0 : 𝔸) (expSeries 𝕂 𝔸).radius) :
    Summable fun n => ‖(n !⁻¹ : 𝕂) • x ^ n‖ 
goal: Summable fun n => ‖(↑n.factorial)⁻¹ • x ^ n‖

full_name: NormedSpace.expSeries_summable_of_mem_ball
code: theorem expSeries_summable_of_mem_ball (x : 𝔸)
    (hx : x ∈ EMetric.ball (0 : 𝔸) (expSeries 𝕂 𝔸).radius) :
    Summable fun n => expSeries 𝕂 𝔸 n fun _ => x 
goal: Summable fun n => (NormedSpace.expSeries 𝕂 𝔸 n) fun x_1 => x

full_name: NormedSpace.expSeries_summable_of_mem_ball'
code: theorem expSeries_summable_of_mem_ball' (x : 𝔸)
    (hx : x ∈ EMetric.ball (0 : 𝔸) (expSeries 𝕂 𝔸).radius) :
    Summable fun n => (n !⁻¹ : 𝕂) • x ^ n 
goal: Summable fun n => (↑n.factorial)⁻¹ • x ^ n

full_name: NormedSpace.expSeries_hasSum_exp_of_mem_ball
code: theorem expSeries_hasSum_exp_of_mem_ball (x : 𝔸)
    (hx : x ∈ EMetric.ball (0 : 𝔸) (expSeries 𝕂 𝔸).radius) :
    HasSum (fun n => expSeries 𝕂 𝔸 n fun _ => x) (exp 𝕂 x) 
goal: HasSum (fun n => (NormedSpace.expSeries 𝕂 𝔸 n) fun x_1 => x) (NormedSpace.exp 𝕂 x)

full_name: NormedSpace.expSeries_hasSum_exp_of_mem_ball'
code: theorem expSeries_hasSum_exp_of_mem_ball' (x : 𝔸)
    (hx : x ∈ EMetric.ball (0 : 𝔸) (expSeries 𝕂 𝔸).radius) :
    HasSum (fun n => (n !⁻¹ : 𝕂) • x ^ n) (exp 𝕂 x) 
goal: HasSum (fun n => (↑n.factorial)⁻¹ • x ^ n) (NormedSpace.exp 𝕂 x)

full_name: NormedSpace.hasFPowerSeriesOnBall_exp_of_radius_pos
code: theorem hasFPowerSeriesOnBall_exp_of_radius_pos (h : 0 < (expSeries 𝕂 𝔸).radius) :
    HasFPowerSeriesOnBall (exp 𝕂) (expSeries 𝕂 𝔸) 0 (expSeries 𝕂 𝔸).radius 
goal: HasFPowerSeriesOnBall (NormedSpace.exp 𝕂) (NormedSpace.expSeries 𝕂 𝔸) 0 (NormedSpace.expSeries 𝕂 𝔸).radius

full_name: NormedSpace.hasFPowerSeriesAt_exp_zero_of_radius_pos
code: theorem hasFPowerSeriesAt_exp_zero_of_radius_pos (h : 0 < (expSeries 𝕂 𝔸).radius) :
    HasFPowerSeriesAt (exp 𝕂) (expSeries 𝕂 𝔸) 0 
goal: HasFPowerSeriesAt (NormedSpace.exp 𝕂) (NormedSpace.expSeries 𝕂 𝔸) 0

full_name: NormedSpace.continuousOn_exp
code: theorem continuousOn_exp : ContinuousOn (exp 𝕂 : 𝔸 → 𝔸) (EMetric.ball 0 (expSeries 𝕂 𝔸).radius) 
goal: ContinuousOn (NormedSpace.exp 𝕂) (EMetric.ball 0 (NormedSpace.expSeries 𝕂 𝔸).radius)

full_name: NormedSpace.analyticAt_exp_of_mem_ball
code: theorem analyticAt_exp_of_mem_ball (x : 𝔸) (hx : x ∈ EMetric.ball (0 : 𝔸) (expSeries 𝕂 𝔸).radius) :
    AnalyticAt 𝕂 (exp 𝕂) x 
goal: AnalyticAt 𝕂 (NormedSpace.exp 𝕂) x

full_name: NormedSpace.exp_add_of_commute_of_mem_ball
code: /-- In a Banach-algebra `𝔸` over a normed field `𝕂` of characteristic zero, if `x` and `y` are
in the disk of convergence and commute, then `exp 𝕂 (x + y) = (exp 𝕂 x) * (exp 𝕂 y)`. -/
theorem exp_add_of_commute_of_mem_ball [CharZero 𝕂] {x y : 𝔸} (hxy : Commute x y)
    (hx : x ∈ EMetric.ball (0 : 𝔸) (expSeries 𝕂 𝔸).radius)
    (hy : y ∈ EMetric.ball (0 : 𝔸) (expSeries 𝕂 𝔸).radius) : exp 𝕂 (x + y) = exp 𝕂 x * exp 𝕂 y 
goal: NormedSpace.exp 𝕂 (x + y) = NormedSpace.exp 𝕂 x * NormedSpace.exp 𝕂 y

full_name: NormedSpace.invertibleExpOfMemBall
code: /-- `exp 𝕂 x` has explicit two-sided inverse `exp 𝕂 (-x)`. -/
noncomputable def invertibleExpOfMemBall [CharZero 𝕂] {x : 𝔸}
    (hx : x ∈ EMetric.ball (0 : 𝔸) (expSeries 𝕂 𝔸).radius) : Invertible (exp 𝕂 x) 
goal: Invertible (NormedSpace.exp 𝕂 x)

full_name: NormedSpace.isUnit_exp_of_mem_ball
code: theorem isUnit_exp_of_mem_ball [CharZero 𝕂] {x : 𝔸}
    (hx : x ∈ EMetric.ball (0 : 𝔸) (expSeries 𝕂 𝔸).radius) : IsUnit (exp 𝕂 x) 
goal: IsUnit (NormedSpace.exp 𝕂 x)

full_name: NormedSpace.invOf_exp_of_mem_ball
code: theorem invOf_exp_of_mem_ball [CharZero 𝕂] {x : 𝔸}
    (hx : x ∈ EMetric.ball (0 : 𝔸) (expSeries 𝕂 𝔸).radius) [Invertible (exp 𝕂 x)] :
    ⅟ (exp 𝕂 x) = exp 𝕂 (-x) 
goal: ⅟(NormedSpace.exp 𝕂 x) = NormedSpace.exp 𝕂 (-x)

full_name: NormedSpace.map_exp_of_mem_ball
code: /-- Any continuous ring homomorphism commutes with `exp`. -/
theorem map_exp_of_mem_ball {F} [FunLike F 𝔸 𝔹] [RingHomClass F 𝔸 𝔹] (f : F) (hf : Continuous f)
    (x : 𝔸) (hx : x ∈ EMetric.ball (0 : 𝔸) (expSeries 𝕂 𝔸).radius) :
    f (exp 𝕂 x) = exp 𝕂 (f x) 
goal: f (NormedSpace.exp 𝕂 x) = NormedSpace.exp 𝕂 (f x)

full_name: NormedSpace.algebraMap_exp_comm_of_mem_ball
code: theorem algebraMap_exp_comm_of_mem_ball [CompleteSpace 𝕂] (x : 𝕂)
    (hx : x ∈ EMetric.ball (0 : 𝕂) (expSeries 𝕂 𝕂).radius) :
    algebraMap 𝕂 𝔸 (exp 𝕂 x) = exp 𝕂 (algebraMap 𝕂 𝔸 x) 
goal: (algebraMap 𝕂 𝔸) (NormedSpace.exp 𝕂 x) = NormedSpace.exp 𝕂 ((algebraMap 𝕂 𝔸) x)

full_name: NormedSpace.norm_expSeries_div_summable_of_mem_ball
code: theorem norm_expSeries_div_summable_of_mem_ball (x : 𝔸)
    (hx : x ∈ EMetric.ball (0 : 𝔸) (expSeries 𝕂 𝔸).radius) :
    Summable fun n => ‖x ^ n / (n ! : 𝔸)‖ 
goal: Summable fun n => ‖x ^ n / ↑n.factorial‖

full_name: NormedSpace.expSeries_div_summable_of_mem_ball
code: theorem expSeries_div_summable_of_mem_ball [CompleteSpace 𝔸] (x : 𝔸)
    (hx : x ∈ EMetric.ball (0 : 𝔸) (expSeries 𝕂 𝔸).radius) : Summable fun n => x ^ n / n ! 
goal: Summable fun n => x ^ n / ↑n.factorial

full_name: NormedSpace.expSeries_div_hasSum_exp_of_mem_ball
code: theorem expSeries_div_hasSum_exp_of_mem_ball [CompleteSpace 𝔸] (x : 𝔸)
    (hx : x ∈ EMetric.ball (0 : 𝔸) (expSeries 𝕂 𝔸).radius) :
    HasSum (fun n => x ^ n / n !) (exp 𝕂 x) 
goal: HasSum (fun n => x ^ n / ↑n.factorial) (NormedSpace.exp 𝕂 x)

full_name: NormedSpace.exp_neg_of_mem_ball
code: theorem exp_neg_of_mem_ball [CharZero 𝕂] [CompleteSpace 𝔸] {x : 𝔸}
    (hx : x ∈ EMetric.ball (0 : 𝔸) (expSeries 𝕂 𝔸).radius) : exp 𝕂 (-x) = (exp 𝕂 x)⁻¹ 
goal: NormedSpace.exp 𝕂 (-x) = (NormedSpace.exp 𝕂 x)⁻¹

full_name: NormedSpace.exp_add_of_mem_ball
code: /-- In a commutative Banach-algebra `𝔸` over a normed field `𝕂` of characteristic zero,
`exp 𝕂 (x+y) = (exp 𝕂 x) * (exp 𝕂 y)` for all `x`, `y` in the disk of convergence. -/
theorem exp_add_of_mem_ball [CharZero 𝕂] {x y : 𝔸}
    (hx : x ∈ EMetric.ball (0 : 𝔸) (expSeries 𝕂 𝔸).radius)
    (hy : y ∈ EMetric.ball (0 : 𝔸) (expSeries 𝕂 𝔸).radius) : exp 𝕂 (x + y) = exp 𝕂 x * exp 𝕂 y 
goal: NormedSpace.exp 𝕂 (x + y) = NormedSpace.exp 𝕂 x * NormedSpace.exp 𝕂 y

full_name: NormedSpace.expSeries_radius_eq_top
code: /-- In a normed algebra `𝔸` over `𝕂 = ℝ` or `𝕂 = ℂ`, the series defining the exponential map
has an infinite radius of convergence. -/
theorem expSeries_radius_eq_top : (expSeries 𝕂 𝔸).radius = ∞ 
goal: (NormedSpace.expSeries 𝕂 𝔸).radius = ⊤

full_name: NormedSpace.expSeries_radius_pos
code: theorem expSeries_radius_pos : 0 < (expSeries 𝕂 𝔸).radius 
goal: 0 < (NormedSpace.expSeries 𝕂 𝔸).radius

full_name: NormedSpace.norm_expSeries_summable
code: theorem norm_expSeries_summable (x : 𝔸) : Summable fun n => ‖expSeries 𝕂 𝔸 n fun _ => x‖ 
goal: Summable fun n => ‖(NormedSpace.expSeries 𝕂 𝔸 n) fun x_1 => x‖

full_name: NormedSpace.norm_expSeries_summable'
code: theorem norm_expSeries_summable' (x : 𝔸) : Summable fun n => ‖(n !⁻¹ : 𝕂) • x ^ n‖ 
goal: Summable fun n => ‖(↑n.factorial)⁻¹ • x ^ n‖

full_name: NormedSpace.expSeries_summable
code: theorem expSeries_summable (x : 𝔸) : Summable fun n => expSeries 𝕂 𝔸 n fun _ => x 
goal: Summable fun n => (NormedSpace.expSeries 𝕂 𝔸 n) fun x_1 => x

full_name: NormedSpace.expSeries_summable'
code: theorem expSeries_summable' (x : 𝔸) : Summable fun n => (n !⁻¹ : 𝕂) • x ^ n 
goal: Summable fun n => (↑n.factorial)⁻¹ • x ^ n

full_name: NormedSpace.expSeries_hasSum_exp
code: theorem expSeries_hasSum_exp (x : 𝔸) : HasSum (fun n => expSeries 𝕂 𝔸 n fun _ => x) (exp 𝕂 x) 
goal: HasSum (fun n => (NormedSpace.expSeries 𝕂 𝔸 n) fun x_1 => x) (NormedSpace.exp 𝕂 x)

full_name: NormedSpace.exp_series_hasSum_exp'
code: theorem exp_series_hasSum_exp' (x : 𝔸) : HasSum (fun n => (n !⁻¹ : 𝕂) • x ^ n) (exp 𝕂 x) 
goal: HasSum (fun n => (↑n.factorial)⁻¹ • x ^ n) (NormedSpace.exp 𝕂 x)

full_name: NormedSpace.exp_hasFPowerSeriesOnBall
code: theorem exp_hasFPowerSeriesOnBall : HasFPowerSeriesOnBall (exp 𝕂) (expSeries 𝕂 𝔸) 0 ∞ 
goal: HasFPowerSeriesOnBall (NormedSpace.exp 𝕂) (NormedSpace.expSeries 𝕂 𝔸) 0 ⊤

full_name: NormedSpace.exp_hasFPowerSeriesAt_zero
code: theorem exp_hasFPowerSeriesAt_zero : HasFPowerSeriesAt (exp 𝕂) (expSeries 𝕂 𝔸) 0 
goal: HasFPowerSeriesAt (NormedSpace.exp 𝕂) (NormedSpace.expSeries 𝕂 𝔸) 0

full_name: NormedSpace.exp_continuous
code: @[continuity]
theorem exp_continuous : Continuous (exp 𝕂 : 𝔸 → 𝔸) 
goal: Continuous (NormedSpace.exp 𝕂)

full_name: Filter.Tendsto.exp
code: lemma _root_.Filter.Tendsto.exp {α : Type*} {l : Filter α} {f : α → 𝔸} {a : 𝔸}
    (hf : Tendsto f l (𝓝 a)) :
    Tendsto (fun x => exp 𝕂 (f x)) l (𝓝 (exp 𝕂 a)) 
goal: Filter.Tendsto (fun x => NormedSpace.exp 𝕂 (f x)) l (nhds (NormedSpace.exp 𝕂 a))

full_name: NormedSpace.exp_analytic
code: theorem exp_analytic (x : 𝔸) : AnalyticAt 𝕂 (exp 𝕂) x 
goal: AnalyticAt 𝕂 (NormedSpace.exp 𝕂) x

full_name: NormedSpace.exp_add_of_commute
code: /-- In a Banach-algebra `𝔸` over `𝕂 = ℝ` or `𝕂 = ℂ`, if `x` and `y` commute, then
`exp 𝕂 (x+y) = (exp 𝕂 x) * (exp 𝕂 y)`. -/
theorem exp_add_of_commute {x y : 𝔸} (hxy : Commute x y) : exp 𝕂 (x + y) = exp 𝕂 x * exp 𝕂 y 
goal: NormedSpace.exp 𝕂 (x + y) = NormedSpace.exp 𝕂 x * NormedSpace.exp 𝕂 y

full_name: NormedSpace.invertibleExp
code: /-- `exp 𝕂 x` has explicit two-sided inverse `exp 𝕂 (-x)`. -/
noncomputable def invertibleExp (x : 𝔸) : Invertible (exp 𝕂 x) 
goal: Invertible (NormedSpace.exp 𝕂 x)

full_name: NormedSpace.isUnit_exp
code: theorem isUnit_exp (x : 𝔸) : IsUnit (exp 𝕂 x) 
goal: IsUnit (NormedSpace.exp 𝕂 x)

full_name: NormedSpace.invOf_exp
code: theorem invOf_exp (x : 𝔸) [Invertible (exp 𝕂 x)] : ⅟ (exp 𝕂 x) = exp 𝕂 (-x) 
goal: ⅟(NormedSpace.exp 𝕂 x) = NormedSpace.exp 𝕂 (-x)

full_name: Ring.inverse_exp
code: theorem _root_.Ring.inverse_exp (x : 𝔸) : Ring.inverse (exp 𝕂 x) = exp 𝕂 (-x) 
goal: Ring.inverse (NormedSpace.exp 𝕂 x) = NormedSpace.exp 𝕂 (-x)

full_name: NormedSpace.exp_mem_unitary_of_mem_skewAdjoint
code: theorem exp_mem_unitary_of_mem_skewAdjoint [StarRing 𝔸] [ContinuousStar 𝔸] {x : 𝔸}
    (h : x ∈ skewAdjoint 𝔸) : exp 𝕂 x ∈ unitary 𝔸 
goal: NormedSpace.exp 𝕂 x ∈ unitary 𝔸

full_name: NormedSpace.exp_sum_of_commute
code: /-- In a Banach-algebra `𝔸` over `𝕂 = ℝ` or `𝕂 = ℂ`, if a family of elements `f i` mutually
commute then `exp 𝕂 (∑ i, f i) = ∏ i, exp 𝕂 (f i)`. -/
theorem exp_sum_of_commute {ι} (s : Finset ι) (f : ι → 𝔸)
    (h : (s : Set ι).Pairwise fun i j => Commute (f i) (f j)) :
    exp 𝕂 (∑ i ∈ s, f i) =
      s.noncommProd (fun i => exp 𝕂 (f i)) fun i hi j hj _ => (h.of_refl hi hj).exp 𝕂 
goal: NormedSpace.exp 𝕂 (∑ i ∈ s, f i) = s.noncommProd (fun i => NormedSpace.exp 𝕂 (f i)) ⋯

full_name: NormedSpace.exp_nsmul
code: theorem exp_nsmul (n : ℕ) (x : 𝔸) : exp 𝕂 (n • x) = exp 𝕂 x ^ n 
goal: NormedSpace.exp 𝕂 (n • x) = NormedSpace.exp 𝕂 x ^ n

full_name: NormedSpace.map_exp
code: /-- Any continuous ring homomorphism commutes with `NormedSpace.exp`. -/
theorem map_exp {F} [FunLike F 𝔸 𝔹] [RingHomClass F 𝔸 𝔹] (f : F) (hf : Continuous f) (x : 𝔸) :
    f (exp 𝕂 x) = exp 𝕂 (f x) 
goal: f (NormedSpace.exp 𝕂 x) = NormedSpace.exp 𝕂 (f x)

full_name: NormedSpace.exp_smul
code: theorem exp_smul {G} [Monoid G] [MulSemiringAction G 𝔸] [ContinuousConstSMul G 𝔸] (g : G) (x : 𝔸) :
    exp 𝕂 (g • x) = g • exp 𝕂 x 
goal: NormedSpace.exp 𝕂 (g • x) = g • NormedSpace.exp 𝕂 x

full_name: NormedSpace.exp_units_conj
code: theorem exp_units_conj (y : 𝔸ˣ) (x : 𝔸) : exp 𝕂 (y * x * ↑y⁻¹ : 𝔸) = y * exp 𝕂 x * ↑y⁻¹ 
goal: NormedSpace.exp 𝕂 (↑y * x * ↑y⁻¹) = ↑y * NormedSpace.exp 𝕂 x * ↑y⁻¹

full_name: NormedSpace.exp_units_conj'
code: theorem exp_units_conj' (y : 𝔸ˣ) (x : 𝔸) : exp 𝕂 (↑y⁻¹ * x * y) = ↑y⁻¹ * exp 𝕂 x * y 
goal: NormedSpace.exp 𝕂 (↑y⁻¹ * x * ↑y) = ↑y⁻¹ * NormedSpace.exp 𝕂 x * ↑y

full_name: Prod.fst_exp
code: @[simp]
theorem _root_.Prod.fst_exp [CompleteSpace 𝔹] (x : 𝔸 × 𝔹) : (exp 𝕂 x).fst = exp 𝕂 x.fst 
goal: (NormedSpace.exp 𝕂 x).1 = NormedSpace.exp 𝕂 x.1

full_name: Prod.snd_exp
code: @[simp]
theorem _root_.Prod.snd_exp [CompleteSpace 𝔹] (x : 𝔸 × 𝔹) : (exp 𝕂 x).snd = exp 𝕂 x.snd 
goal: (NormedSpace.exp 𝕂 x).2 = NormedSpace.exp 𝕂 x.2

full_name: Pi.exp_apply
code: @[simp]
theorem _root_.Pi.exp_apply {ι : Type*} {𝔸 : ι → Type*} [Finite ι] [∀ i, NormedRing (𝔸 i)]
    [∀ i, NormedAlgebra 𝕂 (𝔸 i)] [∀ i, CompleteSpace (𝔸 i)] (x : ∀ i, 𝔸 i) (i : ι) :
    exp 𝕂 x i = exp 𝕂 (x i) 
goal: NormedSpace.exp 𝕂 x i = NormedSpace.exp 𝕂 (x i)

full_name: Pi.exp_def
code: theorem _root_.Pi.exp_def {ι : Type*} {𝔸 : ι → Type*} [Finite ι] [∀ i, NormedRing (𝔸 i)]
    [∀ i, NormedAlgebra 𝕂 (𝔸 i)] [∀ i, CompleteSpace (𝔸 i)] (x : ∀ i, 𝔸 i) :
    exp 𝕂 x = fun i => exp 𝕂 (x i) 
goal: NormedSpace.exp 𝕂 x = fun i => NormedSpace.exp 𝕂 (x i)

full_name: Function.update_exp
code: theorem _root_.Function.update_exp {ι : Type*} {𝔸 : ι → Type*} [Finite ι] [DecidableEq ι]
    [∀ i, NormedRing (𝔸 i)] [∀ i, NormedAlgebra 𝕂 (𝔸 i)] [∀ i, CompleteSpace (𝔸 i)] (x : ∀ i, 𝔸 i)
    (j : ι) (xj : 𝔸 j) :
    Function.update (exp 𝕂 x) j (exp 𝕂 xj) = exp 𝕂 (Function.update x j xj) 
goal: Function.update (NormedSpace.exp 𝕂 x) j (NormedSpace.exp 𝕂 xj) = NormedSpace.exp 𝕂 (Function.update x j xj)

full_name: NormedSpace.algebraMap_exp_comm
code: theorem algebraMap_exp_comm (x : 𝕂) : algebraMap 𝕂 𝔸 (exp 𝕂 x) = exp 𝕂 (algebraMap 𝕂 𝔸 x) 
goal: (algebraMap 𝕂 𝔸) (NormedSpace.exp 𝕂 x) = NormedSpace.exp 𝕂 ((algebraMap 𝕂 𝔸) x)

full_name: NormedSpace.norm_expSeries_div_summable
code: theorem norm_expSeries_div_summable (x : 𝔸) : Summable fun n => ‖(x ^ n / n ! : 𝔸)‖ 
goal: Summable fun n => ‖x ^ n / ↑n.factorial‖

full_name: NormedSpace.expSeries_div_summable
code: theorem expSeries_div_summable (x : 𝔸) : Summable fun n => x ^ n / n ! 
goal: Summable fun n => x ^ n / ↑n.factorial

full_name: NormedSpace.expSeries_div_hasSum_exp
code: theorem expSeries_div_hasSum_exp (x : 𝔸) : HasSum (fun n => x ^ n / n !) (exp 𝕂 x) 
goal: HasSum (fun n => x ^ n / ↑n.factorial) (NormedSpace.exp 𝕂 x)

full_name: NormedSpace.exp_neg
code: theorem exp_neg (x : 𝔸) : exp 𝕂 (-x) = (exp 𝕂 x)⁻¹ 
goal: NormedSpace.exp 𝕂 (-x) = (NormedSpace.exp 𝕂 x)⁻¹

full_name: NormedSpace.exp_zsmul
code: theorem exp_zsmul (z : ℤ) (x : 𝔸) : exp 𝕂 (z • x) = exp 𝕂 x ^ z 
goal: NormedSpace.exp 𝕂 (z • x) = NormedSpace.exp 𝕂 x ^ z

full_name: NormedSpace.exp_conj
code: theorem exp_conj (y : 𝔸) (x : 𝔸) (hy : y ≠ 0) : exp 𝕂 (y * x * y⁻¹) = y * exp 𝕂 x * y⁻¹ 
goal: NormedSpace.exp 𝕂 (y * x * y⁻¹) = y * NormedSpace.exp 𝕂 x * y⁻¹

full_name: NormedSpace.exp_conj'
code: theorem exp_conj' (y : 𝔸) (x : 𝔸) (hy : y ≠ 0) : exp 𝕂 (y⁻¹ * x * y) = y⁻¹ * exp 𝕂 x * y 
goal: NormedSpace.exp 𝕂 (y⁻¹ * x * y) = y⁻¹ * NormedSpace.exp 𝕂 x * y

full_name: NormedSpace.exp_add
code: /-- In a commutative Banach-algebra `𝔸` over `𝕂 = ℝ` or `𝕂 = ℂ`,
`exp 𝕂 (x+y) = (exp 𝕂 x) * (exp 𝕂 y)`. -/
theorem exp_add {x y : 𝔸} : exp 𝕂 (x + y) = exp 𝕂 x * exp 𝕂 y 
goal: NormedSpace.exp 𝕂 (x + y) = NormedSpace.exp 𝕂 x * NormedSpace.exp 𝕂 y

full_name: NormedSpace.exp_sum
code: /-- A version of `NormedSpace.exp_sum_of_commute` for a commutative Banach-algebra. -/
theorem exp_sum {ι} (s : Finset ι) (f : ι → 𝔸) : exp 𝕂 (∑ i ∈ s, f i) = ∏ i ∈ s, exp 𝕂 (f i) 
goal: NormedSpace.exp 𝕂 (∑ i ∈ s, f i) = ∏ i ∈ s, NormedSpace.exp 𝕂 (f i)

full_name: NormedSpace.expSeries_eq_expSeries
code: /-- If a normed ring `𝔸` is a normed algebra over two fields, then they define the same
`expSeries` on `𝔸`. -/
theorem expSeries_eq_expSeries (n : ℕ) (x : 𝔸) :
    (expSeries 𝕂 𝔸 n fun _ => x) = expSeries 𝕂' 𝔸 n fun _ => x 
goal: ((NormedSpace.expSeries 𝕂 𝔸 n) fun x_1 => x) = (NormedSpace.expSeries 𝕂' 𝔸 n) fun x_1 => x

full_name: NormedSpace.exp_eq_exp
code: /-- If a normed ring `𝔸` is a normed algebra over two fields, then they define the same
exponential function on `𝔸`. -/
theorem exp_eq_exp : (exp 𝕂 : 𝔸 → 𝔸) = exp 𝕂' 
goal: NormedSpace.exp 𝕂 = NormedSpace.exp 𝕂'

full_name: NormedSpace.exp_ℝ_ℂ_eq_exp_ℂ_ℂ
code: theorem exp_ℝ_ℂ_eq_exp_ℂ_ℂ : (exp ℝ : ℂ → ℂ) = exp ℂ 
goal: NormedSpace.exp ℝ = NormedSpace.exp ℂ

full_name: NormedSpace.of_real_exp_ℝ_ℝ
code: /-- A version of `Complex.ofReal_exp` for `NormedSpace.exp` instead of `Complex.exp` -/
@[simp, norm_cast]
theorem of_real_exp_ℝ_ℝ (r : ℝ) : ↑(exp ℝ r) = exp ℂ (r : ℂ) 
goal: ↑(NormedSpace.exp ℝ r) = NormedSpace.exp ℂ ↑r