The complex log function

Basic properties, relationship with exp.

noncomputable def Complex.log (x : ℂ) : ℂ

Inverse of the exp function. Returns values such that (log x).im > - π and (log x).im ≤ π. log 0 = 0

Equations

• Complex.log x = ↑(Real.log (Complex.abs x)) + ↑x.arg * Complex.I

theorem Complex.log_re (x : ℂ) : (Complex.log x).re = Real.log (Complex.abs x)

theorem Complex.log_im (x : ℂ) : (Complex.log x).im = x.arg

theorem Complex.neg_pi_lt_log_im (x : ℂ) : -Real.pi < (Complex.log x).im

theorem Complex.log_im_le_pi (x : ℂ) : (Complex.log x).im ≤ Real.pi

theorem Complex.exp_log {x : ℂ} (hx : x ≠ 0) : Complex.exp (Complex.log x) = x

@[simp]

theorem Complex.range_exp : Set.range Complex.exp = {0}ᶜ

theorem Complex.log_exp {x : ℂ} (hx₁ : -Real.pi < x.im) (hx₂ : x.im ≤ Real.pi) : Complex.log (Complex.exp x) = x

theorem Complex.exp_inj_of_neg_pi_lt_of_le_pi {x : ℂ} {y : ℂ} (hx₁ : -Real.pi < x.im) (hx₂ : x.im ≤ Real.pi) (hy₁ : -Real.pi < y.im) (hy₂ : y.im ≤ Real.pi) (hxy : Complex.exp x = Complex.exp y) : x = y

theorem Complex.ofReal_log {x : ℝ} (hx : 0 ≤ x) : ↑(Real.log x) = Complex.log ↑x

@[simp]

theorem Complex.natCast_log {n : ℕ} : ↑(Real.log ↑n) = Complex.log ↑n

@[simp]

theorem Complex.ofNat_log {n : ℕ} [n.AtLeastTwo] : ↑(Real.log (OfNat.ofNat n)) = Complex.log (OfNat.ofNat n)

theorem Complex.log_ofReal_re (x : ℝ) : (Complex.log ↑x).re = Real.log x

theorem Complex.log_ofReal_mul {r : ℝ} (hr : 0 < r) {x : ℂ} (hx : x ≠ 0) : Complex.log (↑r * x) = ↑(Real.log r) + Complex.log x

theorem Complex.log_mul_ofReal (r : ℝ) (hr : 0 < r) (x : ℂ) (hx : x ≠ 0) : Complex.log (x * ↑r) = ↑(Real.log r) + Complex.log x

theorem Complex.log_mul_eq_add_log_iff {x : ℂ} {y : ℂ} (hx₀ : x ≠ 0) (hy₀ : y ≠ 0) : Complex.log (x * y) = Complex.log x + Complex.log y ↔ x.arg + y.arg ∈ Set.Ioc (-Real.pi) Real.pi

theorem Complex.log_mul {x : ℂ} {y : ℂ} (hx₀ : x ≠ 0) (hy₀ : y ≠ 0) : x.arg + y.arg ∈ Set.Ioc (-Real.pi) Real.pi → Complex.log (x * y) = Complex.log x + Complex.log y

Alias of the reverse direction of Complex.log_mul_eq_add_log_iff.

@[simp]

theorem Complex.log_zero : Complex.log 0 = 0

@[simp]

theorem Complex.log_one : Complex.log 1 = 0

theorem Complex.log_neg_one : Complex.log (-1) = ↑Real.pi * Complex.I

theorem Complex.log_I : Complex.log Complex.I = ↑Real.pi / 2 * Complex.I

theorem Complex.log_neg_I : Complex.log (-Complex.I) = -(↑Real.pi / 2) * Complex.I

theorem Complex.log_conj_eq_ite (x : ℂ) : Complex.log ((starRingEnd ℂ) x) = if x.arg = Real.pi then Complex.log x else (starRingEnd ℂ) (Complex.log x)

theorem Complex.log_conj (x : ℂ) (h : x.arg ≠ Real.pi) : Complex.log ((starRingEnd ℂ) x) = (starRingEnd ℂ) (Complex.log x)

theorem Complex.log_inv_eq_ite (x : ℂ) : Complex.log x⁻¹ = if x.arg = Real.pi then -(starRingEnd ℂ) (Complex.log x) else -Complex.log x

theorem Complex.log_inv (x : ℂ) (hx : x.arg ≠ Real.pi) : Complex.log x⁻¹ = -Complex.log x

theorem Complex.two_pi_I_ne_zero : 2 * ↑Real.pi * Complex.I ≠ 0

theorem Complex.exp_eq_one_iff {x : ℂ} : Complex.exp x = 1 ↔ ∃ (n : ℤ), x = ↑n * (2 * ↑Real.pi * Complex.I)

theorem Complex.exp_eq_exp_iff_exp_sub_eq_one {x : ℂ} {y : ℂ} : Complex.exp x = Complex.exp y ↔ Complex.exp (x - y) = 1

theorem Complex.exp_eq_exp_iff_exists_int {x : ℂ} {y : ℂ} : Complex.exp x = Complex.exp y ↔ ∃ (n : ℤ), x = y + ↑n * (2 * ↑Real.pi * Complex.I)

@[simp]

theorem Complex.countable_preimage_exp {s : Set ℂ} : (Complex.exp ⁻¹' s).Countable ↔ s.Countable

theorem Set.Countable.preimage_cexp {s : Set ℂ} : s.Countable → (Complex.exp ⁻¹' s).Countable

Alias of the reverse direction of Complex.countable_preimage_exp.

theorem Complex.tendsto_log_nhdsWithin_im_neg_of_re_neg_of_im_zero {z : ℂ} (hre : z.re < 0) (him : z.im = 0) : Filter.Tendsto Complex.log (nhdsWithin z {z : ℂ | z.im < 0}) (nhds (↑(Real.log (Complex.abs z)) - ↑Real.pi * Complex.I))

theorem Complex.continuousWithinAt_log_of_re_neg_of_im_zero {z : ℂ} (hre : z.re < 0) (him : z.im = 0) : ContinuousWithinAt Complex.log {z : ℂ | 0 ≤ z.im} z

theorem Complex.tendsto_log_nhdsWithin_im_nonneg_of_re_neg_of_im_zero {z : ℂ} (hre : z.re < 0) (him : z.im = 0) : Filter.Tendsto Complex.log (nhdsWithin z {z : ℂ | 0 ≤ z.im}) (nhds (↑(Real.log (Complex.abs z)) + ↑Real.pi * Complex.I))

@[simp]

theorem Complex.map_exp_comap_re_atBot : Filter.map Complex.exp (Filter.comap Complex.re Filter.atBot) = nhdsWithin 0 {0}ᶜ

@[simp]

theorem Complex.map_exp_comap_re_atTop : Filter.map Complex.exp (Filter.comap Complex.re Filter.atTop) = Bornology.cobounded ℂ

theorem continuousAt_clog {x : ℂ} (h : x ∈ Complex.slitPlane) : ContinuousAt Complex.log x

theorem Filter.Tendsto.clog {α : Type u_1} {l : Filter α} {f : α → ℂ} {x : ℂ} (h : Filter.Tendsto f l (nhds x)) (hx : x ∈ Complex.slitPlane) : Filter.Tendsto (fun (t : α) => Complex.log (f t)) l (nhds (Complex.log x))

theorem ContinuousAt.clog {α : Type u_1} [TopologicalSpace α] {f : α → ℂ} {x : α} (h₁ : ContinuousAt f x) (h₂ : f x ∈ Complex.slitPlane) : ContinuousAt (fun (t : α) => Complex.log (f t)) x

theorem ContinuousWithinAt.clog {α : Type u_1} [TopologicalSpace α] {f : α → ℂ} {s : Set α} {x : α} (h₁ : ContinuousWithinAt f s x) (h₂ : f x ∈ Complex.slitPlane) : ContinuousWithinAt (fun (t : α) => Complex.log (f t)) s x

theorem ContinuousOn.clog {α : Type u_1} [TopologicalSpace α] {f : α → ℂ} {s : Set α} (h₁ : ContinuousOn f s) (h₂ : ∀ x ∈ s, f x ∈ Complex.slitPlane) : ContinuousOn (fun (t : α) => Complex.log (f t)) s

theorem Continuous.clog {α : Type u_1} [TopologicalSpace α] {f : α → ℂ} (h₁ : Continuous f) (h₂ : ∀ (x : α), f x ∈ Complex.slitPlane) : Continuous fun (t : α) => Complex.log (f t)

theorem Real.HasSum_rexp_HasProd {α : Type u_1} {ι : Type u_2} (f : ι → α → ℝ) (hfn : ∀ (x : α) (n : ι), 0 < f n x) (hf : ∀ (x : α), HasSum (fun (n : ι) => Real.log (f n x)) (∑' (i : ι), Real.log (f i x))) (a : α) : HasProd (fun (b : ι) => f b a) (∏' (n : ι), f n a)

theorem Real.rexp_tsum_eq_tprod {α : Type u_1} {ι : Type u_2} (f : ι → α → ℝ) (hfn : ∀ (x : α) (n : ι), 0 < f n x) (hf : ∀ (x : α), Summable fun (n : ι) => Real.log (f n x)) : (Real.exp ∘ fun (a : α) => ∑' (n : ι), Real.log (f n a)) = fun (a : α) => ∏' (n : ι), f n a

The exponential of a infinite sum of real logs (which converges absolutely) is an infinite product.

theorem Real.summable_cexp_multipliable {α : Type u_1} {ι : Type u_2} (f : ι → α → ℝ) (hfn : ∀ (x : α) (n : ι), 0 < f n x) (hf : ∀ (x : α), Summable fun (n : ι) => Real.log (f n x)) (a : α) : Multipliable fun (b : ι) => f b a

theorem Complex.HasSum_cexp_HasProd {α : Type u_1} {ι : Type u_2} (f : ι → α → ℂ) (hfn : ∀ (x : α) (n : ι), f n x ≠ 0) (hf : ∀ (x : α), HasSum (fun (n : ι) => Complex.log (f n x)) (∑' (i : ι), Complex.log (f i x))) (a : α) : HasProd (fun (b : ι) => f b a) (∏' (n : ι), f n a)

theorem Complex.summable_cexp_multipliable {α : Type u_1} {ι : Type u_2} (f : ι → α → ℂ) (hfn : ∀ (x : α) (n : ι), f n x ≠ 0) (hf : ∀ (x : α), Summable fun (n : ι) => Complex.log (f n x)) (a : α) : Multipliable fun (b : ι) => f b a

theorem Complex.cexp_tsum_eq_tprod {α : Type u_1} {ι : Type u_2} (f : ι → α → ℂ) (hfn : ∀ (x : α) (n : ι), f n x ≠ 0) (hf : ∀ (x : α), Summable fun (n : ι) => Complex.log (f n x)) : (Complex.exp ∘ fun (a : α) => ∑' (n : ι), Complex.log (f n a)) = fun (a : α) => ∏' (n : ι), f n a

The exponential of a infinite sum of comples logs (which converges absolutely) is an infinite product.