File: Mathlib/Analysis/SpecialFunctions/Arsinh.lean

full_name: Real.arsinh
code: /-- `arsinh` is defined using a logarithm, `arsinh x = log (x + sqrt(1 + x^2))`. -/
@[pp_nodot]
def arsinh (x : ℝ) 
goal: ℝ

full_name: Real.exp_arsinh
code: theorem exp_arsinh (x : ℝ) : exp (arsinh x) = x + √(1 + x ^ 2) 
goal: rexp (Real.arsinh x) = x + √(1 + x ^ 2)

full_name: Real.arsinh_zero
code: @[simp]
theorem arsinh_zero : arsinh 0 = 0 
goal: Real.arsinh 0 = 0

full_name: Real.arsinh_neg
code: @[simp]
theorem arsinh_neg (x : ℝ) : arsinh (-x) = -arsinh x 
goal: Real.arsinh (-x) = -Real.arsinh x

full_name: Real.sinh_arsinh
code: /-- `arsinh` is the right inverse of `sinh`. -/
@[simp]
theorem sinh_arsinh (x : ℝ) : sinh (arsinh x) = x 
goal: Real.sinh (Real.arsinh x) = x

full_name: Real.cosh_arsinh
code: @[simp]
theorem cosh_arsinh (x : ℝ) : cosh (arsinh x) = √(1 + x ^ 2) 
goal: Real.cosh (Real.arsinh x) = √(1 + x ^ 2)

full_name: Real.sinh_surjective
code: /-- `sinh` is surjective, `∀ b, ∃ a, sinh a = b`. In this case, we use `a = arsinh b`. -/
theorem sinh_surjective : Surjective sinh 
goal: Function.Surjective Real.sinh

full_name: Real.sinh_bijective
code: /-- `sinh` is bijective, both injective and surjective. -/
theorem sinh_bijective : Bijective sinh 
goal: Function.Bijective Real.sinh

full_name: Real.arsinh_sinh
code: /-- `arsinh` is the left inverse of `sinh`. -/
@[simp]
theorem arsinh_sinh (x : ℝ) : arsinh (sinh x) = x 
goal: Real.arsinh (Real.sinh x) = x

full_name: Real.sinhEquiv_symm_apply
code: /-- `Real.sinh` as an `Equiv`. -/
@[simps]
def sinhEquiv : ℝ ≃ ℝ 
goal: Real.sinhEquiv.symm x = Real.arsinh x

full_name: Real.sinhEquiv_apply
code: /-- `Real.sinh` as an `Equiv`. -/
@[simps]
def sinhEquiv : ℝ ≃ ℝ 
goal: Real.sinhEquiv x = Real.sinh x

full_name: Real.sinhEquiv
code: /-- `Real.sinh` as an `Equiv`. -/
@[simps]
def sinhEquiv : ℝ ≃ ℝ 
goal: ℝ ≃ ℝ

full_name: Real.sinhOrderIso_apply
code: /-- `Real.sinh` as an `OrderIso`. -/
@[simps! (config := .asFn)]
def sinhOrderIso : ℝ ≃o ℝ 
goal: ⇑Real.sinhOrderIso = Real.sinh

full_name: Real.sinhOrderIso_symm_apply
code: /-- `Real.sinh` as an `OrderIso`. -/
@[simps! (config := .asFn)]
def sinhOrderIso : ℝ ≃o ℝ 
goal: ⇑(RelIso.symm Real.sinhOrderIso) = Real.arsinh

full_name: Real.sinhOrderIso
code: /-- `Real.sinh` as an `OrderIso`. -/
@[simps! (config := .asFn)]
def sinhOrderIso : ℝ ≃o ℝ 
goal: ℝ ≃o ℝ

full_name: Real.sinhHomeomorph
code: /-- `Real.sinh` as a `Homeomorph`. -/
@[simps! (config := .asFn)]
def sinhHomeomorph : ℝ ≃ₜ ℝ 
goal: ℝ ≃ₜ ℝ

full_name: Real.sinhHomeomorph_apply
code: /-- `Real.sinh` as a `Homeomorph`. -/
@[simps! (config := .asFn)]
def sinhHomeomorph : ℝ ≃ₜ ℝ 
goal: ⇑Real.sinhHomeomorph = Real.sinh

full_name: Real.sinhHomeomorph_symm_apply
code: /-- `Real.sinh` as a `Homeomorph`. -/
@[simps! (config := .asFn)]
def sinhHomeomorph : ℝ ≃ₜ ℝ 
goal: ⇑Real.sinhHomeomorph.symm = Real.arsinh

full_name: Real.arsinh_bijective
code: theorem arsinh_bijective : Bijective arsinh 
goal: Function.Bijective Real.arsinh

full_name: Real.arsinh_injective
code: theorem arsinh_injective : Injective arsinh 
goal: Function.Injective Real.arsinh

full_name: Real.arsinh_surjective
code: theorem arsinh_surjective : Surjective arsinh 
goal: Function.Surjective Real.arsinh

full_name: Real.arsinh_strictMono
code: theorem arsinh_strictMono : StrictMono arsinh 
goal: StrictMono Real.arsinh

full_name: Real.arsinh_inj
code: @[simp]
theorem arsinh_inj : arsinh x = arsinh y ↔ x = y 
goal: Real.arsinh x = Real.arsinh y ↔ x = y

full_name: Real.arsinh_le_arsinh
code: @[simp]
theorem arsinh_le_arsinh : arsinh x ≤ arsinh y ↔ x ≤ y 
goal: Real.arsinh x ≤ Real.arsinh y ↔ x ≤ y

full_name: Real.arsinh_lt_arsinh
code: @[simp]
theorem arsinh_lt_arsinh : arsinh x < arsinh y ↔ x < y 
goal: Real.arsinh x < Real.arsinh y ↔ x < y

full_name: Real.arsinh_eq_zero_iff
code: @[simp]
theorem arsinh_eq_zero_iff : arsinh x = 0 ↔ x = 0 
goal: Real.arsinh x = 0 ↔ x = 0

full_name: Real.arsinh_nonneg_iff
code: @[simp]
theorem arsinh_nonneg_iff : 0 ≤ arsinh x ↔ 0 ≤ x 
goal: 0 ≤ Real.arsinh x ↔ 0 ≤ x

full_name: Real.arsinh_nonpos_iff
code: @[simp]
theorem arsinh_nonpos_iff : arsinh x ≤ 0 ↔ x ≤ 0 
goal: Real.arsinh x ≤ 0 ↔ x ≤ 0

full_name: Real.arsinh_pos_iff
code: @[simp]
theorem arsinh_pos_iff : 0 < arsinh x ↔ 0 < x 
goal: 0 < Real.arsinh x ↔ 0 < x

full_name: Real.arsinh_neg_iff
code: @[simp]
theorem arsinh_neg_iff : arsinh x < 0 ↔ x < 0 
goal: Real.arsinh x < 0 ↔ x < 0

full_name: Real.hasStrictDerivAt_arsinh
code: theorem hasStrictDerivAt_arsinh (x : ℝ) : HasStrictDerivAt arsinh (√(1 + x ^ 2))⁻¹ x 
goal: HasStrictDerivAt Real.arsinh (√(1 + x ^ 2))⁻¹ x

full_name: Real.hasDerivAt_arsinh
code: theorem hasDerivAt_arsinh (x : ℝ) : HasDerivAt arsinh (√(1 + x ^ 2))⁻¹ x 
goal: HasDerivAt Real.arsinh (√(1 + x ^ 2))⁻¹ x

full_name: Real.differentiable_arsinh
code: theorem differentiable_arsinh : Differentiable ℝ arsinh 
goal: Differentiable ℝ Real.arsinh

full_name: Real.contDiff_arsinh
code: theorem contDiff_arsinh {n : ℕ∞} : ContDiff ℝ n arsinh 
goal: ContDiff ℝ n Real.arsinh

full_name: Real.continuous_arsinh
code: @[continuity]
theorem continuous_arsinh : Continuous arsinh 
goal: Continuous Real.arsinh

full_name: Filter.Tendsto.arsinh
code: theorem Filter.Tendsto.arsinh {α : Type*} {l : Filter α} {f : α → ℝ} {a : ℝ}
    (h : Tendsto f l (𝓝 a)) : Tendsto (fun x => arsinh (f x)) l (𝓝 (arsinh a)) 
goal: Filter.Tendsto (fun x => Real.arsinh (f x)) l (𝓝 (Real.arsinh a))

full_name: ContinuousAt.arsinh
code: nonrec theorem ContinuousAt.arsinh (h : ContinuousAt f a) :
    ContinuousAt (fun x => arsinh (f x)) a 
goal: ContinuousAt (fun x => Real.arsinh (f x)) a

full_name: ContinuousWithinAt.arsinh
code: nonrec theorem ContinuousWithinAt.arsinh (h : ContinuousWithinAt f s a) :
    ContinuousWithinAt (fun x => arsinh (f x)) s a 
goal: ContinuousWithinAt (fun x => Real.arsinh (f x)) s a

full_name: ContinuousOn.arsinh
code: theorem ContinuousOn.arsinh (h : ContinuousOn f s) : ContinuousOn (fun x => arsinh (f x)) s 
goal: ContinuousOn (fun x => Real.arsinh (f x)) s

full_name: Continuous.arsinh
code: theorem Continuous.arsinh (h : Continuous f) : Continuous fun x => arsinh (f x) 
goal: Continuous fun x => Real.arsinh (f x)

full_name: HasStrictFDerivAt.arsinh
code: theorem HasStrictFDerivAt.arsinh (hf : HasStrictFDerivAt f f' a) :
    HasStrictFDerivAt (fun x => arsinh (f x)) ((√(1 + f a ^ 2))⁻¹ • f') a 
goal: HasStrictFDerivAt (fun x => Real.arsinh (f x)) ((√(1 + f a ^ 2))⁻¹ • f') a

full_name: HasFDerivAt.arsinh
code: theorem HasFDerivAt.arsinh (hf : HasFDerivAt f f' a) :
    HasFDerivAt (fun x => arsinh (f x)) ((√(1 + f a ^ 2))⁻¹ • f') a 
goal: HasFDerivAt (fun x => Real.arsinh (f x)) ((√(1 + f a ^ 2))⁻¹ • f') a

full_name: HasFDerivWithinAt.arsinh
code: theorem HasFDerivWithinAt.arsinh (hf : HasFDerivWithinAt f f' s a) :
    HasFDerivWithinAt (fun x => arsinh (f x)) ((√(1 + f a ^ 2))⁻¹ • f') s a 
goal: HasFDerivWithinAt (fun x => Real.arsinh (f x)) ((√(1 + f a ^ 2))⁻¹ • f') s a

full_name: DifferentiableAt.arsinh
code: theorem DifferentiableAt.arsinh (h : DifferentiableAt ℝ f a) :
    DifferentiableAt ℝ (fun x => arsinh (f x)) a 
goal: DifferentiableAt ℝ (fun x => Real.arsinh (f x)) a

full_name: DifferentiableWithinAt.arsinh
code: theorem DifferentiableWithinAt.arsinh (h : DifferentiableWithinAt ℝ f s a) :
    DifferentiableWithinAt ℝ (fun x => arsinh (f x)) s a 
goal: DifferentiableWithinAt ℝ (fun x => Real.arsinh (f x)) s a

full_name: DifferentiableOn.arsinh
code: theorem DifferentiableOn.arsinh (h : DifferentiableOn ℝ f s) :
    DifferentiableOn ℝ (fun x => arsinh (f x)) s 
goal: DifferentiableOn ℝ (fun x => Real.arsinh (f x)) s

full_name: Differentiable.arsinh
code: theorem Differentiable.arsinh (h : Differentiable ℝ f) : Differentiable ℝ fun x => arsinh (f x) 
goal: Differentiable ℝ fun x => Real.arsinh (f x)

full_name: ContDiffAt.arsinh
code: theorem ContDiffAt.arsinh (h : ContDiffAt ℝ n f a) : ContDiffAt ℝ n (fun x => arsinh (f x)) a 
goal: ContDiffAt ℝ n (fun x => Real.arsinh (f x)) a

full_name: ContDiffWithinAt.arsinh
code: theorem ContDiffWithinAt.arsinh (h : ContDiffWithinAt ℝ n f s a) :
    ContDiffWithinAt ℝ n (fun x => arsinh (f x)) s a 
goal: ContDiffWithinAt ℝ n (fun x => Real.arsinh (f x)) s a

full_name: ContDiff.arsinh
code: theorem ContDiff.arsinh (h : ContDiff ℝ n f) : ContDiff ℝ n fun x => arsinh (f x) 
goal: ContDiff ℝ n fun x => Real.arsinh (f x)

full_name: ContDiffOn.arsinh
code: theorem ContDiffOn.arsinh (h : ContDiffOn ℝ n f s) : ContDiffOn ℝ n (fun x => arsinh (f x)) s 
goal: ContDiffOn ℝ n (fun x => Real.arsinh (f x)) s

full_name: HasStrictDerivAt.arsinh
code: theorem HasStrictDerivAt.arsinh (hf : HasStrictDerivAt f f' a) :
    HasStrictDerivAt (fun x => arsinh (f x)) ((√(1 + f a ^ 2))⁻¹ • f') a 
goal: HasStrictDerivAt (fun x => Real.arsinh (f x)) ((√(1 + f a ^ 2))⁻¹ • f') a

full_name: HasDerivAt.arsinh
code: theorem HasDerivAt.arsinh (hf : HasDerivAt f f' a) :
    HasDerivAt (fun x => arsinh (f x)) ((√(1 + f a ^ 2))⁻¹ • f') a 
goal: HasDerivAt (fun x => Real.arsinh (f x)) ((√(1 + f a ^ 2))⁻¹ • f') a

full_name: HasDerivWithinAt.arsinh
code: theorem HasDerivWithinAt.arsinh (hf : HasDerivWithinAt f f' s a) :
    HasDerivWithinAt (fun x => arsinh (f x)) ((√(1 + f a ^ 2))⁻¹ • f') s a 
goal: HasDerivWithinAt (fun x => Real.arsinh (f x)) ((√(1 + f a ^ 2))⁻¹ • f') s a