ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Real.Angle.cos_nonneg_iff_abs_toReal_le_pi_div_two
theorem cos_nonneg_iff_abs_toReal_le_pi_div_two {θ : Angle} : 0 ≤ cos θ ↔ |θ.toReal| ≤ π / 2 
Arguments: {θ : Real.Angle}
Goal: 0 ≤ θ.cos ↔ |θ.toReal| ≤ π / 2
-- Real.Angle.cos_pos_iff_abs_toReal_lt_pi_div_two
theorem cos_pos_iff_abs_toReal_lt_pi_div_two {θ : Angle} : 0 < cos θ ↔ |θ.toReal| < π / 2 
Arguments: {θ : Real.Angle}
Goal: 0 < θ.cos ↔ |θ.toReal| < π / 2
-- Real.Angle.cos_neg_iff_pi_div_two_lt_abs_toReal
theorem cos_neg_iff_pi_div_two_lt_abs_toReal {θ : Angle} : cos θ < 0 ↔ π / 2 < |θ.toReal| 
Arguments: {θ : Real.Angle}
Goal: θ.cos < 0 ↔ π / 2 < |θ.toReal|
-- Real.Angle.abs_cos_eq_abs_sin_of_two_nsmul_add_two_nsmul_eq_pi
theorem abs_cos_eq_abs_sin_of_two_nsmul_add_two_nsmul_eq_pi {θ ψ : Angle}
    (h : (2 : ℕ) • θ + (2 : ℕ) • ψ = π) : |cos θ| = |sin ψ| 
Arguments: {θ ψ : Real.Angle} (h : 2 • θ + 2 • ψ = ↑π)
Goal: |θ.cos| = |ψ.sin|
-- Real.Angle.abs_cos_eq_abs_sin_of_two_zsmul_add_two_zsmul_eq_pi
theorem abs_cos_eq_abs_sin_of_two_zsmul_add_two_zsmul_eq_pi {θ ψ : Angle}
    (h : (2 : ℤ) • θ + (2 : ℤ) • ψ = π) : |cos θ| = |sin ψ| 
Arguments: {θ ψ : Real.Angle} (h : 2 • θ + 2 • ψ = ↑π)
Goal: |θ.cos| = |ψ.sin|
-- Real.Angle.tan_eq_sin_div_cos
theorem tan_eq_sin_div_cos (θ : Angle) : tan θ = sin θ / cos θ 
Arguments: (θ : Real.Angle)
Goal: θ.tan = θ.sin / θ.cos
-- Real.Angle.tan_coe
@[simp]
theorem tan_coe (x : ℝ) : tan (x : Angle) = Real.tan x 
Arguments: (x : ℝ)
Goal: (↑x).tan = Real.tan x
-- Real.Angle.tan_zero
@[simp]
theorem tan_zero : tan (0 : Angle) = 0 
Goal: Real.Angle.tan 0 = 0
-- Real.Angle.tan_coe_pi
theorem tan_coe_pi : tan (π : Angle) = 0 
Goal: (↑π).tan = 0
-- Real.Angle.tan_periodic
theorem tan_periodic : Function.Periodic tan (π : Angle) 
Goal: Function.Periodic Real.Angle.tan ↑π
-- Real.Angle.tan_add_pi
@[simp]
theorem tan_add_pi (θ : Angle) : tan (θ + π) = tan θ 
Arguments: (θ : Real.Angle)
Goal: (θ + ↑π).tan = θ.tan
-- Real.Angle.tan_sub_pi
@[simp]
theorem tan_sub_pi (θ : Angle) : tan (θ - π) = tan θ 
Arguments: (θ : Real.Angle)
Goal: (θ - ↑π).tan = θ.tan
-- Real.Angle.tan_toReal
@[simp]
theorem tan_toReal (θ : Angle) : Real.tan θ.toReal = tan θ 
Arguments: (θ : Real.Angle)
Goal: Real.tan θ.toReal = θ.tan
-- Real.Angle.tan_eq_of_two_nsmul_eq
theorem tan_eq_of_two_nsmul_eq {θ ψ : Angle} (h : (2 : ℕ) • θ = (2 : ℕ) • ψ) : tan θ = tan ψ 
Arguments: {θ ψ : Real.Angle} (h : 2 • θ = 2 • ψ)
Goal: θ.tan = ψ.tan
-- Real.Angle.tan_eq_of_two_zsmul_eq
theorem tan_eq_of_two_zsmul_eq {θ ψ : Angle} (h : (2 : ℤ) • θ = (2 : ℤ) • ψ) : tan θ = tan ψ 
Arguments: {θ ψ : Real.Angle} (h : 2 • θ = 2 • ψ)
Goal: θ.tan = ψ.tan
-- Real.Angle.tan_eq_inv_of_two_nsmul_add_two_nsmul_eq_pi
theorem tan_eq_inv_of_two_nsmul_add_two_nsmul_eq_pi {θ ψ : Angle}
    (h : (2 : ℕ) • θ + (2 : ℕ) • ψ = π) : tan ψ = (tan θ)⁻¹ 
Arguments: {θ ψ : Real.Angle} (h : 2 • θ + 2 • ψ = ↑π)
Goal: ψ.tan = θ.tan⁻¹
-- Real.Angle.tan_eq_inv_of_two_zsmul_add_two_zsmul_eq_pi
theorem tan_eq_inv_of_two_zsmul_add_two_zsmul_eq_pi {θ ψ : Angle}
    (h : (2 : ℤ) • θ + (2 : ℤ) • ψ = π) : tan ψ = (tan θ)⁻¹ 
Arguments: {θ ψ : Real.Angle} (h : 2 • θ + 2 • ψ = ↑π)
Goal: ψ.tan = θ.tan⁻¹
-- Real.Angle.sign_zero
@[simp]
theorem sign_zero : (0 : Angle).sign = 0 
Goal: Real.Angle.sign 0 = 0
-- Real.Angle.sign_coe_pi
@[simp]
theorem sign_coe_pi : (π : Angle).sign = 0 
Goal: (↑π).sign = 0
-- Real.Angle.sign_neg
@[simp]
theorem sign_neg (θ : Angle) : (-θ).sign = -θ.sign 
Arguments: (θ : Real.Angle)
Goal: (-θ).sign = -θ.sign
-- Real.Angle.sign_antiperiodic
theorem sign_antiperiodic : Function.Antiperiodic sign (π : Angle) 
Goal: Function.Antiperiodic Real.Angle.sign ↑π
-- Real.Angle.sign_add_pi
@[simp]
theorem sign_add_pi (θ : Angle) : (θ + π).sign = -θ.sign 
Arguments: (θ : Real.Angle)
Goal: (θ + ↑π).sign = -θ.sign
-- Real.Angle.sign_pi_add
@[simp]
theorem sign_pi_add (θ : Angle) : ((π : Angle) + θ).sign = -θ.sign 
Arguments: (θ : Real.Angle)
Goal: (↑π + θ).sign = -θ.sign
-- Real.Angle.sign_sub_pi
@[simp]
theorem sign_sub_pi (θ : Angle) : (θ - π).sign = -θ.sign 
Arguments: (θ : Real.Angle)
Goal: (θ - ↑π).sign = -θ.sign
-- Real.Angle.sign_pi_sub
@[simp]
theorem sign_pi_sub (θ : Angle) : ((π : Angle) - θ).sign = θ.sign 
Arguments: (θ : Real.Angle)
Goal: (↑π - θ).sign = θ.sign
-- Real.Angle.sign_eq_zero_iff
theorem sign_eq_zero_iff {θ : Angle} : θ.sign = 0 ↔ θ = 0 ∨ θ = π 
Arguments: {θ : Real.Angle}
Goal: θ.sign = 0 ↔ θ = 0 ∨ θ = ↑π
-- Real.Angle.sign_ne_zero_iff
theorem sign_ne_zero_iff {θ : Angle} : θ.sign ≠ 0 ↔ θ ≠ 0 ∧ θ ≠ π 
Arguments: {θ : Real.Angle}
Goal: θ.sign ≠ 0 ↔ θ ≠ 0 ∧ θ ≠ ↑π
-- Real.Angle.toReal_neg_iff_sign_neg
theorem toReal_neg_iff_sign_neg {θ : Angle} : θ.toReal < 0 ↔ θ.sign = -1 
Arguments: {θ : Real.Angle}
Goal: θ.toReal < 0 ↔ θ.sign = -1
-- Real.Angle.toReal_nonneg_iff_sign_nonneg
theorem toReal_nonneg_iff_sign_nonneg {θ : Angle} : 0 ≤ θ.toReal ↔ 0 ≤ θ.sign 
Arguments: {θ : Real.Angle}
Goal: 0 ≤ θ.toReal ↔ 0 ≤ θ.sign
-- Real.Angle.sign_toReal
@[simp]
theorem sign_toReal {θ : Angle} (h : θ ≠ π) : SignType.sign θ.toReal = θ.sign 
Arguments: {θ : Real.Angle} (h : θ ≠ ↑π)
Goal: SignType.sign θ.toReal = θ.sign
-- Real.Angle.coe_abs_toReal_of_sign_nonneg
theorem coe_abs_toReal_of_sign_nonneg {θ : Angle} (h : 0 ≤ θ.sign) : ↑|θ.toReal| = θ 
Arguments: {θ : Real.Angle} (h : 0 ≤ θ.sign)
Goal: ↑|θ.toReal| = θ
-- Real.Angle.neg_coe_abs_toReal_of_sign_nonpos
theorem neg_coe_abs_toReal_of_sign_nonpos {θ : Angle} (h : θ.sign ≤ 0) : -↑|θ.toReal| = θ 
Arguments: {θ : Real.Angle} (h : θ.sign ≤ 0)
Goal: -↑|θ.toReal| = θ
-- Real.Angle.eq_iff_sign_eq_and_abs_toReal_eq
theorem eq_iff_sign_eq_and_abs_toReal_eq {θ ψ : Angle} :
    θ = ψ ↔ θ.sign = ψ.sign ∧ |θ.toReal| = |ψ.toReal| 
Arguments: {θ ψ : Real.Angle}
Goal: θ = ψ ↔ θ.sign = ψ.sign ∧ |θ.toReal| = |ψ.toReal|
-- Real.Angle.eq_iff_abs_toReal_eq_of_sign_eq
theorem eq_iff_abs_toReal_eq_of_sign_eq {θ ψ : Angle} (h : θ.sign = ψ.sign) :
    θ = ψ ↔ |θ.toReal| = |ψ.toReal| 
Arguments: {θ ψ : Real.Angle} (h : θ.sign = ψ.sign)
Goal: θ = ψ ↔ |θ.toReal| = |ψ.toReal|
-- Real.Angle.sign_coe_pi_div_two
@[simp]
theorem sign_coe_pi_div_two : (↑(π / 2) : Angle).sign = 1 
Goal: (↑(π / 2)).sign = 1
-- Real.Angle.sign_coe_neg_pi_div_two
@[simp]
theorem sign_coe_neg_pi_div_two : (↑(-π / 2) : Angle).sign = -1 
Goal: (↑(-π / 2)).sign = -1
-- Real.Angle.sign_coe_nonneg_of_nonneg_of_le_pi
theorem sign_coe_nonneg_of_nonneg_of_le_pi {θ : ℝ} (h0 : 0 ≤ θ) (hpi : θ ≤ π) :
    0 ≤ (θ : Angle).sign 
Arguments: {θ : ℝ} (h0 : 0 ≤ θ) (hpi : θ ≤ π)
Goal: 0 ≤ (↑θ).sign
-- Real.Angle.sign_neg_coe_nonpos_of_nonneg_of_le_pi
theorem sign_neg_coe_nonpos_of_nonneg_of_le_pi {θ : ℝ} (h0 : 0 ≤ θ) (hpi : θ ≤ π) :
    (-θ : Angle).sign ≤ 0 
Arguments: {θ : ℝ} (h0 : 0 ≤ θ) (hpi : θ ≤ π)
Goal: (-↑θ).sign ≤ 0
-- Real.Angle.sign_two_nsmul_eq_sign_iff
theorem sign_two_nsmul_eq_sign_iff {θ : Angle} :
    ((2 : ℕ) • θ).sign = θ.sign ↔ θ = π ∨ |θ.toReal| < π / 2 
Arguments: {θ : Real.Angle}
Goal: (2 • θ).sign = θ.sign ↔ θ = ↑π ∨ |θ.toReal| < π / 2
-- Real.Angle.sign_two_zsmul_eq_sign_iff
theorem sign_two_zsmul_eq_sign_iff {θ : Angle} :
    ((2 : ℤ) • θ).sign = θ.sign ↔ θ = π ∨ |θ.toReal| < π / 2 
Arguments: {θ : Real.Angle}
Goal: (2 • θ).sign = θ.sign ↔ θ = ↑π ∨ |θ.toReal| < π / 2
-- Real.Angle.continuousAt_sign
theorem continuousAt_sign {θ : Angle} (h0 : θ ≠ 0) (hpi : θ ≠ π) : ContinuousAt sign θ 
Arguments: {θ : Real.Angle} (h0 : θ ≠ 0) (hpi : θ ≠ ↑π)
Goal: ContinuousAt Real.Angle.sign θ
-- ContinuousOn.angle_sign_comp
theorem _root_.ContinuousOn.angle_sign_comp {α : Type*} [TopologicalSpace α] {f : α → Angle}
    {s : Set α} (hf : ContinuousOn f s) (hs : ∀ z ∈ s, f z ≠ 0 ∧ f z ≠ π) :
    ContinuousOn (sign ∘ f) s 
Arguments: {α : Type u_1} [TopologicalSpace α] {f : α → Real.Angle} {s : Set α} (hf : ContinuousOn f s) (hs : ∀ z ∈ s, f z ≠ 0 ∧ f z ≠ ↑π)
Goal: ContinuousOn (Real.Angle.sign ∘ f) s
-- Real.Angle.sign_eq_of_continuousOn
theorem sign_eq_of_continuousOn {α : Type*} [TopologicalSpace α] {f : α → Angle} {s : Set α}
    {x y : α} (hc : IsConnected s) (hf : ContinuousOn f s) (hs : ∀ z ∈ s, f z ≠ 0 ∧ f z ≠ π)
    (hx : x ∈ s) (hy : y ∈ s) : (f y).sign = (f x).sign 
Arguments: {α : Type u_1} [TopologicalSpace α] {f : α → Real.Angle} {s : Set α} {x y : α} (hc : IsConnected s) (hf : ContinuousOn f s) (hs : ∀ z ∈ s, f z ≠ 0 ∧ f z ≠ ↑π) (hx : x ∈ s) (hy : y ∈ s)
Goal: (f y).sign = (f x).sign
-- expNegInvGlue.zero_of_nonpos
theorem zero_of_nonpos {x : ℝ} (hx : x ≤ 0) : expNegInvGlue x = 0 
Arguments: {x : ℝ} (hx : x ≤ 0)
Goal: expNegInvGlue x = 0
-- expNegInvGlue.zero
@[simp]
protected theorem zero : expNegInvGlue 0 = 0 
Goal: expNegInvGlue 0 = 0
-- expNegInvGlue.pos_of_pos
theorem pos_of_pos {x : ℝ} (hx : 0 < x) : 0 < expNegInvGlue x 
Arguments: {x : ℝ} (hx : 0 < x)
Goal: 0 < expNegInvGlue x
-- expNegInvGlue.nonneg
theorem nonneg (x : ℝ) : 0 ≤ expNegInvGlue x 
Arguments: (x : ℝ)
Goal: 0 ≤ expNegInvGlue x
-- expNegInvGlue.zero_iff_nonpos
@[simp] theorem zero_iff_nonpos {x : ℝ} : expNegInvGlue x = 0 ↔ x ≤ 0 
Arguments: {x : ℝ}
Goal: expNegInvGlue x = 0 ↔ x ≤ 0
-- expNegInvGlue.tendsto_polynomial_inv_mul_zero
theorem tendsto_polynomial_inv_mul_zero (p : ℝ[X]) :
    Tendsto (fun x ↦ p.eval x⁻¹ * expNegInvGlue x) (𝓝 0) (𝓝 0) 
Arguments: (p : ℝ[X])
Goal: Filter.Tendsto (fun x => Polynomial.eval x⁻¹ p * expNegInvGlue x) (𝓝 0) (𝓝 0)
-- expNegInvGlue.hasDerivAt_polynomial_eval_inv_mul
theorem hasDerivAt_polynomial_eval_inv_mul (p : ℝ[X]) (x : ℝ) :
    HasDerivAt (fun x ↦ p.eval x⁻¹ * expNegInvGlue x)
      ((X ^ 2 * (p - derivative (R := ℝ) p)).eval x⁻¹ * expNegInvGlue x) x 
Arguments: (p : ℝ[X]) (x : ℝ)
Goal: HasDerivAt (fun x => Polynomial.eval x⁻¹ p * expNegInvGlue x)
  (Polynomial.eval x⁻¹ (Polynomial.X ^ 2 * (p - Polynomial.derivative p)) * expNegInvGlue x) x
-- expNegInvGlue.differentiable_polynomial_eval_inv_mul
theorem differentiable_polynomial_eval_inv_mul (p : ℝ[X]) :
    Differentiable ℝ (fun x ↦ p.eval x⁻¹ * expNegInvGlue x) 
Arguments: (p : ℝ[X])
Goal: Differentiable ℝ fun x => Polynomial.eval x⁻¹ p * expNegInvGlue x
-- expNegInvGlue.continuous_polynomial_eval_inv_mul
theorem continuous_polynomial_eval_inv_mul (p : ℝ[X]) :
    Continuous (fun x ↦ p.eval x⁻¹ * expNegInvGlue x) 
Arguments: (p : ℝ[X])
Goal: Continuous fun x => Polynomial.eval x⁻¹ p * expNegInvGlue x
-- expNegInvGlue.contDiff_polynomial_eval_inv_mul
theorem contDiff_polynomial_eval_inv_mul {n : ℕ∞} (p : ℝ[X]) :
    ContDiff ℝ n (fun x ↦ p.eval x⁻¹ * expNegInvGlue x) 
Arguments: {n : ℕ∞} (p : ℝ[X])
Goal: ContDiff ℝ n fun x => Polynomial.eval x⁻¹ p * expNegInvGlue x
-- expNegInvGlue.contDiff
protected theorem contDiff {n} : ContDiff ℝ n expNegInvGlue 
Arguments: {n : ℕ∞}
Goal: ContDiff ℝ n expNegInvGlue
-- Real.smoothTransition.pos_denom
theorem pos_denom (x) : 0 < expNegInvGlue x + expNegInvGlue (1 - x) 
Arguments: (x : ℝ)
Goal: 0 < expNegInvGlue x + expNegInvGlue (1 - x)
-- Real.smoothTransition.one_of_one_le
theorem one_of_one_le (h : 1 ≤ x) : smoothTransition x = 1 
Arguments: {x : ℝ} (h : 1 ≤ x)
Goal: x.smoothTransition = 1
-- Real.smoothTransition.zero_iff_nonpos
@[simp]
nonrec theorem zero_iff_nonpos : smoothTransition x = 0 ↔ x ≤ 0 
Arguments: {x : ℝ}
Goal: x.smoothTransition = 0 ↔ x ≤ 0
-- Real.smoothTransition.zero_of_nonpos
theorem zero_of_nonpos (h : x ≤ 0) : smoothTransition x = 0 
Arguments: {x : ℝ} (h : x ≤ 0)
Goal: x.smoothTransition = 0
-- Real.smoothTransition.zero
@[simp]
protected theorem zero : smoothTransition 0 = 0 
Goal: Real.smoothTransition 0 = 0
-- Real.smoothTransition.one
@[simp]
protected theorem one : smoothTransition 1 = 1 
Goal: Real.smoothTransition 1 = 1
-- Real.smoothTransition.projIcc
@[simp]
protected theorem projIcc :
    smoothTransition (projIcc (0 : ℝ) 1 zero_le_one x) = smoothTransition x 
Arguments: {x : ℝ}
Goal: (↑(Set.projIcc 0 1 ⋯ x)).smoothTransition = x.smoothTransition
-- Real.smoothTransition.le_one
theorem le_one (x : ℝ) : smoothTransition x ≤ 1 
Arguments: (x : ℝ)
Goal: x.smoothTransition ≤ 1
-- Real.smoothTransition.nonneg
theorem nonneg (x : ℝ) : 0 ≤ smoothTransition x 
Arguments: (x : ℝ)
Goal: 0 ≤ x.smoothTransition
-- Real.smoothTransition.lt_one_of_lt_one
theorem lt_one_of_lt_one (h : x < 1) : smoothTransition x < 1 
Arguments: {x : ℝ} (h : x < 1)
Goal: x.smoothTransition < 1
-- Real.smoothTransition.pos_of_pos
theorem pos_of_pos (h : 0 < x) : 0 < smoothTransition x 
Arguments: {x : ℝ} (h : 0 < x)
Goal: 0 < x.smoothTransition
-- Real.smoothTransition.contDiff
protected theorem contDiff {n} : ContDiff ℝ n smoothTransition 
Arguments: {n : ℕ∞}
Goal: ContDiff ℝ n Real.smoothTransition
-- Real.smoothTransition.contDiffAt
protected theorem contDiffAt {x n} : ContDiffAt ℝ n smoothTransition x 
Arguments: {x : ℝ} {n : ℕ∞}
Goal: ContDiffAt ℝ n Real.smoothTransition x
-- Real.smoothTransition.continuous
protected theorem continuous : Continuous smoothTransition 
Goal: Continuous Real.smoothTransition
-- Real.smoothTransition.continuousAt
protected theorem continuousAt : ContinuousAt smoothTransition x 
Arguments: {x : ℝ}
Goal: ContinuousAt Real.smoothTransition x
-- Real.exp_arsinh
theorem exp_arsinh (x : ℝ) : exp (arsinh x) = x + √(1 + x ^ 2) 
Arguments: (x : ℝ)
Goal: rexp (Real.arsinh x) = x + √(1 + x ^ 2)
-- Real.arsinh_zero
@[simp]
theorem arsinh_zero : arsinh 0 = 0 
Goal: Real.arsinh 0 = 0
-- Real.arsinh_neg
@[simp]
theorem arsinh_neg (x : ℝ) : arsinh (-x) = -arsinh x 
Arguments: (x : ℝ)
Goal: Real.arsinh (-x) = -Real.arsinh x
-- Real.sinh_arsinh
@[simp]
theorem sinh_arsinh (x : ℝ) : sinh (arsinh x) = x 
Arguments: (x : ℝ)
Goal: Real.sinh (Real.arsinh x) = x
-- Real.cosh_arsinh
@[simp]
theorem cosh_arsinh (x : ℝ) : cosh (arsinh x) = √(1 + x ^ 2) 
Arguments: (x : ℝ)
Goal: Real.cosh (Real.arsinh x) = √(1 + x ^ 2)
-- Real.sinh_surjective
theorem sinh_surjective : Surjective sinh 
Goal: Function.Surjective Real.sinh
-- Real.sinh_bijective
theorem sinh_bijective : Bijective sinh 
Goal: Function.Bijective Real.sinh
-- Real.arsinh_sinh
@[simp]
theorem arsinh_sinh (x : ℝ) : arsinh (sinh x) = x 
Arguments: (x : ℝ)
Goal: Real.arsinh (Real.sinh x) = x
-- Real.sinhEquiv_symm_apply
@[simps]
def sinhEquiv : ℝ ≃ ℝ 
Arguments: (x : ℝ)
Goal: Real.sinhEquiv.symm x = Real.arsinh x
-- Real.sinhEquiv_apply
@[simps]
def sinhEquiv : ℝ ≃ ℝ 
Arguments: (x : ℝ)
Goal: Real.sinhEquiv x = Real.sinh x
-- Real.sinhOrderIso_apply
@[simps! (config := .asFn)]
def sinhOrderIso : ℝ ≃o ℝ 
Goal: ⇑Real.sinhOrderIso = Real.sinh
-- Real.sinhOrderIso_symm_apply
@[simps! (config := .asFn)]
def sinhOrderIso : ℝ ≃o ℝ 
Goal: ⇑(RelIso.symm Real.sinhOrderIso) = Real.arsinh
-- Real.sinhHomeomorph_apply
@[simps! (config := .asFn)]
def sinhHomeomorph : ℝ ≃ₜ ℝ 
Goal: ⇑Real.sinhHomeomorph = Real.sinh
-- Real.sinhHomeomorph_symm_apply
@[simps! (config := .asFn)]
def sinhHomeomorph : ℝ ≃ₜ ℝ 
Goal: ⇑Real.sinhHomeomorph.symm = Real.arsinh
-- Real.arsinh_bijective
theorem arsinh_bijective : Bijective arsinh 
Goal: Function.Bijective Real.arsinh
-- Real.arsinh_injective
theorem arsinh_injective : Injective arsinh 
Goal: Function.Injective Real.arsinh
-- Real.arsinh_surjective
theorem arsinh_surjective : Surjective arsinh 
Goal: Function.Surjective Real.arsinh
-- Real.arsinh_strictMono
theorem arsinh_strictMono : StrictMono arsinh 
Goal: StrictMono Real.arsinh
-- Real.arsinh_inj
@[simp]
theorem arsinh_inj : arsinh x = arsinh y ↔ x = y 
Arguments: {x y : ℝ}
Goal: Real.arsinh x = Real.arsinh y ↔ x = y
-- Real.arsinh_le_arsinh
@[simp]
theorem arsinh_le_arsinh : arsinh x ≤ arsinh y ↔ x ≤ y 
Arguments: {x y : ℝ}
Goal: Real.arsinh x ≤ Real.arsinh y ↔ x ≤ y
-- Real.arsinh_lt_arsinh
@[simp]
theorem arsinh_lt_arsinh : arsinh x < arsinh y ↔ x < y 
Arguments: {x y : ℝ}
Goal: Real.arsinh x < Real.arsinh y ↔ x < y
-- Real.arsinh_eq_zero_iff
@[simp]
theorem arsinh_eq_zero_iff : arsinh x = 0 ↔ x = 0 
Arguments: {x : ℝ}
Goal: Real.arsinh x = 0 ↔ x = 0
-- Real.arsinh_nonneg_iff
@[simp]
theorem arsinh_nonneg_iff : 0 ≤ arsinh x ↔ 0 ≤ x 
Arguments: {x : ℝ}
Goal: 0 ≤ Real.arsinh x ↔ 0 ≤ x
-- Real.arsinh_nonpos_iff
@[simp]
theorem arsinh_nonpos_iff : arsinh x ≤ 0 ↔ x ≤ 0 
Arguments: {x : ℝ}
Goal: Real.arsinh x ≤ 0 ↔ x ≤ 0
-- Real.arsinh_pos_iff
@[simp]
theorem arsinh_pos_iff : 0 < arsinh x ↔ 0 < x 
Arguments: {x : ℝ}
Goal: 0 < Real.arsinh x ↔ 0 < x
-- Real.arsinh_neg_iff
@[simp]
theorem arsinh_neg_iff : arsinh x < 0 ↔ x < 0 
Arguments: {x : ℝ}
Goal: Real.arsinh x < 0 ↔ x < 0
-- Real.hasStrictDerivAt_arsinh
theorem hasStrictDerivAt_arsinh (x : ℝ) : HasStrictDerivAt arsinh (√(1 + x ^ 2))⁻¹ x 
Arguments: (x : ℝ)
Goal: HasStrictDerivAt Real.arsinh (√(1 + x ^ 2))⁻¹ x
-- Real.hasDerivAt_arsinh
theorem hasDerivAt_arsinh (x : ℝ) : HasDerivAt arsinh (√(1 + x ^ 2))⁻¹ x 
Arguments: (x : ℝ)
Goal: HasDerivAt Real.arsinh (√(1 + x ^ 2))⁻¹ x
-- Real.differentiable_arsinh
theorem differentiable_arsinh : Differentiable ℝ arsinh 
Goal: Differentiable ℝ Real.arsinh
-- Real.contDiff_arsinh
theorem contDiff_arsinh {n : ℕ∞} : ContDiff ℝ n arsinh 
Arguments: {n : ℕ∞}
Goal: ContDiff ℝ n Real.arsinh
-- Real.continuous_arsinh
@[continuity]
theorem continuous_arsinh : Continuous arsinh 
Goal: Continuous Real.arsinh
-- Filter.Tendsto.arsinh
theorem Filter.Tendsto.arsinh {α : Type*} {l : Filter α} {f : α → ℝ} {a : ℝ}
    (h : Tendsto f l (𝓝 a)) : Tendsto (fun x => arsinh (f x)) l (𝓝 (arsinh a)) 
Arguments: {α : Type u_1} {l : Filter α} {f : α → ℝ} {a : ℝ} (h : Filter.Tendsto f l (𝓝 a))
Goal: Filter.Tendsto (fun x => Real.arsinh (f x)) l (𝓝 (Real.arsinh a))
-- ContinuousAt.arsinh
nonrec theorem ContinuousAt.arsinh (h : ContinuousAt f a) :
    ContinuousAt (fun x => arsinh (f x)) a 
Arguments: {X : Type u_1} [TopologicalSpace X] {f : X → ℝ} {a : X} (h : ContinuousAt f a)
Goal: ContinuousAt (fun x => Real.arsinh (f x)) a
-- ContinuousWithinAt.arsinh
nonrec theorem ContinuousWithinAt.arsinh (h : ContinuousWithinAt f s a) :
    ContinuousWithinAt (fun x => arsinh (f x)) s a 
Arguments: {X : Type u_1} [TopologicalSpace X] {f : X → ℝ} {s : Set X} {a : X} (h : ContinuousWithinAt f s a)
Goal: ContinuousWithinAt (fun x => Real.arsinh (f x)) s a
-- ContinuousOn.arsinh
theorem ContinuousOn.arsinh (h : ContinuousOn f s) : ContinuousOn (fun x => arsinh (f x)) s 
Arguments: {X : Type u_1} [TopologicalSpace X] {f : X → ℝ} {s : Set X} (h : ContinuousOn f s)
Goal: ContinuousOn (fun x => Real.arsinh (f x)) s
-- Continuous.arsinh
theorem Continuous.arsinh (h : Continuous f) : Continuous fun x => arsinh (f x) 
Arguments: {X : Type u_1} [TopologicalSpace X] {f : X → ℝ} (h : Continuous f)
Goal: Continuous fun x => Real.arsinh (f x)
-- HasStrictFDerivAt.arsinh
theorem HasStrictFDerivAt.arsinh (hf : HasStrictFDerivAt f f' a) :
    HasStrictFDerivAt (fun x => arsinh (f x)) ((√(1 + f a ^ 2))⁻¹ • f') a 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] {f : E → ℝ} {a : E} {f' : E →L[ℝ] ℝ} (hf : HasStrictFDerivAt f f' a)
Goal: HasStrictFDerivAt (fun x => Real.arsinh (f x)) ((√(1 + f a ^ 2))⁻¹ • f') a
-- HasFDerivAt.arsinh
theorem HasFDerivAt.arsinh (hf : HasFDerivAt f f' a) :
    HasFDerivAt (fun x => arsinh (f x)) ((√(1 + f a ^ 2))⁻¹ • f') a 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] {f : E → ℝ} {a : E} {f' : E →L[ℝ] ℝ} (hf : HasFDerivAt f f' a)
Goal: HasFDerivAt (fun x => Real.arsinh (f x)) ((√(1 + f a ^ 2))⁻¹ • f') a
-- HasFDerivWithinAt.arsinh
theorem HasFDerivWithinAt.arsinh (hf : HasFDerivWithinAt f f' s a) :
    HasFDerivWithinAt (fun x => arsinh (f x)) ((√(1 + f a ^ 2))⁻¹ • f') s a 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] {f : E → ℝ} {s : Set E} {a : E} {f' : E →L[ℝ] ℝ} (hf : HasFDerivWithinAt f f' s a)
Goal: HasFDerivWithinAt (fun x => Real.arsinh (f x)) ((√(1 + f a ^ 2))⁻¹ • f') s a
-- DifferentiableAt.arsinh
theorem DifferentiableAt.arsinh (h : DifferentiableAt ℝ f a) :
    DifferentiableAt ℝ (fun x => arsinh (f x)) a 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] {f : E → ℝ} {a : E} (h : DifferentiableAt ℝ f a)
Goal: DifferentiableAt ℝ (fun x => Real.arsinh (f x)) a
-- DifferentiableWithinAt.arsinh
theorem DifferentiableWithinAt.arsinh (h : DifferentiableWithinAt ℝ f s a) :
    DifferentiableWithinAt ℝ (fun x => arsinh (f x)) s a 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] {f : E → ℝ} {s : Set E} {a : E} (h : DifferentiableWithinAt ℝ f s a)
Goal: DifferentiableWithinAt ℝ (fun x => Real.arsinh (f x)) s a
-- DifferentiableOn.arsinh
theorem DifferentiableOn.arsinh (h : DifferentiableOn ℝ f s) :
    DifferentiableOn ℝ (fun x => arsinh (f x)) s 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] {f : E → ℝ} {s : Set E} (h : DifferentiableOn ℝ f s)
Goal: DifferentiableOn ℝ (fun x => Real.arsinh (f x)) s
-- Differentiable.arsinh
theorem Differentiable.arsinh (h : Differentiable ℝ f) : Differentiable ℝ fun x => arsinh (f x) 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] {f : E → ℝ} (h : Differentiable ℝ f)
Goal: Differentiable ℝ fun x => Real.arsinh (f x)
-- ContDiffAt.arsinh
theorem ContDiffAt.arsinh (h : ContDiffAt ℝ n f a) : ContDiffAt ℝ n (fun x => arsinh (f x)) a 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] {f : E → ℝ} {a : E} {n : ℕ∞} (h : ContDiffAt ℝ n f a)
Goal: ContDiffAt ℝ n (fun x => Real.arsinh (f x)) a
-- ContDiffWithinAt.arsinh
theorem ContDiffWithinAt.arsinh (h : ContDiffWithinAt ℝ n f s a) :
    ContDiffWithinAt ℝ n (fun x => arsinh (f x)) s a 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] {f : E → ℝ} {s : Set E} {a : E} {n : ℕ∞} (h : ContDiffWithinAt ℝ n f s a)
Goal: ContDiffWithinAt ℝ n (fun x => Real.arsinh (f x)) s a
-- ContDiff.arsinh
theorem ContDiff.arsinh (h : ContDiff ℝ n f) : ContDiff ℝ n fun x => arsinh (f x) 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] {f : E → ℝ} {n : ℕ∞} (h : ContDiff ℝ n f)
Goal: ContDiff ℝ n fun x => Real.arsinh (f x)
-- ContDiffOn.arsinh
theorem ContDiffOn.arsinh (h : ContDiffOn ℝ n f s) : ContDiffOn ℝ n (fun x => arsinh (f x)) s 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] {f : E → ℝ} {s : Set E} {n : ℕ∞} (h : ContDiffOn ℝ n f s)
Goal: ContDiffOn ℝ n (fun x => Real.arsinh (f x)) s
-- HasStrictDerivAt.arsinh
theorem HasStrictDerivAt.arsinh (hf : HasStrictDerivAt f f' a) :
    HasStrictDerivAt (fun x => arsinh (f x)) ((√(1 + f a ^ 2))⁻¹ • f') a 
Arguments: {f : ℝ → ℝ} {a f' : ℝ} (hf : HasStrictDerivAt f f' a)
Goal: HasStrictDerivAt (fun x => Real.arsinh (f x)) ((√(1 + f a ^ 2))⁻¹ • f') a
-- HasDerivAt.arsinh
theorem HasDerivAt.arsinh (hf : HasDerivAt f f' a) :
    HasDerivAt (fun x => arsinh (f x)) ((√(1 + f a ^ 2))⁻¹ • f') a 
Arguments: {f : ℝ → ℝ} {a f' : ℝ} (hf : HasDerivAt f f' a)
Goal: HasDerivAt (fun x => Real.arsinh (f x)) ((√(1 + f a ^ 2))⁻¹ • f') a
-- HasDerivWithinAt.arsinh
theorem HasDerivWithinAt.arsinh (hf : HasDerivWithinAt f f' s a) :
    HasDerivWithinAt (fun x => arsinh (f x)) ((√(1 + f a ^ 2))⁻¹ • f') s a 
Arguments: {f : ℝ → ℝ} {s : Set ℝ} {a f' : ℝ} (hf : HasDerivWithinAt f f' s a)
Goal: HasDerivWithinAt (fun x => Real.arsinh (f x)) ((√(1 + f a ^ 2))⁻¹ • f') s a
-- Complex.continuous_sin
@[continuity, fun_prop]
theorem continuous_sin : Continuous sin 
Goal: Continuous Complex.sin
-- Complex.continuousOn_sin
@[fun_prop]
theorem continuousOn_sin {s : Set ℂ} : ContinuousOn sin s 
Arguments: {s : Set ℂ}
Goal: ContinuousOn Complex.sin s
-- Complex.continuous_cos
@[continuity, fun_prop]
theorem continuous_cos : Continuous cos 
Goal: Continuous Complex.cos
-- Complex.continuousOn_cos
@[fun_prop]
theorem continuousOn_cos {s : Set ℂ} : ContinuousOn cos s 
Arguments: {s : Set ℂ}
Goal: ContinuousOn Complex.cos s
-- Complex.continuous_sinh
@[continuity, fun_prop]
theorem continuous_sinh : Continuous sinh 
Goal: Continuous Complex.sinh
-- Complex.continuous_cosh
@[continuity, fun_prop]
theorem continuous_cosh : Continuous cosh 
Goal: Continuous Complex.cosh
-- Real.continuous_sin
@[continuity, fun_prop]
theorem continuous_sin : Continuous sin 
Goal: Continuous Real.sin
-- Real.continuousOn_sin
@[fun_prop]
theorem continuousOn_sin {s} : ContinuousOn sin s 
Arguments: {s : Set ℝ}
Goal: ContinuousOn Real.sin s
-- Real.continuous_cos
@[continuity, fun_prop]
theorem continuous_cos : Continuous cos 
Goal: Continuous Real.cos
-- Real.continuousOn_cos
@[fun_prop]
theorem continuousOn_cos {s} : ContinuousOn cos s 
Arguments: {s : Set ℝ}
Goal: ContinuousOn Real.cos s
-- Real.continuous_sinh
@[continuity, fun_prop]
theorem continuous_sinh : Continuous sinh 
Goal: Continuous Real.sinh