File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

full_name: Complex.log
code: /-- Inverse of the `exp` function. Returns values such that `(log x).im > - π` and `(log x).im ≤ π`.
  `log 0 = 0`-/
@[pp_nodot]
noncomputable def log (x : ℂ) : ℂ 
goal: ℂ

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

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

full_name: Complex.neg_pi_lt_log_im
code: theorem neg_pi_lt_log_im (x : ℂ) : -π < (log x).im 
goal: -Real.pi < (Complex.log x).im

full_name: Complex.log_im_le_pi
code: theorem log_im_le_pi (x : ℂ) : (log x).im ≤ π 
goal: (Complex.log x).im ≤ Real.pi

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

full_name: Complex.range_exp
code: @[simp]
theorem range_exp : Set.range exp = {0}ᶜ 
goal: Set.range Complex.exp = {0}ᶜ

full_name: Complex.log_exp
code: theorem log_exp {x : ℂ} (hx₁ : -π < x.im) (hx₂ : x.im ≤ π) : log (exp x) = x 
goal: Complex.log (Complex.exp x) = x

full_name: Complex.exp_inj_of_neg_pi_lt_of_le_pi
code: theorem exp_inj_of_neg_pi_lt_of_le_pi {x y : ℂ} (hx₁ : -π < x.im) (hx₂ : x.im ≤ π) (hy₁ : -π < y.im)
    (hy₂ : y.im ≤ π) (hxy : exp x = exp y) : x = y 
goal: x = y

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

full_name: Complex.natCast_log
code: @[simp, norm_cast]
lemma natCast_log {n : ℕ} : Real.log n = log n 
goal: ↑(Real.log ↑n) = Complex.log ↑n

full_name: Complex.ofNat_log
code: @[simp]
lemma ofNat_log {n : ℕ} [n.AtLeastTwo] :
    Real.log (no_index (OfNat.ofNat n)) = log (OfNat.ofNat n) 
goal: ↑(Real.log (OfNat.ofNat n)) = Complex.log (OfNat.ofNat n)

full_name: Complex.log_ofReal_re
code: theorem log_ofReal_re (x : ℝ) : (log (x : ℂ)).re = Real.log x 
goal: (Complex.log ↑x).re = Real.log x

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

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

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

full_name: Complex.log_zero
code: @[simp]
theorem log_zero : log 0 = 0 
goal: Complex.log 0 = 0

full_name: Complex.log_one
code: @[simp]
theorem log_one : log 1 = 0 
goal: Complex.log 1 = 0

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

full_name: Complex.log_I
code: theorem log_I : log I = π / 2 * I 
goal: Complex.log Complex.I = ↑Real.pi / 2 * Complex.I

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

full_name: Complex.log_conj_eq_ite
code: theorem log_conj_eq_ite (x : ℂ) : log (conj x) = if x.arg = π then log x else conj (log x) 
goal: Complex.log ((starRingEnd ℂ) x) = if x.arg = Real.pi then Complex.log x else (starRingEnd ℂ) (Complex.log x)

full_name: Complex.log_conj
code: theorem log_conj (x : ℂ) (h : x.arg ≠ π) : log (conj x) = conj (log x) 
goal: Complex.log ((starRingEnd ℂ) x) = (starRingEnd ℂ) (Complex.log x)

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

full_name: Complex.log_inv
code: theorem log_inv (x : ℂ) (hx : x.arg ≠ π) : log x⁻¹ = -log x 
goal: Complex.log x⁻¹ = -Complex.log x

full_name: Complex.two_pi_I_ne_zero
code: theorem two_pi_I_ne_zero : (2 * π * I : ℂ) ≠ 0 
goal: 2 * ↑Real.pi * Complex.I ≠ 0

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

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

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

full_name: Complex.countable_preimage_exp
code: @[simp]
theorem countable_preimage_exp {s : Set ℂ} : (exp ⁻¹' s).Countable ↔ s.Countable 
goal: (Complex.exp ⁻¹' s).Countable ↔ s.Countable

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

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

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

full_name: Complex.map_exp_comap_re_atBot
code: @[simp]
theorem map_exp_comap_re_atBot : map exp (comap re atBot) = 𝓝[≠] 0 
goal: Filter.map Complex.exp (Filter.comap Complex.re Filter.atBot) = nhdsWithin 0 {0}ᶜ

full_name: Complex.map_exp_comap_re_atTop
code: @[simp]
theorem map_exp_comap_re_atTop : map exp (comap re atTop) = cobounded ℂ 
goal: Filter.map Complex.exp (Filter.comap Complex.re Filter.atTop) = Bornology.cobounded ℂ

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

full_name: Filter.Tendsto.clog
code: theorem _root_.Filter.Tendsto.clog {l : Filter α} {f : α → ℂ} {x : ℂ} (h : Tendsto f l (𝓝 x))
    (hx : x ∈ slitPlane) : Tendsto (fun t => log (f t)) l (𝓝 <| log x) 
goal: Filter.Tendsto (fun t => Complex.log (f t)) l (nhds (Complex.log x))

full_name: ContinuousAt.clog
code: nonrec
theorem _root_.ContinuousAt.clog {f : α → ℂ} {x : α} (h₁ : ContinuousAt f x)
    (h₂ : f x ∈ slitPlane) : ContinuousAt (fun t => log (f t)) x 
goal: ContinuousAt (fun t => Complex.log (f t)) x

full_name: ContinuousWithinAt.clog
code: nonrec
theorem _root_.ContinuousWithinAt.clog {f : α → ℂ} {s : Set α} {x : α}
    (h₁ : ContinuousWithinAt f s x) (h₂ : f x ∈ slitPlane) :
    ContinuousWithinAt (fun t => log (f t)) s x 
goal: ContinuousWithinAt (fun t => Complex.log (f t)) s x

full_name: ContinuousOn.clog
code: nonrec
theorem _root_.ContinuousOn.clog {f : α → ℂ} {s : Set α} (h₁ : ContinuousOn f s)
    (h₂ : ∀ x ∈ s, f x ∈ slitPlane) : ContinuousOn (fun t => log (f t)) s 
goal: ContinuousOn (fun t => Complex.log (f t)) s

full_name: Continuous.clog
code: nonrec
theorem _root_.Continuous.clog {f : α → ℂ} (h₁ : Continuous f)
    (h₂ : ∀ x, f x ∈ slitPlane) : Continuous fun t => log (f t) 
goal: Continuous fun t => Complex.log (f t)