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

full_name: Complex.isOpenMap_exp
code: theorem isOpenMap_exp : IsOpenMap exp 
goal: IsOpenMap Complex.exp

full_name: Complex.expPartialHomeomorph
code: /-- `Complex.exp` as a `PartialHomeomorph` with `source = {z | -π < im z < π}` and
`target = {z | 0 < re z} ∪ {z | im z ≠ 0}`. This definition is used to prove that `Complex.log`
is complex differentiable at all points but the negative real semi-axis. -/
noncomputable def expPartialHomeomorph : PartialHomeomorph ℂ ℂ 
goal: PartialHomeomorph ℂ ℂ

full_name: Complex.hasStrictDerivAt_log
code: theorem hasStrictDerivAt_log {x : ℂ} (h : x ∈ slitPlane) : HasStrictDerivAt log x⁻¹ x 
goal: HasStrictDerivAt Complex.log x⁻¹ x

full_name: Complex.hasDerivAt_log
code: lemma hasDerivAt_log {z : ℂ} (hz : z ∈ slitPlane) : HasDerivAt log z⁻¹ z 
goal: HasDerivAt Complex.log z⁻¹ z

full_name: Complex.differentiableAt_log
code: lemma differentiableAt_log {z : ℂ} (hz : z ∈ slitPlane) : DifferentiableAt ℂ log z 
goal: DifferentiableAt ℂ Complex.log z

full_name: Complex.hasStrictFDerivAt_log_real
code: theorem hasStrictFDerivAt_log_real {x : ℂ} (h : x ∈ slitPlane) :
    HasStrictFDerivAt log (x⁻¹ • (1 : ℂ →L[ℝ] ℂ)) x 
goal: HasStrictFDerivAt Complex.log (x⁻¹ • 1) x

full_name: Complex.contDiffAt_log
code: theorem contDiffAt_log {x : ℂ} (h : x ∈ slitPlane) {n : ℕ∞} : ContDiffAt ℂ n log x 
goal: ContDiffAt ℂ n Complex.log x

full_name: HasStrictFDerivAt.clog
code: theorem HasStrictFDerivAt.clog {f : E → ℂ} {f' : E →L[ℂ] ℂ} {x : E} (h₁ : HasStrictFDerivAt f f' x)
    (h₂ : f x ∈ slitPlane) : HasStrictFDerivAt (fun t => log (f t)) ((f x)⁻¹ • f') x 
goal: HasStrictFDerivAt (fun t => Complex.log (f t)) ((f x)⁻¹ • f') x

full_name: HasStrictDerivAt.clog
code: theorem HasStrictDerivAt.clog {f : ℂ → ℂ} {f' x : ℂ} (h₁ : HasStrictDerivAt f f' x)
    (h₂ : f x ∈ slitPlane) : HasStrictDerivAt (fun t => log (f t)) (f' / f x) x 
goal: HasStrictDerivAt (fun t => Complex.log (f t)) (f' / f x) x

full_name: HasStrictDerivAt.clog_real
code: theorem HasStrictDerivAt.clog_real {f : ℝ → ℂ} {x : ℝ} {f' : ℂ} (h₁ : HasStrictDerivAt f f' x)
    (h₂ : f x ∈ slitPlane) : HasStrictDerivAt (fun t => log (f t)) (f' / f x) x 
goal: HasStrictDerivAt (fun t => Complex.log (f t)) (f' / f x) x

full_name: HasFDerivAt.clog
code: theorem HasFDerivAt.clog {f : E → ℂ} {f' : E →L[ℂ] ℂ} {x : E} (h₁ : HasFDerivAt f f' x)
    (h₂ : f x ∈ slitPlane) : HasFDerivAt (fun t => log (f t)) ((f x)⁻¹ • f') x 
goal: HasFDerivAt (fun t => Complex.log (f t)) ((f x)⁻¹ • f') x

full_name: HasDerivAt.clog
code: theorem HasDerivAt.clog {f : ℂ → ℂ} {f' x : ℂ} (h₁ : HasDerivAt f f' x)
    (h₂ : f x ∈ slitPlane) : HasDerivAt (fun t => log (f t)) (f' / f x) x 
goal: HasDerivAt (fun t => Complex.log (f t)) (f' / f x) x

full_name: HasDerivAt.clog_real
code: theorem HasDerivAt.clog_real {f : ℝ → ℂ} {x : ℝ} {f' : ℂ} (h₁ : HasDerivAt f f' x)
    (h₂ : f x ∈ slitPlane) : HasDerivAt (fun t => log (f t)) (f' / f x) x 
goal: HasDerivAt (fun t => Complex.log (f t)) (f' / f x) x

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

full_name: HasFDerivWithinAt.clog
code: theorem HasFDerivWithinAt.clog {f : E → ℂ} {f' : E →L[ℂ] ℂ} {s : Set E} {x : E}
    (h₁ : HasFDerivWithinAt f f' s x) (h₂ : f x ∈ slitPlane) :
    HasFDerivWithinAt (fun t => log (f t)) ((f x)⁻¹ • f') s x 
goal: HasFDerivWithinAt (fun t => Complex.log (f t)) ((f x)⁻¹ • f') s x

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

full_name: HasDerivWithinAt.clog_real
code: theorem HasDerivWithinAt.clog_real {f : ℝ → ℂ} {s : Set ℝ} {x : ℝ} {f' : ℂ}
    (h₁ : HasDerivWithinAt f f' s x) (h₂ : f x ∈ slitPlane) :
    HasDerivWithinAt (fun t => log (f t)) (f' / f x) s x 
goal: HasDerivWithinAt (fun t => Complex.log (f t)) (f' / f x) s x

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

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

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

full_name: Complex.deriv_log_comp_eq_logDeriv
code: /-- The derivative of `log ∘ f` is the logarithmic derivative provided `f` is differentiable and
we are on the slitPlane. -/
lemma Complex.deriv_log_comp_eq_logDeriv {f : ℂ → ℂ} {x : ℂ} (h₁ : DifferentiableAt ℂ f x)
    (h₂ : f x ∈ Complex.slitPlane) : deriv (Complex.log ∘ f) x = logDeriv f x 
goal: deriv (Complex.log ∘ f) x = logDeriv f x