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

full_name: Real.Angle
code: /-- The type of angles -/
def Angle : Type 
goal: Type

full_name: Real.Angle.instNormedAddCommGroup
code: instance : NormedAddCommGroup Angle 
goal: NormedAddCommGroup Real.Angle

full_name: Real.Angle.instInhabited
code: instance : Inhabited Angle 
goal: Inhabited Real.Angle

full_name: Real.Angle.coe
code: /-- The canonical map from `ℝ` to the quotient `Angle`. -/
@[coe]
protected def coe (r : ℝ) : Angle 
goal: Real.Angle

full_name: Real.Angle.instCoe
code: instance : Coe ℝ Angle 
goal: Coe ℝ Real.Angle

full_name: Real.Angle.instCircularOrder
code: instance : CircularOrder Real.Angle 
goal: CircularOrder Real.Angle

full_name: Real.Angle.continuous_coe
code: @[continuity]
theorem continuous_coe : Continuous ((↑) : ℝ → Angle) 
goal: Continuous Real.Angle.coe

full_name: Real.Angle.coeHom
code: /-- Coercion `ℝ → Angle` as an additive homomorphism. -/
def coeHom : ℝ →+ Angle 
goal: ℝ →+ Real.Angle

full_name: Real.Angle.coe_coeHom
code: @[simp]
theorem coe_coeHom : (coeHom : ℝ → Angle) = ((↑) : ℝ → Angle) 
goal: ⇑Real.Angle.coeHom = Real.Angle.coe

full_name: Real.Angle.induction_on
code: /-- An induction principle to deduce results for `Angle` from those for `ℝ`, used with
`induction θ using Real.Angle.induction_on`. -/
@[elab_as_elim]
protected theorem induction_on {p : Angle → Prop} (θ : Angle) (h : ∀ x : ℝ, p x) : p θ 
goal: p θ

full_name: Real.Angle.coe_zero
code: @[simp]
theorem coe_zero : ↑(0 : ℝ) = (0 : Angle) 
goal: ↑0 = 0

full_name: Real.Angle.coe_add
code: @[simp]
theorem coe_add (x y : ℝ) : ↑(x + y : ℝ) = (↑x + ↑y : Angle) 
goal: ↑(x + y) = ↑x + ↑y

full_name: Real.Angle.coe_neg
code: @[simp]
theorem coe_neg (x : ℝ) : ↑(-x : ℝ) = -(↑x : Angle) 
goal: ↑(-x) = -↑x

full_name: Real.Angle.coe_sub
code: @[simp]
theorem coe_sub (x y : ℝ) : ↑(x - y : ℝ) = (↑x - ↑y : Angle) 
goal: ↑(x - y) = ↑x - ↑y

full_name: Real.Angle.coe_nsmul
code: theorem coe_nsmul (n : ℕ) (x : ℝ) : ↑(n • x : ℝ) = n • (↑x : Angle) 
goal: ↑(n • x) = n • ↑x

full_name: Real.Angle.coe_zsmul
code: theorem coe_zsmul (z : ℤ) (x : ℝ) : ↑(z • x : ℝ) = z • (↑x : Angle) 
goal: ↑(z • x) = z • ↑x

full_name: Real.Angle.natCast_mul_eq_nsmul
code: @[simp, norm_cast]
theorem natCast_mul_eq_nsmul (x : ℝ) (n : ℕ) : ↑((n : ℝ) * x) = n • (↑x : Angle) 
goal: ↑(↑n * x) = n • ↑x

full_name: Real.Angle.intCast_mul_eq_zsmul
code: @[simp, norm_cast]
theorem intCast_mul_eq_zsmul (x : ℝ) (n : ℤ) : ↑((n : ℝ) * x : ℝ) = n • (↑x : Angle) 
goal: ↑(↑n * x) = n • ↑x

full_name: Real.Angle.angle_eq_iff_two_pi_dvd_sub
code: theorem angle_eq_iff_two_pi_dvd_sub {ψ θ : ℝ} : (θ : Angle) = ψ ↔ ∃ k : ℤ, θ - ψ = 2 * π * k 
goal: ↑θ = ↑ψ ↔ ∃ k, θ - ψ = 2 * π * ↑k

full_name: Real.Angle.coe_two_pi
code: @[simp]
theorem coe_two_pi : ↑(2 * π : ℝ) = (0 : Angle) 
goal: ↑(2 * π) = 0

full_name: Real.Angle.neg_coe_pi
code: @[simp]
theorem neg_coe_pi : -(π : Angle) = π 
goal: -↑π = ↑π

full_name: Real.Angle.two_nsmul_coe_div_two
code: @[simp]
theorem two_nsmul_coe_div_two (θ : ℝ) : (2 : ℕ) • (↑(θ / 2) : Angle) = θ 
goal: 2 • ↑(θ / 2) = ↑θ

full_name: Real.Angle.two_zsmul_coe_div_two
code: @[simp]
theorem two_zsmul_coe_div_two (θ : ℝ) : (2 : ℤ) • (↑(θ / 2) : Angle) = θ 
goal: 2 • ↑(θ / 2) = ↑θ

full_name: Real.Angle.two_nsmul_neg_pi_div_two
code: theorem two_nsmul_neg_pi_div_two : (2 : ℕ) • (↑(-π / 2) : Angle) = π 
goal: 2 • ↑(-π / 2) = ↑π

full_name: Real.Angle.two_zsmul_neg_pi_div_two
code: theorem two_zsmul_neg_pi_div_two : (2 : ℤ) • (↑(-π / 2) : Angle) = π 
goal: 2 • ↑(-π / 2) = ↑π

full_name: Real.Angle.sub_coe_pi_eq_add_coe_pi
code: theorem sub_coe_pi_eq_add_coe_pi (θ : Angle) : θ - π = θ + π 
goal: θ - ↑π = θ + ↑π

full_name: Real.Angle.two_nsmul_coe_pi
code: @[simp]
theorem two_nsmul_coe_pi : (2 : ℕ) • (π : Angle) = 0 
goal: 2 • ↑π = 0

full_name: Real.Angle.two_zsmul_coe_pi
code: @[simp]
theorem two_zsmul_coe_pi : (2 : ℤ) • (π : Angle) = 0 
goal: 2 • ↑π = 0

full_name: Real.Angle.coe_pi_add_coe_pi
code: @[simp]
theorem coe_pi_add_coe_pi : (π : Real.Angle) + π = 0 
goal: ↑π + ↑π = 0

full_name: Real.Angle.zsmul_eq_iff
code: theorem zsmul_eq_iff {ψ θ : Angle} {z : ℤ} (hz : z ≠ 0) :
    z • ψ = z • θ ↔ ∃ k : Fin z.natAbs, ψ = θ + (k : ℕ) • (2 * π / z : ℝ) 
goal: z • ψ = z • θ ↔ ∃ k, ψ = θ + ↑k • ↑(2 * π / ↑z)

full_name: Real.Angle.nsmul_eq_iff
code: theorem nsmul_eq_iff {ψ θ : Angle} {n : ℕ} (hz : n ≠ 0) :
    n • ψ = n • θ ↔ ∃ k : Fin n, ψ = θ + (k : ℕ) • (2 * π / n : ℝ) 
goal: n • ψ = n • θ ↔ ∃ k, ψ = θ + ↑k • ↑(2 * π / ↑n)

full_name: Real.Angle.two_zsmul_eq_iff
code: theorem two_zsmul_eq_iff {ψ θ : Angle} : (2 : ℤ) • ψ = (2 : ℤ) • θ ↔ ψ = θ ∨ ψ = θ + ↑π 
goal: 2 • ψ = 2 • θ ↔ ψ = θ ∨ ψ = θ + ↑π

full_name: Real.Angle.two_nsmul_eq_iff
code: theorem two_nsmul_eq_iff {ψ θ : Angle} : (2 : ℕ) • ψ = (2 : ℕ) • θ ↔ ψ = θ ∨ ψ = θ + ↑π 
goal: 2 • ψ = 2 • θ ↔ ψ = θ ∨ ψ = θ + ↑π

full_name: Real.Angle.two_nsmul_eq_zero_iff
code: theorem two_nsmul_eq_zero_iff {θ : Angle} : (2 : ℕ) • θ = 0 ↔ θ = 0 ∨ θ = π 
goal: 2 • θ = 0 ↔ θ = 0 ∨ θ = ↑π

full_name: Real.Angle.two_nsmul_ne_zero_iff
code: theorem two_nsmul_ne_zero_iff {θ : Angle} : (2 : ℕ) • θ ≠ 0 ↔ θ ≠ 0 ∧ θ ≠ π 
goal: 2 • θ ≠ 0 ↔ θ ≠ 0 ∧ θ ≠ ↑π

full_name: Real.Angle.two_zsmul_eq_zero_iff
code: theorem two_zsmul_eq_zero_iff {θ : Angle} : (2 : ℤ) • θ = 0 ↔ θ = 0 ∨ θ = π 
goal: 2 • θ = 0 ↔ θ = 0 ∨ θ = ↑π

full_name: Real.Angle.two_zsmul_ne_zero_iff
code: theorem two_zsmul_ne_zero_iff {θ : Angle} : (2 : ℤ) • θ ≠ 0 ↔ θ ≠ 0 ∧ θ ≠ π 
goal: 2 • θ ≠ 0 ↔ θ ≠ 0 ∧ θ ≠ ↑π

full_name: Real.Angle.eq_neg_self_iff
code: theorem eq_neg_self_iff {θ : Angle} : θ = -θ ↔ θ = 0 ∨ θ = π 
goal: θ = -θ ↔ θ = 0 ∨ θ = ↑π

full_name: Real.Angle.ne_neg_self_iff
code: theorem ne_neg_self_iff {θ : Angle} : θ ≠ -θ ↔ θ ≠ 0 ∧ θ ≠ π 
goal: θ ≠ -θ ↔ θ ≠ 0 ∧ θ ≠ ↑π

full_name: Real.Angle.neg_eq_self_iff
code: theorem neg_eq_self_iff {θ : Angle} : -θ = θ ↔ θ = 0 ∨ θ = π 
goal: -θ = θ ↔ θ = 0 ∨ θ = ↑π

full_name: Real.Angle.neg_ne_self_iff
code: theorem neg_ne_self_iff {θ : Angle} : -θ ≠ θ ↔ θ ≠ 0 ∧ θ ≠ π 
goal: -θ ≠ θ ↔ θ ≠ 0 ∧ θ ≠ ↑π

full_name: Real.Angle.two_nsmul_eq_pi_iff
code: theorem two_nsmul_eq_pi_iff {θ : Angle} : (2 : ℕ) • θ = π ↔ θ = (π / 2 : ℝ) ∨ θ = (-π / 2 : ℝ) 
goal: 2 • θ = ↑π ↔ θ = ↑(π / 2) ∨ θ = ↑(-π / 2)

full_name: Real.Angle.two_zsmul_eq_pi_iff
code: theorem two_zsmul_eq_pi_iff {θ : Angle} : (2 : ℤ) • θ = π ↔ θ = (π / 2 : ℝ) ∨ θ = (-π / 2 : ℝ) 
goal: 2 • θ = ↑π ↔ θ = ↑(π / 2) ∨ θ = ↑(-π / 2)

full_name: Real.Angle.cos_eq_iff_coe_eq_or_eq_neg
code: theorem cos_eq_iff_coe_eq_or_eq_neg {θ ψ : ℝ} :
    cos θ = cos ψ ↔ (θ : Angle) = ψ ∨ (θ : Angle) = -ψ 
goal: Real.cos θ = Real.cos ψ ↔ ↑θ = ↑ψ ∨ ↑θ = -↑ψ

full_name: Real.Angle.sin_eq_iff_coe_eq_or_add_eq_pi
code: theorem sin_eq_iff_coe_eq_or_add_eq_pi {θ ψ : ℝ} :
    sin θ = sin ψ ↔ (θ : Angle) = ψ ∨ (θ : Angle) + ψ = π 
goal: Real.sin θ = Real.sin ψ ↔ ↑θ = ↑ψ ∨ ↑θ + ↑ψ = ↑π

full_name: Real.Angle.cos_sin_inj
code: theorem cos_sin_inj {θ ψ : ℝ} (Hcos : cos θ = cos ψ) (Hsin : sin θ = sin ψ) : (θ : Angle) = ψ 
goal: ↑θ = ↑ψ

full_name: Real.Angle.sin
code: /-- The sine of a `Real.Angle`. -/
def sin (θ : Angle) : ℝ 
goal: ℝ

full_name: Real.Angle.sin_coe
code: @[simp]
theorem sin_coe (x : ℝ) : sin (x : Angle) = Real.sin x 
goal: (↑x).sin = Real.sin x

full_name: Real.Angle.continuous_sin
code: @[continuity]
theorem continuous_sin : Continuous sin 
goal: Continuous Real.Angle.sin

full_name: Real.Angle.cos
code: /-- The cosine of a `Real.Angle`. -/
def cos (θ : Angle) : ℝ 
goal: ℝ

full_name: Real.Angle.cos_coe
code: @[simp]
theorem cos_coe (x : ℝ) : cos (x : Angle) = Real.cos x 
goal: (↑x).cos = Real.cos x

full_name: Real.Angle.continuous_cos
code: @[continuity]
theorem continuous_cos : Continuous cos 
goal: Continuous Real.Angle.cos

full_name: Real.Angle.cos_eq_real_cos_iff_eq_or_eq_neg
code: theorem cos_eq_real_cos_iff_eq_or_eq_neg {θ : Angle} {ψ : ℝ} :
    cos θ = Real.cos ψ ↔ θ = ψ ∨ θ = -ψ 
goal: θ.cos = Real.cos ψ ↔ θ = ↑ψ ∨ θ = -↑ψ

full_name: Real.Angle.cos_eq_iff_eq_or_eq_neg
code: theorem cos_eq_iff_eq_or_eq_neg {θ ψ : Angle} : cos θ = cos ψ ↔ θ = ψ ∨ θ = -ψ 
goal: θ.cos = ψ.cos ↔ θ = ψ ∨ θ = -ψ

full_name: Real.Angle.sin_eq_real_sin_iff_eq_or_add_eq_pi
code: theorem sin_eq_real_sin_iff_eq_or_add_eq_pi {θ : Angle} {ψ : ℝ} :
    sin θ = Real.sin ψ ↔ θ = ψ ∨ θ + ψ = π 
goal: θ.sin = Real.sin ψ ↔ θ = ↑ψ ∨ θ + ↑ψ = ↑π

full_name: Real.Angle.sin_eq_iff_eq_or_add_eq_pi
code: theorem sin_eq_iff_eq_or_add_eq_pi {θ ψ : Angle} : sin θ = sin ψ ↔ θ = ψ ∨ θ + ψ = π 
goal: θ.sin = ψ.sin ↔ θ = ψ ∨ θ + ψ = ↑π

full_name: Real.Angle.sin_zero
code: @[simp]
theorem sin_zero : sin (0 : Angle) = 0 
goal: Real.Angle.sin 0 = 0

full_name: Real.Angle.sin_coe_pi
code: theorem sin_coe_pi : sin (π : Angle) = 0 
goal: (↑π).sin = 0

full_name: Real.Angle.sin_eq_zero_iff
code: theorem sin_eq_zero_iff {θ : Angle} : sin θ = 0 ↔ θ = 0 ∨ θ = π 
goal: θ.sin = 0 ↔ θ = 0 ∨ θ = ↑π

full_name: Real.Angle.sin_ne_zero_iff
code: theorem sin_ne_zero_iff {θ : Angle} : sin θ ≠ 0 ↔ θ ≠ 0 ∧ θ ≠ π 
goal: θ.sin ≠ 0 ↔ θ ≠ 0 ∧ θ ≠ ↑π

full_name: Real.Angle.sin_neg
code: @[simp]
theorem sin_neg (θ : Angle) : sin (-θ) = -sin θ 
goal: (-θ).sin = -θ.sin

full_name: Real.Angle.sin_antiperiodic
code: theorem sin_antiperiodic : Function.Antiperiodic sin (π : Angle) 
goal: Function.Antiperiodic Real.Angle.sin ↑π

full_name: Real.Angle.sin_add_pi
code: @[simp]
theorem sin_add_pi (θ : Angle) : sin (θ + π) = -sin θ 
goal: (θ + ↑π).sin = -θ.sin

full_name: Real.Angle.sin_sub_pi
code: @[simp]
theorem sin_sub_pi (θ : Angle) : sin (θ - π) = -sin θ 
goal: (θ - ↑π).sin = -θ.sin

full_name: Real.Angle.cos_zero
code: @[simp]
theorem cos_zero : cos (0 : Angle) = 1 
goal: Real.Angle.cos 0 = 1

full_name: Real.Angle.cos_coe_pi
code: theorem cos_coe_pi : cos (π : Angle) = -1 
goal: (↑π).cos = -1

full_name: Real.Angle.cos_neg
code: @[simp]
theorem cos_neg (θ : Angle) : cos (-θ) = cos θ 
goal: (-θ).cos = θ.cos

full_name: Real.Angle.cos_antiperiodic
code: theorem cos_antiperiodic : Function.Antiperiodic cos (π : Angle) 
goal: Function.Antiperiodic Real.Angle.cos ↑π

full_name: Real.Angle.cos_add_pi
code: @[simp]
theorem cos_add_pi (θ : Angle) : cos (θ + π) = -cos θ 
goal: (θ + ↑π).cos = -θ.cos

full_name: Real.Angle.cos_sub_pi
code: @[simp]
theorem cos_sub_pi (θ : Angle) : cos (θ - π) = -cos θ 
goal: (θ - ↑π).cos = -θ.cos

full_name: Real.Angle.cos_eq_zero_iff
code: theorem cos_eq_zero_iff {θ : Angle} : cos θ = 0 ↔ θ = (π / 2 : ℝ) ∨ θ = (-π / 2 : ℝ) 
goal: θ.cos = 0 ↔ θ = ↑(π / 2) ∨ θ = ↑(-π / 2)

full_name: Real.Angle.sin_add
code: theorem sin_add (θ₁ θ₂ : Real.Angle) : sin (θ₁ + θ₂) = sin θ₁ * cos θ₂ + cos θ₁ * sin θ₂ 
goal: (θ₁ + θ₂).sin = θ₁.sin * θ₂.cos + θ₁.cos * θ₂.sin

full_name: Real.Angle.cos_add
code: theorem cos_add (θ₁ θ₂ : Real.Angle) : cos (θ₁ + θ₂) = cos θ₁ * cos θ₂ - sin θ₁ * sin θ₂ 
goal: (θ₁ + θ₂).cos = θ₁.cos * θ₂.cos - θ₁.sin * θ₂.sin

full_name: Real.Angle.cos_sq_add_sin_sq
code: @[simp]
theorem cos_sq_add_sin_sq (θ : Real.Angle) : cos θ ^ 2 + sin θ ^ 2 = 1 
goal: θ.cos ^ 2 + θ.sin ^ 2 = 1

full_name: Real.Angle.sin_add_pi_div_two
code: theorem sin_add_pi_div_two (θ : Angle) : sin (θ + ↑(π / 2)) = cos θ 
goal: (θ + ↑(π / 2)).sin = θ.cos

full_name: Real.Angle.sin_sub_pi_div_two
code: theorem sin_sub_pi_div_two (θ : Angle) : sin (θ - ↑(π / 2)) = -cos θ 
goal: (θ - ↑(π / 2)).sin = -θ.cos

full_name: Real.Angle.sin_pi_div_two_sub
code: theorem sin_pi_div_two_sub (θ : Angle) : sin (↑(π / 2) - θ) = cos θ 
goal: (↑(π / 2) - θ).sin = θ.cos

full_name: Real.Angle.cos_add_pi_div_two
code: theorem cos_add_pi_div_two (θ : Angle) : cos (θ + ↑(π / 2)) = -sin θ 
goal: (θ + ↑(π / 2)).cos = -θ.sin

full_name: Real.Angle.cos_sub_pi_div_two
code: theorem cos_sub_pi_div_two (θ : Angle) : cos (θ - ↑(π / 2)) = sin θ 
goal: (θ - ↑(π / 2)).cos = θ.sin

full_name: Real.Angle.cos_pi_div_two_sub
code: theorem cos_pi_div_two_sub (θ : Angle) : cos (↑(π / 2) - θ) = sin θ 
goal: (↑(π / 2) - θ).cos = θ.sin

full_name: Real.Angle.abs_sin_eq_of_two_nsmul_eq
code: theorem abs_sin_eq_of_two_nsmul_eq {θ ψ : Angle} (h : (2 : ℕ) • θ = (2 : ℕ) • ψ) :
    |sin θ| = |sin ψ| 
goal: |θ.sin| = |ψ.sin|

full_name: Real.Angle.abs_sin_eq_of_two_zsmul_eq
code: theorem abs_sin_eq_of_two_zsmul_eq {θ ψ : Angle} (h : (2 : ℤ) • θ = (2 : ℤ) • ψ) :
    |sin θ| = |sin ψ| 
goal: |θ.sin| = |ψ.sin|

full_name: Real.Angle.abs_cos_eq_of_two_nsmul_eq
code: theorem abs_cos_eq_of_two_nsmul_eq {θ ψ : Angle} (h : (2 : ℕ) • θ = (2 : ℕ) • ψ) :
    |cos θ| = |cos ψ| 
goal: |θ.cos| = |ψ.cos|

full_name: Real.Angle.abs_cos_eq_of_two_zsmul_eq
code: theorem abs_cos_eq_of_two_zsmul_eq {θ ψ : Angle} (h : (2 : ℤ) • θ = (2 : ℤ) • ψ) :
    |cos θ| = |cos ψ| 
goal: |θ.cos| = |ψ.cos|

full_name: Real.Angle.coe_toIcoMod
code: @[simp]
theorem coe_toIcoMod (θ ψ : ℝ) : ↑(toIcoMod two_pi_pos ψ θ) = (θ : Angle) 
goal: ↑(toIcoMod Real.two_pi_pos ψ θ) = ↑θ

full_name: Real.Angle.coe_toIocMod
code: @[simp]
theorem coe_toIocMod (θ ψ : ℝ) : ↑(toIocMod two_pi_pos ψ θ) = (θ : Angle) 
goal: ↑(toIocMod Real.two_pi_pos ψ θ) = ↑θ

full_name: Real.Angle.toReal
code: /-- Convert a `Real.Angle` to a real number in the interval `Ioc (-π) π`. -/
def toReal (θ : Angle) : ℝ 
goal: ℝ

full_name: Real.Angle.toReal_coe
code: theorem toReal_coe (θ : ℝ) : (θ : Angle).toReal = toIocMod two_pi_pos (-π) θ 
goal: (↑θ).toReal = toIocMod Real.two_pi_pos (-π) θ

full_name: Real.Angle.toReal_coe_eq_self_iff
code: theorem toReal_coe_eq_self_iff {θ : ℝ} : (θ : Angle).toReal = θ ↔ -π < θ ∧ θ ≤ π 
goal: (↑θ).toReal = θ ↔ -π < θ ∧ θ ≤ π

full_name: Real.Angle.toReal_coe_eq_self_iff_mem_Ioc
code: theorem toReal_coe_eq_self_iff_mem_Ioc {θ : ℝ} : (θ : Angle).toReal = θ ↔ θ ∈ Set.Ioc (-π) π 
goal: (↑θ).toReal = θ ↔ θ ∈ Set.Ioc (-π) π

full_name: Real.Angle.toReal_injective
code: theorem toReal_injective : Function.Injective toReal 
goal: Function.Injective Real.Angle.toReal

full_name: Real.Angle.toReal_inj
code: @[simp]
theorem toReal_inj {θ ψ : Angle} : θ.toReal = ψ.toReal ↔ θ = ψ 
goal: θ.toReal = ψ.toReal ↔ θ = ψ

full_name: Real.Angle.coe_toReal
code: @[simp]
theorem coe_toReal (θ : Angle) : (θ.toReal : Angle) = θ 
goal: ↑θ.toReal = θ

full_name: Real.Angle.neg_pi_lt_toReal
code: theorem neg_pi_lt_toReal (θ : Angle) : -π < θ.toReal 
goal: -π < θ.toReal

full_name: Real.Angle.toReal_le_pi
code: theorem toReal_le_pi (θ : Angle) : θ.toReal ≤ π 
goal: θ.toReal ≤ π

full_name: Real.Angle.abs_toReal_le_pi
code: theorem abs_toReal_le_pi (θ : Angle) : |θ.toReal| ≤ π 
goal: |θ.toReal| ≤ π

full_name: Real.Angle.toReal_mem_Ioc
code: theorem toReal_mem_Ioc (θ : Angle) : θ.toReal ∈ Set.Ioc (-π) π 
goal: θ.toReal ∈ Set.Ioc (-π) π

full_name: Real.Angle.toIocMod_toReal
code: @[simp]
theorem toIocMod_toReal (θ : Angle) : toIocMod two_pi_pos (-π) θ.toReal = θ.toReal 
goal: toIocMod Real.two_pi_pos (-π) θ.toReal = θ.toReal

full_name: Real.Angle.toReal_zero
code: @[simp]
theorem toReal_zero : (0 : Angle).toReal = 0 
goal: Real.Angle.toReal 0 = 0

full_name: Real.Angle.toReal_eq_zero_iff
code: @[simp]
theorem toReal_eq_zero_iff {θ : Angle} : θ.toReal = 0 ↔ θ = 0 
goal: θ.toReal = 0 ↔ θ = 0

full_name: Real.Angle.toReal_pi
code: @[simp]
theorem toReal_pi : (π : Angle).toReal = π 
goal: (↑π).toReal = π

full_name: Real.Angle.toReal_eq_pi_iff
code: @[simp]
theorem toReal_eq_pi_iff {θ : Angle} : θ.toReal = π ↔ θ = π 
goal: θ.toReal = π ↔ θ = ↑π

full_name: Real.Angle.pi_ne_zero
code: theorem pi_ne_zero : (π : Angle) ≠ 0 
goal: ↑π ≠ 0

full_name: Real.Angle.toReal_pi_div_two
code: @[simp]
theorem toReal_pi_div_two : ((π / 2 : ℝ) : Angle).toReal = π / 2 
goal: (↑(π / 2)).toReal = π / 2

full_name: Real.Angle.toReal_eq_pi_div_two_iff
code: @[simp]
theorem toReal_eq_pi_div_two_iff {θ : Angle} : θ.toReal = π / 2 ↔ θ = (π / 2 : ℝ) 
goal: θ.toReal = π / 2 ↔ θ = ↑(π / 2)

full_name: Real.Angle.toReal_neg_pi_div_two
code: @[simp]
theorem toReal_neg_pi_div_two : ((-π / 2 : ℝ) : Angle).toReal = -π / 2 
goal: (↑(-π / 2)).toReal = -π / 2

full_name: Real.Angle.toReal_eq_neg_pi_div_two_iff
code: @[simp]
theorem toReal_eq_neg_pi_div_two_iff {θ : Angle} : θ.toReal = -π / 2 ↔ θ = (-π / 2 : ℝ) 
goal: θ.toReal = -π / 2 ↔ θ = ↑(-π / 2)

full_name: Real.Angle.pi_div_two_ne_zero
code: theorem pi_div_two_ne_zero : ((π / 2 : ℝ) : Angle) ≠ 0 
goal: ↑(π / 2) ≠ 0

full_name: Real.Angle.neg_pi_div_two_ne_zero
code: theorem neg_pi_div_two_ne_zero : ((-π / 2 : ℝ) : Angle) ≠ 0 
goal: ↑(-π / 2) ≠ 0

full_name: Real.Angle.abs_toReal_coe_eq_self_iff
code: theorem abs_toReal_coe_eq_self_iff {θ : ℝ} : |(θ : Angle).toReal| = θ ↔ 0 ≤ θ ∧ θ ≤ π 
goal: |(↑θ).toReal| = θ ↔ 0 ≤ θ ∧ θ ≤ π

full_name: Real.Angle.abs_toReal_neg_coe_eq_self_iff
code: theorem abs_toReal_neg_coe_eq_self_iff {θ : ℝ} : |(-θ : Angle).toReal| = θ ↔ 0 ≤ θ ∧ θ ≤ π 
goal: |(-↑θ).toReal| = θ ↔ 0 ≤ θ ∧ θ ≤ π

full_name: Real.Angle.abs_toReal_eq_pi_div_two_iff
code: theorem abs_toReal_eq_pi_div_two_iff {θ : Angle} :
    |θ.toReal| = π / 2 ↔ θ = (π / 2 : ℝ) ∨ θ = (-π / 2 : ℝ) 
goal: |θ.toReal| = π / 2 ↔ θ = ↑(π / 2) ∨ θ = ↑(-π / 2)

full_name: Real.Angle.nsmul_toReal_eq_mul
code: theorem nsmul_toReal_eq_mul {n : ℕ} (h : n ≠ 0) {θ : Angle} :
    (n • θ).toReal = n * θ.toReal ↔ θ.toReal ∈ Set.Ioc (-π / n) (π / n) 
goal: (n • θ).toReal = ↑n * θ.toReal ↔ θ.toReal ∈ Set.Ioc (-π / ↑n) (π / ↑n)

full_name: Real.Angle.two_nsmul_toReal_eq_two_mul
code: theorem two_nsmul_toReal_eq_two_mul {θ : Angle} :
    ((2 : ℕ) • θ).toReal = 2 * θ.toReal ↔ θ.toReal ∈ Set.Ioc (-π / 2) (π / 2) 
goal: (2 • θ).toReal = 2 * θ.toReal ↔ θ.toReal ∈ Set.Ioc (-π / 2) (π / 2)

full_name: Real.Angle.two_zsmul_toReal_eq_two_mul
code: theorem two_zsmul_toReal_eq_two_mul {θ : Angle} :
    ((2 : ℤ) • θ).toReal = 2 * θ.toReal ↔ θ.toReal ∈ Set.Ioc (-π / 2) (π / 2) 
goal: (2 • θ).toReal = 2 * θ.toReal ↔ θ.toReal ∈ Set.Ioc (-π / 2) (π / 2)

full_name: Real.Angle.toReal_coe_eq_self_sub_two_mul_int_mul_pi_iff
code: theorem toReal_coe_eq_self_sub_two_mul_int_mul_pi_iff {θ : ℝ} {k : ℤ} :
    (θ : Angle).toReal = θ - 2 * k * π ↔ θ ∈ Set.Ioc ((2 * k - 1 : ℝ) * π) ((2 * k + 1) * π) 
goal: (↑θ).toReal = θ - 2 * ↑k * π ↔ θ ∈ Set.Ioc ((2 * ↑k - 1) * π) ((2 * ↑k + 1) * π)

full_name: Real.Angle.toReal_coe_eq_self_sub_two_pi_iff
code: theorem toReal_coe_eq_self_sub_two_pi_iff {θ : ℝ} :
    (θ : Angle).toReal = θ - 2 * π ↔ θ ∈ Set.Ioc π (3 * π) 
goal: (↑θ).toReal = θ - 2 * π ↔ θ ∈ Set.Ioc π (3 * π)

full_name: Real.Angle.toReal_coe_eq_self_add_two_pi_iff
code: theorem toReal_coe_eq_self_add_two_pi_iff {θ : ℝ} :
    (θ : Angle).toReal = θ + 2 * π ↔ θ ∈ Set.Ioc (-3 * π) (-π) 
goal: (↑θ).toReal = θ + 2 * π ↔ θ ∈ Set.Ioc (-3 * π) (-π)

full_name: Real.Angle.two_nsmul_toReal_eq_two_mul_sub_two_pi
code: theorem two_nsmul_toReal_eq_two_mul_sub_two_pi {θ : Angle} :
    ((2 : ℕ) • θ).toReal = 2 * θ.toReal - 2 * π ↔ π / 2 < θ.toReal 
goal: (2 • θ).toReal = 2 * θ.toReal - 2 * π ↔ π / 2 < θ.toReal

full_name: Real.Angle.two_zsmul_toReal_eq_two_mul_sub_two_pi
code: theorem two_zsmul_toReal_eq_two_mul_sub_two_pi {θ : Angle} :
    ((2 : ℤ) • θ).toReal = 2 * θ.toReal - 2 * π ↔ π / 2 < θ.toReal 
goal: (2 • θ).toReal = 2 * θ.toReal - 2 * π ↔ π / 2 < θ.toReal

full_name: Real.Angle.two_nsmul_toReal_eq_two_mul_add_two_pi
code: theorem two_nsmul_toReal_eq_two_mul_add_two_pi {θ : Angle} :
    ((2 : ℕ) • θ).toReal = 2 * θ.toReal + 2 * π ↔ θ.toReal ≤ -π / 2 
goal: (2 • θ).toReal = 2 * θ.toReal + 2 * π ↔ θ.toReal ≤ -π / 2

full_name: Real.Angle.two_zsmul_toReal_eq_two_mul_add_two_pi
code: theorem two_zsmul_toReal_eq_two_mul_add_two_pi {θ : Angle} :
    ((2 : ℤ) • θ).toReal = 2 * θ.toReal + 2 * π ↔ θ.toReal ≤ -π / 2 
goal: (2 • θ).toReal = 2 * θ.toReal + 2 * π ↔ θ.toReal ≤ -π / 2

full_name: Real.Angle.sin_toReal
code: @[simp]
theorem sin_toReal (θ : Angle) : Real.sin θ.toReal = sin θ 
goal: Real.sin θ.toReal = θ.sin

full_name: Real.Angle.cos_toReal
code: @[simp]
theorem cos_toReal (θ : Angle) : Real.cos θ.toReal = cos θ 
goal: Real.cos θ.toReal = θ.cos

full_name: Real.Angle.cos_nonneg_iff_abs_toReal_le_pi_div_two
code: theorem cos_nonneg_iff_abs_toReal_le_pi_div_two {θ : Angle} : 0 ≤ cos θ ↔ |θ.toReal| ≤ π / 2 
goal: 0 ≤ θ.cos ↔ |θ.toReal| ≤ π / 2

full_name: Real.Angle.cos_pos_iff_abs_toReal_lt_pi_div_two
code: theorem cos_pos_iff_abs_toReal_lt_pi_div_two {θ : Angle} : 0 < cos θ ↔ |θ.toReal| < π / 2 
goal: 0 < θ.cos ↔ |θ.toReal| < π / 2

full_name: Real.Angle.cos_neg_iff_pi_div_two_lt_abs_toReal
code: theorem cos_neg_iff_pi_div_two_lt_abs_toReal {θ : Angle} : cos θ < 0 ↔ π / 2 < |θ.toReal| 
goal: θ.cos < 0 ↔ π / 2 < |θ.toReal|

full_name: Real.Angle.abs_cos_eq_abs_sin_of_two_nsmul_add_two_nsmul_eq_pi
code: theorem abs_cos_eq_abs_sin_of_two_nsmul_add_two_nsmul_eq_pi {θ ψ : Angle}
    (h : (2 : ℕ) • θ + (2 : ℕ) • ψ = π) : |cos θ| = |sin ψ| 
goal: |θ.cos| = |ψ.sin|

full_name: Real.Angle.abs_cos_eq_abs_sin_of_two_zsmul_add_two_zsmul_eq_pi
code: theorem abs_cos_eq_abs_sin_of_two_zsmul_add_two_zsmul_eq_pi {θ ψ : Angle}
    (h : (2 : ℤ) • θ + (2 : ℤ) • ψ = π) : |cos θ| = |sin ψ| 
goal: |θ.cos| = |ψ.sin|

full_name: Real.Angle.tan
code: /-- The tangent of a `Real.Angle`. -/
def tan (θ : Angle) : ℝ 
goal: ℝ

full_name: Real.Angle.tan_eq_sin_div_cos
code: theorem tan_eq_sin_div_cos (θ : Angle) : tan θ = sin θ / cos θ 
goal: θ.tan = θ.sin / θ.cos

full_name: Real.Angle.tan_coe
code: @[simp]
theorem tan_coe (x : ℝ) : tan (x : Angle) = Real.tan x 
goal: (↑x).tan = Real.tan x

full_name: Real.Angle.tan_zero
code: @[simp]
theorem tan_zero : tan (0 : Angle) = 0 
goal: Real.Angle.tan 0 = 0

full_name: Real.Angle.tan_coe_pi
code: theorem tan_coe_pi : tan (π : Angle) = 0 
goal: (↑π).tan = 0

full_name: Real.Angle.tan_periodic
code: theorem tan_periodic : Function.Periodic tan (π : Angle) 
goal: Function.Periodic Real.Angle.tan ↑π

full_name: Real.Angle.tan_add_pi
code: @[simp]
theorem tan_add_pi (θ : Angle) : tan (θ + π) = tan θ 
goal: (θ + ↑π).tan = θ.tan

full_name: Real.Angle.tan_sub_pi
code: @[simp]
theorem tan_sub_pi (θ : Angle) : tan (θ - π) = tan θ 
goal: (θ - ↑π).tan = θ.tan

full_name: Real.Angle.tan_toReal
code: @[simp]
theorem tan_toReal (θ : Angle) : Real.tan θ.toReal = tan θ 
goal: Real.tan θ.toReal = θ.tan

full_name: Real.Angle.tan_eq_of_two_nsmul_eq
code: theorem tan_eq_of_two_nsmul_eq {θ ψ : Angle} (h : (2 : ℕ) • θ = (2 : ℕ) • ψ) : tan θ = tan ψ 
goal: θ.tan = ψ.tan

full_name: Real.Angle.tan_eq_of_two_zsmul_eq
code: theorem tan_eq_of_two_zsmul_eq {θ ψ : Angle} (h : (2 : ℤ) • θ = (2 : ℤ) • ψ) : tan θ = tan ψ 
goal: θ.tan = ψ.tan

full_name: Real.Angle.tan_eq_inv_of_two_nsmul_add_two_nsmul_eq_pi
code: theorem tan_eq_inv_of_two_nsmul_add_two_nsmul_eq_pi {θ ψ : Angle}
    (h : (2 : ℕ) • θ + (2 : ℕ) • ψ = π) : tan ψ = (tan θ)⁻¹ 
goal: ψ.tan = θ.tan⁻¹

full_name: Real.Angle.tan_eq_inv_of_two_zsmul_add_two_zsmul_eq_pi
code: theorem tan_eq_inv_of_two_zsmul_add_two_zsmul_eq_pi {θ ψ : Angle}
    (h : (2 : ℤ) • θ + (2 : ℤ) • ψ = π) : tan ψ = (tan θ)⁻¹ 
goal: ψ.tan = θ.tan⁻¹

full_name: Real.Angle.sign
code: /-- The sign of a `Real.Angle` is `0` if the angle is `0` or `π`, `1` if the angle is strictly
between `0` and `π` and `-1` is the angle is strictly between `-π` and `0`. It is defined as the
sign of the sine of the angle. -/
def sign (θ : Angle) : SignType 
goal: SignType

full_name: Real.Angle.sign_zero
code: @[simp]
theorem sign_zero : (0 : Angle).sign = 0 
goal: Real.Angle.sign 0 = 0

full_name: Real.Angle.sign_coe_pi
code: @[simp]
theorem sign_coe_pi : (π : Angle).sign = 0 
goal: (↑π).sign = 0

full_name: Real.Angle.sign_neg
code: @[simp]
theorem sign_neg (θ : Angle) : (-θ).sign = -θ.sign 
goal: (-θ).sign = -θ.sign

full_name: Real.Angle.sign_antiperiodic
code: theorem sign_antiperiodic : Function.Antiperiodic sign (π : Angle) 
goal: Function.Antiperiodic Real.Angle.sign ↑π

full_name: Real.Angle.sign_add_pi
code: @[simp]
theorem sign_add_pi (θ : Angle) : (θ + π).sign = -θ.sign 
goal: (θ + ↑π).sign = -θ.sign

full_name: Real.Angle.sign_pi_add
code: @[simp]
theorem sign_pi_add (θ : Angle) : ((π : Angle) + θ).sign = -θ.sign 
goal: (↑π + θ).sign = -θ.sign

full_name: Real.Angle.sign_sub_pi
code: @[simp]
theorem sign_sub_pi (θ : Angle) : (θ - π).sign = -θ.sign 
goal: (θ - ↑π).sign = -θ.sign

full_name: Real.Angle.sign_pi_sub
code: @[simp]
theorem sign_pi_sub (θ : Angle) : ((π : Angle) - θ).sign = θ.sign 
goal: (↑π - θ).sign = θ.sign

full_name: Real.Angle.sign_eq_zero_iff
code: theorem sign_eq_zero_iff {θ : Angle} : θ.sign = 0 ↔ θ = 0 ∨ θ = π 
goal: θ.sign = 0 ↔ θ = 0 ∨ θ = ↑π

full_name: Real.Angle.sign_ne_zero_iff
code: theorem sign_ne_zero_iff {θ : Angle} : θ.sign ≠ 0 ↔ θ ≠ 0 ∧ θ ≠ π 
goal: θ.sign ≠ 0 ↔ θ ≠ 0 ∧ θ ≠ ↑π

full_name: Real.Angle.toReal_neg_iff_sign_neg
code: theorem toReal_neg_iff_sign_neg {θ : Angle} : θ.toReal < 0 ↔ θ.sign = -1 
goal: θ.toReal < 0 ↔ θ.sign = -1

full_name: Real.Angle.toReal_nonneg_iff_sign_nonneg
code: theorem toReal_nonneg_iff_sign_nonneg {θ : Angle} : 0 ≤ θ.toReal ↔ 0 ≤ θ.sign 
goal: 0 ≤ θ.toReal ↔ 0 ≤ θ.sign

full_name: Real.Angle.sign_toReal
code: @[simp]
theorem sign_toReal {θ : Angle} (h : θ ≠ π) : SignType.sign θ.toReal = θ.sign 
goal: SignType.sign θ.toReal = θ.sign

full_name: Real.Angle.coe_abs_toReal_of_sign_nonneg
code: theorem coe_abs_toReal_of_sign_nonneg {θ : Angle} (h : 0 ≤ θ.sign) : ↑|θ.toReal| = θ 
goal: ↑|θ.toReal| = θ

full_name: Real.Angle.neg_coe_abs_toReal_of_sign_nonpos
code: theorem neg_coe_abs_toReal_of_sign_nonpos {θ : Angle} (h : θ.sign ≤ 0) : -↑|θ.toReal| = θ 
goal: -↑|θ.toReal| = θ

full_name: Real.Angle.eq_iff_sign_eq_and_abs_toReal_eq
code: theorem eq_iff_sign_eq_and_abs_toReal_eq {θ ψ : Angle} :
    θ = ψ ↔ θ.sign = ψ.sign ∧ |θ.toReal| = |ψ.toReal| 
goal: θ = ψ ↔ θ.sign = ψ.sign ∧ |θ.toReal| = |ψ.toReal|

full_name: Real.Angle.eq_iff_abs_toReal_eq_of_sign_eq
code: theorem eq_iff_abs_toReal_eq_of_sign_eq {θ ψ : Angle} (h : θ.sign = ψ.sign) :
    θ = ψ ↔ |θ.toReal| = |ψ.toReal| 
goal: θ = ψ ↔ |θ.toReal| = |ψ.toReal|

full_name: Real.Angle.sign_coe_pi_div_two
code: @[simp]
theorem sign_coe_pi_div_two : (↑(π / 2) : Angle).sign = 1 
goal: (↑(π / 2)).sign = 1

full_name: Real.Angle.sign_coe_neg_pi_div_two
code: @[simp]
theorem sign_coe_neg_pi_div_two : (↑(-π / 2) : Angle).sign = -1 
goal: (↑(-π / 2)).sign = -1

full_name: Real.Angle.sign_coe_nonneg_of_nonneg_of_le_pi
code: theorem sign_coe_nonneg_of_nonneg_of_le_pi {θ : ℝ} (h0 : 0 ≤ θ) (hpi : θ ≤ π) :
    0 ≤ (θ : Angle).sign 
goal: 0 ≤ (↑θ).sign

full_name: Real.Angle.sign_neg_coe_nonpos_of_nonneg_of_le_pi
code: theorem sign_neg_coe_nonpos_of_nonneg_of_le_pi {θ : ℝ} (h0 : 0 ≤ θ) (hpi : θ ≤ π) :
    (-θ : Angle).sign ≤ 0 
goal: (-↑θ).sign ≤ 0

full_name: Real.Angle.sign_two_nsmul_eq_sign_iff
code: theorem sign_two_nsmul_eq_sign_iff {θ : Angle} :
    ((2 : ℕ) • θ).sign = θ.sign ↔ θ = π ∨ |θ.toReal| < π / 2 
goal: (2 • θ).sign = θ.sign ↔ θ = ↑π ∨ |θ.toReal| < π / 2

full_name: Real.Angle.sign_two_zsmul_eq_sign_iff
code: theorem sign_two_zsmul_eq_sign_iff {θ : Angle} :
    ((2 : ℤ) • θ).sign = θ.sign ↔ θ = π ∨ |θ.toReal| < π / 2 
goal: (2 • θ).sign = θ.sign ↔ θ = ↑π ∨ |θ.toReal| < π / 2

full_name: Real.Angle.continuousAt_sign
code: theorem continuousAt_sign {θ : Angle} (h0 : θ ≠ 0) (hpi : θ ≠ π) : ContinuousAt sign θ 
goal: ContinuousAt Real.Angle.sign θ

full_name: ContinuousOn.angle_sign_comp
code: 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 
goal: ContinuousOn (Real.Angle.sign ∘ f) s

full_name: Real.Angle.sign_eq_of_continuousOn
code: /-- Suppose a function to angles is continuous on a connected set and never takes the values `0`
or `π` on that set. Then the values of the function on that set all have the same sign. -/
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 
goal: (f y).sign = (f x).sign