File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

full_name: Real.arcsin
code: /-- Inverse of the `sin` function, returns values in the range `-π / 2 ≤ arcsin x ≤ π / 2`.
It defaults to `-π / 2` on `(-∞, -1)` and to `π / 2` to `(1, ∞)`. -/
@[pp_nodot]
noncomputable def arcsin : ℝ → ℝ 
goal: ℝ → ℝ

full_name: Real.arcsin_mem_Icc
code: theorem arcsin_mem_Icc (x : ℝ) : arcsin x ∈ Icc (-(π / 2)) (π / 2) 
goal: Real.arcsin x ∈ Set.Icc (-(π / 2)) (π / 2)

full_name: Real.range_arcsin
code: @[simp]
theorem range_arcsin : range arcsin = Icc (-(π / 2)) (π / 2) 
goal: Set.range Real.arcsin = Set.Icc (-(π / 2)) (π / 2)

full_name: Real.arcsin_le_pi_div_two
code: theorem arcsin_le_pi_div_two (x : ℝ) : arcsin x ≤ π / 2 
goal: Real.arcsin x ≤ π / 2

full_name: Real.neg_pi_div_two_le_arcsin
code: theorem neg_pi_div_two_le_arcsin (x : ℝ) : -(π / 2) ≤ arcsin x 
goal: -(π / 2) ≤ Real.arcsin x

full_name: Real.arcsin_projIcc
code: theorem arcsin_projIcc (x : ℝ) :
    arcsin (projIcc (-1) 1 (neg_le_self zero_le_one) x) = arcsin x 
goal: Real.arcsin ↑(Set.projIcc (-1) 1 ⋯ x) = Real.arcsin x

full_name: Real.sin_arcsin'
code: theorem sin_arcsin' {x : ℝ} (hx : x ∈ Icc (-1 : ℝ) 1) : sin (arcsin x) = x 
goal: Real.sin (Real.arcsin x) = x

full_name: Real.sin_arcsin
code: theorem sin_arcsin {x : ℝ} (hx₁ : -1 ≤ x) (hx₂ : x ≤ 1) : sin (arcsin x) = x 
goal: Real.sin (Real.arcsin x) = x

full_name: Real.arcsin_sin'
code: theorem arcsin_sin' {x : ℝ} (hx : x ∈ Icc (-(π / 2)) (π / 2)) : arcsin (sin x) = x 
goal: Real.arcsin (Real.sin x) = x

full_name: Real.arcsin_sin
code: theorem arcsin_sin {x : ℝ} (hx₁ : -(π / 2) ≤ x) (hx₂ : x ≤ π / 2) : arcsin (sin x) = x 
goal: Real.arcsin (Real.sin x) = x

full_name: Real.strictMonoOn_arcsin
code: theorem strictMonoOn_arcsin : StrictMonoOn arcsin (Icc (-1) 1) 
goal: StrictMonoOn Real.arcsin (Set.Icc (-1) 1)

full_name: Real.monotone_arcsin
code: theorem monotone_arcsin : Monotone arcsin 
goal: Monotone Real.arcsin

full_name: Real.injOn_arcsin
code: theorem injOn_arcsin : InjOn arcsin (Icc (-1) 1) 
goal: Set.InjOn Real.arcsin (Set.Icc (-1) 1)

full_name: Real.arcsin_inj
code: theorem arcsin_inj {x y : ℝ} (hx₁ : -1 ≤ x) (hx₂ : x ≤ 1) (hy₁ : -1 ≤ y) (hy₂ : y ≤ 1) :
    arcsin x = arcsin y ↔ x = y 
goal: Real.arcsin x = Real.arcsin y ↔ x = y

full_name: Real.continuous_arcsin
code: @[continuity]
theorem continuous_arcsin : Continuous arcsin 
goal: Continuous Real.arcsin

full_name: Real.continuousAt_arcsin
code: theorem continuousAt_arcsin {x : ℝ} : ContinuousAt arcsin x 
goal: ContinuousAt Real.arcsin x

full_name: Real.arcsin_eq_of_sin_eq
code: theorem arcsin_eq_of_sin_eq {x y : ℝ} (h₁ : sin x = y) (h₂ : x ∈ Icc (-(π / 2)) (π / 2)) :
    arcsin y = x 
goal: Real.arcsin y = x

full_name: Real.arcsin_zero
code: @[simp]
theorem arcsin_zero : arcsin 0 = 0 
goal: Real.arcsin 0 = 0

full_name: Real.arcsin_one
code: @[simp]
theorem arcsin_one : arcsin 1 = π / 2 
goal: Real.arcsin 1 = π / 2

full_name: Real.arcsin_of_one_le
code: theorem arcsin_of_one_le {x : ℝ} (hx : 1 ≤ x) : arcsin x = π / 2 
goal: Real.arcsin x = π / 2

full_name: Real.arcsin_neg_one
code: theorem arcsin_neg_one : arcsin (-1) = -(π / 2) 
goal: Real.arcsin (-1) = -(π / 2)

full_name: Real.arcsin_of_le_neg_one
code: theorem arcsin_of_le_neg_one {x : ℝ} (hx : x ≤ -1) : arcsin x = -(π / 2) 
goal: Real.arcsin x = -(π / 2)

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

full_name: Real.arcsin_le_iff_le_sin
code: theorem arcsin_le_iff_le_sin {x y : ℝ} (hx : x ∈ Icc (-1 : ℝ) 1) (hy : y ∈ Icc (-(π / 2)) (π / 2)) :
    arcsin x ≤ y ↔ x ≤ sin y 
goal: Real.arcsin x ≤ y ↔ x ≤ Real.sin y

full_name: Real.arcsin_le_iff_le_sin'
code: theorem arcsin_le_iff_le_sin' {x y : ℝ} (hy : y ∈ Ico (-(π / 2)) (π / 2)) :
    arcsin x ≤ y ↔ x ≤ sin y 
goal: Real.arcsin x ≤ y ↔ x ≤ Real.sin y

full_name: Real.le_arcsin_iff_sin_le
code: theorem le_arcsin_iff_sin_le {x y : ℝ} (hx : x ∈ Icc (-(π / 2)) (π / 2)) (hy : y ∈ Icc (-1 : ℝ) 1) :
    x ≤ arcsin y ↔ sin x ≤ y 
goal: x ≤ Real.arcsin y ↔ Real.sin x ≤ y

full_name: Real.le_arcsin_iff_sin_le'
code: theorem le_arcsin_iff_sin_le' {x y : ℝ} (hx : x ∈ Ioc (-(π / 2)) (π / 2)) :
    x ≤ arcsin y ↔ sin x ≤ y 
goal: x ≤ Real.arcsin y ↔ Real.sin x ≤ y

full_name: Real.arcsin_lt_iff_lt_sin
code: theorem arcsin_lt_iff_lt_sin {x y : ℝ} (hx : x ∈ Icc (-1 : ℝ) 1) (hy : y ∈ Icc (-(π / 2)) (π / 2)) :
    arcsin x < y ↔ x < sin y 
goal: Real.arcsin x < y ↔ x < Real.sin y

full_name: Real.arcsin_lt_iff_lt_sin'
code: theorem arcsin_lt_iff_lt_sin' {x y : ℝ} (hy : y ∈ Ioc (-(π / 2)) (π / 2)) :
    arcsin x < y ↔ x < sin y 
goal: Real.arcsin x < y ↔ x < Real.sin y

full_name: Real.lt_arcsin_iff_sin_lt
code: theorem lt_arcsin_iff_sin_lt {x y : ℝ} (hx : x ∈ Icc (-(π / 2)) (π / 2)) (hy : y ∈ Icc (-1 : ℝ) 1) :
    x < arcsin y ↔ sin x < y 
goal: x < Real.arcsin y ↔ Real.sin x < y

full_name: Real.lt_arcsin_iff_sin_lt'
code: theorem lt_arcsin_iff_sin_lt' {x y : ℝ} (hx : x ∈ Ico (-(π / 2)) (π / 2)) :
    x < arcsin y ↔ sin x < y 
goal: x < Real.arcsin y ↔ Real.sin x < y

full_name: Real.arcsin_eq_iff_eq_sin
code: theorem arcsin_eq_iff_eq_sin {x y : ℝ} (hy : y ∈ Ioo (-(π / 2)) (π / 2)) :
    arcsin x = y ↔ x = sin y 
goal: Real.arcsin x = y ↔ x = Real.sin y

full_name: Real.arcsin_nonneg
code: @[simp]
theorem arcsin_nonneg {x : ℝ} : 0 ≤ arcsin x ↔ 0 ≤ x 
goal: 0 ≤ Real.arcsin x ↔ 0 ≤ x

full_name: Real.arcsin_nonpos
code: @[simp]
theorem arcsin_nonpos {x : ℝ} : arcsin x ≤ 0 ↔ x ≤ 0 
goal: Real.arcsin x ≤ 0 ↔ x ≤ 0

full_name: Real.arcsin_eq_zero_iff
code: @[simp]
theorem arcsin_eq_zero_iff {x : ℝ} : arcsin x = 0 ↔ x = 0 
goal: Real.arcsin x = 0 ↔ x = 0

full_name: Real.zero_eq_arcsin_iff
code: @[simp]
theorem zero_eq_arcsin_iff {x} : 0 = arcsin x ↔ x = 0 
goal: 0 = Real.arcsin x ↔ x = 0

full_name: Real.arcsin_pos
code: @[simp]
theorem arcsin_pos {x : ℝ} : 0 < arcsin x ↔ 0 < x 
goal: 0 < Real.arcsin x ↔ 0 < x

full_name: Real.arcsin_lt_zero
code: @[simp]
theorem arcsin_lt_zero {x : ℝ} : arcsin x < 0 ↔ x < 0 
goal: Real.arcsin x < 0 ↔ x < 0

full_name: Real.arcsin_lt_pi_div_two
code: @[simp]
theorem arcsin_lt_pi_div_two {x : ℝ} : arcsin x < π / 2 ↔ x < 1 
goal: Real.arcsin x < π / 2 ↔ x < 1

full_name: Real.neg_pi_div_two_lt_arcsin
code: @[simp]
theorem neg_pi_div_two_lt_arcsin {x : ℝ} : -(π / 2) < arcsin x ↔ -1 < x 
goal: -(π / 2) < Real.arcsin x ↔ -1 < x

full_name: Real.arcsin_eq_pi_div_two
code: @[simp]
theorem arcsin_eq_pi_div_two {x : ℝ} : arcsin x = π / 2 ↔ 1 ≤ x 
goal: Real.arcsin x = π / 2 ↔ 1 ≤ x

full_name: Real.pi_div_two_eq_arcsin
code: @[simp]
theorem pi_div_two_eq_arcsin {x} : π / 2 = arcsin x ↔ 1 ≤ x 
goal: π / 2 = Real.arcsin x ↔ 1 ≤ x

full_name: Real.pi_div_two_le_arcsin
code: @[simp]
theorem pi_div_two_le_arcsin {x} : π / 2 ≤ arcsin x ↔ 1 ≤ x 
goal: π / 2 ≤ Real.arcsin x ↔ 1 ≤ x

full_name: Real.arcsin_eq_neg_pi_div_two
code: @[simp]
theorem arcsin_eq_neg_pi_div_two {x : ℝ} : arcsin x = -(π / 2) ↔ x ≤ -1 
goal: Real.arcsin x = -(π / 2) ↔ x ≤ -1

full_name: Real.neg_pi_div_two_eq_arcsin
code: @[simp]
theorem neg_pi_div_two_eq_arcsin {x} : -(π / 2) = arcsin x ↔ x ≤ -1 
goal: -(π / 2) = Real.arcsin x ↔ x ≤ -1

full_name: Real.arcsin_le_neg_pi_div_two
code: @[simp]
theorem arcsin_le_neg_pi_div_two {x} : arcsin x ≤ -(π / 2) ↔ x ≤ -1 
goal: Real.arcsin x ≤ -(π / 2) ↔ x ≤ -1

full_name: Real.pi_div_four_le_arcsin
code: @[simp]
theorem pi_div_four_le_arcsin {x} : π / 4 ≤ arcsin x ↔ √2 / 2 ≤ x 
goal: π / 4 ≤ Real.arcsin x ↔ √2 / 2 ≤ x

full_name: Real.mapsTo_sin_Ioo
code: theorem mapsTo_sin_Ioo : MapsTo sin (Ioo (-(π / 2)) (π / 2)) (Ioo (-1) 1) 
goal: Set.MapsTo Real.sin (Set.Ioo (-(π / 2)) (π / 2)) (Set.Ioo (-1) 1)

full_name: Real.sinPartialHomeomorph
code: /-- `Real.sin` as a `PartialHomeomorph` between `(-π / 2, π / 2)` and `(-1, 1)`. -/
@[simp]
def sinPartialHomeomorph : PartialHomeomorph ℝ ℝ 
goal: PartialHomeomorph ℝ ℝ

full_name: Real.cos_arcsin_nonneg
code: theorem cos_arcsin_nonneg (x : ℝ) : 0 ≤ cos (arcsin x) 
goal: 0 ≤ Real.cos (Real.arcsin x)

full_name: Real.cos_arcsin
code: theorem cos_arcsin (x : ℝ) : cos (arcsin x) = √(1 - x ^ 2) 
goal: Real.cos (Real.arcsin x) = √(1 - x ^ 2)

full_name: Real.tan_arcsin
code: theorem tan_arcsin (x : ℝ) : tan (arcsin x) = x / √(1 - x ^ 2) 
goal: Real.tan (Real.arcsin x) = x / √(1 - x ^ 2)

full_name: Real.arccos
code: /-- Inverse of the `cos` function, returns values in the range `0 ≤ arccos x` and `arccos x ≤ π`.
  It defaults to `π` on `(-∞, -1)` and to `0` to `(1, ∞)`. -/
@[pp_nodot]
noncomputable def arccos (x : ℝ) : ℝ 
goal: ℝ

full_name: Real.arccos_eq_pi_div_two_sub_arcsin
code: theorem arccos_eq_pi_div_two_sub_arcsin (x : ℝ) : arccos x = π / 2 - arcsin x 
goal: Real.arccos x = π / 2 - Real.arcsin x

full_name: Real.arcsin_eq_pi_div_two_sub_arccos
code: theorem arcsin_eq_pi_div_two_sub_arccos (x : ℝ) : arcsin x = π / 2 - arccos x 
goal: Real.arcsin x = π / 2 - Real.arccos x

full_name: Real.arccos_le_pi
code: theorem arccos_le_pi (x : ℝ) : arccos x ≤ π 
goal: Real.arccos x ≤ π

full_name: Real.arccos_nonneg
code: theorem arccos_nonneg (x : ℝ) : 0 ≤ arccos x 
goal: 0 ≤ Real.arccos x

full_name: Real.arccos_pos
code: @[simp]
theorem arccos_pos {x : ℝ} : 0 < arccos x ↔ x < 1 
goal: 0 < Real.arccos x ↔ x < 1

full_name: Real.cos_arccos
code: theorem cos_arccos {x : ℝ} (hx₁ : -1 ≤ x) (hx₂ : x ≤ 1) : cos (arccos x) = x 
goal: Real.cos (Real.arccos x) = x

full_name: Real.arccos_cos
code: theorem arccos_cos {x : ℝ} (hx₁ : 0 ≤ x) (hx₂ : x ≤ π) : arccos (cos x) = x 
goal: Real.arccos (Real.cos x) = x

full_name: Real.arccos_eq_of_eq_cos
code: lemma arccos_eq_of_eq_cos (hy₀ : 0 ≤ y) (hy₁ : y ≤ π) (hxy : x = cos y) : arccos x = y 
goal: Real.arccos x = y

full_name: Real.strictAntiOn_arccos
code: theorem strictAntiOn_arccos : StrictAntiOn arccos (Icc (-1) 1) 
goal: StrictAntiOn Real.arccos (Set.Icc (-1) 1)

full_name: Real.arccos_injOn
code: theorem arccos_injOn : InjOn arccos (Icc (-1) 1) 
goal: Set.InjOn Real.arccos (Set.Icc (-1) 1)

full_name: Real.arccos_inj
code: theorem arccos_inj {x y : ℝ} (hx₁ : -1 ≤ x) (hx₂ : x ≤ 1) (hy₁ : -1 ≤ y) (hy₂ : y ≤ 1) :
    arccos x = arccos y ↔ x = y 
goal: Real.arccos x = Real.arccos y ↔ x = y

full_name: Real.arccos_zero
code: @[simp]
theorem arccos_zero : arccos 0 = π / 2 
goal: Real.arccos 0 = π / 2

full_name: Real.arccos_one
code: @[simp]
theorem arccos_one : arccos 1 = 0 
goal: Real.arccos 1 = 0

full_name: Real.arccos_neg_one
code: @[simp]
theorem arccos_neg_one : arccos (-1) = π 
goal: Real.arccos (-1) = π

full_name: Real.arccos_eq_zero
code: @[simp]
theorem arccos_eq_zero {x} : arccos x = 0 ↔ 1 ≤ x 
goal: Real.arccos x = 0 ↔ 1 ≤ x

full_name: Real.arccos_eq_pi_div_two
code: @[simp]
theorem arccos_eq_pi_div_two {x} : arccos x = π / 2 ↔ x = 0 
goal: Real.arccos x = π / 2 ↔ x = 0

full_name: Real.arccos_eq_pi
code: @[simp]
theorem arccos_eq_pi {x} : arccos x = π ↔ x ≤ -1 
goal: Real.arccos x = π ↔ x ≤ -1

full_name: Real.arccos_neg
code: theorem arccos_neg (x : ℝ) : arccos (-x) = π - arccos x 
goal: Real.arccos (-x) = π - Real.arccos x

full_name: Real.arccos_of_one_le
code: theorem arccos_of_one_le {x : ℝ} (hx : 1 ≤ x) : arccos x = 0 
goal: Real.arccos x = 0

full_name: Real.arccos_of_le_neg_one
code: theorem arccos_of_le_neg_one {x : ℝ} (hx : x ≤ -1) : arccos x = π 
goal: Real.arccos x = π

full_name: Real.sin_arccos
code: theorem sin_arccos (x : ℝ) : sin (arccos x) = √(1 - x ^ 2) 
goal: Real.sin (Real.arccos x) = √(1 - x ^ 2)

full_name: Real.arccos_le_pi_div_two
code: @[simp]
theorem arccos_le_pi_div_two {x} : arccos x ≤ π / 2 ↔ 0 ≤ x 
goal: Real.arccos x ≤ π / 2 ↔ 0 ≤ x

full_name: Real.arccos_lt_pi_div_two
code: @[simp]
theorem arccos_lt_pi_div_two {x : ℝ} : arccos x < π / 2 ↔ 0 < x 
goal: Real.arccos x < π / 2 ↔ 0 < x

full_name: Real.arccos_le_pi_div_four
code: @[simp]
theorem arccos_le_pi_div_four {x} : arccos x ≤ π / 4 ↔ √2 / 2 ≤ x 
goal: Real.arccos x ≤ π / 4 ↔ √2 / 2 ≤ x

full_name: Real.continuous_arccos
code: @[continuity]
theorem continuous_arccos : Continuous arccos 
goal: Continuous Real.arccos

full_name: Real.tan_arccos
code: theorem tan_arccos (x : ℝ) : tan (arccos x) = √(1 - x ^ 2) / x 
goal: Real.tan (Real.arccos x) = √(1 - x ^ 2) / x

full_name: Real.arccos_eq_arcsin
code: theorem arccos_eq_arcsin {x : ℝ} (h : 0 ≤ x) : arccos x = arcsin (√(1 - x ^ 2)) 
goal: Real.arccos x = Real.arcsin √(1 - x ^ 2)

full_name: Real.arcsin_eq_arccos
code: theorem arcsin_eq_arccos {x : ℝ} (h : 0 ≤ x) : arcsin x = arccos (√(1 - x ^ 2)) 
goal: Real.arcsin x = Real.arccos √(1 - x ^ 2)