ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Polynomial.div_tendsto_atBot_of_degree_gt
theorem div_tendsto_atBot_of_degree_gt (hdeg : Q.degree < P.degree) (hQ : Q ≠ 0)
    (hnps : P.leadingCoeff / Q.leadingCoeff ≤ 0) :
    Tendsto (fun x => eval x P / eval x Q) atTop atBot 
Arguments: {𝕜 : Type u_1} [NormedLinearOrderedField 𝕜] (P Q : 𝕜[X]) [OrderTopology 𝕜] (hdeg : Q.degree < P.degree) (hQ : Q ≠ 0) (hnps : P.leadingCoeff / Q.leadingCoeff ≤ 0)
Goal: Filter.Tendsto (fun x => Polynomial.eval x P / Polynomial.eval x Q) Filter.atTop Filter.atBot
-- Polynomial.abs_div_tendsto_atTop_of_degree_gt
theorem abs_div_tendsto_atTop_of_degree_gt (hdeg : Q.degree < P.degree) (hQ : Q ≠ 0) :
    Tendsto (fun x => |eval x P / eval x Q|) atTop atTop 
Arguments: {𝕜 : Type u_1} [NormedLinearOrderedField 𝕜] (P Q : 𝕜[X]) [OrderTopology 𝕜] (hdeg : Q.degree < P.degree) (hQ : Q ≠ 0)
Goal: Filter.Tendsto (fun x => |Polynomial.eval x P / Polynomial.eval x Q|) Filter.atTop Filter.atTop
-- Polynomial.isBigO_of_degree_le
theorem isBigO_of_degree_le (h : P.degree ≤ Q.degree) :
    (fun x => eval x P) =O[atTop] fun x => eval x Q 
Arguments: {𝕜 : Type u_1} [NormedLinearOrderedField 𝕜] (P Q : 𝕜[X]) [OrderTopology 𝕜] (h : P.degree ≤ Q.degree)
Goal: (fun x => Polynomial.eval x P) =O[Filter.atTop] fun x => Polynomial.eval x Q
-- Real.deriv_sqrt_aux
theorem deriv_sqrt_aux {x : ℝ} (hx : x ≠ 0) :
    HasStrictDerivAt (√·) (1 / (2 * √x)) x ∧ ∀ n, ContDiffAt ℝ n (√·) x 
Arguments: {x : ℝ} (hx : x ≠ 0)
Goal: HasStrictDerivAt (fun x => √x) (1 / (2 * √x)) x ∧ ∀ (n : ℕ∞), ContDiffAt ℝ n (fun x => √x) x
-- Real.hasStrictDerivAt_sqrt
theorem hasStrictDerivAt_sqrt {x : ℝ} (hx : x ≠ 0) : HasStrictDerivAt (√·) (1 / (2 * √x)) x 
Arguments: {x : ℝ} (hx : x ≠ 0)
Goal: HasStrictDerivAt (fun x => √x) (1 / (2 * √x)) x
-- Real.contDiffAt_sqrt
theorem contDiffAt_sqrt {x : ℝ} {n : ℕ∞} (hx : x ≠ 0) : ContDiffAt ℝ n (√·) x 
Arguments: {x : ℝ} {n : ℕ∞} (hx : x ≠ 0)
Goal: ContDiffAt ℝ n (fun x => √x) x
-- Real.hasDerivAt_sqrt
theorem hasDerivAt_sqrt {x : ℝ} (hx : x ≠ 0) : HasDerivAt (√·) (1 / (2 * √x)) x 
Arguments: {x : ℝ} (hx : x ≠ 0)
Goal: HasDerivAt (fun x => √x) (1 / (2 * √x)) x
-- HasDerivWithinAt.sqrt
theorem HasDerivWithinAt.sqrt (hf : HasDerivWithinAt f f' s x) (hx : f x ≠ 0) :
    HasDerivWithinAt (fun y => √(f y)) (f' / (2 * √(f x))) s x 
Arguments: {f : ℝ → ℝ} {s : Set ℝ} {f' x : ℝ} (hf : HasDerivWithinAt f f' s x) (hx : f x ≠ 0)
Goal: HasDerivWithinAt (fun y => √(f y)) (f' / (2 * √(f x))) s x
-- HasDerivAt.sqrt
theorem HasDerivAt.sqrt (hf : HasDerivAt f f' x) (hx : f x ≠ 0) :
    HasDerivAt (fun y => √(f y)) (f' / (2 * √(f x))) x 
Arguments: {f : ℝ → ℝ} {f' x : ℝ} (hf : HasDerivAt f f' x) (hx : f x ≠ 0)
Goal: HasDerivAt (fun y => √(f y)) (f' / (2 * √(f x))) x
-- HasStrictDerivAt.sqrt
theorem HasStrictDerivAt.sqrt (hf : HasStrictDerivAt f f' x) (hx : f x ≠ 0) :
    HasStrictDerivAt (fun t => √(f t)) (f' / (2 * √(f x))) x 
Arguments: {f : ℝ → ℝ} {f' x : ℝ} (hf : HasStrictDerivAt f f' x) (hx : f x ≠ 0)
Goal: HasStrictDerivAt (fun t => √(f t)) (f' / (2 * √(f x))) x
-- derivWithin_sqrt
theorem derivWithin_sqrt (hf : DifferentiableWithinAt ℝ f s x) (hx : f x ≠ 0)
    (hxs : UniqueDiffWithinAt ℝ s x) :
    derivWithin (fun x => √(f x)) s x = derivWithin f s x / (2 * √(f x)) 
Arguments: {f : ℝ → ℝ} {s : Set ℝ} {x : ℝ} (hf : DifferentiableWithinAt ℝ f s x) (hx : f x ≠ 0) (hxs : UniqueDiffWithinAt ℝ s x)
Goal: derivWithin (fun x => √(f x)) s x = derivWithin f s x / (2 * √(f x))
-- deriv_sqrt
@[simp]
theorem deriv_sqrt (hf : DifferentiableAt ℝ f x) (hx : f x ≠ 0) :
    deriv (fun x => √(f x)) x = deriv f x / (2 * √(f x)) 
Arguments: {f : ℝ → ℝ} {x : ℝ} (hf : DifferentiableAt ℝ f x) (hx : f x ≠ 0)
Goal: deriv (fun x => √(f x)) x = deriv f x / (2 * √(f x))
-- HasFDerivAt.sqrt
theorem HasFDerivAt.sqrt (hf : HasFDerivAt f f' x) (hx : f x ≠ 0) :
    HasFDerivAt (fun y => √(f y)) ((1 / (2 * √(f x))) • f') x 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] {f : E → ℝ} {x : E} {f' : E →L[ℝ] ℝ} (hf : HasFDerivAt f f' x) (hx : f x ≠ 0)
Goal: HasFDerivAt (fun y => √(f y)) ((1 / (2 * √(f x))) • f') x
-- HasStrictFDerivAt.sqrt
theorem HasStrictFDerivAt.sqrt (hf : HasStrictFDerivAt f f' x) (hx : f x ≠ 0) :
    HasStrictFDerivAt (fun y => √(f y)) ((1 / (2 * √(f x))) • f') x 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] {f : E → ℝ} {x : E} {f' : E →L[ℝ] ℝ} (hf : HasStrictFDerivAt f f' x) (hx : f x ≠ 0)
Goal: HasStrictFDerivAt (fun y => √(f y)) ((1 / (2 * √(f x))) • f') x
-- HasFDerivWithinAt.sqrt
theorem HasFDerivWithinAt.sqrt (hf : HasFDerivWithinAt f f' s x) (hx : f x ≠ 0) :
    HasFDerivWithinAt (fun y => √(f y)) ((1 / (2 * √(f x))) • f') s x 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] {f : E → ℝ} {s : Set E} {x : E} {f' : E →L[ℝ] ℝ} (hf : HasFDerivWithinAt f f' s x) (hx : f x ≠ 0)
Goal: HasFDerivWithinAt (fun y => √(f y)) ((1 / (2 * √(f x))) • f') s x
-- DifferentiableWithinAt.sqrt
theorem DifferentiableWithinAt.sqrt (hf : DifferentiableWithinAt ℝ f s x) (hx : f x ≠ 0) :
    DifferentiableWithinAt ℝ (fun y => √(f y)) s x 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] {f : E → ℝ} {s : Set E} {x : E} (hf : DifferentiableWithinAt ℝ f s x) (hx : f x ≠ 0)
Goal: DifferentiableWithinAt ℝ (fun y => √(f y)) s x
-- DifferentiableAt.sqrt
theorem DifferentiableAt.sqrt (hf : DifferentiableAt ℝ f x) (hx : f x ≠ 0) :
    DifferentiableAt ℝ (fun y => √(f y)) x 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] {f : E → ℝ} {x : E} (hf : DifferentiableAt ℝ f x) (hx : f x ≠ 0)
Goal: DifferentiableAt ℝ (fun y => √(f y)) x
-- DifferentiableOn.sqrt
theorem DifferentiableOn.sqrt (hf : DifferentiableOn ℝ f s) (hs : ∀ x ∈ s, f x ≠ 0) :
    DifferentiableOn ℝ (fun y => √(f y)) s 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] {f : E → ℝ} {s : Set E} (hf : DifferentiableOn ℝ f s) (hs : ∀ x ∈ s, f x ≠ 0)
Goal: DifferentiableOn ℝ (fun y => √(f y)) s
-- Differentiable.sqrt
theorem Differentiable.sqrt (hf : Differentiable ℝ f) (hs : ∀ x, f x ≠ 0) :
    Differentiable ℝ fun y => √(f y) 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] {f : E → ℝ} (hf : Differentiable ℝ f) (hs : ∀ (x : E), f x ≠ 0)
Goal: Differentiable ℝ fun y => √(f y)
-- fderivWithin_sqrt
theorem fderivWithin_sqrt (hf : DifferentiableWithinAt ℝ f s x) (hx : f x ≠ 0)
    (hxs : UniqueDiffWithinAt ℝ s x) :
    fderivWithin ℝ (fun x => √(f x)) s x = (1 / (2 * √(f x))) • fderivWithin ℝ f s x 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] {f : E → ℝ} {s : Set E} {x : E} (hf : DifferentiableWithinAt ℝ f s x) (hx : f x ≠ 0) (hxs : UniqueDiffWithinAt ℝ s x)
Goal: fderivWithin ℝ (fun x => √(f x)) s x = (1 / (2 * √(f x))) • fderivWithin ℝ f s x
-- fderiv_sqrt
@[simp]
theorem fderiv_sqrt (hf : DifferentiableAt ℝ f x) (hx : f x ≠ 0) :
    fderiv ℝ (fun x => √(f x)) x = (1 / (2 * √(f x))) • fderiv ℝ f x 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] {f : E → ℝ} {x : E} (hf : DifferentiableAt ℝ f x) (hx : f x ≠ 0)
Goal: fderiv ℝ (fun x => √(f x)) x = (1 / (2 * √(f x))) • fderiv ℝ f x
-- ContDiffAt.sqrt
theorem ContDiffAt.sqrt (hf : ContDiffAt ℝ n f x) (hx : f x ≠ 0) :
    ContDiffAt ℝ n (fun y => √(f y)) x 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] {f : E → ℝ} {n : ℕ∞} {x : E} (hf : ContDiffAt ℝ n f x) (hx : f x ≠ 0)
Goal: ContDiffAt ℝ n (fun y => √(f y)) x
-- ContDiffWithinAt.sqrt
theorem ContDiffWithinAt.sqrt (hf : ContDiffWithinAt ℝ n f s x) (hx : f x ≠ 0) :
    ContDiffWithinAt ℝ n (fun y => √(f y)) s x 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] {f : E → ℝ} {n : ℕ∞} {s : Set E} {x : E} (hf : ContDiffWithinAt ℝ n f s x) (hx : f x ≠ 0)
Goal: ContDiffWithinAt ℝ n (fun y => √(f y)) s x
-- ContDiffOn.sqrt
theorem ContDiffOn.sqrt (hf : ContDiffOn ℝ n f s) (hs : ∀ x ∈ s, f x ≠ 0) :
    ContDiffOn ℝ n (fun y => √(f y)) s 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] {f : E → ℝ} {n : ℕ∞} {s : Set E} (hf : ContDiffOn ℝ n f s) (hs : ∀ x ∈ s, f x ≠ 0)
Goal: ContDiffOn ℝ n (fun y => √(f y)) s
-- ContDiff.sqrt
theorem ContDiff.sqrt (hf : ContDiff ℝ n f) (h : ∀ x, f x ≠ 0) : ContDiff ℝ n fun y => √(f y) 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] {f : E → ℝ} {n : ℕ∞} (hf : ContDiff ℝ n f) (h : ∀ (x : E), f x ≠ 0)
Goal: ContDiff ℝ n fun y => √(f y)
-- Complex.cpow_eq_pow
@[simp]
theorem cpow_eq_pow (x y : ℂ) : cpow x y = x ^ y 
Arguments: (x y : ℂ)
Goal: x.cpow y = x ^ y
-- Complex.cpow_def
theorem cpow_def (x y : ℂ) : x ^ y = if x = 0 then if y = 0 then 1 else 0 else exp (log x * y) 
Arguments: (x y : ℂ)
Goal: x ^ y = if x = 0 then if y = 0 then 1 else 0 else Complex.exp (Complex.log x * y)
-- Complex.cpow_def_of_ne_zero
theorem cpow_def_of_ne_zero {x : ℂ} (hx : x ≠ 0) (y : ℂ) : x ^ y = exp (log x * y) 
Arguments: {x : ℂ} (hx : x ≠ 0) (y : ℂ)
Goal: x ^ y = Complex.exp (Complex.log x * y)
-- Complex.cpow_zero
@[simp]
theorem cpow_zero (x : ℂ) : x ^ (0 : ℂ) = 1 
Arguments: (x : ℂ)
Goal: x ^ 0 = 1
-- Complex.cpow_eq_zero_iff
@[simp]
theorem cpow_eq_zero_iff (x y : ℂ) : x ^ y = 0 ↔ x = 0 ∧ y ≠ 0 
Arguments: (x y : ℂ)
Goal: x ^ y = 0 ↔ x = 0 ∧ y ≠ 0
-- Complex.zero_cpow
@[simp]
theorem zero_cpow {x : ℂ} (h : x ≠ 0) : (0 : ℂ) ^ x = 0 
Arguments: {x : ℂ} (h : x ≠ 0)
Goal: 0 ^ x = 0
-- Complex.zero_cpow_eq_iff
theorem zero_cpow_eq_iff {x : ℂ} {a : ℂ} : (0 : ℂ) ^ x = a ↔ x ≠ 0 ∧ a = 0 ∨ x = 0 ∧ a = 1 
Arguments: {x a : ℂ}
Goal: 0 ^ x = a ↔ x ≠ 0 ∧ a = 0 ∨ x = 0 ∧ a = 1
-- Complex.eq_zero_cpow_iff
theorem eq_zero_cpow_iff {x : ℂ} {a : ℂ} : a = (0 : ℂ) ^ x ↔ x ≠ 0 ∧ a = 0 ∨ x = 0 ∧ a = 1 
Arguments: {x a : ℂ}
Goal: a = 0 ^ x ↔ x ≠ 0 ∧ a = 0 ∨ x = 0 ∧ a = 1
-- Complex.cpow_one
@[simp]
theorem cpow_one (x : ℂ) : x ^ (1 : ℂ) = x 
Arguments: (x : ℂ)
Goal: x ^ 1 = x
-- Complex.one_cpow
@[simp]
theorem one_cpow (x : ℂ) : (1 : ℂ) ^ x = 1 
Arguments: (x : ℂ)
Goal: 1 ^ x = 1
-- Complex.cpow_add
theorem cpow_add {x : ℂ} (y z : ℂ) (hx : x ≠ 0) : x ^ (y + z) = x ^ y * x ^ z 
Arguments: {x : ℂ} (y z : ℂ) (hx : x ≠ 0)
Goal: x ^ (y + z) = x ^ y * x ^ z
-- Complex.cpow_mul
theorem cpow_mul {x y : ℂ} (z : ℂ) (h₁ : -π < (log x * y).im) (h₂ : (log x * y).im ≤ π) :
    x ^ (y * z) = (x ^ y) ^ z 
Arguments: {x y : ℂ} (z : ℂ) (h₁ : -π < (Complex.log x * y).im) (h₂ : (Complex.log x * y).im ≤ π)
Goal: x ^ (y * z) = (x ^ y) ^ z
-- Complex.cpow_neg
theorem cpow_neg (x y : ℂ) : x ^ (-y) = (x ^ y)⁻¹ 
Arguments: (x y : ℂ)
Goal: x ^ (-y) = (x ^ y)⁻¹
-- Complex.cpow_sub
theorem cpow_sub {x : ℂ} (y z : ℂ) (hx : x ≠ 0) : x ^ (y - z) = x ^ y / x ^ z 
Arguments: {x : ℂ} (y z : ℂ) (hx : x ≠ 0)
Goal: x ^ (y - z) = x ^ y / x ^ z
-- Complex.cpow_neg_one
theorem cpow_neg_one (x : ℂ) : x ^ (-1 : ℂ) = x⁻¹ 
Arguments: (x : ℂ)
Goal: x ^ (-1) = x⁻¹
-- Complex.cpow_int_mul
lemma cpow_int_mul (x : ℂ) (n : ℤ) (y : ℂ) : x ^ (n * y) = (x ^ y) ^ n 
Arguments: (x : ℂ) (n : ℤ) (y : ℂ)
Goal: x ^ (↑n * y) = (x ^ y) ^ n
-- Complex.cpow_mul_int
lemma cpow_mul_int (x y : ℂ) (n : ℤ) : x ^ (y * n) = (x ^ y) ^ n 
Arguments: (x y : ℂ) (n : ℤ)
Goal: x ^ (y * ↑n) = (x ^ y) ^ n
-- Complex.cpow_nat_mul
lemma cpow_nat_mul (x : ℂ) (n : ℕ) (y : ℂ) : x ^ (n * y) = (x ^ y) ^ n 
Arguments: (x : ℂ) (n : ℕ) (y : ℂ)
Goal: x ^ (↑n * y) = (x ^ y) ^ n
-- Complex.cpow_ofNat_mul
lemma cpow_ofNat_mul (x : ℂ) (n : ℕ) [n.AtLeastTwo] (y : ℂ) :
    x ^ (no_index (OfNat.ofNat n) * y) = (x ^ y) ^ (OfNat.ofNat n : ℕ) 
Arguments: (x : ℂ) (n : ℕ) [n.AtLeastTwo] (y : ℂ)
Goal: x ^ (OfNat.ofNat n * y) = (x ^ y) ^ OfNat.ofNat n
-- Complex.cpow_mul_nat
lemma cpow_mul_nat (x y : ℂ) (n : ℕ) : x ^ (y * n) = (x ^ y) ^ n 
Arguments: (x y : ℂ) (n : ℕ)
Goal: x ^ (y * ↑n) = (x ^ y) ^ n
-- Complex.cpow_mul_ofNat
lemma cpow_mul_ofNat (x y : ℂ) (n : ℕ) [n.AtLeastTwo] :
    x ^ (y * no_index (OfNat.ofNat n)) = (x ^ y) ^ (OfNat.ofNat n : ℕ) 
Arguments: (x y : ℂ) (n : ℕ) [n.AtLeastTwo]
Goal: x ^ (y * OfNat.ofNat n) = (x ^ y) ^ OfNat.ofNat n
-- Complex.cpow_natCast
@[simp, norm_cast]
theorem cpow_natCast (x : ℂ) (n : ℕ) : x ^ (n : ℂ) = x ^ n 
Arguments: (x : ℂ) (n : ℕ)
Goal: x ^ ↑n = x ^ n
-- Complex.cpow_ofNat
@[simp]
lemma cpow_ofNat (x : ℂ) (n : ℕ) [n.AtLeastTwo] :
    x ^ (no_index (OfNat.ofNat n) : ℂ) = x ^ (OfNat.ofNat n : ℕ) 
Arguments: (x : ℂ) (n : ℕ) [n.AtLeastTwo]
Goal: x ^ OfNat.ofNat n = x ^ OfNat.ofNat n
-- Complex.cpow_two
theorem cpow_two (x : ℂ) : x ^ (2 : ℂ) = x ^ (2 : ℕ) 
Arguments: (x : ℂ)
Goal: x ^ 2 = x ^ 2
-- Complex.cpow_intCast
@[simp, norm_cast]
theorem cpow_intCast (x : ℂ) (n : ℤ) : x ^ (n : ℂ) = x ^ n 
Arguments: (x : ℂ) (n : ℤ)
Goal: x ^ ↑n = x ^ n
-- Complex.cpow_nat_inv_pow
@[simp]
theorem cpow_nat_inv_pow (x : ℂ) {n : ℕ} (hn : n ≠ 0) : (x ^ (n⁻¹ : ℂ)) ^ n = x 
Arguments: (x : ℂ) {n : ℕ} (hn : n ≠ 0)
Goal: (x ^ (↑n)⁻¹) ^ n = x
-- Complex.cpow_ofNat_inv_pow
@[simp]
lemma cpow_ofNat_inv_pow (x : ℂ) (n : ℕ) [n.AtLeastTwo] :
    (x ^ ((no_index (OfNat.ofNat n) : ℂ)⁻¹)) ^ (no_index (OfNat.ofNat n) : ℕ) = x 
Arguments: (x : ℂ) (n : ℕ) [n.AtLeastTwo]
Goal: (x ^ (OfNat.ofNat n)⁻¹) ^ OfNat.ofNat n = x
-- Complex.cpow_int_mul'
lemma cpow_int_mul' {x : ℂ} {n : ℤ} (hlt : -π < n * x.arg) (hle : n * x.arg ≤ π) (y : ℂ) :
    x ^ (n * y) = (x ^ n) ^ y 
Arguments: {x : ℂ} {n : ℤ} (hlt : -π < ↑n * x.arg) (hle : ↑n * x.arg ≤ π) (y : ℂ)
Goal: x ^ (↑n * y) = (x ^ n) ^ y
-- Complex.cpow_nat_mul'
lemma cpow_nat_mul' {x : ℂ} {n : ℕ} (hlt : -π < n * x.arg) (hle : n * x.arg ≤ π) (y : ℂ) :
    x ^ (n * y) = (x ^ n) ^ y 
Arguments: {x : ℂ} {n : ℕ} (hlt : -π < ↑n * x.arg) (hle : ↑n * x.arg ≤ π) (y : ℂ)
Goal: x ^ (↑n * y) = (x ^ n) ^ y
-- Complex.cpow_ofNat_mul'
lemma cpow_ofNat_mul' {x : ℂ} {n : ℕ} [n.AtLeastTwo] (hlt : -π < OfNat.ofNat n * x.arg)
    (hle : OfNat.ofNat n * x.arg ≤ π) (y : ℂ) :
    x ^ (OfNat.ofNat n * y) = (x ^ (OfNat.ofNat n : ℕ)) ^ y 
Arguments: {x : ℂ} {n : ℕ} [n.AtLeastTwo] (hlt : -π < OfNat.ofNat n * x.arg) (hle : OfNat.ofNat n * x.arg ≤ π) (y : ℂ)
Goal: x ^ (OfNat.ofNat n * y) = (x ^ OfNat.ofNat n) ^ y
-- Complex.pow_cpow_nat_inv
lemma pow_cpow_nat_inv {x : ℂ} {n : ℕ} (h₀ : n ≠ 0) (hlt : -(π / n) < x.arg) (hle : x.arg ≤ π / n) :
    (x ^ n) ^ (n⁻¹ : ℂ) = x 
Arguments: {x : ℂ} {n : ℕ} (h₀ : n ≠ 0) (hlt : -(π / ↑n) < x.arg) (hle : x.arg ≤ π / ↑n)
Goal: (x ^ n) ^ (↑n)⁻¹ = x
-- Complex.pow_cpow_ofNat_inv
lemma pow_cpow_ofNat_inv {x : ℂ} {n : ℕ} [n.AtLeastTwo] (hlt : -(π / OfNat.ofNat n) < x.arg)
    (hle : x.arg ≤ π / OfNat.ofNat n) :
    (x ^ (OfNat.ofNat n : ℕ)) ^ ((OfNat.ofNat n : ℂ)⁻¹) = x 
Arguments: {x : ℂ} {n : ℕ} [n.AtLeastTwo] (hlt : -(π / OfNat.ofNat n) < x.arg) (hle : x.arg ≤ π / OfNat.ofNat n)
Goal: (x ^ OfNat.ofNat n) ^ (OfNat.ofNat n)⁻¹ = x
-- Complex.sq_cpow_two_inv
lemma sq_cpow_two_inv {x : ℂ} (hx : 0 < x.re) : (x ^ (2 : ℕ)) ^ (2⁻¹ : ℂ) = x 
Arguments: {x : ℂ} (hx : 0 < x.re)
Goal: (x ^ 2) ^ 2⁻¹ = x
-- Complex.mul_cpow_ofReal_nonneg
theorem mul_cpow_ofReal_nonneg {a b : ℝ} (ha : 0 ≤ a) (hb : 0 ≤ b) (r : ℂ) :
    ((a : ℂ) * (b : ℂ)) ^ r = (a : ℂ) ^ r * (b : ℂ) ^ r 
Arguments: {a b : ℝ} (ha : 0 ≤ a) (hb : 0 ≤ b) (r : ℂ)
Goal: (↑a * ↑b) ^ r = ↑a ^ r * ↑b ^ r
-- Complex.natCast_mul_natCast_cpow
lemma natCast_mul_natCast_cpow (m n : ℕ) (s : ℂ) : (m * n : ℂ) ^ s = m ^ s * n ^ s 
Arguments: (m n : ℕ) (s : ℂ)
Goal: (↑m * ↑n) ^ s = ↑m ^ s * ↑n ^ s
-- Complex.natCast_cpow_natCast_mul
lemma natCast_cpow_natCast_mul (n m : ℕ) (z : ℂ) : (n : ℂ) ^ (m * z) = ((n : ℂ) ^ m) ^ z 
Arguments: (n m : ℕ) (z : ℂ)
Goal: ↑n ^ (↑m * z) = (↑n ^ m) ^ z
-- Complex.inv_cpow_eq_ite
theorem inv_cpow_eq_ite (x : ℂ) (n : ℂ) :
    x⁻¹ ^ n = if x.arg = π then conj (x ^ conj n)⁻¹ else (x ^ n)⁻¹ 
Arguments: (x n : ℂ)
Goal: x⁻¹ ^ n = if x.arg = π then (starRingEnd ℂ) (x ^ (starRingEnd ℂ) n)⁻¹ else (x ^ n)⁻¹
-- Complex.inv_cpow
theorem inv_cpow (x : ℂ) (n : ℂ) (hx : x.arg ≠ π) : x⁻¹ ^ n = (x ^ n)⁻¹ 
Arguments: (x n : ℂ) (hx : x.arg ≠ π)
Goal: x⁻¹ ^ n = (x ^ n)⁻¹
-- Complex.inv_cpow_eq_ite'
theorem inv_cpow_eq_ite' (x : ℂ) (n : ℂ) :
    (x ^ n)⁻¹ = if x.arg = π then conj (x⁻¹ ^ conj n) else x⁻¹ ^ n 
Arguments: (x n : ℂ)
Goal: (x ^ n)⁻¹ = if x.arg = π then (starRingEnd ℂ) (x⁻¹ ^ (starRingEnd ℂ) n) else x⁻¹ ^ n
-- Complex.conj_cpow_eq_ite
theorem conj_cpow_eq_ite (x : ℂ) (n : ℂ) :
    conj x ^ n = if x.arg = π then x ^ n else conj (x ^ conj n) 
Arguments: (x n : ℂ)
Goal: (starRingEnd ℂ) x ^ n = if x.arg = π then x ^ n else (starRingEnd ℂ) (x ^ (starRingEnd ℂ) n)
-- Complex.conj_cpow
theorem conj_cpow (x : ℂ) (n : ℂ) (hx : x.arg ≠ π) : conj x ^ n = conj (x ^ conj n) 
Arguments: (x n : ℂ) (hx : x.arg ≠ π)
Goal: (starRingEnd ℂ) x ^ n = (starRingEnd ℂ) (x ^ (starRingEnd ℂ) n)
-- Complex.cpow_conj
theorem cpow_conj (x : ℂ) (n : ℂ) (hx : x.arg ≠ π) : x ^ conj n = conj (conj x ^ n) 
Arguments: (x n : ℂ) (hx : x.arg ≠ π)
Goal: x ^ (starRingEnd ℂ) n = (starRingEnd ℂ) ((starRingEnd ℂ) x ^ n)
-- Complex.log_re
theorem log_re (x : ℂ) : x.log.re = x.abs.log 
Arguments: (x : ℂ)
Goal: (Complex.log x).re = Real.log (Complex.abs x)
-- Complex.log_im
theorem log_im (x : ℂ) : x.log.im = x.arg 
Arguments: (x : ℂ)
Goal: (Complex.log x).im = x.arg
-- Complex.neg_pi_lt_log_im
theorem neg_pi_lt_log_im (x : ℂ) : -π < (log x).im 
Arguments: (x : ℂ)
Goal: -Real.pi < (Complex.log x).im
-- Complex.log_im_le_pi
theorem log_im_le_pi (x : ℂ) : (log x).im ≤ π 
Arguments: (x : ℂ)
Goal: (Complex.log x).im ≤ Real.pi
-- Complex.exp_log
theorem exp_log {x : ℂ} (hx : x ≠ 0) : exp (log x) = x 
Arguments: {x : ℂ} (hx : x ≠ 0)
Goal: Complex.exp (Complex.log x) = x
-- Complex.range_exp
@[simp]
theorem range_exp : Set.range exp = {0}ᶜ 
Goal: Set.range Complex.exp = {0}ᶜ
-- Complex.log_exp
theorem log_exp {x : ℂ} (hx₁ : -π < x.im) (hx₂ : x.im ≤ π) : log (exp x) = x 
Arguments: {x : ℂ} (hx₁ : -Real.pi < x.im) (hx₂ : x.im ≤ Real.pi)
Goal: Complex.log (Complex.exp x) = x
-- Complex.exp_inj_of_neg_pi_lt_of_le_pi
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 
Arguments: {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)
Goal: x = y
-- Complex.ofReal_log
theorem ofReal_log {x : ℝ} (hx : 0 ≤ x) : (x.log : ℂ) = log x 
Arguments: {x : ℝ} (hx : 0 ≤ x)
Goal: ↑(Real.log x) = Complex.log ↑x
-- Complex.natCast_log
@[simp, norm_cast]
lemma natCast_log {n : ℕ} : Real.log n = log n 
Arguments: {n : ℕ}
Goal: ↑(Real.log ↑n) = Complex.log ↑n
-- Complex.ofNat_log
@[simp]
lemma ofNat_log {n : ℕ} [n.AtLeastTwo] :
    Real.log (no_index (OfNat.ofNat n)) = log (OfNat.ofNat n) 
Arguments: {n : ℕ} [n.AtLeastTwo]
Goal: ↑(Real.log (OfNat.ofNat n)) = Complex.log (OfNat.ofNat n)
-- Complex.log_ofReal_re
theorem log_ofReal_re (x : ℝ) : (log (x : ℂ)).re = Real.log x 
Arguments: (x : ℝ)
Goal: (Complex.log ↑x).re = Real.log x
-- Complex.log_ofReal_mul
theorem log_ofReal_mul {r : ℝ} (hr : 0 < r) {x : ℂ} (hx : x ≠ 0) :
    log (r * x) = Real.log r + log x 
Arguments: {r : ℝ} (hr : 0 < r) {x : ℂ} (hx : x ≠ 0)
Goal: Complex.log (↑r * x) = ↑(Real.log r) + Complex.log x
-- Complex.log_mul_ofReal
theorem log_mul_ofReal (r : ℝ) (hr : 0 < r) (x : ℂ) (hx : x ≠ 0) :
    log (x * r) = Real.log r + log x 
Arguments: (r : ℝ) (hr : 0 < r) (x : ℂ) (hx : x ≠ 0)
Goal: Complex.log (x * ↑r) = ↑(Real.log r) + Complex.log x
-- Complex.log_mul_eq_add_log_iff
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 (-π) π 
Arguments: {x y : ℂ} (hx₀ : x ≠ 0) (hy₀ : y ≠ 0)
Goal: Complex.log (x * y) = Complex.log x + Complex.log y ↔ x.arg + y.arg ∈ Set.Ioc (-Real.pi) Real.pi
-- Complex.log_zero
@[simp]
theorem log_zero : log 0 = 0 
Goal: Complex.log 0 = 0
-- Complex.log_one
@[simp]
theorem log_one : log 1 = 0 
Goal: Complex.log 1 = 0
-- Complex.log_neg_one
theorem log_neg_one : log (-1) = π * I 
Goal: Complex.log (-1) = ↑Real.pi * Complex.I
-- Complex.log_I
theorem log_I : log I = π / 2 * I 
Goal: Complex.log Complex.I = ↑Real.pi / 2 * Complex.I
-- Complex.log_neg_I
theorem log_neg_I : log (-I) = -(π / 2) * I 
Goal: Complex.log (-Complex.I) = -(↑Real.pi / 2) * Complex.I
-- Complex.log_conj_eq_ite
theorem log_conj_eq_ite (x : ℂ) : log (conj x) = if x.arg = π then log x else conj (log x) 
Arguments: (x : ℂ)
Goal: Complex.log ((starRingEnd ℂ) x) = if x.arg = Real.pi then Complex.log x else (starRingEnd ℂ) (Complex.log x)
-- Complex.log_conj
theorem log_conj (x : ℂ) (h : x.arg ≠ π) : log (conj x) = conj (log x) 
Arguments: (x : ℂ) (h : x.arg ≠ Real.pi)
Goal: Complex.log ((starRingEnd ℂ) x) = (starRingEnd ℂ) (Complex.log x)
-- Complex.log_inv_eq_ite
theorem log_inv_eq_ite (x : ℂ) : log x⁻¹ = if x.arg = π then -conj (log x) else -log x 
Arguments: (x : ℂ)
Goal: Complex.log x⁻¹ = if x.arg = Real.pi then -(starRingEnd ℂ) (Complex.log x) else -Complex.log x
-- Complex.log_inv
theorem log_inv (x : ℂ) (hx : x.arg ≠ π) : log x⁻¹ = -log x 
Arguments: (x : ℂ) (hx : x.arg ≠ Real.pi)
Goal: Complex.log x⁻¹ = -Complex.log x
-- Complex.two_pi_I_ne_zero
theorem two_pi_I_ne_zero : (2 * π * I : ℂ) ≠ 0 
Goal: 2 * ↑Real.pi * Complex.I ≠ 0
-- Complex.exp_eq_one_iff
theorem exp_eq_one_iff {x : ℂ} : exp x = 1 ↔ ∃ n : ℤ, x = n * (2 * π * I) 
Arguments: {x : ℂ}
Goal: Complex.exp x = 1 ↔ ∃ n, x = ↑n * (2 * ↑Real.pi * Complex.I)
-- Complex.exp_eq_exp_iff_exp_sub_eq_one
theorem exp_eq_exp_iff_exp_sub_eq_one {x y : ℂ} : exp x = exp y ↔ exp (x - y) = 1 
Arguments: {x y : ℂ}
Goal: Complex.exp x = Complex.exp y ↔ Complex.exp (x - y) = 1
-- Complex.exp_eq_exp_iff_exists_int
theorem exp_eq_exp_iff_exists_int {x y : ℂ} : exp x = exp y ↔ ∃ n : ℤ, x = y + n * (2 * π * I) 
Arguments: {x y : ℂ}
Goal: Complex.exp x = Complex.exp y ↔ ∃ n, x = y + ↑n * (2 * ↑Real.pi * Complex.I)
-- Complex.countable_preimage_exp
@[simp]
theorem countable_preimage_exp {s : Set ℂ} : (exp ⁻¹' s).Countable ↔ s.Countable 
Arguments: {s : Set ℂ}
Goal: (Complex.exp ⁻¹' s).Countable ↔ s.Countable
-- Complex.tendsto_log_nhdsWithin_im_neg_of_re_neg_of_im_zero
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) 
Arguments: {z : ℂ} (hre : z.re < 0) (him : z.im = 0)
Goal: Filter.Tendsto Complex.log (nhdsWithin z {z | z.im < 0}) (nhds (↑(Real.log (Complex.abs z)) - ↑Real.pi * Complex.I))
-- Complex.continuousWithinAt_log_of_re_neg_of_im_zero
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 
Arguments: {z : ℂ} (hre : z.re < 0) (him : z.im = 0)
Goal: ContinuousWithinAt Complex.log {z | 0 ≤ z.im} z
-- Complex.tendsto_log_nhdsWithin_im_nonneg_of_re_neg_of_im_zero
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) 
Arguments: {z : ℂ} (hre : z.re < 0) (him : z.im = 0)
Goal: Filter.Tendsto Complex.log (nhdsWithin z {z | 0 ≤ z.im}) (nhds (↑(Real.log (Complex.abs z)) + ↑Real.pi * Complex.I))
-- Complex.map_exp_comap_re_atBot
@[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}ᶜ
-- Complex.map_exp_comap_re_atTop
@[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 ℂ
-- continuousAt_clog
theorem continuousAt_clog {x : ℂ} (h : x ∈ slitPlane) : ContinuousAt log x 
Arguments: {x : ℂ} (h : x ∈ Complex.slitPlane)
Goal: ContinuousAt Complex.log x
-- Filter.Tendsto.clog
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) 
Arguments: {α : Type u_1} {l : Filter α} {f : α → ℂ} {x : ℂ} (h : Filter.Tendsto f l (nhds x)) (hx : x ∈ Complex.slitPlane)
Goal: Filter.Tendsto (fun t => Complex.log (f t)) l (nhds (Complex.log x))
-- ContinuousAt.clog
nonrec
theorem _root_.ContinuousAt.clog {f : α → ℂ} {x : α} (h₁ : ContinuousAt f x)
    (h₂ : f x ∈ slitPlane) : ContinuousAt (fun t => log (f t)) x 
Arguments: {α : Type u_1} [TopologicalSpace α] {f : α → ℂ} {x : α} (h₁ : ContinuousAt f x) (h₂ : f x ∈ Complex.slitPlane)
Goal: ContinuousAt (fun t => Complex.log (f t)) x