mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

@@ -219,13 +219,13 @@ theorem nsmul_eq_iff {ψ θ : Angle} {n : ℕ} (hz : n ≠ 0) :
 theorem two_zsmul_eq_iff {ψ θ : Angle} : (2 : ℤ) • ψ = (2 : ℤ) • θ ↔ ψ = θ ∨ ψ = θ + π := by
   rw [zsmul_eq_iff two_ne_zero, Int.natAbs_bit0, Int.natAbs_one, Fin.exists_fin_two, Fin.val_zero,
     Fin.val_one, zero_smul, add_zero, one_smul, Int.cast_two,
-    mul_div_cancel_left (_ : ℝ) two_ne_zero]
+    mul_div_cancel_left₀ (_ : ℝ) two_ne_zero]
 #align real.angle.two_zsmul_eq_iff Real.Angle.two_zsmul_eq_iff
 -/
 
 #print Real.Angle.two_nsmul_eq_iff /-
 theorem two_nsmul_eq_iff {ψ θ : Angle} : (2 : ℕ) • ψ = (2 : ℕ) • θ ↔ ψ = θ ∨ ψ = θ + π := by
-  simp_rw [← coe_nat_zsmul, Int.ofNat_bit0, Int.ofNat_one, two_zsmul_eq_iff]
+  simp_rw [← natCast_zsmul, Int.ofNat_bit0, Int.ofNat_one, two_zsmul_eq_iff]
 #align real.angle.two_nsmul_eq_iff Real.Angle.two_nsmul_eq_iff
 -/
 
@@ -313,10 +313,10 @@ theorem cos_eq_iff_coe_eq_or_eq_neg {θ ψ : ℝ} :
         zero_add]
   · rw [angle_eq_iff_two_pi_dvd_sub, ← coe_neg, angle_eq_iff_two_pi_dvd_sub]
     rintro (⟨k, H⟩ | ⟨k, H⟩)
-    rw [← sub_eq_zero, cos_sub_cos, H, mul_assoc 2 π k, mul_div_cancel_left _ (two_ne_zero' ℝ),
+    rw [← sub_eq_zero, cos_sub_cos, H, mul_assoc 2 π k, mul_div_cancel_left₀ _ (two_ne_zero' ℝ),
       mul_comm π _, sin_int_mul_pi, MulZeroClass.mul_zero]
     rw [← sub_eq_zero, cos_sub_cos, ← sub_neg_eq_add, H, mul_assoc 2 π k,
-      mul_div_cancel_left _ (two_ne_zero' ℝ), mul_comm π _, sin_int_mul_pi, MulZeroClass.mul_zero,
+      mul_div_cancel_left₀ _ (two_ne_zero' ℝ), mul_comm π _, sin_int_mul_pi, MulZeroClass.mul_zero,
       MulZeroClass.zero_mul]
 #align real.angle.cos_eq_iff_coe_eq_or_eq_neg Real.Angle.cos_eq_iff_coe_eq_or_eq_neg
 -/
@@ -335,13 +335,13 @@ theorem sin_eq_iff_coe_eq_or_add_eq_pi {θ ψ : ℝ} :
     exact h.symm
   · rw [angle_eq_iff_two_pi_dvd_sub, ← eq_sub_iff_add_eq, ← coe_sub, angle_eq_iff_two_pi_dvd_sub]
     rintro (⟨k, H⟩ | ⟨k, H⟩)
-    rw [← sub_eq_zero, sin_sub_sin, H, mul_assoc 2 π k, mul_div_cancel_left _ (two_ne_zero' ℝ),
+    rw [← sub_eq_zero, sin_sub_sin, H, mul_assoc 2 π k, mul_div_cancel_left₀ _ (two_ne_zero' ℝ),
       mul_comm π _, sin_int_mul_pi, MulZeroClass.mul_zero, MulZeroClass.zero_mul]
     have H' : θ + ψ = 2 * k * π + π := by
       rwa [← sub_add, sub_add_eq_add_sub, sub_eq_iff_eq_add, mul_assoc, mul_comm π _, ←
         mul_assoc] at H
     rw [← sub_eq_zero, sin_sub_sin, H', add_div, mul_assoc 2 _ π,
-      mul_div_cancel_left _ (two_ne_zero' ℝ), cos_add_pi_div_two, sin_int_mul_pi, neg_zero,
+      mul_div_cancel_left₀ _ (two_ne_zero' ℝ), cos_add_pi_div_two, sin_int_mul_pi, neg_zero,
       MulZeroClass.mul_zero]
 #align real.angle.sin_eq_iff_coe_eq_or_add_eq_pi Real.Angle.sin_eq_iff_coe_eq_or_add_eq_pi
 -/

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

@@ -301,14 +301,14 @@ theorem cos_eq_iff_coe_eq_or_eq_neg {θ ψ : ℝ} :
   constructor
   · intro Hcos
     rw [← sub_eq_zero, cos_sub_cos, mul_eq_zero, mul_eq_zero, neg_eq_zero,
-      eq_false (two_ne_zero' ℝ), false_or_iff, sin_eq_zero_iff, sin_eq_zero_iff] at Hcos 
+      eq_false (two_ne_zero' ℝ), false_or_iff, sin_eq_zero_iff, sin_eq_zero_iff] at Hcos
     rcases Hcos with (⟨n, hn⟩ | ⟨n, hn⟩)
     · right
-      rw [eq_div_iff_mul_eq (two_ne_zero' ℝ), ← sub_eq_iff_eq_add] at hn 
+      rw [eq_div_iff_mul_eq (two_ne_zero' ℝ), ← sub_eq_iff_eq_add] at hn
       rw [← hn, coe_sub, eq_neg_iff_add_eq_zero, sub_add_cancel, mul_assoc, coe_int_mul_eq_zsmul,
         mul_comm, coe_two_pi, zsmul_zero]
     · left
-      rw [eq_div_iff_mul_eq (two_ne_zero' ℝ), eq_sub_iff_add_eq] at hn 
+      rw [eq_div_iff_mul_eq (two_ne_zero' ℝ), eq_sub_iff_add_eq] at hn
       rw [← hn, coe_add, mul_assoc, coe_int_mul_eq_zsmul, mul_comm, coe_two_pi, zsmul_zero,
         zero_add]
   · rw [angle_eq_iff_two_pi_dvd_sub, ← coe_neg, angle_eq_iff_two_pi_dvd_sub]
@@ -326,12 +326,12 @@ theorem sin_eq_iff_coe_eq_or_add_eq_pi {θ ψ : ℝ} :
     sin θ = sin ψ ↔ (θ : Angle) = ψ ∨ (θ : Angle) + ψ = π :=
   by
   constructor
-  · intro Hsin; rw [← cos_pi_div_two_sub, ← cos_pi_div_two_sub] at Hsin 
+  · intro Hsin; rw [← cos_pi_div_two_sub, ← cos_pi_div_two_sub] at Hsin
     cases' cos_eq_iff_coe_eq_or_eq_neg.mp Hsin with h h
-    · left; rw [coe_sub, coe_sub] at h ; exact sub_right_inj.1 h
+    · left; rw [coe_sub, coe_sub] at h; exact sub_right_inj.1 h
     right;
     rw [coe_sub, coe_sub, eq_neg_iff_add_eq_zero, add_sub, sub_add_eq_add_sub, ← coe_add,
-      add_halves, sub_sub, sub_eq_zero] at h 
+      add_halves, sub_sub, sub_eq_zero] at h
     exact h.symm
   · rw [angle_eq_iff_two_pi_dvd_sub, ← eq_sub_iff_add_eq, ← coe_sub, angle_eq_iff_two_pi_dvd_sub]
     rintro (⟨k, H⟩ | ⟨k, H⟩)
@@ -339,7 +339,7 @@ theorem sin_eq_iff_coe_eq_or_add_eq_pi {θ ψ : ℝ} :
       mul_comm π _, sin_int_mul_pi, MulZeroClass.mul_zero, MulZeroClass.zero_mul]
     have H' : θ + ψ = 2 * k * π + π := by
       rwa [← sub_add, sub_add_eq_add_sub, sub_eq_iff_eq_add, mul_assoc, mul_comm π _, ←
-        mul_assoc] at H 
+        mul_assoc] at H
     rw [← sub_eq_zero, sin_sub_sin, H', add_div, mul_assoc 2 _ π,
       mul_div_cancel_left _ (two_ne_zero' ℝ), cos_add_pi_div_two, sin_int_mul_pi, neg_zero,
       MulZeroClass.mul_zero]
@@ -351,13 +351,13 @@ theorem cos_sin_inj {θ ψ : ℝ} (Hcos : cos θ = cos ψ) (Hsin : sin θ = sin
   by
   cases' cos_eq_iff_coe_eq_or_eq_neg.mp Hcos with hc hc; · exact hc
   cases' sin_eq_iff_coe_eq_or_add_eq_pi.mp Hsin with hs hs; · exact hs
-  rw [eq_neg_iff_add_eq_zero, hs] at hc 
+  rw [eq_neg_iff_add_eq_zero, hs] at hc
   obtain ⟨n, hn⟩ : ∃ n, n • _ = _ := quotient_add_group.left_rel_apply.mp (Quotient.exact' hc)
   rw [← neg_one_mul, add_zero, ← sub_eq_zero, zsmul_eq_mul, ← mul_assoc, ← sub_mul, mul_eq_zero,
     eq_false (ne_of_gt pi_pos), or_false_iff, sub_neg_eq_add, ← Int.cast_zero, ← Int.cast_one, ←
-    Int.cast_bit0, ← Int.cast_mul, ← Int.cast_add, Int.cast_inj] at hn 
+    Int.cast_bit0, ← Int.cast_mul, ← Int.cast_add, Int.cast_inj] at hn
   have : (n * 2 + 1) % (2 : ℤ) = 0 % (2 : ℤ) := congr_arg (· % (2 : ℤ)) hn
-  rw [add_comm, Int.add_mul_emod_self] at this 
+  rw [add_comm, Int.add_mul_emod_self] at this
   exact absurd this one_ne_zero
 #align real.angle.cos_sin_inj Real.Angle.cos_sin_inj
 -/
@@ -625,7 +625,7 @@ theorem cos_pi_div_two_sub (θ : Angle) : cos (↑(π / 2) - θ) = sin θ :=
 #print Real.Angle.abs_sin_eq_of_two_nsmul_eq /-
 theorem abs_sin_eq_of_two_nsmul_eq {θ ψ : Angle} (h : (2 : ℕ) • θ = (2 : ℕ) • ψ) :
     |sin θ| = |sin ψ| := by
-  rw [two_nsmul_eq_iff] at h 
+  rw [two_nsmul_eq_iff] at h
   rcases h with (rfl | rfl)
   · rfl
   · rw [sin_add_pi, abs_neg]
@@ -635,7 +635,7 @@ theorem abs_sin_eq_of_two_nsmul_eq {θ ψ : Angle} (h : (2 : ℕ) • θ = (2 :
 #print Real.Angle.abs_sin_eq_of_two_zsmul_eq /-
 theorem abs_sin_eq_of_two_zsmul_eq {θ ψ : Angle} (h : (2 : ℤ) • θ = (2 : ℤ) • ψ) :
     |sin θ| = |sin ψ| := by
-  simp_rw [two_zsmul, ← two_nsmul] at h 
+  simp_rw [two_zsmul, ← two_nsmul] at h
   exact abs_sin_eq_of_two_nsmul_eq h
 #align real.angle.abs_sin_eq_of_two_zsmul_eq Real.Angle.abs_sin_eq_of_two_zsmul_eq
 -/
@@ -643,7 +643,7 @@ theorem abs_sin_eq_of_two_zsmul_eq {θ ψ : Angle} (h : (2 : ℤ) • θ = (2 :
 #print Real.Angle.abs_cos_eq_of_two_nsmul_eq /-
 theorem abs_cos_eq_of_two_nsmul_eq {θ ψ : Angle} (h : (2 : ℕ) • θ = (2 : ℕ) • ψ) :
     |cos θ| = |cos ψ| := by
-  rw [two_nsmul_eq_iff] at h 
+  rw [two_nsmul_eq_iff] at h
   rcases h with (rfl | rfl)
   · rfl
   · rw [cos_add_pi, abs_neg]
@@ -653,7 +653,7 @@ theorem abs_cos_eq_of_two_nsmul_eq {θ ψ : Angle} (h : (2 : ℕ) • θ = (2 :
 #print Real.Angle.abs_cos_eq_of_two_zsmul_eq /-
 theorem abs_cos_eq_of_two_zsmul_eq {θ ψ : Angle} (h : (2 : ℤ) • θ = (2 : ℤ) • ψ) :
     |cos θ| = |cos ψ| := by
-  simp_rw [two_zsmul, ← two_nsmul] at h 
+  simp_rw [two_zsmul, ← two_nsmul] at h
   exact abs_cos_eq_of_two_nsmul_eq h
 #align real.angle.abs_cos_eq_of_two_zsmul_eq Real.Angle.abs_cos_eq_of_two_zsmul_eq
 -/
@@ -992,7 +992,7 @@ theorem cos_nonneg_iff_abs_toReal_le_pi_div_two {θ : Angle} : 0 ≤ cos θ ↔
   rw [abs_le, cos_coe]
   refine' ⟨fun h => _, cos_nonneg_of_mem_Icc⟩
   by_contra hn
-  rw [not_and_or, not_le, not_le] at hn 
+  rw [not_and_or, not_le, not_le] at hn
   refine' (not_lt.2 h) _
   rcases hn with (hn | hn)
   · rw [← Real.cos_neg]
@@ -1023,7 +1023,7 @@ theorem cos_neg_iff_pi_div_two_lt_abs_toReal {θ : Angle} : cos θ < 0 ↔ π /
 theorem abs_cos_eq_abs_sin_of_two_nsmul_add_two_nsmul_eq_pi {θ ψ : Angle}
     (h : (2 : ℕ) • θ + (2 : ℕ) • ψ = π) : |cos θ| = |sin ψ| :=
   by
-  rw [← eq_sub_iff_add_eq, ← two_nsmul_coe_div_two, ← nsmul_sub, two_nsmul_eq_iff] at h 
+  rw [← eq_sub_iff_add_eq, ← two_nsmul_coe_div_two, ← nsmul_sub, two_nsmul_eq_iff] at h
   rcases h with (rfl | rfl) <;> simp [cos_pi_div_two_sub]
 #align real.angle.abs_cos_eq_abs_sin_of_two_nsmul_add_two_nsmul_eq_pi Real.Angle.abs_cos_eq_abs_sin_of_two_nsmul_add_two_nsmul_eq_pi
 -/
@@ -1032,7 +1032,7 @@ theorem abs_cos_eq_abs_sin_of_two_nsmul_add_two_nsmul_eq_pi {θ ψ : Angle}
 theorem abs_cos_eq_abs_sin_of_two_zsmul_add_two_zsmul_eq_pi {θ ψ : Angle}
     (h : (2 : ℤ) • θ + (2 : ℤ) • ψ = π) : |cos θ| = |sin ψ| :=
   by
-  simp_rw [two_zsmul, ← two_nsmul] at h 
+  simp_rw [two_zsmul, ← two_nsmul] at h
   exact abs_cos_eq_abs_sin_of_two_nsmul_add_two_nsmul_eq_pi h
 #align real.angle.abs_cos_eq_abs_sin_of_two_zsmul_add_two_zsmul_eq_pi Real.Angle.abs_cos_eq_abs_sin_of_two_zsmul_add_two_zsmul_eq_pi
 -/
@@ -1103,7 +1103,7 @@ theorem tan_toReal (θ : Angle) : Real.tan θ.toReal = tan θ := by
 #print Real.Angle.tan_eq_of_two_nsmul_eq /-
 theorem tan_eq_of_two_nsmul_eq {θ ψ : Angle} (h : (2 : ℕ) • θ = (2 : ℕ) • ψ) : tan θ = tan ψ :=
   by
-  rw [two_nsmul_eq_iff] at h 
+  rw [two_nsmul_eq_iff] at h
   rcases h with (rfl | rfl)
   · rfl
   · exact tan_add_pi _
@@ -1113,7 +1113,7 @@ theorem tan_eq_of_two_nsmul_eq {θ ψ : Angle} (h : (2 : ℕ) • θ = (2 : ℕ)
 #print Real.Angle.tan_eq_of_two_zsmul_eq /-
 theorem tan_eq_of_two_zsmul_eq {θ ψ : Angle} (h : (2 : ℤ) • θ = (2 : ℤ) • ψ) : tan θ = tan ψ :=
   by
-  simp_rw [two_zsmul, ← two_nsmul] at h 
+  simp_rw [two_zsmul, ← two_nsmul] at h
   exact tan_eq_of_two_nsmul_eq h
 #align real.angle.tan_eq_of_two_zsmul_eq Real.Angle.tan_eq_of_two_zsmul_eq
 -/
@@ -1124,11 +1124,11 @@ theorem tan_eq_inv_of_two_nsmul_add_two_nsmul_eq_pi {θ ψ : Angle}
   by
   induction θ using Real.Angle.induction_on
   induction ψ using Real.Angle.induction_on
-  rw [← smul_add, ← coe_add, ← coe_nsmul, two_nsmul, ← two_mul, angle_eq_iff_two_pi_dvd_sub] at h 
+  rw [← smul_add, ← coe_add, ← coe_nsmul, two_nsmul, ← two_mul, angle_eq_iff_two_pi_dvd_sub] at h
   rcases h with ⟨k, h⟩
   rw [sub_eq_iff_eq_add, ← mul_inv_cancel_left₀ two_ne_zero π, mul_assoc, ← mul_add,
     mul_right_inj' (two_ne_zero' ℝ), ← eq_sub_iff_add_eq', mul_inv_cancel_left₀ two_ne_zero π,
-    inv_mul_eq_div, mul_comm] at h 
+    inv_mul_eq_div, mul_comm] at h
   rw [tan_coe, tan_coe, ← tan_pi_div_two_sub, h, add_sub_assoc, add_comm]
   exact real.tan_periodic.int_mul _ _
 #align real.angle.tan_eq_inv_of_two_nsmul_add_two_nsmul_eq_pi Real.Angle.tan_eq_inv_of_two_nsmul_add_two_nsmul_eq_pi
@@ -1138,7 +1138,7 @@ theorem tan_eq_inv_of_two_nsmul_add_two_nsmul_eq_pi {θ ψ : Angle}
 theorem tan_eq_inv_of_two_zsmul_add_two_zsmul_eq_pi {θ ψ : Angle}
     (h : (2 : ℤ) • θ + (2 : ℤ) • ψ = π) : tan ψ = (tan θ)⁻¹ :=
   by
-  simp_rw [two_zsmul, ← two_nsmul] at h 
+  simp_rw [two_zsmul, ← two_nsmul] at h
   exact tan_eq_inv_of_two_nsmul_add_two_nsmul_eq_pi h
 #align real.angle.tan_eq_inv_of_two_zsmul_add_two_zsmul_eq_pi Real.Angle.tan_eq_inv_of_two_zsmul_add_two_zsmul_eq_pi
 -/
@@ -1235,7 +1235,7 @@ theorem toReal_nonneg_iff_sign_nonneg {θ : Angle} : 0 ≤ θ.toReal ↔ 0 ≤ 
   by
   rcases lt_trichotomy θ.to_real 0 with (h | h | h)
   · refine' ⟨fun hn => False.elim (h.not_le hn), fun hn => _⟩
-    rw [to_real_neg_iff_sign_neg.1 h] at hn 
+    rw [to_real_neg_iff_sign_neg.1 h] at hn
     exact False.elim (hn.not_lt (by decide))
   · simp [h, SignType.sign, ← sin_to_real]
   · refine' ⟨fun _ => _, fun _ => h.le⟩
@@ -1267,10 +1267,10 @@ theorem coe_abs_toReal_of_sign_nonneg {θ : Angle} (h : 0 ≤ θ.sign) : ↑|θ.
 #print Real.Angle.neg_coe_abs_toReal_of_sign_nonpos /-
 theorem neg_coe_abs_toReal_of_sign_nonpos {θ : Angle} (h : θ.sign ≤ 0) : -↑|θ.toReal| = θ :=
   by
-  rw [SignType.nonpos_iff] at h 
+  rw [SignType.nonpos_iff] at h
   rcases h with (h | h)
   · rw [abs_of_neg (to_real_neg_iff_sign_neg.2 h), coe_neg, neg_neg, coe_to_real]
-  · rw [sign_eq_zero_iff] at h 
+  · rw [sign_eq_zero_iff] at h
     rcases h with (rfl | rfl) <;> simp [abs_of_pos Real.pi_pos]
 #align real.angle.neg_coe_abs_to_real_of_sign_nonpos Real.Angle.neg_coe_abs_toReal_of_sign_nonpos
 -/
@@ -1281,18 +1281,18 @@ theorem eq_iff_sign_eq_and_abs_toReal_eq {θ ψ : Angle} :
   by
   refine' ⟨_, fun h => _⟩; · rintro rfl; exact ⟨rfl, rfl⟩
   rcases h with ⟨hs, hr⟩
-  rw [abs_eq_abs] at hr 
+  rw [abs_eq_abs] at hr
   rcases hr with (hr | hr)
   · exact to_real_injective hr
   · by_cases h : θ = π
-    · rw [h, to_real_pi, ← neg_eq_iff_eq_neg] at hr 
+    · rw [h, to_real_pi, ← neg_eq_iff_eq_neg] at hr
       exact False.elim ((neg_pi_lt_to_real ψ).Ne hr)
     · by_cases h' : ψ = π
-      · rw [h', to_real_pi] at hr 
+      · rw [h', to_real_pi] at hr
         exact False.elim ((neg_pi_lt_to_real θ).Ne hr.symm)
       · rw [← sign_to_real h, ← sign_to_real h', hr, Left.sign_neg, SignType.neg_eq_self_iff,
-          _root_.sign_eq_zero_iff, to_real_eq_zero_iff] at hs 
-        rw [hs, to_real_zero, neg_zero, to_real_eq_zero_iff] at hr 
+          _root_.sign_eq_zero_iff, to_real_eq_zero_iff] at hs
+        rw [hs, to_real_zero, neg_zero, to_real_eq_zero_iff] at hr
         rw [hr, hs]
 #align real.angle.eq_iff_sign_eq_and_abs_to_real_eq Real.Angle.eq_iff_sign_eq_and_abs_toReal_eq
 -/
@@ -1342,22 +1342,22 @@ theorem sign_two_nsmul_eq_sign_iff {θ : Angle} :
   rw [or_iff_right hpi]
   refine' ⟨fun h => _, fun h => _⟩
   · by_contra hle
-    rw [not_lt, le_abs, le_neg] at hle 
+    rw [not_lt, le_abs, le_neg] at hle
     have hpi' : θ.to_real ≠ π := by simpa using hpi
     rcases hle with (hle | hle) <;> rcases hle.eq_or_lt with (heq | hlt)
-    · rw [← coe_to_real θ, ← HEq] at h ; simpa using h
+    · rw [← coe_to_real θ, ← HEq] at h; simpa using h
     · rw [← sign_to_real hpi, sign_pos (pi_div_two_pos.trans hlt), ← sign_to_real,
-        two_nsmul_to_real_eq_two_mul_sub_two_pi.2 hlt, _root_.sign_neg] at h 
+        two_nsmul_to_real_eq_two_mul_sub_two_pi.2 hlt, _root_.sign_neg] at h
       · simpa using h
       · rw [← mul_sub]
         exact mul_neg_of_pos_of_neg two_pos (sub_neg.2 ((to_real_le_pi _).lt_of_ne hpi'))
       · intro he; simpa [he] using h
-    · rw [← coe_to_real θ, HEq] at h ; simpa using h
+    · rw [← coe_to_real θ, HEq] at h; simpa using h
     · rw [← sign_to_real hpi, _root_.sign_neg (hlt.trans (Left.neg_neg_iff.2 pi_div_two_pos)), ←
-        sign_to_real] at h 
+        sign_to_real] at h
       swap; · intro he; simpa [he] using h
-      rw [← neg_div] at hlt 
-      rw [two_nsmul_to_real_eq_two_mul_add_two_pi.2 hlt.le, sign_pos] at h 
+      rw [← neg_div] at hlt
+      rw [two_nsmul_to_real_eq_two_mul_add_two_pi.2 hlt.le, sign_pos] at h
       · simpa using h
       · linarith [neg_pi_lt_to_real θ]
   · have hpi' : (2 : ℕ) • θ ≠ π :=
@@ -1366,9 +1366,9 @@ theorem sign_two_nsmul_eq_sign_iff {θ : Angle} :
       constructor
       · rintro rfl; simpa [pi_pos, div_pos, abs_of_pos] using h
       · rintro rfl
-        rw [to_real_neg_pi_div_two] at h 
+        rw [to_real_neg_pi_div_two] at h
         simpa [pi_pos, div_pos, neg_div, abs_of_pos] using h
-    rw [abs_lt, ← neg_div] at h 
+    rw [abs_lt, ← neg_div] at h
     rw [← sign_to_real hpi, ← sign_to_real hpi', two_nsmul_to_real_eq_two_mul.2 ⟨h.1, h.2.le⟩,
       sign_mul, sign_pos (zero_lt_two' ℝ), one_mul]
 #align real.angle.sign_two_nsmul_eq_sign_iff Real.Angle.sign_two_nsmul_eq_sign_iff

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce64cd319bb6b3e82f31c2d38e79080d377be451

@@ -3,10 +3,10 @@ Copyright (c) 2019 Calle Sönne. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Calle Sönne
 -/
-import Mathbin.Analysis.SpecialFunctions.Trigonometric.Basic
-import Mathbin.Analysis.Normed.Group.AddCircle
-import Mathbin.Algebra.CharZero.Quotient
-import Mathbin.Topology.Instances.Sign
+import Analysis.SpecialFunctions.Trigonometric.Basic
+import Analysis.Normed.Group.AddCircle
+import Algebra.CharZero.Quotient
+import Topology.Instances.Sign
 
 #align_import analysis.special_functions.trigonometric.angle from "leanprover-community/mathlib"@"50251fd6309cca5ca2e747882ffecd2729f38c5d"
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/63721b2c3eba6c325ecf8ae8cca27155a4f6306f

@@ -145,7 +145,7 @@ theorem coe_two_pi : ↑(2 * π : ℝ) = (0 : Angle) :=
 theorem neg_coe_pi : -(π : Angle) = π :=
   by
   rw [← coe_neg, angle_eq_iff_two_pi_dvd_sub]
-  use -1
+  use-1
   simp [two_mul, sub_eq_add_neg]
 #align real.angle.neg_coe_pi Real.Angle.neg_coe_pi
 -/

mathlib commit https://github.com/leanprover-community/mathlib/commit/8ea5598db6caeddde6cb734aa179cc2408dbd345

@@ -2,17 +2,14 @@
 Copyright (c) 2019 Calle Sönne. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Calle Sönne
-
-! This file was ported from Lean 3 source module analysis.special_functions.trigonometric.angle
-! leanprover-community/mathlib commit 50251fd6309cca5ca2e747882ffecd2729f38c5d
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Analysis.SpecialFunctions.Trigonometric.Basic
 import Mathbin.Analysis.Normed.Group.AddCircle
 import Mathbin.Algebra.CharZero.Quotient
 import Mathbin.Topology.Instances.Sign
 
+#align_import analysis.special_functions.trigonometric.angle from "leanprover-community/mathlib"@"50251fd6309cca5ca2e747882ffecd2729f38c5d"
+
 /-!
 # The type of angles
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/9240e8be927a0955b9a82c6c85ef499ee3a626b8

@@ -1262,13 +1262,13 @@ theorem sign_toReal {θ : Angle} (h : θ ≠ π) : SignType.sign θ.toReal = θ.
 -/
 
 #print Real.Angle.coe_abs_toReal_of_sign_nonneg /-
-theorem coe_abs_toReal_of_sign_nonneg {θ : Angle} (h : 0 ≤ θ.sign) : ↑(|θ.toReal|) = θ := by
+theorem coe_abs_toReal_of_sign_nonneg {θ : Angle} (h : 0 ≤ θ.sign) : ↑|θ.toReal| = θ := by
   rw [abs_eq_self.2 (to_real_nonneg_iff_sign_nonneg.2 h), coe_to_real]
 #align real.angle.coe_abs_to_real_of_sign_nonneg Real.Angle.coe_abs_toReal_of_sign_nonneg
 -/
 
 #print Real.Angle.neg_coe_abs_toReal_of_sign_nonpos /-
-theorem neg_coe_abs_toReal_of_sign_nonpos {θ : Angle} (h : θ.sign ≤ 0) : -↑(|θ.toReal|) = θ :=
+theorem neg_coe_abs_toReal_of_sign_nonpos {θ : Angle} (h : θ.sign ≤ 0) : -↑|θ.toReal| = θ :=
   by
   rw [SignType.nonpos_iff] at h 
   rcases h with (h | h)

mathlib commit https://github.com/leanprover-community/mathlib/commit/9fb8964792b4237dac6200193a0d533f1b3f7423

@@ -45,76 +45,105 @@ namespace Angle
 instance : CircularOrder Real.Angle :=
   @AddCircle.circularOrder _ _ _ _ _ ⟨by norm_num [pi_pos]⟩ _
 
+#print Real.Angle.continuous_coe /-
 @[continuity]
 theorem continuous_coe : Continuous (coe : ℝ → Angle) :=
   continuous_quotient_mk'
 #align real.angle.continuous_coe Real.Angle.continuous_coe
+-/
 
+#print Real.Angle.coeHom /-
 /-- Coercion `ℝ → angle` as an additive homomorphism. -/
 def coeHom : ℝ →+ Angle :=
   QuotientAddGroup.mk' _
 #align real.angle.coe_hom Real.Angle.coeHom
+-/
 
+#print Real.Angle.coe_coeHom /-
 @[simp]
 theorem coe_coeHom : (coeHom : ℝ → Angle) = coe :=
   rfl
 #align real.angle.coe_coe_hom Real.Angle.coe_coeHom
+-/
 
+#print Real.Angle.induction_on /-
 /-- 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 θ :=
   Quotient.inductionOn' θ h
 #align real.angle.induction_on Real.Angle.induction_on
+-/
 
+#print Real.Angle.coe_zero /-
 @[simp]
 theorem coe_zero : ↑(0 : ℝ) = (0 : Angle) :=
   rfl
 #align real.angle.coe_zero Real.Angle.coe_zero
+-/
 
+#print Real.Angle.coe_add /-
 @[simp]
 theorem coe_add (x y : ℝ) : ↑(x + y : ℝ) = (↑x + ↑y : Angle) :=
   rfl
 #align real.angle.coe_add Real.Angle.coe_add
+-/
 
+#print Real.Angle.coe_neg /-
 @[simp]
 theorem coe_neg (x : ℝ) : ↑(-x : ℝ) = -(↑x : Angle) :=
   rfl
 #align real.angle.coe_neg Real.Angle.coe_neg
+-/
 
+#print Real.Angle.coe_sub /-
 @[simp]
 theorem coe_sub (x y : ℝ) : ↑(x - y : ℝ) = (↑x - ↑y : Angle) :=
   rfl
 #align real.angle.coe_sub Real.Angle.coe_sub
+-/
 
+#print Real.Angle.coe_nsmul /-
 theorem coe_nsmul (n : ℕ) (x : ℝ) : ↑(n • x : ℝ) = (n • ↑x : Angle) :=
   rfl
 #align real.angle.coe_nsmul Real.Angle.coe_nsmul
+-/
 
+#print Real.Angle.coe_zsmul /-
 theorem coe_zsmul (z : ℤ) (x : ℝ) : ↑(z • x : ℝ) = (z • ↑x : Angle) :=
   rfl
 #align real.angle.coe_zsmul Real.Angle.coe_zsmul
+-/
 
+#print Real.Angle.coe_nat_mul_eq_nsmul /-
 @[simp, norm_cast]
 theorem coe_nat_mul_eq_nsmul (x : ℝ) (n : ℕ) : ↑((n : ℝ) * x) = n • (↑x : Angle) := by
   simpa only [nsmul_eq_mul] using coe_hom.map_nsmul x n
 #align real.angle.coe_nat_mul_eq_nsmul Real.Angle.coe_nat_mul_eq_nsmul
+-/
 
+#print Real.Angle.coe_int_mul_eq_zsmul /-
 @[simp, norm_cast]
 theorem coe_int_mul_eq_zsmul (x : ℝ) (n : ℤ) : ↑((n : ℝ) * x : ℝ) = n • (↑x : Angle) := by
   simpa only [zsmul_eq_mul] using coe_hom.map_zsmul x n
 #align real.angle.coe_int_mul_eq_zsmul Real.Angle.coe_int_mul_eq_zsmul
+-/
 
+#print Real.Angle.angle_eq_iff_two_pi_dvd_sub /-
 theorem angle_eq_iff_two_pi_dvd_sub {ψ θ : ℝ} : (θ : Angle) = ψ ↔ ∃ k : ℤ, θ - ψ = 2 * π * k := by
   simp only [QuotientAddGroup.eq, AddSubgroup.zmultiples_eq_closure,
     AddSubgroup.mem_closure_singleton, zsmul_eq_mul', (sub_eq_neg_add _ _).symm, eq_comm]
 #align real.angle.angle_eq_iff_two_pi_dvd_sub Real.Angle.angle_eq_iff_two_pi_dvd_sub
+-/
 
+#print Real.Angle.coe_two_pi /-
 @[simp]
 theorem coe_two_pi : ↑(2 * π : ℝ) = (0 : Angle) :=
   angle_eq_iff_two_pi_dvd_sub.2 ⟨1, by rw [sub_zero, Int.cast_one, mul_one]⟩
 #align real.angle.coe_two_pi Real.Angle.coe_two_pi
+-/
 
+#print Real.Angle.neg_coe_pi /-
 @[simp]
 theorem neg_coe_pi : -(π : Angle) = π :=
   by
@@ -122,93 +151,135 @@ theorem neg_coe_pi : -(π : Angle) = π :=
   use -1
   simp [two_mul, sub_eq_add_neg]
 #align real.angle.neg_coe_pi Real.Angle.neg_coe_pi
+-/
 
+#print Real.Angle.two_nsmul_coe_div_two /-
 @[simp]
 theorem two_nsmul_coe_div_two (θ : ℝ) : (2 : ℕ) • (↑(θ / 2) : Angle) = θ := by
   rw [← coe_nsmul, two_nsmul, add_halves]
 #align real.angle.two_nsmul_coe_div_two Real.Angle.two_nsmul_coe_div_two
+-/
 
+#print Real.Angle.two_zsmul_coe_div_two /-
 @[simp]
 theorem two_zsmul_coe_div_two (θ : ℝ) : (2 : ℤ) • (↑(θ / 2) : Angle) = θ := by
   rw [← coe_zsmul, two_zsmul, add_halves]
 #align real.angle.two_zsmul_coe_div_two Real.Angle.two_zsmul_coe_div_two
+-/
 
+#print Real.Angle.two_nsmul_neg_pi_div_two /-
 @[simp]
 theorem two_nsmul_neg_pi_div_two : (2 : ℕ) • (↑(-π / 2) : Angle) = π := by
   rw [two_nsmul_coe_div_two, coe_neg, neg_coe_pi]
 #align real.angle.two_nsmul_neg_pi_div_two Real.Angle.two_nsmul_neg_pi_div_two
+-/
 
+#print Real.Angle.two_zsmul_neg_pi_div_two /-
 @[simp]
 theorem two_zsmul_neg_pi_div_two : (2 : ℤ) • (↑(-π / 2) : Angle) = π := by
   rw [two_zsmul, ← two_nsmul, two_nsmul_neg_pi_div_two]
 #align real.angle.two_zsmul_neg_pi_div_two Real.Angle.two_zsmul_neg_pi_div_two
+-/
 
+#print Real.Angle.sub_coe_pi_eq_add_coe_pi /-
 theorem sub_coe_pi_eq_add_coe_pi (θ : Angle) : θ - π = θ + π := by rw [sub_eq_add_neg, neg_coe_pi]
 #align real.angle.sub_coe_pi_eq_add_coe_pi Real.Angle.sub_coe_pi_eq_add_coe_pi
+-/
 
+#print Real.Angle.two_nsmul_coe_pi /-
 @[simp]
 theorem two_nsmul_coe_pi : (2 : ℕ) • (π : Angle) = 0 := by simp [← coe_nat_mul_eq_nsmul]
 #align real.angle.two_nsmul_coe_pi Real.Angle.two_nsmul_coe_pi
+-/
 
+#print Real.Angle.two_zsmul_coe_pi /-
 @[simp]
 theorem two_zsmul_coe_pi : (2 : ℤ) • (π : Angle) = 0 := by simp [← coe_int_mul_eq_zsmul]
 #align real.angle.two_zsmul_coe_pi Real.Angle.two_zsmul_coe_pi
+-/
 
+#print Real.Angle.coe_pi_add_coe_pi /-
 @[simp]
 theorem coe_pi_add_coe_pi : (π : Real.Angle) + π = 0 := by rw [← two_nsmul, two_nsmul_coe_pi]
 #align real.angle.coe_pi_add_coe_pi Real.Angle.coe_pi_add_coe_pi
+-/
 
+#print Real.Angle.zsmul_eq_iff /-
 theorem zsmul_eq_iff {ψ θ : Angle} {z : ℤ} (hz : z ≠ 0) :
     z • ψ = z • θ ↔ ∃ k : Fin z.natAbs, ψ = θ + (k : ℕ) • (2 * π / z : ℝ) :=
   QuotientAddGroup.zmultiples_zsmul_eq_zsmul_iff hz
 #align real.angle.zsmul_eq_iff Real.Angle.zsmul_eq_iff
+-/
 
+#print Real.Angle.nsmul_eq_iff /-
 theorem nsmul_eq_iff {ψ θ : Angle} {n : ℕ} (hz : n ≠ 0) :
     n • ψ = n • θ ↔ ∃ k : Fin n, ψ = θ + (k : ℕ) • (2 * π / n : ℝ) :=
   QuotientAddGroup.zmultiples_nsmul_eq_nsmul_iff hz
 #align real.angle.nsmul_eq_iff Real.Angle.nsmul_eq_iff
+-/
 
+#print Real.Angle.two_zsmul_eq_iff /-
 theorem two_zsmul_eq_iff {ψ θ : Angle} : (2 : ℤ) • ψ = (2 : ℤ) • θ ↔ ψ = θ ∨ ψ = θ + π := by
   rw [zsmul_eq_iff two_ne_zero, Int.natAbs_bit0, Int.natAbs_one, Fin.exists_fin_two, Fin.val_zero,
     Fin.val_one, zero_smul, add_zero, one_smul, Int.cast_two,
     mul_div_cancel_left (_ : ℝ) two_ne_zero]
 #align real.angle.two_zsmul_eq_iff Real.Angle.two_zsmul_eq_iff
+-/
 
+#print Real.Angle.two_nsmul_eq_iff /-
 theorem two_nsmul_eq_iff {ψ θ : Angle} : (2 : ℕ) • ψ = (2 : ℕ) • θ ↔ ψ = θ ∨ ψ = θ + π := by
   simp_rw [← coe_nat_zsmul, Int.ofNat_bit0, Int.ofNat_one, two_zsmul_eq_iff]
 #align real.angle.two_nsmul_eq_iff Real.Angle.two_nsmul_eq_iff
+-/
 
+#print Real.Angle.two_nsmul_eq_zero_iff /-
 theorem two_nsmul_eq_zero_iff {θ : Angle} : (2 : ℕ) • θ = 0 ↔ θ = 0 ∨ θ = π := by
   convert two_nsmul_eq_iff <;> simp
 #align real.angle.two_nsmul_eq_zero_iff Real.Angle.two_nsmul_eq_zero_iff
+-/
 
+#print Real.Angle.two_nsmul_ne_zero_iff /-
 theorem two_nsmul_ne_zero_iff {θ : Angle} : (2 : ℕ) • θ ≠ 0 ↔ θ ≠ 0 ∧ θ ≠ π := by
   rw [← not_or, ← two_nsmul_eq_zero_iff]
 #align real.angle.two_nsmul_ne_zero_iff Real.Angle.two_nsmul_ne_zero_iff
+-/
 
+#print Real.Angle.two_zsmul_eq_zero_iff /-
 theorem two_zsmul_eq_zero_iff {θ : Angle} : (2 : ℤ) • θ = 0 ↔ θ = 0 ∨ θ = π := by
   simp_rw [two_zsmul, ← two_nsmul, two_nsmul_eq_zero_iff]
 #align real.angle.two_zsmul_eq_zero_iff Real.Angle.two_zsmul_eq_zero_iff
+-/
 
+#print Real.Angle.two_zsmul_ne_zero_iff /-
 theorem two_zsmul_ne_zero_iff {θ : Angle} : (2 : ℤ) • θ ≠ 0 ↔ θ ≠ 0 ∧ θ ≠ π := by
   rw [← not_or, ← two_zsmul_eq_zero_iff]
 #align real.angle.two_zsmul_ne_zero_iff Real.Angle.two_zsmul_ne_zero_iff
+-/
 
+#print Real.Angle.eq_neg_self_iff /-
 theorem eq_neg_self_iff {θ : Angle} : θ = -θ ↔ θ = 0 ∨ θ = π := by
   rw [← add_eq_zero_iff_eq_neg, ← two_nsmul, two_nsmul_eq_zero_iff]
 #align real.angle.eq_neg_self_iff Real.Angle.eq_neg_self_iff
+-/
 
+#print Real.Angle.ne_neg_self_iff /-
 theorem ne_neg_self_iff {θ : Angle} : θ ≠ -θ ↔ θ ≠ 0 ∧ θ ≠ π := by
   rw [← not_or, ← eq_neg_self_iff.not]
 #align real.angle.ne_neg_self_iff Real.Angle.ne_neg_self_iff
+-/
 
+#print Real.Angle.neg_eq_self_iff /-
 theorem neg_eq_self_iff {θ : Angle} : -θ = θ ↔ θ = 0 ∨ θ = π := by rw [eq_comm, eq_neg_self_iff]
 #align real.angle.neg_eq_self_iff Real.Angle.neg_eq_self_iff
+-/
 
+#print Real.Angle.neg_ne_self_iff /-
 theorem neg_ne_self_iff {θ : Angle} : -θ ≠ θ ↔ θ ≠ 0 ∧ θ ≠ π := by
   rw [← not_or, ← neg_eq_self_iff.not]
 #align real.angle.neg_ne_self_iff Real.Angle.neg_ne_self_iff
+-/
 
+#print Real.Angle.two_nsmul_eq_pi_iff /-
 theorem two_nsmul_eq_pi_iff {θ : Angle} : (2 : ℕ) • θ = π ↔ θ = (π / 2 : ℝ) ∨ θ = (-π / 2 : ℝ) :=
   by
   have h : (π : angle) = (2 : ℕ) • (π / 2 : ℝ) := by rw [two_nsmul, ← coe_add, add_halves]
@@ -218,11 +289,15 @@ theorem two_nsmul_eq_pi_iff {θ : Angle} : (2 : ℕ) • θ = π ↔ θ = (π /
   rw [add_comm, ← coe_add, ← sub_eq_zero, ← coe_sub, add_sub_assoc, neg_div, sub_neg_eq_add,
     add_halves, ← two_mul, coe_two_pi]
 #align real.angle.two_nsmul_eq_pi_iff Real.Angle.two_nsmul_eq_pi_iff
+-/
 
+#print Real.Angle.two_zsmul_eq_pi_iff /-
 theorem two_zsmul_eq_pi_iff {θ : Angle} : (2 : ℤ) • θ = π ↔ θ = (π / 2 : ℝ) ∨ θ = (-π / 2 : ℝ) := by
   rw [two_zsmul, ← two_nsmul, two_nsmul_eq_pi_iff]
 #align real.angle.two_zsmul_eq_pi_iff Real.Angle.two_zsmul_eq_pi_iff
+-/
 
+#print Real.Angle.cos_eq_iff_coe_eq_or_eq_neg /-
 theorem cos_eq_iff_coe_eq_or_eq_neg {θ ψ : ℝ} :
     cos θ = cos ψ ↔ (θ : Angle) = ψ ∨ (θ : Angle) = -ψ :=
   by
@@ -247,7 +322,9 @@ theorem cos_eq_iff_coe_eq_or_eq_neg {θ ψ : ℝ} :
       mul_div_cancel_left _ (two_ne_zero' ℝ), mul_comm π _, sin_int_mul_pi, MulZeroClass.mul_zero,
       MulZeroClass.zero_mul]
 #align real.angle.cos_eq_iff_coe_eq_or_eq_neg Real.Angle.cos_eq_iff_coe_eq_or_eq_neg
+-/
 
+#print Real.Angle.sin_eq_iff_coe_eq_or_add_eq_pi /-
 theorem sin_eq_iff_coe_eq_or_add_eq_pi {θ ψ : ℝ} :
     sin θ = sin ψ ↔ (θ : Angle) = ψ ∨ (θ : Angle) + ψ = π :=
   by
@@ -270,7 +347,9 @@ theorem sin_eq_iff_coe_eq_or_add_eq_pi {θ ψ : ℝ} :
       mul_div_cancel_left _ (two_ne_zero' ℝ), cos_add_pi_div_two, sin_int_mul_pi, neg_zero,
       MulZeroClass.mul_zero]
 #align real.angle.sin_eq_iff_coe_eq_or_add_eq_pi Real.Angle.sin_eq_iff_coe_eq_or_add_eq_pi
+-/
 
+#print Real.Angle.cos_sin_inj /-
 theorem cos_sin_inj {θ ψ : ℝ} (Hcos : cos θ = cos ψ) (Hsin : sin θ = sin ψ) : (θ : Angle) = ψ :=
   by
   cases' cos_eq_iff_coe_eq_or_eq_neg.mp Hcos with hc hc; · exact hc
@@ -284,6 +363,7 @@ theorem cos_sin_inj {θ ψ : ℝ} (Hcos : cos θ = cos ψ) (Hsin : sin θ = sin
   rw [add_comm, Int.add_mul_emod_self] at this 
   exact absurd this one_ne_zero
 #align real.angle.cos_sin_inj Real.Angle.cos_sin_inj
+-/
 
 #print Real.Angle.sin /-
 /-- The sine of a `real.angle`. -/
@@ -292,15 +372,19 @@ def sin (θ : Angle) : ℝ :=
 #align real.angle.sin Real.Angle.sin
 -/
 
+#print Real.Angle.sin_coe /-
 @[simp]
 theorem sin_coe (x : ℝ) : sin (x : Angle) = Real.sin x :=
   rfl
 #align real.angle.sin_coe Real.Angle.sin_coe
+-/
 
+#print Real.Angle.continuous_sin /-
 @[continuity]
 theorem continuous_sin : Continuous sin :=
   Real.continuous_sin.quotient_liftOn' _
 #align real.angle.continuous_sin Real.Angle.continuous_sin
+-/
 
 #print Real.Angle.cos /-
 /-- The cosine of a `real.angle`. -/
@@ -309,178 +393,239 @@ def cos (θ : Angle) : ℝ :=
 #align real.angle.cos Real.Angle.cos
 -/
 
+#print Real.Angle.cos_coe /-
 @[simp]
 theorem cos_coe (x : ℝ) : cos (x : Angle) = Real.cos x :=
   rfl
 #align real.angle.cos_coe Real.Angle.cos_coe
+-/
 
+#print Real.Angle.continuous_cos /-
 @[continuity]
 theorem continuous_cos : Continuous cos :=
   Real.continuous_cos.quotient_liftOn' _
 #align real.angle.continuous_cos Real.Angle.continuous_cos
+-/
 
+#print Real.Angle.cos_eq_real_cos_iff_eq_or_eq_neg /-
 theorem cos_eq_real_cos_iff_eq_or_eq_neg {θ : Angle} {ψ : ℝ} :
     cos θ = Real.cos ψ ↔ θ = ψ ∨ θ = -ψ :=
   by
   induction θ using Real.Angle.induction_on
   exact cos_eq_iff_coe_eq_or_eq_neg
 #align real.angle.cos_eq_real_cos_iff_eq_or_eq_neg Real.Angle.cos_eq_real_cos_iff_eq_or_eq_neg
+-/
 
+#print Real.Angle.cos_eq_iff_eq_or_eq_neg /-
 theorem cos_eq_iff_eq_or_eq_neg {θ ψ : Angle} : cos θ = cos ψ ↔ θ = ψ ∨ θ = -ψ :=
   by
   induction ψ using Real.Angle.induction_on
   exact cos_eq_real_cos_iff_eq_or_eq_neg
 #align real.angle.cos_eq_iff_eq_or_eq_neg Real.Angle.cos_eq_iff_eq_or_eq_neg
+-/
 
+#print Real.Angle.sin_eq_real_sin_iff_eq_or_add_eq_pi /-
 theorem sin_eq_real_sin_iff_eq_or_add_eq_pi {θ : Angle} {ψ : ℝ} :
     sin θ = Real.sin ψ ↔ θ = ψ ∨ θ + ψ = π :=
   by
   induction θ using Real.Angle.induction_on
   exact sin_eq_iff_coe_eq_or_add_eq_pi
 #align real.angle.sin_eq_real_sin_iff_eq_or_add_eq_pi Real.Angle.sin_eq_real_sin_iff_eq_or_add_eq_pi
+-/
 
+#print Real.Angle.sin_eq_iff_eq_or_add_eq_pi /-
 theorem sin_eq_iff_eq_or_add_eq_pi {θ ψ : Angle} : sin θ = sin ψ ↔ θ = ψ ∨ θ + ψ = π :=
   by
   induction ψ using Real.Angle.induction_on
   exact sin_eq_real_sin_iff_eq_or_add_eq_pi
 #align real.angle.sin_eq_iff_eq_or_add_eq_pi Real.Angle.sin_eq_iff_eq_or_add_eq_pi
+-/
 
+#print Real.Angle.sin_zero /-
 @[simp]
 theorem sin_zero : sin (0 : Angle) = 0 := by rw [← coe_zero, sin_coe, Real.sin_zero]
 #align real.angle.sin_zero Real.Angle.sin_zero
+-/
 
+#print Real.Angle.sin_coe_pi /-
 @[simp]
 theorem sin_coe_pi : sin (π : Angle) = 0 := by rw [sin_coe, Real.sin_pi]
 #align real.angle.sin_coe_pi Real.Angle.sin_coe_pi
+-/
 
+#print Real.Angle.sin_eq_zero_iff /-
 theorem sin_eq_zero_iff {θ : Angle} : sin θ = 0 ↔ θ = 0 ∨ θ = π :=
   by
   nth_rw 1 [← sin_zero]
   rw [sin_eq_iff_eq_or_add_eq_pi]
   simp
 #align real.angle.sin_eq_zero_iff Real.Angle.sin_eq_zero_iff
+-/
 
+#print Real.Angle.sin_ne_zero_iff /-
 theorem sin_ne_zero_iff {θ : Angle} : sin θ ≠ 0 ↔ θ ≠ 0 ∧ θ ≠ π := by
   rw [← not_or, ← sin_eq_zero_iff]
 #align real.angle.sin_ne_zero_iff Real.Angle.sin_ne_zero_iff
+-/
 
+#print Real.Angle.sin_neg /-
 @[simp]
 theorem sin_neg (θ : Angle) : sin (-θ) = -sin θ :=
   by
   induction θ using Real.Angle.induction_on
   exact Real.sin_neg _
 #align real.angle.sin_neg Real.Angle.sin_neg
+-/
 
+#print Real.Angle.sin_antiperiodic /-
 theorem sin_antiperiodic : Function.Antiperiodic sin (π : Angle) :=
   by
   intro θ
   induction θ using Real.Angle.induction_on
   exact Real.sin_antiperiodic θ
 #align real.angle.sin_antiperiodic Real.Angle.sin_antiperiodic
+-/
 
+#print Real.Angle.sin_add_pi /-
 @[simp]
 theorem sin_add_pi (θ : Angle) : sin (θ + π) = -sin θ :=
   sin_antiperiodic θ
 #align real.angle.sin_add_pi Real.Angle.sin_add_pi
+-/
 
+#print Real.Angle.sin_sub_pi /-
 @[simp]
 theorem sin_sub_pi (θ : Angle) : sin (θ - π) = -sin θ :=
   sin_antiperiodic.sub_eq θ
 #align real.angle.sin_sub_pi Real.Angle.sin_sub_pi
+-/
 
+#print Real.Angle.cos_zero /-
 @[simp]
 theorem cos_zero : cos (0 : Angle) = 1 := by rw [← coe_zero, cos_coe, Real.cos_zero]
 #align real.angle.cos_zero Real.Angle.cos_zero
+-/
 
+#print Real.Angle.cos_coe_pi /-
 @[simp]
 theorem cos_coe_pi : cos (π : Angle) = -1 := by rw [cos_coe, Real.cos_pi]
 #align real.angle.cos_coe_pi Real.Angle.cos_coe_pi
+-/
 
+#print Real.Angle.cos_neg /-
 @[simp]
 theorem cos_neg (θ : Angle) : cos (-θ) = cos θ :=
   by
   induction θ using Real.Angle.induction_on
   exact Real.cos_neg _
 #align real.angle.cos_neg Real.Angle.cos_neg
+-/
 
+#print Real.Angle.cos_antiperiodic /-
 theorem cos_antiperiodic : Function.Antiperiodic cos (π : Angle) :=
   by
   intro θ
   induction θ using Real.Angle.induction_on
   exact Real.cos_antiperiodic θ
 #align real.angle.cos_antiperiodic Real.Angle.cos_antiperiodic
+-/
 
+#print Real.Angle.cos_add_pi /-
 @[simp]
 theorem cos_add_pi (θ : Angle) : cos (θ + π) = -cos θ :=
   cos_antiperiodic θ
 #align real.angle.cos_add_pi Real.Angle.cos_add_pi
+-/
 
+#print Real.Angle.cos_sub_pi /-
 @[simp]
 theorem cos_sub_pi (θ : Angle) : cos (θ - π) = -cos θ :=
   cos_antiperiodic.sub_eq θ
 #align real.angle.cos_sub_pi Real.Angle.cos_sub_pi
+-/
 
+#print Real.Angle.cos_eq_zero_iff /-
 theorem cos_eq_zero_iff {θ : Angle} : cos θ = 0 ↔ θ = (π / 2 : ℝ) ∨ θ = (-π / 2 : ℝ) := by
   rw [← cos_pi_div_two, ← cos_coe, cos_eq_iff_eq_or_eq_neg, ← coe_neg, ← neg_div]
 #align real.angle.cos_eq_zero_iff Real.Angle.cos_eq_zero_iff
+-/
 
+#print Real.Angle.sin_add /-
 theorem sin_add (θ₁ θ₂ : Real.Angle) : sin (θ₁ + θ₂) = sin θ₁ * cos θ₂ + cos θ₁ * sin θ₂ :=
   by
   induction θ₁ using Real.Angle.induction_on
   induction θ₂ using Real.Angle.induction_on
   exact Real.sin_add θ₁ θ₂
 #align real.angle.sin_add Real.Angle.sin_add
+-/
 
+#print Real.Angle.cos_add /-
 theorem cos_add (θ₁ θ₂ : Real.Angle) : cos (θ₁ + θ₂) = cos θ₁ * cos θ₂ - sin θ₁ * sin θ₂ :=
   by
   induction θ₂ using Real.Angle.induction_on
   induction θ₁ using Real.Angle.induction_on
   exact Real.cos_add θ₁ θ₂
 #align real.angle.cos_add Real.Angle.cos_add
+-/
 
+#print Real.Angle.cos_sq_add_sin_sq /-
 @[simp]
 theorem cos_sq_add_sin_sq (θ : Real.Angle) : cos θ ^ 2 + sin θ ^ 2 = 1 :=
   by
   induction θ using Real.Angle.induction_on
   exact Real.cos_sq_add_sin_sq θ
 #align real.angle.cos_sq_add_sin_sq Real.Angle.cos_sq_add_sin_sq
+-/
 
+#print Real.Angle.sin_add_pi_div_two /-
 theorem sin_add_pi_div_two (θ : Angle) : sin (θ + ↑(π / 2)) = cos θ :=
   by
   induction θ using Real.Angle.induction_on
   exact sin_add_pi_div_two _
 #align real.angle.sin_add_pi_div_two Real.Angle.sin_add_pi_div_two
+-/
 
+#print Real.Angle.sin_sub_pi_div_two /-
 theorem sin_sub_pi_div_two (θ : Angle) : sin (θ - ↑(π / 2)) = -cos θ :=
   by
   induction θ using Real.Angle.induction_on
   exact sin_sub_pi_div_two _
 #align real.angle.sin_sub_pi_div_two Real.Angle.sin_sub_pi_div_two
+-/
 
+#print Real.Angle.sin_pi_div_two_sub /-
 theorem sin_pi_div_two_sub (θ : Angle) : sin (↑(π / 2) - θ) = cos θ :=
   by
   induction θ using Real.Angle.induction_on
   exact sin_pi_div_two_sub _
 #align real.angle.sin_pi_div_two_sub Real.Angle.sin_pi_div_two_sub
+-/
 
+#print Real.Angle.cos_add_pi_div_two /-
 theorem cos_add_pi_div_two (θ : Angle) : cos (θ + ↑(π / 2)) = -sin θ :=
   by
   induction θ using Real.Angle.induction_on
   exact cos_add_pi_div_two _
 #align real.angle.cos_add_pi_div_two Real.Angle.cos_add_pi_div_two
+-/
 
+#print Real.Angle.cos_sub_pi_div_two /-
 theorem cos_sub_pi_div_two (θ : Angle) : cos (θ - ↑(π / 2)) = sin θ :=
   by
   induction θ using Real.Angle.induction_on
   exact cos_sub_pi_div_two _
 #align real.angle.cos_sub_pi_div_two Real.Angle.cos_sub_pi_div_two
+-/
 
+#print Real.Angle.cos_pi_div_two_sub /-
 theorem cos_pi_div_two_sub (θ : Angle) : cos (↑(π / 2) - θ) = sin θ :=
   by
   induction θ using Real.Angle.induction_on
   exact cos_pi_div_two_sub _
 #align real.angle.cos_pi_div_two_sub Real.Angle.cos_pi_div_two_sub
+-/
 
+#print Real.Angle.abs_sin_eq_of_two_nsmul_eq /-
 theorem abs_sin_eq_of_two_nsmul_eq {θ ψ : Angle} (h : (2 : ℕ) • θ = (2 : ℕ) • ψ) :
     |sin θ| = |sin ψ| := by
   rw [two_nsmul_eq_iff] at h 
@@ -488,13 +633,17 @@ theorem abs_sin_eq_of_two_nsmul_eq {θ ψ : Angle} (h : (2 : ℕ) • θ = (2 :
   · rfl
   · rw [sin_add_pi, abs_neg]
 #align real.angle.abs_sin_eq_of_two_nsmul_eq Real.Angle.abs_sin_eq_of_two_nsmul_eq
+-/
 
+#print Real.Angle.abs_sin_eq_of_two_zsmul_eq /-
 theorem abs_sin_eq_of_two_zsmul_eq {θ ψ : Angle} (h : (2 : ℤ) • θ = (2 : ℤ) • ψ) :
     |sin θ| = |sin ψ| := by
   simp_rw [two_zsmul, ← two_nsmul] at h 
   exact abs_sin_eq_of_two_nsmul_eq h
 #align real.angle.abs_sin_eq_of_two_zsmul_eq Real.Angle.abs_sin_eq_of_two_zsmul_eq
+-/
 
+#print Real.Angle.abs_cos_eq_of_two_nsmul_eq /-
 theorem abs_cos_eq_of_two_nsmul_eq {θ ψ : Angle} (h : (2 : ℕ) • θ = (2 : ℕ) • ψ) :
     |cos θ| = |cos ψ| := by
   rw [two_nsmul_eq_iff] at h 
@@ -502,13 +651,17 @@ theorem abs_cos_eq_of_two_nsmul_eq {θ ψ : Angle} (h : (2 : ℕ) • θ = (2 :
   · rfl
   · rw [cos_add_pi, abs_neg]
 #align real.angle.abs_cos_eq_of_two_nsmul_eq Real.Angle.abs_cos_eq_of_two_nsmul_eq
+-/
 
+#print Real.Angle.abs_cos_eq_of_two_zsmul_eq /-
 theorem abs_cos_eq_of_two_zsmul_eq {θ ψ : Angle} (h : (2 : ℤ) • θ = (2 : ℤ) • ψ) :
     |cos θ| = |cos ψ| := by
   simp_rw [two_zsmul, ← two_nsmul] at h 
   exact abs_cos_eq_of_two_nsmul_eq h
 #align real.angle.abs_cos_eq_of_two_zsmul_eq Real.Angle.abs_cos_eq_of_two_zsmul_eq
+-/
 
+#print Real.Angle.coe_toIcoMod /-
 @[simp]
 theorem coe_toIcoMod (θ ψ : ℝ) : ↑(toIcoMod two_pi_pos ψ θ) = (θ : Angle) :=
   by
@@ -516,7 +669,9 @@ theorem coe_toIcoMod (θ ψ : ℝ) : ↑(toIcoMod two_pi_pos ψ θ) = (θ : Angl
   refine' ⟨-toIcoDiv two_pi_pos ψ θ, _⟩
   rw [toIcoMod_sub_self, zsmul_eq_mul, mul_comm]
 #align real.angle.coe_to_Ico_mod Real.Angle.coe_toIcoMod
+-/
 
+#print Real.Angle.coe_toIocMod /-
 @[simp]
 theorem coe_toIocMod (θ ψ : ℝ) : ↑(toIocMod two_pi_pos ψ θ) = (θ : Angle) :=
   by
@@ -524,6 +679,7 @@ theorem coe_toIocMod (θ ψ : ℝ) : ↑(toIocMod two_pi_pos ψ θ) = (θ : Angl
   refine' ⟨-toIocDiv two_pi_pos ψ θ, _⟩
   rw [toIocMod_sub_self, zsmul_eq_mul, mul_comm]
 #align real.angle.coe_to_Ioc_mod Real.Angle.coe_toIocMod
+-/
 
 #print Real.Angle.toReal /-
 /-- Convert a `real.angle` to a real number in the interval `Ioc (-π) π`. -/
@@ -532,19 +688,25 @@ def toReal (θ : Angle) : ℝ :=
 #align real.angle.to_real Real.Angle.toReal
 -/
 
+#print Real.Angle.toReal_coe /-
 theorem toReal_coe (θ : ℝ) : (θ : Angle).toReal = toIocMod two_pi_pos (-π) θ :=
   rfl
 #align real.angle.to_real_coe Real.Angle.toReal_coe
+-/
 
+#print Real.Angle.toReal_coe_eq_self_iff /-
 theorem toReal_coe_eq_self_iff {θ : ℝ} : (θ : Angle).toReal = θ ↔ -π < θ ∧ θ ≤ π :=
   by
   rw [to_real_coe, toIocMod_eq_self two_pi_pos]
   ring_nf
 #align real.angle.to_real_coe_eq_self_iff Real.Angle.toReal_coe_eq_self_iff
+-/
 
+#print Real.Angle.toReal_coe_eq_self_iff_mem_Ioc /-
 theorem toReal_coe_eq_self_iff_mem_Ioc {θ : ℝ} : (θ : Angle).toReal = θ ↔ θ ∈ Set.Ioc (-π) π := by
   rw [to_real_coe_eq_self_iff, ← Set.mem_Ioc]
 #align real.angle.to_real_coe_eq_self_iff_mem_Ioc Real.Angle.toReal_coe_eq_self_iff_mem_Ioc
+-/
 
 #print Real.Angle.toReal_injective /-
 theorem toReal_injective : Function.Injective toReal :=
@@ -564,34 +726,45 @@ theorem toReal_inj {θ ψ : Angle} : θ.toReal = ψ.toReal ↔ θ = ψ :=
 #align real.angle.to_real_inj Real.Angle.toReal_inj
 -/
 
+#print Real.Angle.coe_toReal /-
 @[simp]
 theorem coe_toReal (θ : Angle) : (θ.toReal : Angle) = θ :=
   by
   induction θ using Real.Angle.induction_on
   exact coe_to_Ioc_mod _ _
 #align real.angle.coe_to_real Real.Angle.coe_toReal
+-/
 
+#print Real.Angle.neg_pi_lt_toReal /-
 theorem neg_pi_lt_toReal (θ : Angle) : -π < θ.toReal :=
   by
   induction θ using Real.Angle.induction_on
   exact left_lt_toIocMod _ _ _
 #align real.angle.neg_pi_lt_to_real Real.Angle.neg_pi_lt_toReal
+-/
 
+#print Real.Angle.toReal_le_pi /-
 theorem toReal_le_pi (θ : Angle) : θ.toReal ≤ π :=
   by
   induction θ using Real.Angle.induction_on
   convert toIocMod_le_right two_pi_pos _ _
   ring
 #align real.angle.to_real_le_pi Real.Angle.toReal_le_pi
+-/
 
+#print Real.Angle.abs_toReal_le_pi /-
 theorem abs_toReal_le_pi (θ : Angle) : |θ.toReal| ≤ π :=
   abs_le.2 ⟨(neg_pi_lt_toReal _).le, toReal_le_pi _⟩
 #align real.angle.abs_to_real_le_pi Real.Angle.abs_toReal_le_pi
+-/
 
+#print Real.Angle.toReal_mem_Ioc /-
 theorem toReal_mem_Ioc (θ : Angle) : θ.toReal ∈ Set.Ioc (-π) π :=
   ⟨neg_pi_lt_toReal _, toReal_le_pi _⟩
 #align real.angle.to_real_mem_Ioc Real.Angle.toReal_mem_Ioc
+-/
 
+#print Real.Angle.toIocMod_toReal /-
 @[simp]
 theorem toIocMod_toReal (θ : Angle) : toIocMod two_pi_pos (-π) θ.toReal = θ.toReal :=
   by
@@ -599,76 +772,102 @@ theorem toIocMod_toReal (θ : Angle) : toIocMod two_pi_pos (-π) θ.toReal = θ.
   rw [to_real_coe]
   exact toIocMod_toIocMod _ _ _ _
 #align real.angle.to_Ioc_mod_to_real Real.Angle.toIocMod_toReal
+-/
 
+#print Real.Angle.toReal_zero /-
 @[simp]
 theorem toReal_zero : (0 : Angle).toReal = 0 :=
   by
   rw [← coe_zero, to_real_coe_eq_self_iff]
   exact ⟨Left.neg_neg_iff.2 Real.pi_pos, real.pi_pos.le⟩
 #align real.angle.to_real_zero Real.Angle.toReal_zero
+-/
 
+#print Real.Angle.toReal_eq_zero_iff /-
 @[simp]
 theorem toReal_eq_zero_iff {θ : Angle} : θ.toReal = 0 ↔ θ = 0 :=
   by
   nth_rw 1 [← to_real_zero]
   exact to_real_inj
 #align real.angle.to_real_eq_zero_iff Real.Angle.toReal_eq_zero_iff
+-/
 
+#print Real.Angle.toReal_pi /-
 @[simp]
 theorem toReal_pi : (π : Angle).toReal = π :=
   by
   rw [to_real_coe_eq_self_iff]
   exact ⟨Left.neg_lt_self Real.pi_pos, le_refl _⟩
 #align real.angle.to_real_pi Real.Angle.toReal_pi
+-/
 
+#print Real.Angle.toReal_eq_pi_iff /-
 @[simp]
 theorem toReal_eq_pi_iff {θ : Angle} : θ.toReal = π ↔ θ = π := by rw [← to_real_inj, to_real_pi]
 #align real.angle.to_real_eq_pi_iff Real.Angle.toReal_eq_pi_iff
+-/
 
+#print Real.Angle.pi_ne_zero /-
 theorem pi_ne_zero : (π : Angle) ≠ 0 :=
   by
   rw [← to_real_injective.ne_iff, to_real_pi, to_real_zero]
   exact pi_ne_zero
 #align real.angle.pi_ne_zero Real.Angle.pi_ne_zero
+-/
 
+#print Real.Angle.toReal_pi_div_two /-
 @[simp]
 theorem toReal_pi_div_two : ((π / 2 : ℝ) : Angle).toReal = π / 2 :=
   toReal_coe_eq_self_iff.2 <| by constructor <;> linarith [pi_pos]
 #align real.angle.to_real_pi_div_two Real.Angle.toReal_pi_div_two
+-/
 
+#print Real.Angle.toReal_eq_pi_div_two_iff /-
 @[simp]
 theorem toReal_eq_pi_div_two_iff {θ : Angle} : θ.toReal = π / 2 ↔ θ = (π / 2 : ℝ) := by
   rw [← to_real_inj, to_real_pi_div_two]
 #align real.angle.to_real_eq_pi_div_two_iff Real.Angle.toReal_eq_pi_div_two_iff
+-/
 
+#print Real.Angle.toReal_neg_pi_div_two /-
 @[simp]
 theorem toReal_neg_pi_div_two : ((-π / 2 : ℝ) : Angle).toReal = -π / 2 :=
   toReal_coe_eq_self_iff.2 <| by constructor <;> linarith [pi_pos]
 #align real.angle.to_real_neg_pi_div_two Real.Angle.toReal_neg_pi_div_two
+-/
 
+#print Real.Angle.toReal_eq_neg_pi_div_two_iff /-
 @[simp]
 theorem toReal_eq_neg_pi_div_two_iff {θ : Angle} : θ.toReal = -π / 2 ↔ θ = (-π / 2 : ℝ) := by
   rw [← to_real_inj, to_real_neg_pi_div_two]
 #align real.angle.to_real_eq_neg_pi_div_two_iff Real.Angle.toReal_eq_neg_pi_div_two_iff
+-/
 
+#print Real.Angle.pi_div_two_ne_zero /-
 theorem pi_div_two_ne_zero : ((π / 2 : ℝ) : Angle) ≠ 0 :=
   by
   rw [← to_real_injective.ne_iff, to_real_pi_div_two, to_real_zero]
   exact div_ne_zero Real.pi_ne_zero two_ne_zero
 #align real.angle.pi_div_two_ne_zero Real.Angle.pi_div_two_ne_zero
+-/
 
+#print Real.Angle.neg_pi_div_two_ne_zero /-
 theorem neg_pi_div_two_ne_zero : ((-π / 2 : ℝ) : Angle) ≠ 0 :=
   by
   rw [← to_real_injective.ne_iff, to_real_neg_pi_div_two, to_real_zero]
   exact div_ne_zero (neg_ne_zero.2 Real.pi_ne_zero) two_ne_zero
 #align real.angle.neg_pi_div_two_ne_zero Real.Angle.neg_pi_div_two_ne_zero
+-/
 
+#print Real.Angle.abs_toReal_coe_eq_self_iff /-
 theorem abs_toReal_coe_eq_self_iff {θ : ℝ} : |(θ : Angle).toReal| = θ ↔ 0 ≤ θ ∧ θ ≤ π :=
   ⟨fun h => h ▸ ⟨abs_nonneg _, abs_toReal_le_pi _⟩, fun h =>
     (toReal_coe_eq_self_iff.2 ⟨(Left.neg_neg_iff.2 Real.pi_pos).trans_le h.1, h.2⟩).symm ▸
       abs_eq_self.2 h.1⟩
 #align real.angle.abs_to_real_coe_eq_self_iff Real.Angle.abs_toReal_coe_eq_self_iff
+-/
 
+#print Real.Angle.abs_toReal_neg_coe_eq_self_iff /-
 theorem abs_toReal_neg_coe_eq_self_iff {θ : ℝ} : |(-θ : Angle).toReal| = θ ↔ 0 ≤ θ ∧ θ ≤ π :=
   by
   refine' ⟨fun h => h ▸ ⟨abs_nonneg _, abs_to_real_le_pi _⟩, fun h => _⟩
@@ -678,13 +877,17 @@ theorem abs_toReal_neg_coe_eq_self_iff {θ : ℝ} : |(-θ : Angle).toReal| = θ
       ⟨neg_lt_neg (lt_of_le_of_ne h.2 hnegpi), (neg_nonpos.2 h.1).trans real.pi_pos.le⟩,
     abs_neg, abs_eq_self.2 h.1]
 #align real.angle.abs_to_real_neg_coe_eq_self_iff Real.Angle.abs_toReal_neg_coe_eq_self_iff
+-/
 
+#print Real.Angle.abs_toReal_eq_pi_div_two_iff /-
 theorem abs_toReal_eq_pi_div_two_iff {θ : Angle} :
     |θ.toReal| = π / 2 ↔ θ = (π / 2 : ℝ) ∨ θ = (-π / 2 : ℝ) := by
   rw [abs_eq (div_nonneg real.pi_pos.le two_pos.le), ← neg_div, to_real_eq_pi_div_two_iff,
     to_real_eq_neg_pi_div_two_iff]
 #align real.angle.abs_to_real_eq_pi_div_two_iff Real.Angle.abs_toReal_eq_pi_div_two_iff
+-/
 
+#print Real.Angle.nsmul_toReal_eq_mul /-
 theorem nsmul_toReal_eq_mul {n : ℕ} (h : n ≠ 0) {θ : Angle} :
     (n • θ).toReal = n * θ.toReal ↔ θ.toReal ∈ Set.Ioc (-π / n) (π / n) :=
   by
@@ -693,17 +896,23 @@ theorem nsmul_toReal_eq_mul {n : ℕ} (h : n ≠ 0) {θ : Angle} :
   rw [← coe_nsmul, nsmul_eq_mul, to_real_coe_eq_self_iff, Set.mem_Ioc, div_lt_iff' h',
     le_div_iff' h']
 #align real.angle.nsmul_to_real_eq_mul Real.Angle.nsmul_toReal_eq_mul
+-/
 
+#print Real.Angle.two_nsmul_toReal_eq_two_mul /-
 theorem two_nsmul_toReal_eq_two_mul {θ : Angle} :
     ((2 : ℕ) • θ).toReal = 2 * θ.toReal ↔ θ.toReal ∈ Set.Ioc (-π / 2) (π / 2) := by
   exact_mod_cast nsmul_to_real_eq_mul two_ne_zero
 #align real.angle.two_nsmul_to_real_eq_two_mul Real.Angle.two_nsmul_toReal_eq_two_mul
+-/
 
+#print Real.Angle.two_zsmul_toReal_eq_two_mul /-
 theorem two_zsmul_toReal_eq_two_mul {θ : Angle} :
     ((2 : ℤ) • θ).toReal = 2 * θ.toReal ↔ θ.toReal ∈ Set.Ioc (-π / 2) (π / 2) := by
   rw [two_zsmul, ← two_nsmul, two_nsmul_to_real_eq_two_mul]
 #align real.angle.two_zsmul_to_real_eq_two_mul Real.Angle.two_zsmul_toReal_eq_two_mul
+-/
 
+#print Real.Angle.toReal_coe_eq_self_sub_two_mul_int_mul_pi_iff /-
 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) * π) :=
   by
@@ -711,17 +920,23 @@ theorem toReal_coe_eq_self_sub_two_mul_int_mul_pi_iff {θ : ℝ} {k : ℤ} :
     mul_assoc, mul_comm (k : ℝ), to_real_coe_eq_self_iff, Set.mem_Ioc]
   exact ⟨fun h => ⟨by linarith, by linarith⟩, fun h => ⟨by linarith, by linarith⟩⟩
 #align real.angle.to_real_coe_eq_self_sub_two_mul_int_mul_pi_iff Real.Angle.toReal_coe_eq_self_sub_two_mul_int_mul_pi_iff
+-/
 
+#print Real.Angle.toReal_coe_eq_self_sub_two_pi_iff /-
 theorem toReal_coe_eq_self_sub_two_pi_iff {θ : ℝ} :
     (θ : Angle).toReal = θ - 2 * π ↔ θ ∈ Set.Ioc π (3 * π) := by
   convert @to_real_coe_eq_self_sub_two_mul_int_mul_pi_iff θ 1 <;> norm_num
 #align real.angle.to_real_coe_eq_self_sub_two_pi_iff Real.Angle.toReal_coe_eq_self_sub_two_pi_iff
+-/
 
+#print Real.Angle.toReal_coe_eq_self_add_two_pi_iff /-
 theorem toReal_coe_eq_self_add_two_pi_iff {θ : ℝ} :
     (θ : Angle).toReal = θ + 2 * π ↔ θ ∈ Set.Ioc (-3 * π) (-π) := by
   convert @to_real_coe_eq_self_sub_two_mul_int_mul_pi_iff θ (-1) <;> norm_num
 #align real.angle.to_real_coe_eq_self_add_two_pi_iff Real.Angle.toReal_coe_eq_self_add_two_pi_iff
+-/
 
+#print Real.Angle.two_nsmul_toReal_eq_two_mul_sub_two_pi /-
 theorem two_nsmul_toReal_eq_two_mul_sub_two_pi {θ : Angle} :
     ((2 : ℕ) • θ).toReal = 2 * θ.toReal - 2 * π ↔ π / 2 < θ.toReal :=
   by
@@ -731,12 +946,16 @@ theorem two_nsmul_toReal_eq_two_mul_sub_two_pi {θ : Angle} :
     ⟨fun h => by linarith, fun h =>
       ⟨(div_lt_iff' (zero_lt_two' ℝ)).1 h, by linarith [pi_pos, to_real_le_pi θ]⟩⟩
 #align real.angle.two_nsmul_to_real_eq_two_mul_sub_two_pi Real.Angle.two_nsmul_toReal_eq_two_mul_sub_two_pi
+-/
 
+#print Real.Angle.two_zsmul_toReal_eq_two_mul_sub_two_pi /-
 theorem two_zsmul_toReal_eq_two_mul_sub_two_pi {θ : Angle} :
     ((2 : ℤ) • θ).toReal = 2 * θ.toReal - 2 * π ↔ π / 2 < θ.toReal := by
   rw [two_zsmul, ← two_nsmul, two_nsmul_to_real_eq_two_mul_sub_two_pi]
 #align real.angle.two_zsmul_to_real_eq_two_mul_sub_two_pi Real.Angle.two_zsmul_toReal_eq_two_mul_sub_two_pi
+-/
 
+#print Real.Angle.two_nsmul_toReal_eq_two_mul_add_two_pi /-
 theorem two_nsmul_toReal_eq_two_mul_add_two_pi {θ : Angle} :
     ((2 : ℕ) • θ).toReal = 2 * θ.toReal + 2 * π ↔ θ.toReal ≤ -π / 2 :=
   by
@@ -746,11 +965,14 @@ theorem two_nsmul_toReal_eq_two_mul_add_two_pi {θ : Angle} :
     ⟨fun h => by linarith, fun h =>
       ⟨by linarith [pi_pos, neg_pi_lt_to_real θ], (le_div_iff' (zero_lt_two' ℝ)).1 h⟩⟩
 #align real.angle.two_nsmul_to_real_eq_two_mul_add_two_pi Real.Angle.two_nsmul_toReal_eq_two_mul_add_two_pi
+-/
 
+#print Real.Angle.two_zsmul_toReal_eq_two_mul_add_two_pi /-
 theorem two_zsmul_toReal_eq_two_mul_add_two_pi {θ : Angle} :
     ((2 : ℤ) • θ).toReal = 2 * θ.toReal + 2 * π ↔ θ.toReal ≤ -π / 2 := by
   rw [two_zsmul, ← two_nsmul, two_nsmul_to_real_eq_two_mul_add_two_pi]
 #align real.angle.two_zsmul_to_real_eq_two_mul_add_two_pi Real.Angle.two_zsmul_toReal_eq_two_mul_add_two_pi
+-/
 
 #print Real.Angle.sin_toReal /-
 @[simp]
@@ -766,6 +988,7 @@ theorem cos_toReal (θ : Angle) : Real.cos θ.toReal = cos θ := by
 #align real.angle.cos_to_real Real.Angle.cos_toReal
 -/
 
+#print 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 :=
   by
   nth_rw 1 [← coe_to_real θ]
@@ -781,7 +1004,9 @@ theorem cos_nonneg_iff_abs_toReal_le_pi_div_two {θ : Angle} : 0 ≤ cos θ ↔
   · refine' cos_neg_of_pi_div_two_lt_of_lt hn _
     linarith [to_real_le_pi θ]
 #align real.angle.cos_nonneg_iff_abs_to_real_le_pi_div_two Real.Angle.cos_nonneg_iff_abs_toReal_le_pi_div_two
+-/
 
+#print 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 :=
   by
   rw [lt_iff_le_and_ne, lt_iff_le_and_ne, cos_nonneg_iff_abs_to_real_le_pi_div_two, ←
@@ -789,24 +1014,31 @@ theorem cos_pos_iff_abs_toReal_lt_pi_div_two {θ : Angle} : 0 < cos θ ↔ |θ.t
   rintro -
   rw [Ne.def, Ne.def, not_iff_not, @eq_comm ℝ 0, abs_to_real_eq_pi_div_two_iff, cos_eq_zero_iff]
 #align real.angle.cos_pos_iff_abs_to_real_lt_pi_div_two Real.Angle.cos_pos_iff_abs_toReal_lt_pi_div_two
+-/
 
+#print 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| := by
   rw [← not_le, ← not_le, not_iff_not, cos_nonneg_iff_abs_to_real_le_pi_div_two]
 #align real.angle.cos_neg_iff_pi_div_two_lt_abs_to_real Real.Angle.cos_neg_iff_pi_div_two_lt_abs_toReal
+-/
 
+#print 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 ψ| :=
   by
   rw [← eq_sub_iff_add_eq, ← two_nsmul_coe_div_two, ← nsmul_sub, two_nsmul_eq_iff] at h 
   rcases h with (rfl | rfl) <;> simp [cos_pi_div_two_sub]
 #align real.angle.abs_cos_eq_abs_sin_of_two_nsmul_add_two_nsmul_eq_pi Real.Angle.abs_cos_eq_abs_sin_of_two_nsmul_add_two_nsmul_eq_pi
+-/
 
+#print 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 ψ| :=
   by
   simp_rw [two_zsmul, ← two_nsmul] at h 
   exact abs_cos_eq_abs_sin_of_two_nsmul_add_two_nsmul_eq_pi h
 #align real.angle.abs_cos_eq_abs_sin_of_two_zsmul_add_two_zsmul_eq_pi Real.Angle.abs_cos_eq_abs_sin_of_two_zsmul_add_two_zsmul_eq_pi
+-/
 
 #print Real.Angle.tan /-
 /-- The tangent of a `real.angle`. -/
@@ -815,23 +1047,32 @@ def tan (θ : Angle) : ℝ :=
 #align real.angle.tan Real.Angle.tan
 -/
 
+#print Real.Angle.tan_eq_sin_div_cos /-
 theorem tan_eq_sin_div_cos (θ : Angle) : tan θ = sin θ / cos θ :=
   rfl
 #align real.angle.tan_eq_sin_div_cos Real.Angle.tan_eq_sin_div_cos
+-/
 
+#print Real.Angle.tan_coe /-
 @[simp]
 theorem tan_coe (x : ℝ) : tan (x : Angle) = Real.tan x := by
   rw [tan, sin_coe, cos_coe, Real.tan_eq_sin_div_cos]
 #align real.angle.tan_coe Real.Angle.tan_coe
+-/
 
+#print Real.Angle.tan_zero /-
 @[simp]
 theorem tan_zero : tan (0 : Angle) = 0 := by rw [← coe_zero, tan_coe, Real.tan_zero]
 #align real.angle.tan_zero Real.Angle.tan_zero
+-/
 
+#print Real.Angle.tan_coe_pi /-
 @[simp]
 theorem tan_coe_pi : tan (π : Angle) = 0 := by rw [tan_eq_sin_div_cos, sin_coe_pi, zero_div]
 #align real.angle.tan_coe_pi Real.Angle.tan_coe_pi
+-/
 
+#print Real.Angle.tan_periodic /-
 theorem tan_periodic : Function.Periodic tan (π : Angle) :=
   by
   intro θ
@@ -839,16 +1080,21 @@ theorem tan_periodic : Function.Periodic tan (π : Angle) :=
   rw [← coe_add, tan_coe, tan_coe]
   exact Real.tan_periodic θ
 #align real.angle.tan_periodic Real.Angle.tan_periodic
+-/
 
+#print Real.Angle.tan_add_pi /-
 @[simp]
 theorem tan_add_pi (θ : Angle) : tan (θ + π) = tan θ :=
   tan_periodic θ
 #align real.angle.tan_add_pi Real.Angle.tan_add_pi
+-/
 
+#print Real.Angle.tan_sub_pi /-
 @[simp]
 theorem tan_sub_pi (θ : Angle) : tan (θ - π) = tan θ :=
   tan_periodic.sub_eq θ
 #align real.angle.tan_sub_pi Real.Angle.tan_sub_pi
+-/
 
 #print Real.Angle.tan_toReal /-
 @[simp]
@@ -857,6 +1103,7 @@ theorem tan_toReal (θ : Angle) : Real.tan θ.toReal = tan θ := by
 #align real.angle.tan_to_real Real.Angle.tan_toReal
 -/
 
+#print Real.Angle.tan_eq_of_two_nsmul_eq /-
 theorem tan_eq_of_two_nsmul_eq {θ ψ : Angle} (h : (2 : ℕ) • θ = (2 : ℕ) • ψ) : tan θ = tan ψ :=
   by
   rw [two_nsmul_eq_iff] at h 
@@ -864,13 +1111,17 @@ theorem tan_eq_of_two_nsmul_eq {θ ψ : Angle} (h : (2 : ℕ) • θ = (2 : ℕ)
   · rfl
   · exact tan_add_pi _
 #align real.angle.tan_eq_of_two_nsmul_eq Real.Angle.tan_eq_of_two_nsmul_eq
+-/
 
+#print Real.Angle.tan_eq_of_two_zsmul_eq /-
 theorem tan_eq_of_two_zsmul_eq {θ ψ : Angle} (h : (2 : ℤ) • θ = (2 : ℤ) • ψ) : tan θ = tan ψ :=
   by
   simp_rw [two_zsmul, ← two_nsmul] at h 
   exact tan_eq_of_two_nsmul_eq h
 #align real.angle.tan_eq_of_two_zsmul_eq Real.Angle.tan_eq_of_two_zsmul_eq
+-/
 
+#print 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 θ)⁻¹ :=
   by
@@ -884,13 +1135,16 @@ theorem tan_eq_inv_of_two_nsmul_add_two_nsmul_eq_pi {θ ψ : Angle}
   rw [tan_coe, tan_coe, ← tan_pi_div_two_sub, h, add_sub_assoc, add_comm]
   exact real.tan_periodic.int_mul _ _
 #align real.angle.tan_eq_inv_of_two_nsmul_add_two_nsmul_eq_pi Real.Angle.tan_eq_inv_of_two_nsmul_add_two_nsmul_eq_pi
+-/
 
+#print 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 θ)⁻¹ :=
   by
   simp_rw [two_zsmul, ← two_nsmul] at h 
   exact tan_eq_inv_of_two_nsmul_add_two_nsmul_eq_pi h
 #align real.angle.tan_eq_inv_of_two_zsmul_add_two_zsmul_eq_pi Real.Angle.tan_eq_inv_of_two_zsmul_add_two_zsmul_eq_pi
+-/
 
 #print Real.Angle.sign /-
 /-- The sign of a `real.angle` is `0` if the angle is `0` or `π`, `1` if the angle is strictly
@@ -901,50 +1155,71 @@ def sign (θ : Angle) : SignType :=
 #align real.angle.sign Real.Angle.sign
 -/
 
+#print Real.Angle.sign_zero /-
 @[simp]
 theorem sign_zero : (0 : Angle).sign = 0 := by rw [SignType.sign, sin_zero, sign_zero]
 #align real.angle.sign_zero Real.Angle.sign_zero
+-/
 
+#print Real.Angle.sign_coe_pi /-
 @[simp]
 theorem sign_coe_pi : (π : Angle).sign = 0 := by rw [SignType.sign, sin_coe_pi, _root_.sign_zero]
 #align real.angle.sign_coe_pi Real.Angle.sign_coe_pi
+-/
 
+#print Real.Angle.sign_neg /-
 @[simp]
 theorem sign_neg (θ : Angle) : (-θ).sign = -θ.sign := by
   simp_rw [SignType.sign, sin_neg, Left.sign_neg]
 #align real.angle.sign_neg Real.Angle.sign_neg
+-/
 
+#print Real.Angle.sign_antiperiodic /-
 theorem sign_antiperiodic : Function.Antiperiodic sign (π : Angle) := fun θ => by
   rw [SignType.sign, SignType.sign, sin_add_pi, Left.sign_neg]
 #align real.angle.sign_antiperiodic Real.Angle.sign_antiperiodic
+-/
 
+#print Real.Angle.sign_add_pi /-
 @[simp]
 theorem sign_add_pi (θ : Angle) : (θ + π).sign = -θ.sign :=
   sign_antiperiodic θ
 #align real.angle.sign_add_pi Real.Angle.sign_add_pi
+-/
 
+#print Real.Angle.sign_pi_add /-
 @[simp]
 theorem sign_pi_add (θ : Angle) : ((π : Angle) + θ).sign = -θ.sign := by rw [add_comm, sign_add_pi]
 #align real.angle.sign_pi_add Real.Angle.sign_pi_add
+-/
 
+#print Real.Angle.sign_sub_pi /-
 @[simp]
 theorem sign_sub_pi (θ : Angle) : (θ - π).sign = -θ.sign :=
   sign_antiperiodic.sub_eq θ
 #align real.angle.sign_sub_pi Real.Angle.sign_sub_pi
+-/
 
+#print Real.Angle.sign_pi_sub /-
 @[simp]
 theorem sign_pi_sub (θ : Angle) : ((π : Angle) - θ).sign = θ.sign := by
   simp [sign_antiperiodic.sub_eq']
 #align real.angle.sign_pi_sub Real.Angle.sign_pi_sub
+-/
 
+#print Real.Angle.sign_eq_zero_iff /-
 theorem sign_eq_zero_iff {θ : Angle} : θ.sign = 0 ↔ θ = 0 ∨ θ = π := by
   rw [SignType.sign, sign_eq_zero_iff, sin_eq_zero_iff]
 #align real.angle.sign_eq_zero_iff Real.Angle.sign_eq_zero_iff
+-/
 
+#print Real.Angle.sign_ne_zero_iff /-
 theorem sign_ne_zero_iff {θ : Angle} : θ.sign ≠ 0 ↔ θ ≠ 0 ∧ θ ≠ π := by
   rw [← not_or, ← sign_eq_zero_iff]
 #align real.angle.sign_ne_zero_iff Real.Angle.sign_ne_zero_iff
+-/
 
+#print Real.Angle.toReal_neg_iff_sign_neg /-
 theorem toReal_neg_iff_sign_neg {θ : Angle} : θ.toReal < 0 ↔ θ.sign = -1 :=
   by
   rw [SignType.sign, ← sin_to_real, sign_eq_neg_one_iff]
@@ -956,7 +1231,9 @@ theorem toReal_neg_iff_sign_neg {θ : Angle} : θ.toReal < 0 ↔ θ.sign = -1 :=
       ⟨fun hn => False.elim (h.asymm hn), fun hn =>
         False.elim (hn.not_le (sin_nonneg_of_nonneg_of_le_pi h.le (to_real_le_pi θ)))⟩
 #align real.angle.to_real_neg_iff_sign_neg Real.Angle.toReal_neg_iff_sign_neg
+-/
 
+#print Real.Angle.toReal_nonneg_iff_sign_nonneg /-
 theorem toReal_nonneg_iff_sign_nonneg {θ : Angle} : 0 ≤ θ.toReal ↔ 0 ≤ θ.sign :=
   by
   rcases lt_trichotomy θ.to_real 0 with (h | h | h)
@@ -968,7 +1245,9 @@ theorem toReal_nonneg_iff_sign_nonneg {θ : Angle} : 0 ≤ θ.toReal ↔ 0 ≤ 
     rw [SignType.sign, ← sin_to_real, sign_nonneg_iff]
     exact sin_nonneg_of_nonneg_of_le_pi h.le (to_real_le_pi θ)
 #align real.angle.to_real_nonneg_iff_sign_nonneg Real.Angle.toReal_nonneg_iff_sign_nonneg
+-/
 
+#print Real.Angle.sign_toReal /-
 @[simp]
 theorem sign_toReal {θ : Angle} (h : θ ≠ π) : SignType.sign θ.toReal = θ.sign :=
   by
@@ -980,11 +1259,15 @@ theorem sign_toReal {θ : Angle} (h : θ ≠ π) : SignType.sign θ.toReal = θ.
       sign_pos
         (sin_pos_of_pos_of_lt_pi ht ((to_real_le_pi θ).lt_of_ne (to_real_eq_pi_iff.not.2 h)))]
 #align real.angle.sign_to_real Real.Angle.sign_toReal
+-/
 
+#print Real.Angle.coe_abs_toReal_of_sign_nonneg /-
 theorem coe_abs_toReal_of_sign_nonneg {θ : Angle} (h : 0 ≤ θ.sign) : ↑(|θ.toReal|) = θ := by
   rw [abs_eq_self.2 (to_real_nonneg_iff_sign_nonneg.2 h), coe_to_real]
 #align real.angle.coe_abs_to_real_of_sign_nonneg Real.Angle.coe_abs_toReal_of_sign_nonneg
+-/
 
+#print Real.Angle.neg_coe_abs_toReal_of_sign_nonpos /-
 theorem neg_coe_abs_toReal_of_sign_nonpos {θ : Angle} (h : θ.sign ≤ 0) : -↑(|θ.toReal|) = θ :=
   by
   rw [SignType.nonpos_iff] at h 
@@ -993,7 +1276,9 @@ theorem neg_coe_abs_toReal_of_sign_nonpos {θ : Angle} (h : θ.sign ≤ 0) : -
   · rw [sign_eq_zero_iff] at h 
     rcases h with (rfl | rfl) <;> simp [abs_of_pos Real.pi_pos]
 #align real.angle.neg_coe_abs_to_real_of_sign_nonpos Real.Angle.neg_coe_abs_toReal_of_sign_nonpos
+-/
 
+#print Real.Angle.eq_iff_sign_eq_and_abs_toReal_eq /-
 theorem eq_iff_sign_eq_and_abs_toReal_eq {θ ψ : Angle} :
     θ = ψ ↔ θ.sign = ψ.sign ∧ |θ.toReal| = |ψ.toReal| :=
   by
@@ -1013,34 +1298,46 @@ theorem eq_iff_sign_eq_and_abs_toReal_eq {θ ψ : Angle} :
         rw [hs, to_real_zero, neg_zero, to_real_eq_zero_iff] at hr 
         rw [hr, hs]
 #align real.angle.eq_iff_sign_eq_and_abs_to_real_eq Real.Angle.eq_iff_sign_eq_and_abs_toReal_eq
+-/
 
+#print 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| := by simpa [h] using @eq_iff_sign_eq_and_abs_to_real_eq θ ψ
 #align real.angle.eq_iff_abs_to_real_eq_of_sign_eq Real.Angle.eq_iff_abs_toReal_eq_of_sign_eq
+-/
 
+#print Real.Angle.sign_coe_pi_div_two /-
 @[simp]
 theorem sign_coe_pi_div_two : (↑(π / 2) : Angle).sign = 1 := by
   rw [SignType.sign, sin_coe, sin_pi_div_two, sign_one]
 #align real.angle.sign_coe_pi_div_two Real.Angle.sign_coe_pi_div_two
+-/
 
+#print Real.Angle.sign_coe_neg_pi_div_two /-
 @[simp]
 theorem sign_coe_neg_pi_div_two : (↑(-π / 2) : Angle).sign = -1 := by
   rw [SignType.sign, sin_coe, neg_div, Real.sin_neg, sin_pi_div_two, Left.sign_neg, sign_one]
 #align real.angle.sign_coe_neg_pi_div_two Real.Angle.sign_coe_neg_pi_div_two
+-/
 
+#print 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 := by
   rw [SignType.sign, sign_nonneg_iff]
   exact sin_nonneg_of_nonneg_of_le_pi h0 hpi
 #align real.angle.sign_coe_nonneg_of_nonneg_of_le_pi Real.Angle.sign_coe_nonneg_of_nonneg_of_le_pi
+-/
 
+#print 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 :=
   by
   rw [SignType.sign, sign_nonpos_iff, sin_neg, Left.neg_nonpos_iff]
   exact sin_nonneg_of_nonneg_of_le_pi h0 hpi
 #align real.angle.sign_neg_coe_nonpos_of_nonneg_of_le_pi Real.Angle.sign_neg_coe_nonpos_of_nonneg_of_le_pi
+-/
 
+#print Real.Angle.sign_two_nsmul_eq_sign_iff /-
 theorem sign_two_nsmul_eq_sign_iff {θ : Angle} :
     ((2 : ℕ) • θ).sign = θ.sign ↔ θ = π ∨ |θ.toReal| < π / 2 :=
   by
@@ -1078,16 +1375,22 @@ theorem sign_two_nsmul_eq_sign_iff {θ : Angle} :
     rw [← sign_to_real hpi, ← sign_to_real hpi', two_nsmul_to_real_eq_two_mul.2 ⟨h.1, h.2.le⟩,
       sign_mul, sign_pos (zero_lt_two' ℝ), one_mul]
 #align real.angle.sign_two_nsmul_eq_sign_iff Real.Angle.sign_two_nsmul_eq_sign_iff
+-/
 
+#print Real.Angle.sign_two_zsmul_eq_sign_iff /-
 theorem sign_two_zsmul_eq_sign_iff {θ : Angle} :
     ((2 : ℤ) • θ).sign = θ.sign ↔ θ = π ∨ |θ.toReal| < π / 2 := by
   rw [two_zsmul, ← two_nsmul, sign_two_nsmul_eq_sign_iff]
 #align real.angle.sign_two_zsmul_eq_sign_iff Real.Angle.sign_two_zsmul_eq_sign_iff
+-/
 
+#print Real.Angle.continuousAt_sign /-
 theorem continuousAt_sign {θ : Angle} (h0 : θ ≠ 0) (hpi : θ ≠ π) : ContinuousAt sign θ :=
   (continuousAt_sign_of_ne_zero (sin_ne_zero_iff.2 ⟨h0, hpi⟩)).comp continuous_sin.ContinuousAt
 #align real.angle.continuous_at_sign Real.Angle.continuousAt_sign
+-/
 
+#print ContinuousOn.angle_sign_comp /-
 theorem 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 :=
   by
@@ -1095,7 +1398,9 @@ theorem ContinuousOn.angle_sign_comp {α : Type _} [TopologicalSpace α] {f : α
   obtain ⟨z, hz, rfl⟩ := hθ
   exact continuous_at_sign (hs _ hz).1 (hs _ hz).2
 #align continuous_on.angle_sign_comp ContinuousOn.angle_sign_comp
+-/
 
+#print Real.Angle.sign_eq_of_continuousOn /-
 /-- 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 α}
@@ -1104,6 +1409,7 @@ theorem sign_eq_of_continuousOn {α : Type _} [TopologicalSpace α] {f : α →
   (hc.image _ (hf.angle_sign_comp hs)).IsPreconnected.Subsingleton (Set.mem_image_of_mem _ hy)
     (Set.mem_image_of_mem _ hx)
 #align real.angle.sign_eq_of_continuous_on Real.Angle.sign_eq_of_continuousOn
+-/
 
 end Angle
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/5f25c089cb34db4db112556f23c50d12da81b297

@@ -30,13 +30,13 @@ noncomputable section
 
 namespace Real
 
-/- ./././Mathport/Syntax/Translate/Command.lean:42:9: unsupported derive handler has_coe_t[has_coe_t] exprℝ() -/
+/- ./././Mathport/Syntax/Translate/Command.lean:43:9: unsupported derive handler has_coe_t[has_coe_t] exprℝ() -/
 #print Real.Angle /-
 /-- The type of angles -/
 def Angle : Type :=
   AddCircle (2 * π)
 deriving NormedAddCommGroup, Inhabited,
-  «./././Mathport/Syntax/Translate/Command.lean:42:9: unsupported derive handler has_coe_t[has_coe_t] exprℝ()»
+  «./././Mathport/Syntax/Translate/Command.lean:43:9: unsupported derive handler has_coe_t[has_coe_t] exprℝ()»
 #align real.angle Real.Angle
 -/
 
@@ -714,12 +714,12 @@ theorem toReal_coe_eq_self_sub_two_mul_int_mul_pi_iff {θ : ℝ} {k : ℤ} :
 
 theorem toReal_coe_eq_self_sub_two_pi_iff {θ : ℝ} :
     (θ : Angle).toReal = θ - 2 * π ↔ θ ∈ Set.Ioc π (3 * π) := by
-  convert@to_real_coe_eq_self_sub_two_mul_int_mul_pi_iff θ 1 <;> norm_num
+  convert @to_real_coe_eq_self_sub_two_mul_int_mul_pi_iff θ 1 <;> norm_num
 #align real.angle.to_real_coe_eq_self_sub_two_pi_iff Real.Angle.toReal_coe_eq_self_sub_two_pi_iff
 
 theorem toReal_coe_eq_self_add_two_pi_iff {θ : ℝ} :
     (θ : Angle).toReal = θ + 2 * π ↔ θ ∈ Set.Ioc (-3 * π) (-π) := by
-  convert@to_real_coe_eq_self_sub_two_mul_int_mul_pi_iff θ (-1) <;> norm_num
+  convert @to_real_coe_eq_self_sub_two_mul_int_mul_pi_iff θ (-1) <;> norm_num
 #align real.angle.to_real_coe_eq_self_add_two_pi_iff Real.Angle.toReal_coe_eq_self_add_two_pi_iff
 
 theorem two_nsmul_toReal_eq_two_mul_sub_two_pi {θ : Angle} :

mathlib commit https://github.com/leanprover-community/mathlib/commit/cca40788df1b8755d5baf17ab2f27dacc2e17acb

@@ -34,7 +34,8 @@ namespace Real
 #print Real.Angle /-
 /-- The type of angles -/
 def Angle : Type :=
-  AddCircle (2 * π)deriving NormedAddCommGroup, Inhabited,
+  AddCircle (2 * π)
+deriving NormedAddCommGroup, Inhabited,
   «./././Mathport/Syntax/Translate/Command.lean:42:9: unsupported derive handler has_coe_t[has_coe_t] exprℝ()»
 #align real.angle Real.Angle
 -/
@@ -42,7 +43,7 @@ def Angle : Type :=
 namespace Angle
 
 instance : CircularOrder Real.Angle :=
-  @AddCircle.circularOrder _ _ _ _ _ ⟨by norm_num [pi_pos] ⟩ _
+  @AddCircle.circularOrder _ _ _ _ _ ⟨by norm_num [pi_pos]⟩ _
 
 @[continuity]
 theorem continuous_coe : Continuous (coe : ℝ → Angle) :=
@@ -228,14 +229,14 @@ theorem cos_eq_iff_coe_eq_or_eq_neg {θ ψ : ℝ} :
   constructor
   · intro Hcos
     rw [← sub_eq_zero, cos_sub_cos, mul_eq_zero, mul_eq_zero, neg_eq_zero,
-      eq_false (two_ne_zero' ℝ), false_or_iff, sin_eq_zero_iff, sin_eq_zero_iff] at Hcos
+      eq_false (two_ne_zero' ℝ), false_or_iff, sin_eq_zero_iff, sin_eq_zero_iff] at Hcos 
     rcases Hcos with (⟨n, hn⟩ | ⟨n, hn⟩)
     · right
-      rw [eq_div_iff_mul_eq (two_ne_zero' ℝ), ← sub_eq_iff_eq_add] at hn
+      rw [eq_div_iff_mul_eq (two_ne_zero' ℝ), ← sub_eq_iff_eq_add] at hn 
       rw [← hn, coe_sub, eq_neg_iff_add_eq_zero, sub_add_cancel, mul_assoc, coe_int_mul_eq_zsmul,
         mul_comm, coe_two_pi, zsmul_zero]
     · left
-      rw [eq_div_iff_mul_eq (two_ne_zero' ℝ), eq_sub_iff_add_eq] at hn
+      rw [eq_div_iff_mul_eq (two_ne_zero' ℝ), eq_sub_iff_add_eq] at hn 
       rw [← hn, coe_add, mul_assoc, coe_int_mul_eq_zsmul, mul_comm, coe_two_pi, zsmul_zero,
         zero_add]
   · rw [angle_eq_iff_two_pi_dvd_sub, ← coe_neg, angle_eq_iff_two_pi_dvd_sub]
@@ -251,12 +252,12 @@ theorem sin_eq_iff_coe_eq_or_add_eq_pi {θ ψ : ℝ} :
     sin θ = sin ψ ↔ (θ : Angle) = ψ ∨ (θ : Angle) + ψ = π :=
   by
   constructor
-  · intro Hsin; rw [← cos_pi_div_two_sub, ← cos_pi_div_two_sub] at Hsin
+  · intro Hsin; rw [← cos_pi_div_two_sub, ← cos_pi_div_two_sub] at Hsin 
     cases' cos_eq_iff_coe_eq_or_eq_neg.mp Hsin with h h
-    · left; rw [coe_sub, coe_sub] at h; exact sub_right_inj.1 h
+    · left; rw [coe_sub, coe_sub] at h ; exact sub_right_inj.1 h
     right;
     rw [coe_sub, coe_sub, eq_neg_iff_add_eq_zero, add_sub, sub_add_eq_add_sub, ← coe_add,
-      add_halves, sub_sub, sub_eq_zero] at h
+      add_halves, sub_sub, sub_eq_zero] at h 
     exact h.symm
   · rw [angle_eq_iff_two_pi_dvd_sub, ← eq_sub_iff_add_eq, ← coe_sub, angle_eq_iff_two_pi_dvd_sub]
     rintro (⟨k, H⟩ | ⟨k, H⟩)
@@ -264,7 +265,7 @@ theorem sin_eq_iff_coe_eq_or_add_eq_pi {θ ψ : ℝ} :
       mul_comm π _, sin_int_mul_pi, MulZeroClass.mul_zero, MulZeroClass.zero_mul]
     have H' : θ + ψ = 2 * k * π + π := by
       rwa [← sub_add, sub_add_eq_add_sub, sub_eq_iff_eq_add, mul_assoc, mul_comm π _, ←
-        mul_assoc] at H
+        mul_assoc] at H 
     rw [← sub_eq_zero, sin_sub_sin, H', add_div, mul_assoc 2 _ π,
       mul_div_cancel_left _ (two_ne_zero' ℝ), cos_add_pi_div_two, sin_int_mul_pi, neg_zero,
       MulZeroClass.mul_zero]
@@ -274,13 +275,13 @@ theorem cos_sin_inj {θ ψ : ℝ} (Hcos : cos θ = cos ψ) (Hsin : sin θ = sin
   by
   cases' cos_eq_iff_coe_eq_or_eq_neg.mp Hcos with hc hc; · exact hc
   cases' sin_eq_iff_coe_eq_or_add_eq_pi.mp Hsin with hs hs; · exact hs
-  rw [eq_neg_iff_add_eq_zero, hs] at hc
+  rw [eq_neg_iff_add_eq_zero, hs] at hc 
   obtain ⟨n, hn⟩ : ∃ n, n • _ = _ := quotient_add_group.left_rel_apply.mp (Quotient.exact' hc)
   rw [← neg_one_mul, add_zero, ← sub_eq_zero, zsmul_eq_mul, ← mul_assoc, ← sub_mul, mul_eq_zero,
     eq_false (ne_of_gt pi_pos), or_false_iff, sub_neg_eq_add, ← Int.cast_zero, ← Int.cast_one, ←
-    Int.cast_bit0, ← Int.cast_mul, ← Int.cast_add, Int.cast_inj] at hn
+    Int.cast_bit0, ← Int.cast_mul, ← Int.cast_add, Int.cast_inj] at hn 
   have : (n * 2 + 1) % (2 : ℤ) = 0 % (2 : ℤ) := congr_arg (· % (2 : ℤ)) hn
-  rw [add_comm, Int.add_mul_emod_self] at this
+  rw [add_comm, Int.add_mul_emod_self] at this 
   exact absurd this one_ne_zero
 #align real.angle.cos_sin_inj Real.Angle.cos_sin_inj
 
@@ -482,7 +483,7 @@ theorem cos_pi_div_two_sub (θ : Angle) : cos (↑(π / 2) - θ) = sin θ :=
 
 theorem abs_sin_eq_of_two_nsmul_eq {θ ψ : Angle} (h : (2 : ℕ) • θ = (2 : ℕ) • ψ) :
     |sin θ| = |sin ψ| := by
-  rw [two_nsmul_eq_iff] at h
+  rw [two_nsmul_eq_iff] at h 
   rcases h with (rfl | rfl)
   · rfl
   · rw [sin_add_pi, abs_neg]
@@ -490,13 +491,13 @@ theorem abs_sin_eq_of_two_nsmul_eq {θ ψ : Angle} (h : (2 : ℕ) • θ = (2 :
 
 theorem abs_sin_eq_of_two_zsmul_eq {θ ψ : Angle} (h : (2 : ℤ) • θ = (2 : ℤ) • ψ) :
     |sin θ| = |sin ψ| := by
-  simp_rw [two_zsmul, ← two_nsmul] at h
+  simp_rw [two_zsmul, ← two_nsmul] at h 
   exact abs_sin_eq_of_two_nsmul_eq h
 #align real.angle.abs_sin_eq_of_two_zsmul_eq Real.Angle.abs_sin_eq_of_two_zsmul_eq
 
 theorem abs_cos_eq_of_two_nsmul_eq {θ ψ : Angle} (h : (2 : ℕ) • θ = (2 : ℕ) • ψ) :
     |cos θ| = |cos ψ| := by
-  rw [two_nsmul_eq_iff] at h
+  rw [two_nsmul_eq_iff] at h 
   rcases h with (rfl | rfl)
   · rfl
   · rw [cos_add_pi, abs_neg]
@@ -504,7 +505,7 @@ theorem abs_cos_eq_of_two_nsmul_eq {θ ψ : Angle} (h : (2 : ℕ) • θ = (2 :
 
 theorem abs_cos_eq_of_two_zsmul_eq {θ ψ : Angle} (h : (2 : ℤ) • θ = (2 : ℤ) • ψ) :
     |cos θ| = |cos ψ| := by
-  simp_rw [two_zsmul, ← two_nsmul] at h
+  simp_rw [two_zsmul, ← two_nsmul] at h 
   exact abs_cos_eq_of_two_nsmul_eq h
 #align real.angle.abs_cos_eq_of_two_zsmul_eq Real.Angle.abs_cos_eq_of_two_zsmul_eq
 
@@ -771,7 +772,7 @@ theorem cos_nonneg_iff_abs_toReal_le_pi_div_two {θ : Angle} : 0 ≤ cos θ ↔
   rw [abs_le, cos_coe]
   refine' ⟨fun h => _, cos_nonneg_of_mem_Icc⟩
   by_contra hn
-  rw [not_and_or, not_le, not_le] at hn
+  rw [not_and_or, not_le, not_le] at hn 
   refine' (not_lt.2 h) _
   rcases hn with (hn | hn)
   · rw [← Real.cos_neg]
@@ -796,14 +797,14 @@ theorem cos_neg_iff_pi_div_two_lt_abs_toReal {θ : Angle} : cos θ < 0 ↔ π /
 theorem abs_cos_eq_abs_sin_of_two_nsmul_add_two_nsmul_eq_pi {θ ψ : Angle}
     (h : (2 : ℕ) • θ + (2 : ℕ) • ψ = π) : |cos θ| = |sin ψ| :=
   by
-  rw [← eq_sub_iff_add_eq, ← two_nsmul_coe_div_two, ← nsmul_sub, two_nsmul_eq_iff] at h
+  rw [← eq_sub_iff_add_eq, ← two_nsmul_coe_div_two, ← nsmul_sub, two_nsmul_eq_iff] at h 
   rcases h with (rfl | rfl) <;> simp [cos_pi_div_two_sub]
 #align real.angle.abs_cos_eq_abs_sin_of_two_nsmul_add_two_nsmul_eq_pi Real.Angle.abs_cos_eq_abs_sin_of_two_nsmul_add_two_nsmul_eq_pi
 
 theorem abs_cos_eq_abs_sin_of_two_zsmul_add_two_zsmul_eq_pi {θ ψ : Angle}
     (h : (2 : ℤ) • θ + (2 : ℤ) • ψ = π) : |cos θ| = |sin ψ| :=
   by
-  simp_rw [two_zsmul, ← two_nsmul] at h
+  simp_rw [two_zsmul, ← two_nsmul] at h 
   exact abs_cos_eq_abs_sin_of_two_nsmul_add_two_nsmul_eq_pi h
 #align real.angle.abs_cos_eq_abs_sin_of_two_zsmul_add_two_zsmul_eq_pi Real.Angle.abs_cos_eq_abs_sin_of_two_zsmul_add_two_zsmul_eq_pi
 
@@ -858,7 +859,7 @@ theorem tan_toReal (θ : Angle) : Real.tan θ.toReal = tan θ := by
 
 theorem tan_eq_of_two_nsmul_eq {θ ψ : Angle} (h : (2 : ℕ) • θ = (2 : ℕ) • ψ) : tan θ = tan ψ :=
   by
-  rw [two_nsmul_eq_iff] at h
+  rw [two_nsmul_eq_iff] at h 
   rcases h with (rfl | rfl)
   · rfl
   · exact tan_add_pi _
@@ -866,7 +867,7 @@ theorem tan_eq_of_two_nsmul_eq {θ ψ : Angle} (h : (2 : ℕ) • θ = (2 : ℕ)
 
 theorem tan_eq_of_two_zsmul_eq {θ ψ : Angle} (h : (2 : ℤ) • θ = (2 : ℤ) • ψ) : tan θ = tan ψ :=
   by
-  simp_rw [two_zsmul, ← two_nsmul] at h
+  simp_rw [two_zsmul, ← two_nsmul] at h 
   exact tan_eq_of_two_nsmul_eq h
 #align real.angle.tan_eq_of_two_zsmul_eq Real.Angle.tan_eq_of_two_zsmul_eq
 
@@ -875,11 +876,11 @@ theorem tan_eq_inv_of_two_nsmul_add_two_nsmul_eq_pi {θ ψ : Angle}
   by
   induction θ using Real.Angle.induction_on
   induction ψ using Real.Angle.induction_on
-  rw [← smul_add, ← coe_add, ← coe_nsmul, two_nsmul, ← two_mul, angle_eq_iff_two_pi_dvd_sub] at h
+  rw [← smul_add, ← coe_add, ← coe_nsmul, two_nsmul, ← two_mul, angle_eq_iff_two_pi_dvd_sub] at h 
   rcases h with ⟨k, h⟩
   rw [sub_eq_iff_eq_add, ← mul_inv_cancel_left₀ two_ne_zero π, mul_assoc, ← mul_add,
     mul_right_inj' (two_ne_zero' ℝ), ← eq_sub_iff_add_eq', mul_inv_cancel_left₀ two_ne_zero π,
-    inv_mul_eq_div, mul_comm] at h
+    inv_mul_eq_div, mul_comm] at h 
   rw [tan_coe, tan_coe, ← tan_pi_div_two_sub, h, add_sub_assoc, add_comm]
   exact real.tan_periodic.int_mul _ _
 #align real.angle.tan_eq_inv_of_two_nsmul_add_two_nsmul_eq_pi Real.Angle.tan_eq_inv_of_two_nsmul_add_two_nsmul_eq_pi
@@ -887,7 +888,7 @@ theorem tan_eq_inv_of_two_nsmul_add_two_nsmul_eq_pi {θ ψ : Angle}
 theorem tan_eq_inv_of_two_zsmul_add_two_zsmul_eq_pi {θ ψ : Angle}
     (h : (2 : ℤ) • θ + (2 : ℤ) • ψ = π) : tan ψ = (tan θ)⁻¹ :=
   by
-  simp_rw [two_zsmul, ← two_nsmul] at h
+  simp_rw [two_zsmul, ← two_nsmul] at h 
   exact tan_eq_inv_of_two_nsmul_add_two_nsmul_eq_pi h
 #align real.angle.tan_eq_inv_of_two_zsmul_add_two_zsmul_eq_pi Real.Angle.tan_eq_inv_of_two_zsmul_add_two_zsmul_eq_pi
 
@@ -960,7 +961,7 @@ theorem toReal_nonneg_iff_sign_nonneg {θ : Angle} : 0 ≤ θ.toReal ↔ 0 ≤ 
   by
   rcases lt_trichotomy θ.to_real 0 with (h | h | h)
   · refine' ⟨fun hn => False.elim (h.not_le hn), fun hn => _⟩
-    rw [to_real_neg_iff_sign_neg.1 h] at hn
+    rw [to_real_neg_iff_sign_neg.1 h] at hn 
     exact False.elim (hn.not_lt (by decide))
   · simp [h, SignType.sign, ← sin_to_real]
   · refine' ⟨fun _ => _, fun _ => h.le⟩
@@ -986,10 +987,10 @@ theorem coe_abs_toReal_of_sign_nonneg {θ : Angle} (h : 0 ≤ θ.sign) : ↑(|θ
 
 theorem neg_coe_abs_toReal_of_sign_nonpos {θ : Angle} (h : θ.sign ≤ 0) : -↑(|θ.toReal|) = θ :=
   by
-  rw [SignType.nonpos_iff] at h
+  rw [SignType.nonpos_iff] at h 
   rcases h with (h | h)
   · rw [abs_of_neg (to_real_neg_iff_sign_neg.2 h), coe_neg, neg_neg, coe_to_real]
-  · rw [sign_eq_zero_iff] at h
+  · rw [sign_eq_zero_iff] at h 
     rcases h with (rfl | rfl) <;> simp [abs_of_pos Real.pi_pos]
 #align real.angle.neg_coe_abs_to_real_of_sign_nonpos Real.Angle.neg_coe_abs_toReal_of_sign_nonpos
 
@@ -998,18 +999,18 @@ theorem eq_iff_sign_eq_and_abs_toReal_eq {θ ψ : Angle} :
   by
   refine' ⟨_, fun h => _⟩; · rintro rfl; exact ⟨rfl, rfl⟩
   rcases h with ⟨hs, hr⟩
-  rw [abs_eq_abs] at hr
+  rw [abs_eq_abs] at hr 
   rcases hr with (hr | hr)
   · exact to_real_injective hr
   · by_cases h : θ = π
-    · rw [h, to_real_pi, ← neg_eq_iff_eq_neg] at hr
+    · rw [h, to_real_pi, ← neg_eq_iff_eq_neg] at hr 
       exact False.elim ((neg_pi_lt_to_real ψ).Ne hr)
     · by_cases h' : ψ = π
-      · rw [h', to_real_pi] at hr
+      · rw [h', to_real_pi] at hr 
         exact False.elim ((neg_pi_lt_to_real θ).Ne hr.symm)
       · rw [← sign_to_real h, ← sign_to_real h', hr, Left.sign_neg, SignType.neg_eq_self_iff,
-          _root_.sign_eq_zero_iff, to_real_eq_zero_iff] at hs
-        rw [hs, to_real_zero, neg_zero, to_real_eq_zero_iff] at hr
+          _root_.sign_eq_zero_iff, to_real_eq_zero_iff] at hs 
+        rw [hs, to_real_zero, neg_zero, to_real_eq_zero_iff] at hr 
         rw [hr, hs]
 #align real.angle.eq_iff_sign_eq_and_abs_to_real_eq Real.Angle.eq_iff_sign_eq_and_abs_toReal_eq
 
@@ -1047,22 +1048,22 @@ theorem sign_two_nsmul_eq_sign_iff {θ : Angle} :
   rw [or_iff_right hpi]
   refine' ⟨fun h => _, fun h => _⟩
   · by_contra hle
-    rw [not_lt, le_abs, le_neg] at hle
+    rw [not_lt, le_abs, le_neg] at hle 
     have hpi' : θ.to_real ≠ π := by simpa using hpi
     rcases hle with (hle | hle) <;> rcases hle.eq_or_lt with (heq | hlt)
-    · rw [← coe_to_real θ, ← HEq] at h; simpa using h
+    · rw [← coe_to_real θ, ← HEq] at h ; simpa using h
     · rw [← sign_to_real hpi, sign_pos (pi_div_two_pos.trans hlt), ← sign_to_real,
-        two_nsmul_to_real_eq_two_mul_sub_two_pi.2 hlt, _root_.sign_neg] at h
+        two_nsmul_to_real_eq_two_mul_sub_two_pi.2 hlt, _root_.sign_neg] at h 
       · simpa using h
       · rw [← mul_sub]
         exact mul_neg_of_pos_of_neg two_pos (sub_neg.2 ((to_real_le_pi _).lt_of_ne hpi'))
       · intro he; simpa [he] using h
-    · rw [← coe_to_real θ, HEq] at h; simpa using h
+    · rw [← coe_to_real θ, HEq] at h ; simpa using h
     · rw [← sign_to_real hpi, _root_.sign_neg (hlt.trans (Left.neg_neg_iff.2 pi_div_two_pos)), ←
-        sign_to_real] at h
+        sign_to_real] at h 
       swap; · intro he; simpa [he] using h
-      rw [← neg_div] at hlt
-      rw [two_nsmul_to_real_eq_two_mul_add_two_pi.2 hlt.le, sign_pos] at h
+      rw [← neg_div] at hlt 
+      rw [two_nsmul_to_real_eq_two_mul_add_two_pi.2 hlt.le, sign_pos] at h 
       · simpa using h
       · linarith [neg_pi_lt_to_real θ]
   · have hpi' : (2 : ℕ) • θ ≠ π :=
@@ -1071,9 +1072,9 @@ theorem sign_two_nsmul_eq_sign_iff {θ : Angle} :
       constructor
       · rintro rfl; simpa [pi_pos, div_pos, abs_of_pos] using h
       · rintro rfl
-        rw [to_real_neg_pi_div_two] at h
+        rw [to_real_neg_pi_div_two] at h 
         simpa [pi_pos, div_pos, neg_div, abs_of_pos] using h
-    rw [abs_lt, ← neg_div] at h
+    rw [abs_lt, ← neg_div] at h 
     rw [← sign_to_real hpi, ← sign_to_real hpi', two_nsmul_to_real_eq_two_mul.2 ⟨h.1, h.2.le⟩,
       sign_mul, sign_pos (zero_lt_two' ℝ), one_mul]
 #align real.angle.sign_two_nsmul_eq_sign_iff Real.Angle.sign_two_nsmul_eq_sign_iff

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -24,7 +24,7 @@ about trigonometric functions and angles.
 -/
 
 
-open Real
+open scoped Real
 
 noncomputable section
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -44,45 +44,21 @@ namespace Angle
 instance : CircularOrder Real.Angle :=
   @AddCircle.circularOrder _ _ _ _ _ ⟨by norm_num [pi_pos] ⟩ _
 
-/- warning: real.angle.continuous_coe -> Real.Angle.continuous_coe is a dubious translation:
-lean 3 declaration is
-  Continuous.{0, 0} Real Real.Angle (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (UniformSpace.toTopologicalSpace.{0} Real.Angle (PseudoMetricSpace.toUniformSpace.{0} Real.Angle (SeminormedAddCommGroup.toPseudoMetricSpace.{0} Real.Angle (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)))
-but is expected to have type
-  Continuous.{0, 0} Real Real.Angle (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (UniformSpace.toTopologicalSpace.{0} Real.Angle (PseudoMetricSpace.toUniformSpace.{0} Real.Angle (SeminormedAddCommGroup.toPseudoMetricSpace.{0} Real.Angle (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))) Real.Angle.coe
-Case conversion may be inaccurate. Consider using '#align real.angle.continuous_coe Real.Angle.continuous_coeₓ'. -/
 @[continuity]
 theorem continuous_coe : Continuous (coe : ℝ → Angle) :=
   continuous_quotient_mk'
 #align real.angle.continuous_coe Real.Angle.continuous_coe
 
-/- warning: real.angle.coe_hom -> Real.Angle.coeHom is a dubious translation:
-lean 3 declaration is
-  AddMonoidHom.{0, 0} Real Real.Angle (AddMonoid.toAddZeroClass.{0} Real Real.addMonoid) (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))
-but is expected to have type
-  AddMonoidHom.{0, 0} Real Real.Angle (AddMonoid.toAddZeroClass.{0} Real Real.instAddMonoidReal) (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))
-Case conversion may be inaccurate. Consider using '#align real.angle.coe_hom Real.Angle.coeHomₓ'. -/
 /-- Coercion `ℝ → angle` as an additive homomorphism. -/
 def coeHom : ℝ →+ Angle :=
   QuotientAddGroup.mk' _
 #align real.angle.coe_hom Real.Angle.coeHom
 
-/- warning: real.angle.coe_coe_hom -> Real.Angle.coe_coeHom is a dubious translation:
-lean 3 declaration is
-  Eq.{1} ((fun (_x : AddMonoidHom.{0, 0} Real Real.Angle (AddMonoid.toAddZeroClass.{0} Real Real.addMonoid) (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))) => Real -> Real.Angle) Real.Angle.coeHom) (coeFn.{1, 1} (AddMonoidHom.{0, 0} Real Real.Angle (AddMonoid.toAddZeroClass.{0} Real Real.addMonoid) (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))) (fun (_x : AddMonoidHom.{0, 0} Real Real.Angle (AddMonoid.toAddZeroClass.{0} Real Real.addMonoid) (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))) => Real -> Real.Angle) (AddMonoidHom.hasCoeToFun.{0, 0} Real Real.Angle (AddMonoid.toAddZeroClass.{0} Real Real.addMonoid) (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))) Real.Angle.coeHom) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)))
-but is expected to have type
-  Eq.{1} (forall (a : Real), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : Real) => Real.Angle) a) (FunLike.coe.{1, 1, 1} (AddMonoidHom.{0, 0} Real Real.Angle (AddMonoid.toAddZeroClass.{0} Real Real.instAddMonoidReal) (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) Real (fun (_x : Real) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : Real) => Real.Angle) _x) (AddHomClass.toFunLike.{0, 0, 0} (AddMonoidHom.{0, 0} Real Real.Angle (AddMonoid.toAddZeroClass.{0} Real Real.instAddMonoidReal) (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) Real Real.Angle (AddZeroClass.toAdd.{0} Real (AddMonoid.toAddZeroClass.{0} Real Real.instAddMonoidReal)) (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (AddMonoidHomClass.toAddHomClass.{0, 0, 0} (AddMonoidHom.{0, 0} Real Real.Angle (AddMonoid.toAddZeroClass.{0} Real Real.instAddMonoidReal) (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) Real Real.Angle (AddMonoid.toAddZeroClass.{0} Real Real.instAddMonoidReal) (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (AddMonoidHom.addMonoidHomClass.{0, 0} Real Real.Angle (AddMonoid.toAddZeroClass.{0} Real Real.instAddMonoidReal) (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))))) Real.Angle.coeHom) Real.Angle.coe
-Case conversion may be inaccurate. Consider using '#align real.angle.coe_coe_hom Real.Angle.coe_coeHomₓ'. -/
 @[simp]
 theorem coe_coeHom : (coeHom : ℝ → Angle) = coe :=
   rfl
 #align real.angle.coe_coe_hom Real.Angle.coe_coeHom
 
-/- warning: real.angle.induction_on -> Real.Angle.induction_on is a dubious translation:
-lean 3 declaration is
-  forall {p : Real.Angle -> Prop} (θ : Real.Angle), (forall (x : Real), p ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) x)) -> (p θ)
-but is expected to have type
-  forall {p : Real.Angle -> Prop} (θ : Real.Angle), (forall (x : Real), p (Real.Angle.coe x)) -> (p θ)
-Case conversion may be inaccurate. Consider using '#align real.angle.induction_on Real.Angle.induction_onₓ'. -/
 /-- An induction principle to deduce results for `angle` from those for `ℝ`, used with
 `induction θ using real.angle.induction_on`. -/
 @[elab_as_elim]
@@ -90,120 +66,54 @@ protected theorem induction_on {p : Angle → Prop} (θ : Angle) (h : ∀ x : 
   Quotient.inductionOn' θ h
 #align real.angle.induction_on Real.Angle.induction_on
 
-/- warning: real.angle.coe_zero -> Real.Angle.coe_zero is a dubious translation:
-lean 3 declaration is
-  Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))
-but is expected to have type
-  Eq.{1} Real.Angle (Real.Angle.coe (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))
-Case conversion may be inaccurate. Consider using '#align real.angle.coe_zero Real.Angle.coe_zeroₓ'. -/
 @[simp]
 theorem coe_zero : ↑(0 : ℝ) = (0 : Angle) :=
   rfl
 #align real.angle.coe_zero Real.Angle.coe_zero
 
-/- warning: real.angle.coe_add -> Real.Angle.coe_add is a dubious translation:
-lean 3 declaration is
-  forall (x : Real) (y : Real), Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) x y)) (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) x) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) y))
-but is expected to have type
-  forall (x : Real) (y : Real), Eq.{1} Real.Angle (Real.Angle.coe (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) x y)) (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) (Real.Angle.coe x) (Real.Angle.coe y))
-Case conversion may be inaccurate. Consider using '#align real.angle.coe_add Real.Angle.coe_addₓ'. -/
 @[simp]
 theorem coe_add (x y : ℝ) : ↑(x + y : ℝ) = (↑x + ↑y : Angle) :=
   rfl
 #align real.angle.coe_add Real.Angle.coe_add
 
-/- warning: real.angle.coe_neg -> Real.Angle.coe_neg is a dubious translation:
-lean 3 declaration is
-  forall (x : Real), Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (Neg.neg.{0} Real Real.hasNeg x)) (Neg.neg.{0} Real.Angle (SubNegMonoid.toHasNeg.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) x))
-but is expected to have type
-  forall (x : Real), Eq.{1} Real.Angle (Real.Angle.coe (Neg.neg.{0} Real Real.instNegReal x)) (Neg.neg.{0} Real.Angle (NegZeroClass.toNeg.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (Real.Angle.coe x))
-Case conversion may be inaccurate. Consider using '#align real.angle.coe_neg Real.Angle.coe_negₓ'. -/
 @[simp]
 theorem coe_neg (x : ℝ) : ↑(-x : ℝ) = -(↑x : Angle) :=
   rfl
 #align real.angle.coe_neg Real.Angle.coe_neg
 
-/- warning: real.angle.coe_sub -> Real.Angle.coe_sub is a dubious translation:
-lean 3 declaration is
-  forall (x : Real) (y : Real), Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) x y)) (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toHasSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) x) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) y))
-but is expected to have type
-  forall (x : Real) (y : Real), Eq.{1} Real.Angle (Real.Angle.coe (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) x y)) (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (Real.Angle.coe x) (Real.Angle.coe y))
-Case conversion may be inaccurate. Consider using '#align real.angle.coe_sub Real.Angle.coe_subₓ'. -/
 @[simp]
 theorem coe_sub (x y : ℝ) : ↑(x - y : ℝ) = (↑x - ↑y : Angle) :=
   rfl
 #align real.angle.coe_sub Real.Angle.coe_sub
 
-/- warning: real.angle.coe_nsmul -> Real.Angle.coe_nsmul is a dubious translation:
-lean 3 declaration is
-  forall (n : Nat) (x : Real), Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (SMul.smul.{0, 0} Nat Real (AddMonoid.SMul.{0} Real Real.addMonoid) n x)) (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) n ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) x))
-but is expected to have type
-  forall (n : Nat) (x : Real), Eq.{1} Real.Angle (Real.Angle.coe (HSMul.hSMul.{0, 0, 0} Nat Real Real (instHSMul.{0, 0} Nat Real (AddMonoid.SMul.{0} Real Real.instAddMonoidReal)) n x)) (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) n (Real.Angle.coe x))
-Case conversion may be inaccurate. Consider using '#align real.angle.coe_nsmul Real.Angle.coe_nsmulₓ'. -/
 theorem coe_nsmul (n : ℕ) (x : ℝ) : ↑(n • x : ℝ) = (n • ↑x : Angle) :=
   rfl
 #align real.angle.coe_nsmul Real.Angle.coe_nsmul
 
-/- warning: real.angle.coe_zsmul -> Real.Angle.coe_zsmul is a dubious translation:
-lean 3 declaration is
-  forall (z : Int) (x : Real), Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (SMul.smul.{0, 0} Int Real (SubNegMonoid.SMulInt.{0} Real (AddGroup.toSubNegMonoid.{0} Real Real.addGroup)) z x)) (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) z ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) x))
-but is expected to have type
-  forall (z : Int) (x : Real), Eq.{1} Real.Angle (Real.Angle.coe (HSMul.hSMul.{0, 0, 0} Int Real Real (instHSMul.{0, 0} Int Real (SubNegMonoid.SMulInt.{0} Real (AddGroup.toSubNegMonoid.{0} Real Real.instAddGroupReal))) z x)) (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) z (Real.Angle.coe x))
-Case conversion may be inaccurate. Consider using '#align real.angle.coe_zsmul Real.Angle.coe_zsmulₓ'. -/
 theorem coe_zsmul (z : ℤ) (x : ℝ) : ↑(z • x : ℝ) = (z • ↑x : Angle) :=
   rfl
 #align real.angle.coe_zsmul Real.Angle.coe_zsmul
 
-/- warning: real.angle.coe_nat_mul_eq_nsmul -> Real.Angle.coe_nat_mul_eq_nsmul is a dubious translation:
-lean 3 declaration is
-  forall (x : Real) (n : Nat), Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Real (HasLiftT.mk.{1, 1} Nat Real (CoeTCₓ.coe.{1, 1} Nat Real (Nat.castCoe.{0} Real Real.hasNatCast))) n) x)) (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) n ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) x))
-but is expected to have type
-  forall (x : Real) (n : Nat), Eq.{1} Real.Angle (Real.Angle.coe (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Nat.cast.{0} Real Real.natCast n) x)) (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) n (Real.Angle.coe x))
-Case conversion may be inaccurate. Consider using '#align real.angle.coe_nat_mul_eq_nsmul Real.Angle.coe_nat_mul_eq_nsmulₓ'. -/
 @[simp, norm_cast]
 theorem coe_nat_mul_eq_nsmul (x : ℝ) (n : ℕ) : ↑((n : ℝ) * x) = n • (↑x : Angle) := by
   simpa only [nsmul_eq_mul] using coe_hom.map_nsmul x n
 #align real.angle.coe_nat_mul_eq_nsmul Real.Angle.coe_nat_mul_eq_nsmul
 
-/- warning: real.angle.coe_int_mul_eq_zsmul -> Real.Angle.coe_int_mul_eq_zsmul is a dubious translation:
-lean 3 declaration is
-  forall (x : Real) (n : Int), Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Int Real (HasLiftT.mk.{1, 1} Int Real (CoeTCₓ.coe.{1, 1} Int Real (Int.castCoe.{0} Real Real.hasIntCast))) n) x)) (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) n ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) x))
-but is expected to have type
-  forall (x : Real) (n : Int), Eq.{1} Real.Angle (Real.Angle.coe (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Int.cast.{0} Real Real.intCast n) x)) (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) n (Real.Angle.coe x))
-Case conversion may be inaccurate. Consider using '#align real.angle.coe_int_mul_eq_zsmul Real.Angle.coe_int_mul_eq_zsmulₓ'. -/
 @[simp, norm_cast]
 theorem coe_int_mul_eq_zsmul (x : ℝ) (n : ℤ) : ↑((n : ℝ) * x : ℝ) = n • (↑x : Angle) := by
   simpa only [zsmul_eq_mul] using coe_hom.map_zsmul x n
 #align real.angle.coe_int_mul_eq_zsmul Real.Angle.coe_int_mul_eq_zsmul
 
-/- warning: real.angle.angle_eq_iff_two_pi_dvd_sub -> Real.Angle.angle_eq_iff_two_pi_dvd_sub is a dubious translation:
-lean 3 declaration is
-  forall {ψ : Real} {θ : Real}, Iff (Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) ψ)) (Exists.{1} Int (fun (k : Int) => Eq.{1} Real (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) θ ψ) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Int Real (HasLiftT.mk.{1, 1} Int Real (CoeTCₓ.coe.{1, 1} Int Real (Int.castCoe.{0} Real Real.hasIntCast))) k))))
-but is expected to have type
-  forall {ψ : Real} {θ : Real}, Iff (Eq.{1} Real.Angle (Real.Angle.coe θ) (Real.Angle.coe ψ)) (Exists.{1} Int (fun (k : Int) => Eq.{1} Real (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) θ ψ) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi) (Int.cast.{0} Real Real.intCast k))))
-Case conversion may be inaccurate. Consider using '#align real.angle.angle_eq_iff_two_pi_dvd_sub Real.Angle.angle_eq_iff_two_pi_dvd_subₓ'. -/
 theorem angle_eq_iff_two_pi_dvd_sub {ψ θ : ℝ} : (θ : Angle) = ψ ↔ ∃ k : ℤ, θ - ψ = 2 * π * k := by
   simp only [QuotientAddGroup.eq, AddSubgroup.zmultiples_eq_closure,
     AddSubgroup.mem_closure_singleton, zsmul_eq_mul', (sub_eq_neg_add _ _).symm, eq_comm]
 #align real.angle.angle_eq_iff_two_pi_dvd_sub Real.Angle.angle_eq_iff_two_pi_dvd_sub
 
-/- warning: real.angle.coe_two_pi -> Real.Angle.coe_two_pi is a dubious translation:
-lean 3 declaration is
-  Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi)) (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))
-but is expected to have type
-  Eq.{1} Real.Angle (Real.Angle.coe (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi)) (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))
-Case conversion may be inaccurate. Consider using '#align real.angle.coe_two_pi Real.Angle.coe_two_piₓ'. -/
 @[simp]
 theorem coe_two_pi : ↑(2 * π : ℝ) = (0 : Angle) :=
   angle_eq_iff_two_pi_dvd_sub.2 ⟨1, by rw [sub_zero, Int.cast_one, mul_one]⟩
 #align real.angle.coe_two_pi Real.Angle.coe_two_pi
 
-/- warning: real.angle.neg_coe_pi -> Real.Angle.neg_coe_pi is a dubious translation:
-lean 3 declaration is
-  Eq.{1} Real.Angle (Neg.neg.{0} Real.Angle (SubNegMonoid.toHasNeg.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)
-but is expected to have type
-  Eq.{1} Real.Angle (Neg.neg.{0} Real.Angle (NegZeroClass.toNeg.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (Real.Angle.coe Real.pi)) (Real.Angle.coe Real.pi)
-Case conversion may be inaccurate. Consider using '#align real.angle.neg_coe_pi Real.Angle.neg_coe_piₓ'. -/
 @[simp]
 theorem neg_coe_pi : -(π : Angle) = π :=
   by
@@ -212,218 +122,92 @@ theorem neg_coe_pi : -(π : Angle) = π :=
   simp [two_mul, sub_eq_add_neg]
 #align real.angle.neg_coe_pi Real.Angle.neg_coe_pi
 
-/- warning: real.angle.two_nsmul_coe_div_two -> Real.Angle.two_nsmul_coe_div_two is a dubious translation:
-lean 3 declaration is
-  forall (θ : Real), Eq.{1} Real.Angle (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) θ (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ)
-but is expected to have type
-  forall (θ : Real), Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) θ (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))) (Real.Angle.coe θ)
-Case conversion may be inaccurate. Consider using '#align real.angle.two_nsmul_coe_div_two Real.Angle.two_nsmul_coe_div_twoₓ'. -/
 @[simp]
 theorem two_nsmul_coe_div_two (θ : ℝ) : (2 : ℕ) • (↑(θ / 2) : Angle) = θ := by
   rw [← coe_nsmul, two_nsmul, add_halves]
 #align real.angle.two_nsmul_coe_div_two Real.Angle.two_nsmul_coe_div_two
 
-/- warning: real.angle.two_zsmul_coe_div_two -> Real.Angle.two_zsmul_coe_div_two is a dubious translation:
-lean 3 declaration is
-  forall (θ : Real), Eq.{1} Real.Angle (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) θ (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ)
-but is expected to have type
-  forall (θ : Real), Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) θ (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))) (Real.Angle.coe θ)
-Case conversion may be inaccurate. Consider using '#align real.angle.two_zsmul_coe_div_two Real.Angle.two_zsmul_coe_div_twoₓ'. -/
 @[simp]
 theorem two_zsmul_coe_div_two (θ : ℝ) : (2 : ℤ) • (↑(θ / 2) : Angle) = θ := by
   rw [← coe_zsmul, two_zsmul, add_halves]
 #align real.angle.two_zsmul_coe_div_two Real.Angle.two_zsmul_coe_div_two
 
-/- warning: real.angle.two_nsmul_neg_pi_div_two -> Real.Angle.two_nsmul_neg_pi_div_two is a dubious translation:
-lean 3 declaration is
-  Eq.{1} Real.Angle (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Neg.neg.{0} Real Real.hasNeg Real.pi) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)
-but is expected to have type
-  Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Neg.neg.{0} Real Real.instNegReal Real.pi) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))) (Real.Angle.coe Real.pi)
-Case conversion may be inaccurate. Consider using '#align real.angle.two_nsmul_neg_pi_div_two Real.Angle.two_nsmul_neg_pi_div_twoₓ'. -/
 @[simp]
 theorem two_nsmul_neg_pi_div_two : (2 : ℕ) • (↑(-π / 2) : Angle) = π := by
   rw [two_nsmul_coe_div_two, coe_neg, neg_coe_pi]
 #align real.angle.two_nsmul_neg_pi_div_two Real.Angle.two_nsmul_neg_pi_div_two
 
-/- warning: real.angle.two_zsmul_neg_pi_div_two -> Real.Angle.two_zsmul_neg_pi_div_two is a dubious translation:
-lean 3 declaration is
-  Eq.{1} Real.Angle (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Neg.neg.{0} Real Real.hasNeg Real.pi) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)
-but is expected to have type
-  Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Neg.neg.{0} Real Real.instNegReal Real.pi) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))) (Real.Angle.coe Real.pi)
-Case conversion may be inaccurate. Consider using '#align real.angle.two_zsmul_neg_pi_div_two Real.Angle.two_zsmul_neg_pi_div_twoₓ'. -/
 @[simp]
 theorem two_zsmul_neg_pi_div_two : (2 : ℤ) • (↑(-π / 2) : Angle) = π := by
   rw [two_zsmul, ← two_nsmul, two_nsmul_neg_pi_div_two]
 #align real.angle.two_zsmul_neg_pi_div_two Real.Angle.two_zsmul_neg_pi_div_two
 
-/- warning: real.angle.sub_coe_pi_eq_add_coe_pi -> Real.Angle.sub_coe_pi_eq_add_coe_pi is a dubious translation:
-lean 3 declaration is
-  forall (θ : Real.Angle), Eq.{1} Real.Angle (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toHasSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi))
-but is expected to have type
-  forall (θ : Real.Angle), Eq.{1} Real.Angle (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) θ (Real.Angle.coe Real.pi)) (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) θ (Real.Angle.coe Real.pi))
-Case conversion may be inaccurate. Consider using '#align real.angle.sub_coe_pi_eq_add_coe_pi Real.Angle.sub_coe_pi_eq_add_coe_piₓ'. -/
 theorem sub_coe_pi_eq_add_coe_pi (θ : Angle) : θ - π = θ + π := by rw [sub_eq_add_neg, neg_coe_pi]
 #align real.angle.sub_coe_pi_eq_add_coe_pi Real.Angle.sub_coe_pi_eq_add_coe_pi
 
-/- warning: real.angle.two_nsmul_coe_pi -> Real.Angle.two_nsmul_coe_pi is a dubious translation:
-lean 3 declaration is
-  Eq.{1} Real.Angle (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))
-but is expected to have type
-  Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) (Real.Angle.coe Real.pi)) (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))
-Case conversion may be inaccurate. Consider using '#align real.angle.two_nsmul_coe_pi Real.Angle.two_nsmul_coe_piₓ'. -/
 @[simp]
 theorem two_nsmul_coe_pi : (2 : ℕ) • (π : Angle) = 0 := by simp [← coe_nat_mul_eq_nsmul]
 #align real.angle.two_nsmul_coe_pi Real.Angle.two_nsmul_coe_pi
 
-/- warning: real.angle.two_zsmul_coe_pi -> Real.Angle.two_zsmul_coe_pi is a dubious translation:
-lean 3 declaration is
-  Eq.{1} Real.Angle (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))
-but is expected to have type
-  Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) (Real.Angle.coe Real.pi)) (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))
-Case conversion may be inaccurate. Consider using '#align real.angle.two_zsmul_coe_pi Real.Angle.two_zsmul_coe_piₓ'. -/
 @[simp]
 theorem two_zsmul_coe_pi : (2 : ℤ) • (π : Angle) = 0 := by simp [← coe_int_mul_eq_zsmul]
 #align real.angle.two_zsmul_coe_pi Real.Angle.two_zsmul_coe_pi
 
-/- warning: real.angle.coe_pi_add_coe_pi -> Real.Angle.coe_pi_add_coe_pi is a dubious translation:
-lean 3 declaration is
-  Eq.{1} Real.Angle (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))
-but is expected to have type
-  Eq.{1} Real.Angle (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) (Real.Angle.coe Real.pi) (Real.Angle.coe Real.pi)) (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))
-Case conversion may be inaccurate. Consider using '#align real.angle.coe_pi_add_coe_pi Real.Angle.coe_pi_add_coe_piₓ'. -/
 @[simp]
 theorem coe_pi_add_coe_pi : (π : Real.Angle) + π = 0 := by rw [← two_nsmul, two_nsmul_coe_pi]
 #align real.angle.coe_pi_add_coe_pi Real.Angle.coe_pi_add_coe_pi
 
-/- warning: real.angle.zsmul_eq_iff -> Real.Angle.zsmul_eq_iff is a dubious translation:
-lean 3 declaration is
-  forall {ψ : Real.Angle} {θ : Real.Angle} {z : Int}, (Ne.{1} Int z (OfNat.ofNat.{0} Int 0 (OfNat.mk.{0} Int 0 (Zero.zero.{0} Int Int.hasZero)))) -> (Iff (Eq.{1} Real.Angle (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) z ψ) (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) z θ)) (Exists.{1} (Fin (Int.natAbs z)) (fun (k : Fin (Int.natAbs z)) => Eq.{1} Real.Angle ψ (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) θ (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Fin (Int.natAbs z)) Nat (HasLiftT.mk.{1, 1} (Fin (Int.natAbs z)) Nat (CoeTCₓ.coe.{1, 1} (Fin (Int.natAbs z)) Nat (coeBase.{1, 1} (Fin (Int.natAbs z)) Nat (Fin.coeToNat (Int.natAbs z))))) k) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Int Real (HasLiftT.mk.{1, 1} Int Real (CoeTCₓ.coe.{1, 1} Int Real (Int.castCoe.{0} Real Real.hasIntCast))) z))))))))
-but is expected to have type
-  forall {ψ : Real.Angle} {θ : Real.Angle} {z : Int}, (Ne.{1} Int z (OfNat.ofNat.{0} Int 0 (instOfNatInt 0))) -> (Iff (Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) z ψ) (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) z θ)) (Exists.{1} (Fin (Int.natAbs z)) (fun (k : Fin (Int.natAbs z)) => Eq.{1} Real.Angle ψ (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) θ (Real.Angle.coe (HSMul.hSMul.{0, 0, 0} Nat Real Real (instHSMul.{0, 0} Nat Real (AddMonoid.SMul.{0} Real Real.instAddMonoidReal)) (Fin.val (Int.natAbs z) k) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi) (Int.cast.{0} Real Real.intCast z))))))))
-Case conversion may be inaccurate. Consider using '#align real.angle.zsmul_eq_iff Real.Angle.zsmul_eq_iffₓ'. -/
 theorem zsmul_eq_iff {ψ θ : Angle} {z : ℤ} (hz : z ≠ 0) :
     z • ψ = z • θ ↔ ∃ k : Fin z.natAbs, ψ = θ + (k : ℕ) • (2 * π / z : ℝ) :=
   QuotientAddGroup.zmultiples_zsmul_eq_zsmul_iff hz
 #align real.angle.zsmul_eq_iff Real.Angle.zsmul_eq_iff
 
-/- warning: real.angle.nsmul_eq_iff -> Real.Angle.nsmul_eq_iff is a dubious translation:
-lean 3 declaration is
-  forall {ψ : Real.Angle} {θ : Real.Angle} {n : Nat}, (Ne.{1} Nat n (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) -> (Iff (Eq.{1} Real.Angle (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) n ψ) (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) n θ)) (Exists.{1} (Fin n) (fun (k : Fin n) => Eq.{1} Real.Angle ψ (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) θ (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Fin n) Nat (HasLiftT.mk.{1, 1} (Fin n) Nat (CoeTCₓ.coe.{1, 1} (Fin n) Nat (coeBase.{1, 1} (Fin n) Nat (Fin.coeToNat n)))) k) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Real (HasLiftT.mk.{1, 1} Nat Real (CoeTCₓ.coe.{1, 1} Nat Real (Nat.castCoe.{0} Real Real.hasNatCast))) n))))))))
-but is expected to have type
-  forall {ψ : Real.Angle} {θ : Real.Angle} {n : Nat}, (Ne.{1} Nat n (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) -> (Iff (Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) n ψ) (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) n θ)) (Exists.{1} (Fin n) (fun (k : Fin n) => Eq.{1} Real.Angle ψ (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) θ (Real.Angle.coe (HSMul.hSMul.{0, 0, 0} Nat Real Real (instHSMul.{0, 0} Nat Real (AddMonoid.SMul.{0} Real Real.instAddMonoidReal)) (Fin.val n k) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi) (Nat.cast.{0} Real Real.natCast n))))))))
-Case conversion may be inaccurate. Consider using '#align real.angle.nsmul_eq_iff Real.Angle.nsmul_eq_iffₓ'. -/
 theorem nsmul_eq_iff {ψ θ : Angle} {n : ℕ} (hz : n ≠ 0) :
     n • ψ = n • θ ↔ ∃ k : Fin n, ψ = θ + (k : ℕ) • (2 * π / n : ℝ) :=
   QuotientAddGroup.zmultiples_nsmul_eq_nsmul_iff hz
 #align real.angle.nsmul_eq_iff Real.Angle.nsmul_eq_iff
 
-/- warning: real.angle.two_zsmul_eq_iff -> Real.Angle.two_zsmul_eq_iff is a dubious translation:
-lean 3 declaration is
-  forall {ψ : Real.Angle} {θ : Real.Angle}, Iff (Eq.{1} Real.Angle (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) ψ) (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) θ)) (Or (Eq.{1} Real.Angle ψ θ) (Eq.{1} Real.Angle ψ (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi))))
-but is expected to have type
-  forall {ψ : Real.Angle} {θ : Real.Angle}, Iff (Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) ψ) (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) θ)) (Or (Eq.{1} Real.Angle ψ θ) (Eq.{1} Real.Angle ψ (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) θ (Real.Angle.coe Real.pi))))
-Case conversion may be inaccurate. Consider using '#align real.angle.two_zsmul_eq_iff Real.Angle.two_zsmul_eq_iffₓ'. -/
 theorem two_zsmul_eq_iff {ψ θ : Angle} : (2 : ℤ) • ψ = (2 : ℤ) • θ ↔ ψ = θ ∨ ψ = θ + π := by
   rw [zsmul_eq_iff two_ne_zero, Int.natAbs_bit0, Int.natAbs_one, Fin.exists_fin_two, Fin.val_zero,
     Fin.val_one, zero_smul, add_zero, one_smul, Int.cast_two,
     mul_div_cancel_left (_ : ℝ) two_ne_zero]
 #align real.angle.two_zsmul_eq_iff Real.Angle.two_zsmul_eq_iff
 
-/- warning: real.angle.two_nsmul_eq_iff -> Real.Angle.two_nsmul_eq_iff is a dubious translation:
-lean 3 declaration is
-  forall {ψ : Real.Angle} {θ : Real.Angle}, Iff (Eq.{1} Real.Angle (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) ψ) (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) θ)) (Or (Eq.{1} Real.Angle ψ θ) (Eq.{1} Real.Angle ψ (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi))))
-but is expected to have type
-  forall {ψ : Real.Angle} {θ : Real.Angle}, Iff (Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) ψ) (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) θ)) (Or (Eq.{1} Real.Angle ψ θ) (Eq.{1} Real.Angle ψ (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) θ (Real.Angle.coe Real.pi))))
-Case conversion may be inaccurate. Consider using '#align real.angle.two_nsmul_eq_iff Real.Angle.two_nsmul_eq_iffₓ'. -/
 theorem two_nsmul_eq_iff {ψ θ : Angle} : (2 : ℕ) • ψ = (2 : ℕ) • θ ↔ ψ = θ ∨ ψ = θ + π := by
   simp_rw [← coe_nat_zsmul, Int.ofNat_bit0, Int.ofNat_one, two_zsmul_eq_iff]
 #align real.angle.two_nsmul_eq_iff Real.Angle.two_nsmul_eq_iff
 
-/- warning: real.angle.two_nsmul_eq_zero_iff -> Real.Angle.two_nsmul_eq_zero_iff is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real.Angle (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) θ) (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (Or (Eq.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)))
-but is expected to have type
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) θ) (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (Or (Eq.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (Eq.{1} Real.Angle θ (Real.Angle.coe Real.pi)))
-Case conversion may be inaccurate. Consider using '#align real.angle.two_nsmul_eq_zero_iff Real.Angle.two_nsmul_eq_zero_iffₓ'. -/
 theorem two_nsmul_eq_zero_iff {θ : Angle} : (2 : ℕ) • θ = 0 ↔ θ = 0 ∨ θ = π := by
   convert two_nsmul_eq_iff <;> simp
 #align real.angle.two_nsmul_eq_zero_iff Real.Angle.two_nsmul_eq_zero_iff
 
-/- warning: real.angle.two_nsmul_ne_zero_iff -> Real.Angle.two_nsmul_ne_zero_iff is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, Iff (Ne.{1} Real.Angle (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) θ) (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (And (Ne.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (Ne.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)))
-but is expected to have type
-  forall {θ : Real.Angle}, Iff (Ne.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) θ) (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (And (Ne.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (Ne.{1} Real.Angle θ (Real.Angle.coe Real.pi)))
-Case conversion may be inaccurate. Consider using '#align real.angle.two_nsmul_ne_zero_iff Real.Angle.two_nsmul_ne_zero_iffₓ'. -/
 theorem two_nsmul_ne_zero_iff {θ : Angle} : (2 : ℕ) • θ ≠ 0 ↔ θ ≠ 0 ∧ θ ≠ π := by
   rw [← not_or, ← two_nsmul_eq_zero_iff]
 #align real.angle.two_nsmul_ne_zero_iff Real.Angle.two_nsmul_ne_zero_iff
 
-/- warning: real.angle.two_zsmul_eq_zero_iff -> Real.Angle.two_zsmul_eq_zero_iff is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real.Angle (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) θ) (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (Or (Eq.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)))
-but is expected to have type
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) θ) (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (Or (Eq.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (Eq.{1} Real.Angle θ (Real.Angle.coe Real.pi)))
-Case conversion may be inaccurate. Consider using '#align real.angle.two_zsmul_eq_zero_iff Real.Angle.two_zsmul_eq_zero_iffₓ'. -/
 theorem two_zsmul_eq_zero_iff {θ : Angle} : (2 : ℤ) • θ = 0 ↔ θ = 0 ∨ θ = π := by
   simp_rw [two_zsmul, ← two_nsmul, two_nsmul_eq_zero_iff]
 #align real.angle.two_zsmul_eq_zero_iff Real.Angle.two_zsmul_eq_zero_iff
 
-/- warning: real.angle.two_zsmul_ne_zero_iff -> Real.Angle.two_zsmul_ne_zero_iff is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, Iff (Ne.{1} Real.Angle (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) θ) (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (And (Ne.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (Ne.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)))
-but is expected to have type
-  forall {θ : Real.Angle}, Iff (Ne.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) θ) (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (And (Ne.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (Ne.{1} Real.Angle θ (Real.Angle.coe Real.pi)))
-Case conversion may be inaccurate. Consider using '#align real.angle.two_zsmul_ne_zero_iff Real.Angle.two_zsmul_ne_zero_iffₓ'. -/
 theorem two_zsmul_ne_zero_iff {θ : Angle} : (2 : ℤ) • θ ≠ 0 ↔ θ ≠ 0 ∧ θ ≠ π := by
   rw [← not_or, ← two_zsmul_eq_zero_iff]
 #align real.angle.two_zsmul_ne_zero_iff Real.Angle.two_zsmul_ne_zero_iff
 
-/- warning: real.angle.eq_neg_self_iff -> Real.Angle.eq_neg_self_iff is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real.Angle θ (Neg.neg.{0} Real.Angle (SubNegMonoid.toHasNeg.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) θ)) (Or (Eq.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)))
-but is expected to have type
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real.Angle θ (Neg.neg.{0} Real.Angle (NegZeroClass.toNeg.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) θ)) (Or (Eq.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (Eq.{1} Real.Angle θ (Real.Angle.coe Real.pi)))
-Case conversion may be inaccurate. Consider using '#align real.angle.eq_neg_self_iff Real.Angle.eq_neg_self_iffₓ'. -/
 theorem eq_neg_self_iff {θ : Angle} : θ = -θ ↔ θ = 0 ∨ θ = π := by
   rw [← add_eq_zero_iff_eq_neg, ← two_nsmul, two_nsmul_eq_zero_iff]
 #align real.angle.eq_neg_self_iff Real.Angle.eq_neg_self_iff
 
-/- warning: real.angle.ne_neg_self_iff -> Real.Angle.ne_neg_self_iff is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, Iff (Ne.{1} Real.Angle θ (Neg.neg.{0} Real.Angle (SubNegMonoid.toHasNeg.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) θ)) (And (Ne.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (Ne.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)))
-but is expected to have type
-  forall {θ : Real.Angle}, Iff (Ne.{1} Real.Angle θ (Neg.neg.{0} Real.Angle (NegZeroClass.toNeg.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) θ)) (And (Ne.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (Ne.{1} Real.Angle θ (Real.Angle.coe Real.pi)))
-Case conversion may be inaccurate. Consider using '#align real.angle.ne_neg_self_iff Real.Angle.ne_neg_self_iffₓ'. -/
 theorem ne_neg_self_iff {θ : Angle} : θ ≠ -θ ↔ θ ≠ 0 ∧ θ ≠ π := by
   rw [← not_or, ← eq_neg_self_iff.not]
 #align real.angle.ne_neg_self_iff Real.Angle.ne_neg_self_iff
 
-/- warning: real.angle.neg_eq_self_iff -> Real.Angle.neg_eq_self_iff is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real.Angle (Neg.neg.{0} Real.Angle (SubNegMonoid.toHasNeg.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) θ) θ) (Or (Eq.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)))
-but is expected to have type
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real.Angle (Neg.neg.{0} Real.Angle (NegZeroClass.toNeg.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) θ) θ) (Or (Eq.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (Eq.{1} Real.Angle θ (Real.Angle.coe Real.pi)))
-Case conversion may be inaccurate. Consider using '#align real.angle.neg_eq_self_iff Real.Angle.neg_eq_self_iffₓ'. -/
 theorem neg_eq_self_iff {θ : Angle} : -θ = θ ↔ θ = 0 ∨ θ = π := by rw [eq_comm, eq_neg_self_iff]
 #align real.angle.neg_eq_self_iff Real.Angle.neg_eq_self_iff
 
-/- warning: real.angle.neg_ne_self_iff -> Real.Angle.neg_ne_self_iff is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, Iff (Ne.{1} Real.Angle (Neg.neg.{0} Real.Angle (SubNegMonoid.toHasNeg.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) θ) θ) (And (Ne.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (Ne.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)))
-but is expected to have type
-  forall {θ : Real.Angle}, Iff (Ne.{1} Real.Angle (Neg.neg.{0} Real.Angle (NegZeroClass.toNeg.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) θ) θ) (And (Ne.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (Ne.{1} Real.Angle θ (Real.Angle.coe Real.pi)))
-Case conversion may be inaccurate. Consider using '#align real.angle.neg_ne_self_iff Real.Angle.neg_ne_self_iffₓ'. -/
 theorem neg_ne_self_iff {θ : Angle} : -θ ≠ θ ↔ θ ≠ 0 ∧ θ ≠ π := by
   rw [← not_or, ← neg_eq_self_iff.not]
 #align real.angle.neg_ne_self_iff Real.Angle.neg_ne_self_iff
 
-/- warning: real.angle.two_nsmul_eq_pi_iff -> Real.Angle.two_nsmul_eq_pi_iff is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real.Angle (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) θ) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) (Or (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))) (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Neg.neg.{0} Real Real.hasNeg Real.pi) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))))
-but is expected to have type
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) θ) (Real.Angle.coe Real.pi)) (Or (Eq.{1} Real.Angle θ (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))) (Eq.{1} Real.Angle θ (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Neg.neg.{0} Real Real.instNegReal Real.pi) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))))
-Case conversion may be inaccurate. Consider using '#align real.angle.two_nsmul_eq_pi_iff Real.Angle.two_nsmul_eq_pi_iffₓ'. -/
 theorem two_nsmul_eq_pi_iff {θ : Angle} : (2 : ℕ) • θ = π ↔ θ = (π / 2 : ℝ) ∨ θ = (-π / 2 : ℝ) :=
   by
   have h : (π : angle) = (2 : ℕ) • (π / 2 : ℝ) := by rw [two_nsmul, ← coe_add, add_halves]
@@ -434,22 +218,10 @@ theorem two_nsmul_eq_pi_iff {θ : Angle} : (2 : ℕ) • θ = π ↔ θ = (π /
     add_halves, ← two_mul, coe_two_pi]
 #align real.angle.two_nsmul_eq_pi_iff Real.Angle.two_nsmul_eq_pi_iff
 
-/- warning: real.angle.two_zsmul_eq_pi_iff -> Real.Angle.two_zsmul_eq_pi_iff is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real.Angle (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) θ) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) (Or (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))) (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Neg.neg.{0} Real Real.hasNeg Real.pi) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))))
-but is expected to have type
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) θ) (Real.Angle.coe Real.pi)) (Or (Eq.{1} Real.Angle θ (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))) (Eq.{1} Real.Angle θ (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Neg.neg.{0} Real Real.instNegReal Real.pi) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))))
-Case conversion may be inaccurate. Consider using '#align real.angle.two_zsmul_eq_pi_iff Real.Angle.two_zsmul_eq_pi_iffₓ'. -/
 theorem two_zsmul_eq_pi_iff {θ : Angle} : (2 : ℤ) • θ = π ↔ θ = (π / 2 : ℝ) ∨ θ = (-π / 2 : ℝ) := by
   rw [two_zsmul, ← two_nsmul, two_nsmul_eq_pi_iff]
 #align real.angle.two_zsmul_eq_pi_iff Real.Angle.two_zsmul_eq_pi_iff
 
-/- warning: real.angle.cos_eq_iff_coe_eq_or_eq_neg -> Real.Angle.cos_eq_iff_coe_eq_or_eq_neg is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real} {ψ : Real}, Iff (Eq.{1} Real (Real.cos θ) (Real.cos ψ)) (Or (Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) ψ)) (Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ) (Neg.neg.{0} Real.Angle (SubNegMonoid.toHasNeg.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) ψ))))
-but is expected to have type
-  forall {θ : Real} {ψ : Real}, Iff (Eq.{1} Real (Real.cos θ) (Real.cos ψ)) (Or (Eq.{1} Real.Angle (Real.Angle.coe θ) (Real.Angle.coe ψ)) (Eq.{1} Real.Angle (Real.Angle.coe θ) (Neg.neg.{0} Real.Angle (NegZeroClass.toNeg.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (Real.Angle.coe ψ))))
-Case conversion may be inaccurate. Consider using '#align real.angle.cos_eq_iff_coe_eq_or_eq_neg Real.Angle.cos_eq_iff_coe_eq_or_eq_negₓ'. -/
 theorem cos_eq_iff_coe_eq_or_eq_neg {θ ψ : ℝ} :
     cos θ = cos ψ ↔ (θ : Angle) = ψ ∨ (θ : Angle) = -ψ :=
   by
@@ -475,12 +247,6 @@ theorem cos_eq_iff_coe_eq_or_eq_neg {θ ψ : ℝ} :
       MulZeroClass.zero_mul]
 #align real.angle.cos_eq_iff_coe_eq_or_eq_neg Real.Angle.cos_eq_iff_coe_eq_or_eq_neg
 
-/- warning: real.angle.sin_eq_iff_coe_eq_or_add_eq_pi -> Real.Angle.sin_eq_iff_coe_eq_or_add_eq_pi is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real} {ψ : Real}, Iff (Eq.{1} Real (Real.sin θ) (Real.sin ψ)) (Or (Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) ψ)) (Eq.{1} Real.Angle (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) ψ)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)))
-but is expected to have type
-  forall {θ : Real} {ψ : Real}, Iff (Eq.{1} Real (Real.sin θ) (Real.sin ψ)) (Or (Eq.{1} Real.Angle (Real.Angle.coe θ) (Real.Angle.coe ψ)) (Eq.{1} Real.Angle (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) (Real.Angle.coe θ) (Real.Angle.coe ψ)) (Real.Angle.coe Real.pi)))
-Case conversion may be inaccurate. Consider using '#align real.angle.sin_eq_iff_coe_eq_or_add_eq_pi Real.Angle.sin_eq_iff_coe_eq_or_add_eq_piₓ'. -/
 theorem sin_eq_iff_coe_eq_or_add_eq_pi {θ ψ : ℝ} :
     sin θ = sin ψ ↔ (θ : Angle) = ψ ∨ (θ : Angle) + ψ = π :=
   by
@@ -504,12 +270,6 @@ theorem sin_eq_iff_coe_eq_or_add_eq_pi {θ ψ : ℝ} :
       MulZeroClass.mul_zero]
 #align real.angle.sin_eq_iff_coe_eq_or_add_eq_pi Real.Angle.sin_eq_iff_coe_eq_or_add_eq_pi
 
-/- warning: real.angle.cos_sin_inj -> Real.Angle.cos_sin_inj is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real} {ψ : Real}, (Eq.{1} Real (Real.cos θ) (Real.cos ψ)) -> (Eq.{1} Real (Real.sin θ) (Real.sin ψ)) -> (Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) ψ))
-but is expected to have type
-  forall {θ : Real} {ψ : Real}, (Eq.{1} Real (Real.cos θ) (Real.cos ψ)) -> (Eq.{1} Real (Real.sin θ) (Real.sin ψ)) -> (Eq.{1} Real.Angle (Real.Angle.coe θ) (Real.Angle.coe ψ))
-Case conversion may be inaccurate. Consider using '#align real.angle.cos_sin_inj Real.Angle.cos_sin_injₓ'. -/
 theorem cos_sin_inj {θ ψ : ℝ} (Hcos : cos θ = cos ψ) (Hsin : sin θ = sin ψ) : (θ : Angle) = ψ :=
   by
   cases' cos_eq_iff_coe_eq_or_eq_neg.mp Hcos with hc hc; · exact hc
@@ -531,23 +291,11 @@ def sin (θ : Angle) : ℝ :=
 #align real.angle.sin Real.Angle.sin
 -/
 
-/- warning: real.angle.sin_coe -> Real.Angle.sin_coe is a dubious translation:
-lean 3 declaration is
-  forall (x : Real), Eq.{1} Real (Real.Angle.sin ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) x)) (Real.sin x)
-but is expected to have type
-  forall (x : Real), Eq.{1} Real (Real.Angle.sin (Real.Angle.coe x)) (Real.sin x)
-Case conversion may be inaccurate. Consider using '#align real.angle.sin_coe Real.Angle.sin_coeₓ'. -/
 @[simp]
 theorem sin_coe (x : ℝ) : sin (x : Angle) = Real.sin x :=
   rfl
 #align real.angle.sin_coe Real.Angle.sin_coe
 
-/- warning: real.angle.continuous_sin -> Real.Angle.continuous_sin is a dubious translation:
-lean 3 declaration is
-  Continuous.{0, 0} Real.Angle Real (UniformSpace.toTopologicalSpace.{0} Real.Angle (PseudoMetricSpace.toUniformSpace.{0} Real.Angle (SeminormedAddCommGroup.toPseudoMetricSpace.{0} Real.Angle (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) Real.Angle.sin
-but is expected to have type
-  Continuous.{0, 0} Real.Angle Real (UniformSpace.toTopologicalSpace.{0} Real.Angle (PseudoMetricSpace.toUniformSpace.{0} Real.Angle (SeminormedAddCommGroup.toPseudoMetricSpace.{0} Real.Angle (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))) (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) Real.Angle.sin
-Case conversion may be inaccurate. Consider using '#align real.angle.continuous_sin Real.Angle.continuous_sinₓ'. -/
 @[continuity]
 theorem continuous_sin : Continuous sin :=
   Real.continuous_sin.quotient_liftOn' _
@@ -560,34 +308,16 @@ def cos (θ : Angle) : ℝ :=
 #align real.angle.cos Real.Angle.cos
 -/
 
-/- warning: real.angle.cos_coe -> Real.Angle.cos_coe is a dubious translation:
-lean 3 declaration is
-  forall (x : Real), Eq.{1} Real (Real.Angle.cos ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) x)) (Real.cos x)
-but is expected to have type
-  forall (x : Real), Eq.{1} Real (Real.Angle.cos (Real.Angle.coe x)) (Real.cos x)
-Case conversion may be inaccurate. Consider using '#align real.angle.cos_coe Real.Angle.cos_coeₓ'. -/
 @[simp]
 theorem cos_coe (x : ℝ) : cos (x : Angle) = Real.cos x :=
   rfl
 #align real.angle.cos_coe Real.Angle.cos_coe
 
-/- warning: real.angle.continuous_cos -> Real.Angle.continuous_cos is a dubious translation:
-lean 3 declaration is
-  Continuous.{0, 0} Real.Angle Real (UniformSpace.toTopologicalSpace.{0} Real.Angle (PseudoMetricSpace.toUniformSpace.{0} Real.Angle (SeminormedAddCommGroup.toPseudoMetricSpace.{0} Real.Angle (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) Real.Angle.cos
-but is expected to have type
-  Continuous.{0, 0} Real.Angle Real (UniformSpace.toTopologicalSpace.{0} Real.Angle (PseudoMetricSpace.toUniformSpace.{0} Real.Angle (SeminormedAddCommGroup.toPseudoMetricSpace.{0} Real.Angle (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))) (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) Real.Angle.cos
-Case conversion may be inaccurate. Consider using '#align real.angle.continuous_cos Real.Angle.continuous_cosₓ'. -/
 @[continuity]
 theorem continuous_cos : Continuous cos :=
   Real.continuous_cos.quotient_liftOn' _
 #align real.angle.continuous_cos Real.Angle.continuous_cos
 
-/- warning: real.angle.cos_eq_real_cos_iff_eq_or_eq_neg -> Real.Angle.cos_eq_real_cos_iff_eq_or_eq_neg is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle} {ψ : Real}, Iff (Eq.{1} Real (Real.Angle.cos θ) (Real.cos ψ)) (Or (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) ψ)) (Eq.{1} Real.Angle θ (Neg.neg.{0} Real.Angle (SubNegMonoid.toHasNeg.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) ψ))))
-but is expected to have type
-  forall {θ : Real.Angle} {ψ : Real}, Iff (Eq.{1} Real (Real.Angle.cos θ) (Real.cos ψ)) (Or (Eq.{1} Real.Angle θ (Real.Angle.coe ψ)) (Eq.{1} Real.Angle θ (Neg.neg.{0} Real.Angle (NegZeroClass.toNeg.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (Real.Angle.coe ψ))))
-Case conversion may be inaccurate. Consider using '#align real.angle.cos_eq_real_cos_iff_eq_or_eq_neg Real.Angle.cos_eq_real_cos_iff_eq_or_eq_negₓ'. -/
 theorem cos_eq_real_cos_iff_eq_or_eq_neg {θ : Angle} {ψ : ℝ} :
     cos θ = Real.cos ψ ↔ θ = ψ ∨ θ = -ψ :=
   by
@@ -595,24 +325,12 @@ theorem cos_eq_real_cos_iff_eq_or_eq_neg {θ : Angle} {ψ : ℝ} :
   exact cos_eq_iff_coe_eq_or_eq_neg
 #align real.angle.cos_eq_real_cos_iff_eq_or_eq_neg Real.Angle.cos_eq_real_cos_iff_eq_or_eq_neg
 
-/- warning: real.angle.cos_eq_iff_eq_or_eq_neg -> Real.Angle.cos_eq_iff_eq_or_eq_neg is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle} {ψ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.cos θ) (Real.Angle.cos ψ)) (Or (Eq.{1} Real.Angle θ ψ) (Eq.{1} Real.Angle θ (Neg.neg.{0} Real.Angle (SubNegMonoid.toHasNeg.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) ψ)))
-but is expected to have type
-  forall {θ : Real.Angle} {ψ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.cos θ) (Real.Angle.cos ψ)) (Or (Eq.{1} Real.Angle θ ψ) (Eq.{1} Real.Angle θ (Neg.neg.{0} Real.Angle (NegZeroClass.toNeg.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) ψ)))
-Case conversion may be inaccurate. Consider using '#align real.angle.cos_eq_iff_eq_or_eq_neg Real.Angle.cos_eq_iff_eq_or_eq_negₓ'. -/
 theorem cos_eq_iff_eq_or_eq_neg {θ ψ : Angle} : cos θ = cos ψ ↔ θ = ψ ∨ θ = -ψ :=
   by
   induction ψ using Real.Angle.induction_on
   exact cos_eq_real_cos_iff_eq_or_eq_neg
 #align real.angle.cos_eq_iff_eq_or_eq_neg Real.Angle.cos_eq_iff_eq_or_eq_neg
 
-/- warning: real.angle.sin_eq_real_sin_iff_eq_or_add_eq_pi -> Real.Angle.sin_eq_real_sin_iff_eq_or_add_eq_pi is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle} {ψ : Real}, Iff (Eq.{1} Real (Real.Angle.sin θ) (Real.sin ψ)) (Or (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) ψ)) (Eq.{1} Real.Angle (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) ψ)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)))
-but is expected to have type
-  forall {θ : Real.Angle} {ψ : Real}, Iff (Eq.{1} Real (Real.Angle.sin θ) (Real.sin ψ)) (Or (Eq.{1} Real.Angle θ (Real.Angle.coe ψ)) (Eq.{1} Real.Angle (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) θ (Real.Angle.coe ψ)) (Real.Angle.coe Real.pi)))
-Case conversion may be inaccurate. Consider using '#align real.angle.sin_eq_real_sin_iff_eq_or_add_eq_pi Real.Angle.sin_eq_real_sin_iff_eq_or_add_eq_piₓ'. -/
 theorem sin_eq_real_sin_iff_eq_or_add_eq_pi {θ : Angle} {ψ : ℝ} :
     sin θ = Real.sin ψ ↔ θ = ψ ∨ θ + ψ = π :=
   by
@@ -620,44 +338,20 @@ theorem sin_eq_real_sin_iff_eq_or_add_eq_pi {θ : Angle} {ψ : ℝ} :
   exact sin_eq_iff_coe_eq_or_add_eq_pi
 #align real.angle.sin_eq_real_sin_iff_eq_or_add_eq_pi Real.Angle.sin_eq_real_sin_iff_eq_or_add_eq_pi
 
-/- warning: real.angle.sin_eq_iff_eq_or_add_eq_pi -> Real.Angle.sin_eq_iff_eq_or_add_eq_pi is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle} {ψ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.sin θ) (Real.Angle.sin ψ)) (Or (Eq.{1} Real.Angle θ ψ) (Eq.{1} Real.Angle (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) θ ψ) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)))
-but is expected to have type
-  forall {θ : Real.Angle} {ψ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.sin θ) (Real.Angle.sin ψ)) (Or (Eq.{1} Real.Angle θ ψ) (Eq.{1} Real.Angle (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) θ ψ) (Real.Angle.coe Real.pi)))
-Case conversion may be inaccurate. Consider using '#align real.angle.sin_eq_iff_eq_or_add_eq_pi Real.Angle.sin_eq_iff_eq_or_add_eq_piₓ'. -/
 theorem sin_eq_iff_eq_or_add_eq_pi {θ ψ : Angle} : sin θ = sin ψ ↔ θ = ψ ∨ θ + ψ = π :=
   by
   induction ψ using Real.Angle.induction_on
   exact sin_eq_real_sin_iff_eq_or_add_eq_pi
 #align real.angle.sin_eq_iff_eq_or_add_eq_pi Real.Angle.sin_eq_iff_eq_or_add_eq_pi
 
-/- warning: real.angle.sin_zero -> Real.Angle.sin_zero is a dubious translation:
-lean 3 declaration is
-  Eq.{1} Real (Real.Angle.sin (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))
-but is expected to have type
-  Eq.{1} Real (Real.Angle.sin (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))
-Case conversion may be inaccurate. Consider using '#align real.angle.sin_zero Real.Angle.sin_zeroₓ'. -/
 @[simp]
 theorem sin_zero : sin (0 : Angle) = 0 := by rw [← coe_zero, sin_coe, Real.sin_zero]
 #align real.angle.sin_zero Real.Angle.sin_zero
 
-/- warning: real.angle.sin_coe_pi -> Real.Angle.sin_coe_pi is a dubious translation:
-lean 3 declaration is
-  Eq.{1} Real (Real.Angle.sin ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))
-but is expected to have type
-  Eq.{1} Real (Real.Angle.sin (Real.Angle.coe Real.pi)) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))
-Case conversion may be inaccurate. Consider using '#align real.angle.sin_coe_pi Real.Angle.sin_coe_piₓ'. -/
 @[simp]
 theorem sin_coe_pi : sin (π : Angle) = 0 := by rw [sin_coe, Real.sin_pi]
 #align real.angle.sin_coe_pi Real.Angle.sin_coe_pi
 
-/- warning: real.angle.sin_eq_zero_iff -> Real.Angle.sin_eq_zero_iff is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.sin θ) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (Or (Eq.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)))
-but is expected to have type
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.sin θ) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (Or (Eq.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (Eq.{1} Real.Angle θ (Real.Angle.coe Real.pi)))
-Case conversion may be inaccurate. Consider using '#align real.angle.sin_eq_zero_iff Real.Angle.sin_eq_zero_iffₓ'. -/
 theorem sin_eq_zero_iff {θ : Angle} : sin θ = 0 ↔ θ = 0 ∨ θ = π :=
   by
   nth_rw 1 [← sin_zero]
@@ -665,22 +359,10 @@ theorem sin_eq_zero_iff {θ : Angle} : sin θ = 0 ↔ θ = 0 ∨ θ = π :=
   simp
 #align real.angle.sin_eq_zero_iff Real.Angle.sin_eq_zero_iff
 
-/- warning: real.angle.sin_ne_zero_iff -> Real.Angle.sin_ne_zero_iff is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, Iff (Ne.{1} Real (Real.Angle.sin θ) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (And (Ne.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (Ne.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)))
-but is expected to have type
-  forall {θ : Real.Angle}, Iff (Ne.{1} Real (Real.Angle.sin θ) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (And (Ne.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (Ne.{1} Real.Angle θ (Real.Angle.coe Real.pi)))
-Case conversion may be inaccurate. Consider using '#align real.angle.sin_ne_zero_iff Real.Angle.sin_ne_zero_iffₓ'. -/
 theorem sin_ne_zero_iff {θ : Angle} : sin θ ≠ 0 ↔ θ ≠ 0 ∧ θ ≠ π := by
   rw [← not_or, ← sin_eq_zero_iff]
 #align real.angle.sin_ne_zero_iff Real.Angle.sin_ne_zero_iff
 
-/- warning: real.angle.sin_neg -> Real.Angle.sin_neg is a dubious translation:
-lean 3 declaration is
-  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.sin (Neg.neg.{0} Real.Angle (SubNegMonoid.toHasNeg.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) θ)) (Neg.neg.{0} Real Real.hasNeg (Real.Angle.sin θ))
-but is expected to have type
-  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.sin (Neg.neg.{0} Real.Angle (NegZeroClass.toNeg.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) θ)) (Neg.neg.{0} Real Real.instNegReal (Real.Angle.sin θ))
-Case conversion may be inaccurate. Consider using '#align real.angle.sin_neg Real.Angle.sin_negₓ'. -/
 @[simp]
 theorem sin_neg (θ : Angle) : sin (-θ) = -sin θ :=
   by
@@ -688,12 +370,6 @@ theorem sin_neg (θ : Angle) : sin (-θ) = -sin θ :=
   exact Real.sin_neg _
 #align real.angle.sin_neg Real.Angle.sin_neg
 
-/- warning: real.angle.sin_antiperiodic -> Real.Angle.sin_antiperiodic is a dubious translation:
-lean 3 declaration is
-  Function.Antiperiodic.{0, 0} Real.Angle Real (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))) Real.hasNeg Real.Angle.sin ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)
-but is expected to have type
-  Function.Antiperiodic.{0, 0} Real.Angle Real (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) Real.instNegReal Real.Angle.sin (Real.Angle.coe Real.pi)
-Case conversion may be inaccurate. Consider using '#align real.angle.sin_antiperiodic Real.Angle.sin_antiperiodicₓ'. -/
 theorem sin_antiperiodic : Function.Antiperiodic sin (π : Angle) :=
   by
   intro θ
@@ -701,54 +377,24 @@ theorem sin_antiperiodic : Function.Antiperiodic sin (π : Angle) :=
   exact Real.sin_antiperiodic θ
 #align real.angle.sin_antiperiodic Real.Angle.sin_antiperiodic
 
-/- warning: real.angle.sin_add_pi -> Real.Angle.sin_add_pi is a dubious translation:
-lean 3 declaration is
-  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.sin (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi))) (Neg.neg.{0} Real Real.hasNeg (Real.Angle.sin θ))
-but is expected to have type
-  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.sin (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) θ (Real.Angle.coe Real.pi))) (Neg.neg.{0} Real Real.instNegReal (Real.Angle.sin θ))
-Case conversion may be inaccurate. Consider using '#align real.angle.sin_add_pi Real.Angle.sin_add_piₓ'. -/
 @[simp]
 theorem sin_add_pi (θ : Angle) : sin (θ + π) = -sin θ :=
   sin_antiperiodic θ
 #align real.angle.sin_add_pi Real.Angle.sin_add_pi
 
-/- warning: real.angle.sin_sub_pi -> Real.Angle.sin_sub_pi is a dubious translation:
-lean 3 declaration is
-  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.sin (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toHasSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi))) (Neg.neg.{0} Real Real.hasNeg (Real.Angle.sin θ))
-but is expected to have type
-  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.sin (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) θ (Real.Angle.coe Real.pi))) (Neg.neg.{0} Real Real.instNegReal (Real.Angle.sin θ))
-Case conversion may be inaccurate. Consider using '#align real.angle.sin_sub_pi Real.Angle.sin_sub_piₓ'. -/
 @[simp]
 theorem sin_sub_pi (θ : Angle) : sin (θ - π) = -sin θ :=
   sin_antiperiodic.sub_eq θ
 #align real.angle.sin_sub_pi Real.Angle.sin_sub_pi
 
-/- warning: real.angle.cos_zero -> Real.Angle.cos_zero is a dubious translation:
-lean 3 declaration is
-  Eq.{1} Real (Real.Angle.cos (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne)))
-but is expected to have type
-  Eq.{1} Real (Real.Angle.cos (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal))
-Case conversion may be inaccurate. Consider using '#align real.angle.cos_zero Real.Angle.cos_zeroₓ'. -/
 @[simp]
 theorem cos_zero : cos (0 : Angle) = 1 := by rw [← coe_zero, cos_coe, Real.cos_zero]
 #align real.angle.cos_zero Real.Angle.cos_zero
 
-/- warning: real.angle.cos_coe_pi -> Real.Angle.cos_coe_pi is a dubious translation:
-lean 3 declaration is
-  Eq.{1} Real (Real.Angle.cos ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) (Neg.neg.{0} Real Real.hasNeg (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne))))
-but is expected to have type
-  Eq.{1} Real (Real.Angle.cos (Real.Angle.coe Real.pi)) (Neg.neg.{0} Real Real.instNegReal (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal)))
-Case conversion may be inaccurate. Consider using '#align real.angle.cos_coe_pi Real.Angle.cos_coe_piₓ'. -/
 @[simp]
 theorem cos_coe_pi : cos (π : Angle) = -1 := by rw [cos_coe, Real.cos_pi]
 #align real.angle.cos_coe_pi Real.Angle.cos_coe_pi
 
-/- warning: real.angle.cos_neg -> Real.Angle.cos_neg is a dubious translation:
-lean 3 declaration is
-  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.cos (Neg.neg.{0} Real.Angle (SubNegMonoid.toHasNeg.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) θ)) (Real.Angle.cos θ)
-but is expected to have type
-  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.cos (Neg.neg.{0} Real.Angle (NegZeroClass.toNeg.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) θ)) (Real.Angle.cos θ)
-Case conversion may be inaccurate. Consider using '#align real.angle.cos_neg Real.Angle.cos_negₓ'. -/
 @[simp]
 theorem cos_neg (θ : Angle) : cos (-θ) = cos θ :=
   by
@@ -756,12 +402,6 @@ theorem cos_neg (θ : Angle) : cos (-θ) = cos θ :=
   exact Real.cos_neg _
 #align real.angle.cos_neg Real.Angle.cos_neg
 
-/- warning: real.angle.cos_antiperiodic -> Real.Angle.cos_antiperiodic is a dubious translation:
-lean 3 declaration is
-  Function.Antiperiodic.{0, 0} Real.Angle Real (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))) Real.hasNeg Real.Angle.cos ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)
-but is expected to have type
-  Function.Antiperiodic.{0, 0} Real.Angle Real (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) Real.instNegReal Real.Angle.cos (Real.Angle.coe Real.pi)
-Case conversion may be inaccurate. Consider using '#align real.angle.cos_antiperiodic Real.Angle.cos_antiperiodicₓ'. -/
 theorem cos_antiperiodic : Function.Antiperiodic cos (π : Angle) :=
   by
   intro θ
@@ -769,44 +409,20 @@ theorem cos_antiperiodic : Function.Antiperiodic cos (π : Angle) :=
   exact Real.cos_antiperiodic θ
 #align real.angle.cos_antiperiodic Real.Angle.cos_antiperiodic
 
-/- warning: real.angle.cos_add_pi -> Real.Angle.cos_add_pi is a dubious translation:
-lean 3 declaration is
-  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.cos (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi))) (Neg.neg.{0} Real Real.hasNeg (Real.Angle.cos θ))
-but is expected to have type
-  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.cos (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) θ (Real.Angle.coe Real.pi))) (Neg.neg.{0} Real Real.instNegReal (Real.Angle.cos θ))
-Case conversion may be inaccurate. Consider using '#align real.angle.cos_add_pi Real.Angle.cos_add_piₓ'. -/
 @[simp]
 theorem cos_add_pi (θ : Angle) : cos (θ + π) = -cos θ :=
   cos_antiperiodic θ
 #align real.angle.cos_add_pi Real.Angle.cos_add_pi
 
-/- warning: real.angle.cos_sub_pi -> Real.Angle.cos_sub_pi is a dubious translation:
-lean 3 declaration is
-  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.cos (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toHasSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi))) (Neg.neg.{0} Real Real.hasNeg (Real.Angle.cos θ))
-but is expected to have type
-  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.cos (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) θ (Real.Angle.coe Real.pi))) (Neg.neg.{0} Real Real.instNegReal (Real.Angle.cos θ))
-Case conversion may be inaccurate. Consider using '#align real.angle.cos_sub_pi Real.Angle.cos_sub_piₓ'. -/
 @[simp]
 theorem cos_sub_pi (θ : Angle) : cos (θ - π) = -cos θ :=
   cos_antiperiodic.sub_eq θ
 #align real.angle.cos_sub_pi Real.Angle.cos_sub_pi
 
-/- warning: real.angle.cos_eq_zero_iff -> Real.Angle.cos_eq_zero_iff is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.cos θ) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (Or (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))) (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Neg.neg.{0} Real Real.hasNeg Real.pi) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))))
-but is expected to have type
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.cos θ) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (Or (Eq.{1} Real.Angle θ (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))) (Eq.{1} Real.Angle θ (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Neg.neg.{0} Real Real.instNegReal Real.pi) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))))
-Case conversion may be inaccurate. Consider using '#align real.angle.cos_eq_zero_iff Real.Angle.cos_eq_zero_iffₓ'. -/
 theorem cos_eq_zero_iff {θ : Angle} : cos θ = 0 ↔ θ = (π / 2 : ℝ) ∨ θ = (-π / 2 : ℝ) := by
   rw [← cos_pi_div_two, ← cos_coe, cos_eq_iff_eq_or_eq_neg, ← coe_neg, ← neg_div]
 #align real.angle.cos_eq_zero_iff Real.Angle.cos_eq_zero_iff
 
-/- warning: real.angle.sin_add -> Real.Angle.sin_add is a dubious translation:
-lean 3 declaration is
-  forall (θ₁ : Real.Angle) (θ₂ : Real.Angle), Eq.{1} Real (Real.Angle.sin (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) θ₁ θ₂)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (Real.Angle.sin θ₁) (Real.Angle.cos θ₂)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (Real.Angle.cos θ₁) (Real.Angle.sin θ₂)))
-but is expected to have type
-  forall (θ₁ : Real.Angle) (θ₂ : Real.Angle), Eq.{1} Real (Real.Angle.sin (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) θ₁ θ₂)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Real.Angle.sin θ₁) (Real.Angle.cos θ₂)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Real.Angle.cos θ₁) (Real.Angle.sin θ₂)))
-Case conversion may be inaccurate. Consider using '#align real.angle.sin_add Real.Angle.sin_addₓ'. -/
 theorem sin_add (θ₁ θ₂ : Real.Angle) : sin (θ₁ + θ₂) = sin θ₁ * cos θ₂ + cos θ₁ * sin θ₂ :=
   by
   induction θ₁ using Real.Angle.induction_on
@@ -814,12 +430,6 @@ theorem sin_add (θ₁ θ₂ : Real.Angle) : sin (θ₁ + θ₂) = sin θ₁ * c
   exact Real.sin_add θ₁ θ₂
 #align real.angle.sin_add Real.Angle.sin_add
 
-/- warning: real.angle.cos_add -> Real.Angle.cos_add is a dubious translation:
-lean 3 declaration is
-  forall (θ₁ : Real.Angle) (θ₂ : Real.Angle), Eq.{1} Real (Real.Angle.cos (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) θ₁ θ₂)) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (Real.Angle.cos θ₁) (Real.Angle.cos θ₂)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (Real.Angle.sin θ₁) (Real.Angle.sin θ₂)))
-but is expected to have type
-  forall (θ₁ : Real.Angle) (θ₂ : Real.Angle), Eq.{1} Real (Real.Angle.cos (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) θ₁ θ₂)) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Real.Angle.cos θ₁) (Real.Angle.cos θ₂)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Real.Angle.sin θ₁) (Real.Angle.sin θ₂)))
-Case conversion may be inaccurate. Consider using '#align real.angle.cos_add Real.Angle.cos_addₓ'. -/
 theorem cos_add (θ₁ θ₂ : Real.Angle) : cos (θ₁ + θ₂) = cos θ₁ * cos θ₂ - sin θ₁ * sin θ₂ :=
   by
   induction θ₂ using Real.Angle.induction_on
@@ -827,12 +437,6 @@ theorem cos_add (θ₁ θ₂ : Real.Angle) : cos (θ₁ + θ₂) = cos θ₁ * c
   exact Real.cos_add θ₁ θ₂
 #align real.angle.cos_add Real.Angle.cos_add
 
-/- warning: real.angle.cos_sq_add_sin_sq -> Real.Angle.cos_sq_add_sin_sq is a dubious translation:
-lean 3 declaration is
-  forall (θ : Real.Angle), Eq.{1} Real (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (HPow.hPow.{0, 0, 0} Real Nat Real (instHPow.{0, 0} Real Nat (Monoid.Pow.{0} Real Real.monoid)) (Real.Angle.cos θ) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) (HPow.hPow.{0, 0, 0} Real Nat Real (instHPow.{0, 0} Real Nat (Monoid.Pow.{0} Real Real.monoid)) (Real.Angle.sin θ) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))))) (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne)))
-but is expected to have type
-  forall (θ : Real.Angle), Eq.{1} Real (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (HPow.hPow.{0, 0, 0} Real Nat Real (instHPow.{0, 0} Real Nat (Monoid.Pow.{0} Real Real.instMonoidReal)) (Real.Angle.cos θ) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) (HPow.hPow.{0, 0, 0} Real Nat Real (instHPow.{0, 0} Real Nat (Monoid.Pow.{0} Real Real.instMonoidReal)) (Real.Angle.sin θ) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))) (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal))
-Case conversion may be inaccurate. Consider using '#align real.angle.cos_sq_add_sin_sq Real.Angle.cos_sq_add_sin_sqₓ'. -/
 @[simp]
 theorem cos_sq_add_sin_sq (θ : Real.Angle) : cos θ ^ 2 + sin θ ^ 2 = 1 :=
   by
@@ -840,84 +444,42 @@ theorem cos_sq_add_sin_sq (θ : Real.Angle) : cos θ ^ 2 + sin θ ^ 2 = 1 :=
   exact Real.cos_sq_add_sin_sq θ
 #align real.angle.cos_sq_add_sin_sq Real.Angle.cos_sq_add_sin_sq
 
-/- warning: real.angle.sin_add_pi_div_two -> Real.Angle.sin_add_pi_div_two is a dubious translation:
-lean 3 declaration is
-  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.sin (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))))) (Real.Angle.cos θ)
-but is expected to have type
-  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.sin (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) θ (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))))) (Real.Angle.cos θ)
-Case conversion may be inaccurate. Consider using '#align real.angle.sin_add_pi_div_two Real.Angle.sin_add_pi_div_twoₓ'. -/
 theorem sin_add_pi_div_two (θ : Angle) : sin (θ + ↑(π / 2)) = cos θ :=
   by
   induction θ using Real.Angle.induction_on
   exact sin_add_pi_div_two _
 #align real.angle.sin_add_pi_div_two Real.Angle.sin_add_pi_div_two
 
-/- warning: real.angle.sin_sub_pi_div_two -> Real.Angle.sin_sub_pi_div_two is a dubious translation:
-lean 3 declaration is
-  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.sin (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toHasSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))))) (Neg.neg.{0} Real Real.hasNeg (Real.Angle.cos θ))
-but is expected to have type
-  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.sin (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) θ (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))))) (Neg.neg.{0} Real Real.instNegReal (Real.Angle.cos θ))
-Case conversion may be inaccurate. Consider using '#align real.angle.sin_sub_pi_div_two Real.Angle.sin_sub_pi_div_twoₓ'. -/
 theorem sin_sub_pi_div_two (θ : Angle) : sin (θ - ↑(π / 2)) = -cos θ :=
   by
   induction θ using Real.Angle.induction_on
   exact sin_sub_pi_div_two _
 #align real.angle.sin_sub_pi_div_two Real.Angle.sin_sub_pi_div_two
 
-/- warning: real.angle.sin_pi_div_two_sub -> Real.Angle.sin_pi_div_two_sub is a dubious translation:
-lean 3 declaration is
-  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.sin (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toHasSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))) θ)) (Real.Angle.cos θ)
-but is expected to have type
-  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.sin (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))) θ)) (Real.Angle.cos θ)
-Case conversion may be inaccurate. Consider using '#align real.angle.sin_pi_div_two_sub Real.Angle.sin_pi_div_two_subₓ'. -/
 theorem sin_pi_div_two_sub (θ : Angle) : sin (↑(π / 2) - θ) = cos θ :=
   by
   induction θ using Real.Angle.induction_on
   exact sin_pi_div_two_sub _
 #align real.angle.sin_pi_div_two_sub Real.Angle.sin_pi_div_two_sub
 
-/- warning: real.angle.cos_add_pi_div_two -> Real.Angle.cos_add_pi_div_two is a dubious translation:
-lean 3 declaration is
-  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.cos (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))))) (Neg.neg.{0} Real Real.hasNeg (Real.Angle.sin θ))
-but is expected to have type
-  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.cos (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) θ (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))))) (Neg.neg.{0} Real Real.instNegReal (Real.Angle.sin θ))
-Case conversion may be inaccurate. Consider using '#align real.angle.cos_add_pi_div_two Real.Angle.cos_add_pi_div_twoₓ'. -/
 theorem cos_add_pi_div_two (θ : Angle) : cos (θ + ↑(π / 2)) = -sin θ :=
   by
   induction θ using Real.Angle.induction_on
   exact cos_add_pi_div_two _
 #align real.angle.cos_add_pi_div_two Real.Angle.cos_add_pi_div_two
 
-/- warning: real.angle.cos_sub_pi_div_two -> Real.Angle.cos_sub_pi_div_two is a dubious translation:
-lean 3 declaration is
-  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.cos (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toHasSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))))) (Real.Angle.sin θ)
-but is expected to have type
-  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.cos (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) θ (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))))) (Real.Angle.sin θ)
-Case conversion may be inaccurate. Consider using '#align real.angle.cos_sub_pi_div_two Real.Angle.cos_sub_pi_div_twoₓ'. -/
 theorem cos_sub_pi_div_two (θ : Angle) : cos (θ - ↑(π / 2)) = sin θ :=
   by
   induction θ using Real.Angle.induction_on
   exact cos_sub_pi_div_two _
 #align real.angle.cos_sub_pi_div_two Real.Angle.cos_sub_pi_div_two
 
-/- warning: real.angle.cos_pi_div_two_sub -> Real.Angle.cos_pi_div_two_sub is a dubious translation:
-lean 3 declaration is
-  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.cos (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toHasSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))) θ)) (Real.Angle.sin θ)
-but is expected to have type
-  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.cos (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))) θ)) (Real.Angle.sin θ)
-Case conversion may be inaccurate. Consider using '#align real.angle.cos_pi_div_two_sub Real.Angle.cos_pi_div_two_subₓ'. -/
 theorem cos_pi_div_two_sub (θ : Angle) : cos (↑(π / 2) - θ) = sin θ :=
   by
   induction θ using Real.Angle.induction_on
   exact cos_pi_div_two_sub _
 #align real.angle.cos_pi_div_two_sub Real.Angle.cos_pi_div_two_sub
 
-/- warning: real.angle.abs_sin_eq_of_two_nsmul_eq -> Real.Angle.abs_sin_eq_of_two_nsmul_eq is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) θ) (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) ψ)) -> (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.sin θ)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.sin ψ)))
-but is expected to have type
-  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) θ) (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) ψ)) -> (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.sin θ)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.sin ψ)))
-Case conversion may be inaccurate. Consider using '#align real.angle.abs_sin_eq_of_two_nsmul_eq Real.Angle.abs_sin_eq_of_two_nsmul_eqₓ'. -/
 theorem abs_sin_eq_of_two_nsmul_eq {θ ψ : Angle} (h : (2 : ℕ) • θ = (2 : ℕ) • ψ) :
     |sin θ| = |sin ψ| := by
   rw [two_nsmul_eq_iff] at h
@@ -926,24 +488,12 @@ theorem abs_sin_eq_of_two_nsmul_eq {θ ψ : Angle} (h : (2 : ℕ) • θ = (2 :
   · rw [sin_add_pi, abs_neg]
 #align real.angle.abs_sin_eq_of_two_nsmul_eq Real.Angle.abs_sin_eq_of_two_nsmul_eq
 
-/- warning: real.angle.abs_sin_eq_of_two_zsmul_eq -> Real.Angle.abs_sin_eq_of_two_zsmul_eq is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) θ) (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) ψ)) -> (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.sin θ)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.sin ψ)))
-but is expected to have type
-  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) θ) (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) ψ)) -> (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.sin θ)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.sin ψ)))
-Case conversion may be inaccurate. Consider using '#align real.angle.abs_sin_eq_of_two_zsmul_eq Real.Angle.abs_sin_eq_of_two_zsmul_eqₓ'. -/
 theorem abs_sin_eq_of_two_zsmul_eq {θ ψ : Angle} (h : (2 : ℤ) • θ = (2 : ℤ) • ψ) :
     |sin θ| = |sin ψ| := by
   simp_rw [two_zsmul, ← two_nsmul] at h
   exact abs_sin_eq_of_two_nsmul_eq h
 #align real.angle.abs_sin_eq_of_two_zsmul_eq Real.Angle.abs_sin_eq_of_two_zsmul_eq
 
-/- warning: real.angle.abs_cos_eq_of_two_nsmul_eq -> Real.Angle.abs_cos_eq_of_two_nsmul_eq is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) θ) (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) ψ)) -> (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.cos θ)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.cos ψ)))
-but is expected to have type
-  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) θ) (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) ψ)) -> (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.cos θ)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.cos ψ)))
-Case conversion may be inaccurate. Consider using '#align real.angle.abs_cos_eq_of_two_nsmul_eq Real.Angle.abs_cos_eq_of_two_nsmul_eqₓ'. -/
 theorem abs_cos_eq_of_two_nsmul_eq {θ ψ : Angle} (h : (2 : ℕ) • θ = (2 : ℕ) • ψ) :
     |cos θ| = |cos ψ| := by
   rw [two_nsmul_eq_iff] at h
@@ -952,24 +502,12 @@ theorem abs_cos_eq_of_two_nsmul_eq {θ ψ : Angle} (h : (2 : ℕ) • θ = (2 :
   · rw [cos_add_pi, abs_neg]
 #align real.angle.abs_cos_eq_of_two_nsmul_eq Real.Angle.abs_cos_eq_of_two_nsmul_eq
 
-/- warning: real.angle.abs_cos_eq_of_two_zsmul_eq -> Real.Angle.abs_cos_eq_of_two_zsmul_eq is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) θ) (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) ψ)) -> (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.cos θ)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.cos ψ)))
-but is expected to have type
-  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) θ) (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) ψ)) -> (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.cos θ)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.cos ψ)))
-Case conversion may be inaccurate. Consider using '#align real.angle.abs_cos_eq_of_two_zsmul_eq Real.Angle.abs_cos_eq_of_two_zsmul_eqₓ'. -/
 theorem abs_cos_eq_of_two_zsmul_eq {θ ψ : Angle} (h : (2 : ℤ) • θ = (2 : ℤ) • ψ) :
     |cos θ| = |cos ψ| := by
   simp_rw [two_zsmul, ← two_nsmul] at h
   exact abs_cos_eq_of_two_nsmul_eq h
 #align real.angle.abs_cos_eq_of_two_zsmul_eq Real.Angle.abs_cos_eq_of_two_zsmul_eq
 
-/- warning: real.angle.coe_to_Ico_mod -> Real.Angle.coe_toIcoMod is a dubious translation:
-lean 3 declaration is
-  forall (θ : Real) (ψ : Real), Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (toIcoMod.{0} Real Real.linearOrderedAddCommGroup Real.instArchimedean (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi) Real.two_pi_pos ψ θ)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ)
-but is expected to have type
-  forall (θ : Real) (ψ : Real), Eq.{1} Real.Angle (Real.Angle.coe (toIcoMod.{0} Real Real.instLinearOrderedAddCommGroupReal Real.instArchimedean (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi) Real.two_pi_pos ψ θ)) (Real.Angle.coe θ)
-Case conversion may be inaccurate. Consider using '#align real.angle.coe_to_Ico_mod Real.Angle.coe_toIcoModₓ'. -/
 @[simp]
 theorem coe_toIcoMod (θ ψ : ℝ) : ↑(toIcoMod two_pi_pos ψ θ) = (θ : Angle) :=
   by
@@ -978,12 +516,6 @@ theorem coe_toIcoMod (θ ψ : ℝ) : ↑(toIcoMod two_pi_pos ψ θ) = (θ : Angl
   rw [toIcoMod_sub_self, zsmul_eq_mul, mul_comm]
 #align real.angle.coe_to_Ico_mod Real.Angle.coe_toIcoMod
 
-/- warning: real.angle.coe_to_Ioc_mod -> Real.Angle.coe_toIocMod is a dubious translation:
-lean 3 declaration is
-  forall (θ : Real) (ψ : Real), Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (toIocMod.{0} Real Real.linearOrderedAddCommGroup Real.instArchimedean (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi) Real.two_pi_pos ψ θ)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ)
-but is expected to have type
-  forall (θ : Real) (ψ : Real), Eq.{1} Real.Angle (Real.Angle.coe (toIocMod.{0} Real Real.instLinearOrderedAddCommGroupReal Real.instArchimedean (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi) Real.two_pi_pos ψ θ)) (Real.Angle.coe θ)
-Case conversion may be inaccurate. Consider using '#align real.angle.coe_to_Ioc_mod Real.Angle.coe_toIocModₓ'. -/
 @[simp]
 theorem coe_toIocMod (θ ψ : ℝ) : ↑(toIocMod two_pi_pos ψ θ) = (θ : Angle) :=
   by
@@ -999,34 +531,16 @@ def toReal (θ : Angle) : ℝ :=
 #align real.angle.to_real Real.Angle.toReal
 -/
 
-/- warning: real.angle.to_real_coe -> Real.Angle.toReal_coe is a dubious translation:
-lean 3 declaration is
-  forall (θ : Real), Eq.{1} Real (Real.Angle.toReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ)) (toIocMod.{0} Real Real.linearOrderedAddCommGroup Real.instArchimedean (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi) Real.two_pi_pos (Neg.neg.{0} Real Real.hasNeg Real.pi) θ)
-but is expected to have type
-  forall (θ : Real), Eq.{1} Real (Real.Angle.toReal (Real.Angle.coe θ)) (toIocMod.{0} Real Real.instLinearOrderedAddCommGroupReal Real.instArchimedean (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi) Real.two_pi_pos (Neg.neg.{0} Real Real.instNegReal Real.pi) θ)
-Case conversion may be inaccurate. Consider using '#align real.angle.to_real_coe Real.Angle.toReal_coeₓ'. -/
 theorem toReal_coe (θ : ℝ) : (θ : Angle).toReal = toIocMod two_pi_pos (-π) θ :=
   rfl
 #align real.angle.to_real_coe Real.Angle.toReal_coe
 
-/- warning: real.angle.to_real_coe_eq_self_iff -> Real.Angle.toReal_coe_eq_self_iff is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real}, Iff (Eq.{1} Real (Real.Angle.toReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ)) θ) (And (LT.lt.{0} Real Real.hasLt (Neg.neg.{0} Real Real.hasNeg Real.pi) θ) (LE.le.{0} Real Real.hasLe θ Real.pi))
-but is expected to have type
-  forall {θ : Real}, Iff (Eq.{1} Real (Real.Angle.toReal (Real.Angle.coe θ)) θ) (And (LT.lt.{0} Real Real.instLTReal (Neg.neg.{0} Real Real.instNegReal Real.pi) θ) (LE.le.{0} Real Real.instLEReal θ Real.pi))
-Case conversion may be inaccurate. Consider using '#align real.angle.to_real_coe_eq_self_iff Real.Angle.toReal_coe_eq_self_iffₓ'. -/
 theorem toReal_coe_eq_self_iff {θ : ℝ} : (θ : Angle).toReal = θ ↔ -π < θ ∧ θ ≤ π :=
   by
   rw [to_real_coe, toIocMod_eq_self two_pi_pos]
   ring_nf
 #align real.angle.to_real_coe_eq_self_iff Real.Angle.toReal_coe_eq_self_iff
 
-/- warning: real.angle.to_real_coe_eq_self_iff_mem_Ioc -> Real.Angle.toReal_coe_eq_self_iff_mem_Ioc is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real}, Iff (Eq.{1} Real (Real.Angle.toReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ)) θ) (Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) θ (Set.Ioc.{0} Real Real.preorder (Neg.neg.{0} Real Real.hasNeg Real.pi) Real.pi))
-but is expected to have type
-  forall {θ : Real}, Iff (Eq.{1} Real (Real.Angle.toReal (Real.Angle.coe θ)) θ) (Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) θ (Set.Ioc.{0} Real Real.instPreorderReal (Neg.neg.{0} Real Real.instNegReal Real.pi) Real.pi))
-Case conversion may be inaccurate. Consider using '#align real.angle.to_real_coe_eq_self_iff_mem_Ioc Real.Angle.toReal_coe_eq_self_iff_mem_Iocₓ'. -/
 theorem toReal_coe_eq_self_iff_mem_Ioc {θ : ℝ} : (θ : Angle).toReal = θ ↔ θ ∈ Set.Ioc (-π) π := by
   rw [to_real_coe_eq_self_iff, ← Set.mem_Ioc]
 #align real.angle.to_real_coe_eq_self_iff_mem_Ioc Real.Angle.toReal_coe_eq_self_iff_mem_Ioc
@@ -1049,12 +563,6 @@ theorem toReal_inj {θ ψ : Angle} : θ.toReal = ψ.toReal ↔ θ = ψ :=
 #align real.angle.to_real_inj Real.Angle.toReal_inj
 -/
 
-/- warning: real.angle.coe_to_real -> Real.Angle.coe_toReal is a dubious translation:
-lean 3 declaration is
-  forall (θ : Real.Angle), Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (Real.Angle.toReal θ)) θ
-but is expected to have type
-  forall (θ : Real.Angle), Eq.{1} Real.Angle (Real.Angle.coe (Real.Angle.toReal θ)) θ
-Case conversion may be inaccurate. Consider using '#align real.angle.coe_to_real Real.Angle.coe_toRealₓ'. -/
 @[simp]
 theorem coe_toReal (θ : Angle) : (θ.toReal : Angle) = θ :=
   by
@@ -1062,24 +570,12 @@ theorem coe_toReal (θ : Angle) : (θ.toReal : Angle) = θ :=
   exact coe_to_Ioc_mod _ _
 #align real.angle.coe_to_real Real.Angle.coe_toReal
 
-/- warning: real.angle.neg_pi_lt_to_real -> Real.Angle.neg_pi_lt_toReal is a dubious translation:
-lean 3 declaration is
-  forall (θ : Real.Angle), LT.lt.{0} Real Real.hasLt (Neg.neg.{0} Real Real.hasNeg Real.pi) (Real.Angle.toReal θ)
-but is expected to have type
-  forall (θ : Real.Angle), LT.lt.{0} Real Real.instLTReal (Neg.neg.{0} Real Real.instNegReal Real.pi) (Real.Angle.toReal θ)
-Case conversion may be inaccurate. Consider using '#align real.angle.neg_pi_lt_to_real Real.Angle.neg_pi_lt_toRealₓ'. -/
 theorem neg_pi_lt_toReal (θ : Angle) : -π < θ.toReal :=
   by
   induction θ using Real.Angle.induction_on
   exact left_lt_toIocMod _ _ _
 #align real.angle.neg_pi_lt_to_real Real.Angle.neg_pi_lt_toReal
 
-/- warning: real.angle.to_real_le_pi -> Real.Angle.toReal_le_pi is a dubious translation:
-lean 3 declaration is
-  forall (θ : Real.Angle), LE.le.{0} Real Real.hasLe (Real.Angle.toReal θ) Real.pi
-but is expected to have type
-  forall (θ : Real.Angle), LE.le.{0} Real Real.instLEReal (Real.Angle.toReal θ) Real.pi
-Case conversion may be inaccurate. Consider using '#align real.angle.to_real_le_pi Real.Angle.toReal_le_piₓ'. -/
 theorem toReal_le_pi (θ : Angle) : θ.toReal ≤ π :=
   by
   induction θ using Real.Angle.induction_on
@@ -1087,32 +583,14 @@ theorem toReal_le_pi (θ : Angle) : θ.toReal ≤ π :=
   ring
 #align real.angle.to_real_le_pi Real.Angle.toReal_le_pi
 
-/- warning: real.angle.abs_to_real_le_pi -> Real.Angle.abs_toReal_le_pi is a dubious translation:
-lean 3 declaration is
-  forall (θ : Real.Angle), LE.le.{0} Real Real.hasLe (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.toReal θ)) Real.pi
-but is expected to have type
-  forall (θ : Real.Angle), LE.le.{0} Real Real.instLEReal (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.toReal θ)) Real.pi
-Case conversion may be inaccurate. Consider using '#align real.angle.abs_to_real_le_pi Real.Angle.abs_toReal_le_piₓ'. -/
 theorem abs_toReal_le_pi (θ : Angle) : |θ.toReal| ≤ π :=
   abs_le.2 ⟨(neg_pi_lt_toReal _).le, toReal_le_pi _⟩
 #align real.angle.abs_to_real_le_pi Real.Angle.abs_toReal_le_pi
 
-/- warning: real.angle.to_real_mem_Ioc -> Real.Angle.toReal_mem_Ioc is a dubious translation:
-lean 3 declaration is
-  forall (θ : Real.Angle), Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) (Real.Angle.toReal θ) (Set.Ioc.{0} Real Real.preorder (Neg.neg.{0} Real Real.hasNeg Real.pi) Real.pi)
-but is expected to have type
-  forall (θ : Real.Angle), Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) (Real.Angle.toReal θ) (Set.Ioc.{0} Real Real.instPreorderReal (Neg.neg.{0} Real Real.instNegReal Real.pi) Real.pi)
-Case conversion may be inaccurate. Consider using '#align real.angle.to_real_mem_Ioc Real.Angle.toReal_mem_Iocₓ'. -/
 theorem toReal_mem_Ioc (θ : Angle) : θ.toReal ∈ Set.Ioc (-π) π :=
   ⟨neg_pi_lt_toReal _, toReal_le_pi _⟩
 #align real.angle.to_real_mem_Ioc Real.Angle.toReal_mem_Ioc
 
-/- warning: real.angle.to_Ioc_mod_to_real -> Real.Angle.toIocMod_toReal is a dubious translation:
-lean 3 declaration is
-  forall (θ : Real.Angle), Eq.{1} Real (toIocMod.{0} Real Real.linearOrderedAddCommGroup Real.instArchimedean (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi) Real.two_pi_pos (Neg.neg.{0} Real Real.hasNeg Real.pi) (Real.Angle.toReal θ)) (Real.Angle.toReal θ)
-but is expected to have type
-  forall (θ : Real.Angle), Eq.{1} Real (toIocMod.{0} Real Real.instLinearOrderedAddCommGroupReal Real.instArchimedean (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi) Real.two_pi_pos (Neg.neg.{0} Real Real.instNegReal Real.pi) (Real.Angle.toReal θ)) (Real.Angle.toReal θ)
-Case conversion may be inaccurate. Consider using '#align real.angle.to_Ioc_mod_to_real Real.Angle.toIocMod_toRealₓ'. -/
 @[simp]
 theorem toIocMod_toReal (θ : Angle) : toIocMod two_pi_pos (-π) θ.toReal = θ.toReal :=
   by
@@ -1121,12 +599,6 @@ theorem toIocMod_toReal (θ : Angle) : toIocMod two_pi_pos (-π) θ.toReal = θ.
   exact toIocMod_toIocMod _ _ _ _
 #align real.angle.to_Ioc_mod_to_real Real.Angle.toIocMod_toReal
 
-/- warning: real.angle.to_real_zero -> Real.Angle.toReal_zero is a dubious translation:
-lean 3 declaration is
-  Eq.{1} Real (Real.Angle.toReal (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))
-but is expected to have type
-  Eq.{1} Real (Real.Angle.toReal (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))
-Case conversion may be inaccurate. Consider using '#align real.angle.to_real_zero Real.Angle.toReal_zeroₓ'. -/
 @[simp]
 theorem toReal_zero : (0 : Angle).toReal = 0 :=
   by
@@ -1134,12 +606,6 @@ theorem toReal_zero : (0 : Angle).toReal = 0 :=
   exact ⟨Left.neg_neg_iff.2 Real.pi_pos, real.pi_pos.le⟩
 #align real.angle.to_real_zero Real.Angle.toReal_zero
 
-/- warning: real.angle.to_real_eq_zero_iff -> Real.Angle.toReal_eq_zero_iff is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal θ) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (Eq.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))))))
-but is expected to have type
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal θ) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (Eq.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))))))
-Case conversion may be inaccurate. Consider using '#align real.angle.to_real_eq_zero_iff Real.Angle.toReal_eq_zero_iffₓ'. -/
 @[simp]
 theorem toReal_eq_zero_iff {θ : Angle} : θ.toReal = 0 ↔ θ = 0 :=
   by
@@ -1147,12 +613,6 @@ theorem toReal_eq_zero_iff {θ : Angle} : θ.toReal = 0 ↔ θ = 0 :=
   exact to_real_inj
 #align real.angle.to_real_eq_zero_iff Real.Angle.toReal_eq_zero_iff
 
-/- warning: real.angle.to_real_pi -> Real.Angle.toReal_pi is a dubious translation:
-lean 3 declaration is
-  Eq.{1} Real (Real.Angle.toReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) Real.pi
-but is expected to have type
-  Eq.{1} Real (Real.Angle.toReal (Real.Angle.coe Real.pi)) Real.pi
-Case conversion may be inaccurate. Consider using '#align real.angle.to_real_pi Real.Angle.toReal_piₓ'. -/
 @[simp]
 theorem toReal_pi : (π : Angle).toReal = π :=
   by
@@ -1160,114 +620,54 @@ theorem toReal_pi : (π : Angle).toReal = π :=
   exact ⟨Left.neg_lt_self Real.pi_pos, le_refl _⟩
 #align real.angle.to_real_pi Real.Angle.toReal_pi
 
-/- warning: real.angle.to_real_eq_pi_iff -> Real.Angle.toReal_eq_pi_iff is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal θ) Real.pi) (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi))
-but is expected to have type
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal θ) Real.pi) (Eq.{1} Real.Angle θ (Real.Angle.coe Real.pi))
-Case conversion may be inaccurate. Consider using '#align real.angle.to_real_eq_pi_iff Real.Angle.toReal_eq_pi_iffₓ'. -/
 @[simp]
 theorem toReal_eq_pi_iff {θ : Angle} : θ.toReal = π ↔ θ = π := by rw [← to_real_inj, to_real_pi]
 #align real.angle.to_real_eq_pi_iff Real.Angle.toReal_eq_pi_iff
 
-/- warning: real.angle.pi_ne_zero -> Real.Angle.pi_ne_zero is a dubious translation:
-lean 3 declaration is
-  Ne.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi) (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))
-but is expected to have type
-  Ne.{1} Real.Angle (Real.Angle.coe Real.pi) (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))
-Case conversion may be inaccurate. Consider using '#align real.angle.pi_ne_zero Real.Angle.pi_ne_zeroₓ'. -/
 theorem pi_ne_zero : (π : Angle) ≠ 0 :=
   by
   rw [← to_real_injective.ne_iff, to_real_pi, to_real_zero]
   exact pi_ne_zero
 #align real.angle.pi_ne_zero Real.Angle.pi_ne_zero
 
-/- warning: real.angle.to_real_pi_div_two -> Real.Angle.toReal_pi_div_two is a dubious translation:
-lean 3 declaration is
-  Eq.{1} Real (Real.Angle.toReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))
-but is expected to have type
-  Eq.{1} Real (Real.Angle.toReal (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))
-Case conversion may be inaccurate. Consider using '#align real.angle.to_real_pi_div_two Real.Angle.toReal_pi_div_twoₓ'. -/
 @[simp]
 theorem toReal_pi_div_two : ((π / 2 : ℝ) : Angle).toReal = π / 2 :=
   toReal_coe_eq_self_iff.2 <| by constructor <;> linarith [pi_pos]
 #align real.angle.to_real_pi_div_two Real.Angle.toReal_pi_div_two
 
-/- warning: real.angle.to_real_eq_pi_div_two_iff -> Real.Angle.toReal_eq_pi_div_two_iff is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal θ) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))) (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))))
-but is expected to have type
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal θ) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))) (Eq.{1} Real.Angle θ (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))))
-Case conversion may be inaccurate. Consider using '#align real.angle.to_real_eq_pi_div_two_iff Real.Angle.toReal_eq_pi_div_two_iffₓ'. -/
 @[simp]
 theorem toReal_eq_pi_div_two_iff {θ : Angle} : θ.toReal = π / 2 ↔ θ = (π / 2 : ℝ) := by
   rw [← to_real_inj, to_real_pi_div_two]
 #align real.angle.to_real_eq_pi_div_two_iff Real.Angle.toReal_eq_pi_div_two_iff
 
-/- warning: real.angle.to_real_neg_pi_div_two -> Real.Angle.toReal_neg_pi_div_two is a dubious translation:
-lean 3 declaration is
-  Eq.{1} Real (Real.Angle.toReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Neg.neg.{0} Real Real.hasNeg Real.pi) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Neg.neg.{0} Real Real.hasNeg Real.pi) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))
-but is expected to have type
-  Eq.{1} Real (Real.Angle.toReal (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Neg.neg.{0} Real Real.instNegReal Real.pi) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Neg.neg.{0} Real Real.instNegReal Real.pi) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))
-Case conversion may be inaccurate. Consider using '#align real.angle.to_real_neg_pi_div_two Real.Angle.toReal_neg_pi_div_twoₓ'. -/
 @[simp]
 theorem toReal_neg_pi_div_two : ((-π / 2 : ℝ) : Angle).toReal = -π / 2 :=
   toReal_coe_eq_self_iff.2 <| by constructor <;> linarith [pi_pos]
 #align real.angle.to_real_neg_pi_div_two Real.Angle.toReal_neg_pi_div_two
 
-/- warning: real.angle.to_real_eq_neg_pi_div_two_iff -> Real.Angle.toReal_eq_neg_pi_div_two_iff is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal θ) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Neg.neg.{0} Real Real.hasNeg Real.pi) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))) (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Neg.neg.{0} Real Real.hasNeg Real.pi) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))))
-but is expected to have type
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal θ) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Neg.neg.{0} Real Real.instNegReal Real.pi) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))) (Eq.{1} Real.Angle θ (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Neg.neg.{0} Real Real.instNegReal Real.pi) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))))
-Case conversion may be inaccurate. Consider using '#align real.angle.to_real_eq_neg_pi_div_two_iff Real.Angle.toReal_eq_neg_pi_div_two_iffₓ'. -/
 @[simp]
 theorem toReal_eq_neg_pi_div_two_iff {θ : Angle} : θ.toReal = -π / 2 ↔ θ = (-π / 2 : ℝ) := by
   rw [← to_real_inj, to_real_neg_pi_div_two]
 #align real.angle.to_real_eq_neg_pi_div_two_iff Real.Angle.toReal_eq_neg_pi_div_two_iff
 
-/- warning: real.angle.pi_div_two_ne_zero -> Real.Angle.pi_div_two_ne_zero is a dubious translation:
-lean 3 declaration is
-  Ne.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))) (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))
-but is expected to have type
-  Ne.{1} Real.Angle (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))) (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))
-Case conversion may be inaccurate. Consider using '#align real.angle.pi_div_two_ne_zero Real.Angle.pi_div_two_ne_zeroₓ'. -/
 theorem pi_div_two_ne_zero : ((π / 2 : ℝ) : Angle) ≠ 0 :=
   by
   rw [← to_real_injective.ne_iff, to_real_pi_div_two, to_real_zero]
   exact div_ne_zero Real.pi_ne_zero two_ne_zero
 #align real.angle.pi_div_two_ne_zero Real.Angle.pi_div_two_ne_zero
 
-/- warning: real.angle.neg_pi_div_two_ne_zero -> Real.Angle.neg_pi_div_two_ne_zero is a dubious translation:
-lean 3 declaration is
-  Ne.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Neg.neg.{0} Real Real.hasNeg Real.pi) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))) (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))
-but is expected to have type
-  Ne.{1} Real.Angle (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Neg.neg.{0} Real Real.instNegReal Real.pi) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))) (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))
-Case conversion may be inaccurate. Consider using '#align real.angle.neg_pi_div_two_ne_zero Real.Angle.neg_pi_div_two_ne_zeroₓ'. -/
 theorem neg_pi_div_two_ne_zero : ((-π / 2 : ℝ) : Angle) ≠ 0 :=
   by
   rw [← to_real_injective.ne_iff, to_real_neg_pi_div_two, to_real_zero]
   exact div_ne_zero (neg_ne_zero.2 Real.pi_ne_zero) two_ne_zero
 #align real.angle.neg_pi_div_two_ne_zero Real.Angle.neg_pi_div_two_ne_zero
 
-/- warning: real.angle.abs_to_real_coe_eq_self_iff -> Real.Angle.abs_toReal_coe_eq_self_iff is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real}, Iff (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.toReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ))) θ) (And (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) θ) (LE.le.{0} Real Real.hasLe θ Real.pi))
-but is expected to have type
-  forall {θ : Real}, Iff (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.toReal (Real.Angle.coe θ))) θ) (And (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) θ) (LE.le.{0} Real Real.instLEReal θ Real.pi))
-Case conversion may be inaccurate. Consider using '#align real.angle.abs_to_real_coe_eq_self_iff Real.Angle.abs_toReal_coe_eq_self_iffₓ'. -/
 theorem abs_toReal_coe_eq_self_iff {θ : ℝ} : |(θ : Angle).toReal| = θ ↔ 0 ≤ θ ∧ θ ≤ π :=
   ⟨fun h => h ▸ ⟨abs_nonneg _, abs_toReal_le_pi _⟩, fun h =>
     (toReal_coe_eq_self_iff.2 ⟨(Left.neg_neg_iff.2 Real.pi_pos).trans_le h.1, h.2⟩).symm ▸
       abs_eq_self.2 h.1⟩
 #align real.angle.abs_to_real_coe_eq_self_iff Real.Angle.abs_toReal_coe_eq_self_iff
 
-/- warning: real.angle.abs_to_real_neg_coe_eq_self_iff -> Real.Angle.abs_toReal_neg_coe_eq_self_iff is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real}, Iff (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.toReal (Neg.neg.{0} Real.Angle (SubNegMonoid.toHasNeg.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ)))) θ) (And (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) θ) (LE.le.{0} Real Real.hasLe θ Real.pi))
-but is expected to have type
-  forall {θ : Real}, Iff (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.toReal (Neg.neg.{0} Real.Angle (NegZeroClass.toNeg.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (Real.Angle.coe θ)))) θ) (And (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) θ) (LE.le.{0} Real Real.instLEReal θ Real.pi))
-Case conversion may be inaccurate. Consider using '#align real.angle.abs_to_real_neg_coe_eq_self_iff Real.Angle.abs_toReal_neg_coe_eq_self_iffₓ'. -/
 theorem abs_toReal_neg_coe_eq_self_iff {θ : ℝ} : |(-θ : Angle).toReal| = θ ↔ 0 ≤ θ ∧ θ ≤ π :=
   by
   refine' ⟨fun h => h ▸ ⟨abs_nonneg _, abs_to_real_le_pi _⟩, fun h => _⟩
@@ -1278,24 +678,12 @@ theorem abs_toReal_neg_coe_eq_self_iff {θ : ℝ} : |(-θ : Angle).toReal| = θ
     abs_neg, abs_eq_self.2 h.1]
 #align real.angle.abs_to_real_neg_coe_eq_self_iff Real.Angle.abs_toReal_neg_coe_eq_self_iff
 
-/- warning: real.angle.abs_to_real_eq_pi_div_two_iff -> Real.Angle.abs_toReal_eq_pi_div_two_iff is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.toReal θ)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))) (Or (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))) (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Neg.neg.{0} Real Real.hasNeg Real.pi) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))))
-but is expected to have type
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.toReal θ)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))) (Or (Eq.{1} Real.Angle θ (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))) (Eq.{1} Real.Angle θ (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Neg.neg.{0} Real Real.instNegReal Real.pi) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))))
-Case conversion may be inaccurate. Consider using '#align real.angle.abs_to_real_eq_pi_div_two_iff Real.Angle.abs_toReal_eq_pi_div_two_iffₓ'. -/
 theorem abs_toReal_eq_pi_div_two_iff {θ : Angle} :
     |θ.toReal| = π / 2 ↔ θ = (π / 2 : ℝ) ∨ θ = (-π / 2 : ℝ) := by
   rw [abs_eq (div_nonneg real.pi_pos.le two_pos.le), ← neg_div, to_real_eq_pi_div_two_iff,
     to_real_eq_neg_pi_div_two_iff]
 #align real.angle.abs_to_real_eq_pi_div_two_iff Real.Angle.abs_toReal_eq_pi_div_two_iff
 
-/- warning: real.angle.nsmul_to_real_eq_mul -> Real.Angle.nsmul_toReal_eq_mul is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat}, (Ne.{1} Nat n (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) -> (forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) n θ)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Real (HasLiftT.mk.{1, 1} Nat Real (CoeTCₓ.coe.{1, 1} Nat Real (Nat.castCoe.{0} Real Real.hasNatCast))) n) (Real.Angle.toReal θ))) (Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) (Real.Angle.toReal θ) (Set.Ioc.{0} Real Real.preorder (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Neg.neg.{0} Real Real.hasNeg Real.pi) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Real (HasLiftT.mk.{1, 1} Nat Real (CoeTCₓ.coe.{1, 1} Nat Real (Nat.castCoe.{0} Real Real.hasNatCast))) n)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Real (HasLiftT.mk.{1, 1} Nat Real (CoeTCₓ.coe.{1, 1} Nat Real (Nat.castCoe.{0} Real Real.hasNatCast))) n)))))
-but is expected to have type
-  forall {n : Nat}, (Ne.{1} Nat n (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) -> (forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) n θ)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Nat.cast.{0} Real Real.natCast n) (Real.Angle.toReal θ))) (Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) (Real.Angle.toReal θ) (Set.Ioc.{0} Real Real.instPreorderReal (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Neg.neg.{0} Real Real.instNegReal Real.pi) (Nat.cast.{0} Real Real.natCast n)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (Nat.cast.{0} Real Real.natCast n)))))
-Case conversion may be inaccurate. Consider using '#align real.angle.nsmul_to_real_eq_mul Real.Angle.nsmul_toReal_eq_mulₓ'. -/
 theorem nsmul_toReal_eq_mul {n : ℕ} (h : n ≠ 0) {θ : Angle} :
     (n • θ).toReal = n * θ.toReal ↔ θ.toReal ∈ Set.Ioc (-π / n) (π / n) :=
   by
@@ -1305,34 +693,16 @@ theorem nsmul_toReal_eq_mul {n : ℕ} (h : n ≠ 0) {θ : Angle} :
     le_div_iff' h']
 #align real.angle.nsmul_to_real_eq_mul Real.Angle.nsmul_toReal_eq_mul
 
-/- warning: real.angle.two_nsmul_to_real_eq_two_mul -> Real.Angle.two_nsmul_toReal_eq_two_mul is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) θ)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) (Real.Angle.toReal θ))) (Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) (Real.Angle.toReal θ) (Set.Ioc.{0} Real Real.preorder (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Neg.neg.{0} Real Real.hasNeg Real.pi) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))))
-but is expected to have type
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) θ)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) (Real.Angle.toReal θ))) (Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) (Real.Angle.toReal θ) (Set.Ioc.{0} Real Real.instPreorderReal (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Neg.neg.{0} Real Real.instNegReal Real.pi) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))))
-Case conversion may be inaccurate. Consider using '#align real.angle.two_nsmul_to_real_eq_two_mul Real.Angle.two_nsmul_toReal_eq_two_mulₓ'. -/
 theorem two_nsmul_toReal_eq_two_mul {θ : Angle} :
     ((2 : ℕ) • θ).toReal = 2 * θ.toReal ↔ θ.toReal ∈ Set.Ioc (-π / 2) (π / 2) := by
   exact_mod_cast nsmul_to_real_eq_mul two_ne_zero
 #align real.angle.two_nsmul_to_real_eq_two_mul Real.Angle.two_nsmul_toReal_eq_two_mul
 
-/- warning: real.angle.two_zsmul_to_real_eq_two_mul -> Real.Angle.two_zsmul_toReal_eq_two_mul is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) θ)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) (Real.Angle.toReal θ))) (Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) (Real.Angle.toReal θ) (Set.Ioc.{0} Real Real.preorder (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Neg.neg.{0} Real Real.hasNeg Real.pi) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))))
-but is expected to have type
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) θ)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) (Real.Angle.toReal θ))) (Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) (Real.Angle.toReal θ) (Set.Ioc.{0} Real Real.instPreorderReal (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Neg.neg.{0} Real Real.instNegReal Real.pi) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))))
-Case conversion may be inaccurate. Consider using '#align real.angle.two_zsmul_to_real_eq_two_mul Real.Angle.two_zsmul_toReal_eq_two_mulₓ'. -/
 theorem two_zsmul_toReal_eq_two_mul {θ : Angle} :
     ((2 : ℤ) • θ).toReal = 2 * θ.toReal ↔ θ.toReal ∈ Set.Ioc (-π / 2) (π / 2) := by
   rw [two_zsmul, ← two_nsmul, two_nsmul_to_real_eq_two_mul]
 #align real.angle.two_zsmul_to_real_eq_two_mul Real.Angle.two_zsmul_toReal_eq_two_mul
 
-/- warning: real.angle.to_real_coe_eq_self_sub_two_mul_int_mul_pi_iff -> Real.Angle.toReal_coe_eq_self_sub_two_mul_int_mul_pi_iff is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real} {k : Int}, Iff (Eq.{1} Real (Real.Angle.toReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ)) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) θ (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Int Real (HasLiftT.mk.{1, 1} Int Real (CoeTCₓ.coe.{1, 1} Int Real (Int.castCoe.{0} Real Real.hasIntCast))) k)) Real.pi))) (Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) θ (Set.Ioc.{0} Real Real.preorder (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Int Real (HasLiftT.mk.{1, 1} Int Real (CoeTCₓ.coe.{1, 1} Int Real (Int.castCoe.{0} Real Real.hasIntCast))) k)) (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne)))) Real.pi) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Int Real (HasLiftT.mk.{1, 1} Int Real (CoeTCₓ.coe.{1, 1} Int Real (Int.castCoe.{0} Real Real.hasIntCast))) k)) (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne)))) Real.pi)))
-but is expected to have type
-  forall {θ : Real} {k : Int}, Iff (Eq.{1} Real (Real.Angle.toReal (Real.Angle.coe θ)) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) θ (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) (Int.cast.{0} Real Real.intCast k)) Real.pi))) (Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) θ (Set.Ioc.{0} Real Real.instPreorderReal (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) (Int.cast.{0} Real Real.intCast k)) (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal))) Real.pi) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) (Int.cast.{0} Real Real.intCast k)) (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal))) Real.pi)))
-Case conversion may be inaccurate. Consider using '#align real.angle.to_real_coe_eq_self_sub_two_mul_int_mul_pi_iff Real.Angle.toReal_coe_eq_self_sub_two_mul_int_mul_pi_iffₓ'. -/
 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) * π) :=
   by
@@ -1341,34 +711,16 @@ theorem toReal_coe_eq_self_sub_two_mul_int_mul_pi_iff {θ : ℝ} {k : ℤ} :
   exact ⟨fun h => ⟨by linarith, by linarith⟩, fun h => ⟨by linarith, by linarith⟩⟩
 #align real.angle.to_real_coe_eq_self_sub_two_mul_int_mul_pi_iff Real.Angle.toReal_coe_eq_self_sub_two_mul_int_mul_pi_iff
 
-/- warning: real.angle.to_real_coe_eq_self_sub_two_pi_iff -> Real.Angle.toReal_coe_eq_self_sub_two_pi_iff is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real}, Iff (Eq.{1} Real (Real.Angle.toReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ)) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) θ (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi))) (Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) θ (Set.Ioc.{0} Real Real.preorder Real.pi (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 3 (OfNat.mk.{0} Real 3 (bit1.{0} Real Real.hasOne Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi)))
-but is expected to have type
-  forall {θ : Real}, Iff (Eq.{1} Real (Real.Angle.toReal (Real.Angle.coe θ)) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) θ (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi))) (Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) θ (Set.Ioc.{0} Real Real.instPreorderReal Real.pi (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 3 (instOfNat.{0} Real 3 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))))) Real.pi)))
-Case conversion may be inaccurate. Consider using '#align real.angle.to_real_coe_eq_self_sub_two_pi_iff Real.Angle.toReal_coe_eq_self_sub_two_pi_iffₓ'. -/
 theorem toReal_coe_eq_self_sub_two_pi_iff {θ : ℝ} :
     (θ : Angle).toReal = θ - 2 * π ↔ θ ∈ Set.Ioc π (3 * π) := by
   convert@to_real_coe_eq_self_sub_two_mul_int_mul_pi_iff θ 1 <;> norm_num
 #align real.angle.to_real_coe_eq_self_sub_two_pi_iff Real.Angle.toReal_coe_eq_self_sub_two_pi_iff
 
-/- warning: real.angle.to_real_coe_eq_self_add_two_pi_iff -> Real.Angle.toReal_coe_eq_self_add_two_pi_iff is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real}, Iff (Eq.{1} Real (Real.Angle.toReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) θ (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi))) (Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) θ (Set.Ioc.{0} Real Real.preorder (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (Neg.neg.{0} Real Real.hasNeg (OfNat.ofNat.{0} Real 3 (OfNat.mk.{0} Real 3 (bit1.{0} Real Real.hasOne Real.hasAdd (One.one.{0} Real Real.hasOne))))) Real.pi) (Neg.neg.{0} Real Real.hasNeg Real.pi)))
-but is expected to have type
-  forall {θ : Real}, Iff (Eq.{1} Real (Real.Angle.toReal (Real.Angle.coe θ)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) θ (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi))) (Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) θ (Set.Ioc.{0} Real Real.instPreorderReal (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Neg.neg.{0} Real Real.instNegReal (OfNat.ofNat.{0} Real 3 (instOfNat.{0} Real 3 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))))) Real.pi) (Neg.neg.{0} Real Real.instNegReal Real.pi)))
-Case conversion may be inaccurate. Consider using '#align real.angle.to_real_coe_eq_self_add_two_pi_iff Real.Angle.toReal_coe_eq_self_add_two_pi_iffₓ'. -/
 theorem toReal_coe_eq_self_add_two_pi_iff {θ : ℝ} :
     (θ : Angle).toReal = θ + 2 * π ↔ θ ∈ Set.Ioc (-3 * π) (-π) := by
   convert@to_real_coe_eq_self_sub_two_mul_int_mul_pi_iff θ (-1) <;> norm_num
 #align real.angle.to_real_coe_eq_self_add_two_pi_iff Real.Angle.toReal_coe_eq_self_add_two_pi_iff
 
-/- warning: real.angle.two_nsmul_to_real_eq_two_mul_sub_two_pi -> Real.Angle.two_nsmul_toReal_eq_two_mul_sub_two_pi is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) θ)) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) (Real.Angle.toReal θ)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi))) (LT.lt.{0} Real Real.hasLt (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))) (Real.Angle.toReal θ))
-but is expected to have type
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) θ)) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) (Real.Angle.toReal θ)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi))) (LT.lt.{0} Real Real.instLTReal (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))) (Real.Angle.toReal θ))
-Case conversion may be inaccurate. Consider using '#align real.angle.two_nsmul_to_real_eq_two_mul_sub_two_pi Real.Angle.two_nsmul_toReal_eq_two_mul_sub_two_piₓ'. -/
 theorem two_nsmul_toReal_eq_two_mul_sub_two_pi {θ : Angle} :
     ((2 : ℕ) • θ).toReal = 2 * θ.toReal - 2 * π ↔ π / 2 < θ.toReal :=
   by
@@ -1379,23 +731,11 @@ theorem two_nsmul_toReal_eq_two_mul_sub_two_pi {θ : Angle} :
       ⟨(div_lt_iff' (zero_lt_two' ℝ)).1 h, by linarith [pi_pos, to_real_le_pi θ]⟩⟩
 #align real.angle.two_nsmul_to_real_eq_two_mul_sub_two_pi Real.Angle.two_nsmul_toReal_eq_two_mul_sub_two_pi
 
-/- warning: real.angle.two_zsmul_to_real_eq_two_mul_sub_two_pi -> Real.Angle.two_zsmul_toReal_eq_two_mul_sub_two_pi is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) θ)) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) (Real.Angle.toReal θ)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi))) (LT.lt.{0} Real Real.hasLt (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))) (Real.Angle.toReal θ))
-but is expected to have type
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) θ)) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) (Real.Angle.toReal θ)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi))) (LT.lt.{0} Real Real.instLTReal (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))) (Real.Angle.toReal θ))
-Case conversion may be inaccurate. Consider using '#align real.angle.two_zsmul_to_real_eq_two_mul_sub_two_pi Real.Angle.two_zsmul_toReal_eq_two_mul_sub_two_piₓ'. -/
 theorem two_zsmul_toReal_eq_two_mul_sub_two_pi {θ : Angle} :
     ((2 : ℤ) • θ).toReal = 2 * θ.toReal - 2 * π ↔ π / 2 < θ.toReal := by
   rw [two_zsmul, ← two_nsmul, two_nsmul_to_real_eq_two_mul_sub_two_pi]
 #align real.angle.two_zsmul_to_real_eq_two_mul_sub_two_pi Real.Angle.two_zsmul_toReal_eq_two_mul_sub_two_pi
 
-/- warning: real.angle.two_nsmul_to_real_eq_two_mul_add_two_pi -> Real.Angle.two_nsmul_toReal_eq_two_mul_add_two_pi is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) θ)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) (Real.Angle.toReal θ)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi))) (LE.le.{0} Real Real.hasLe (Real.Angle.toReal θ) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Neg.neg.{0} Real Real.hasNeg Real.pi) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))
-but is expected to have type
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) θ)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) (Real.Angle.toReal θ)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi))) (LE.le.{0} Real Real.instLEReal (Real.Angle.toReal θ) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Neg.neg.{0} Real Real.instNegReal Real.pi) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))
-Case conversion may be inaccurate. Consider using '#align real.angle.two_nsmul_to_real_eq_two_mul_add_two_pi Real.Angle.two_nsmul_toReal_eq_two_mul_add_two_piₓ'. -/
 theorem two_nsmul_toReal_eq_two_mul_add_two_pi {θ : Angle} :
     ((2 : ℕ) • θ).toReal = 2 * θ.toReal + 2 * π ↔ θ.toReal ≤ -π / 2 :=
   by
@@ -1406,12 +746,6 @@ theorem two_nsmul_toReal_eq_two_mul_add_two_pi {θ : Angle} :
       ⟨by linarith [pi_pos, neg_pi_lt_to_real θ], (le_div_iff' (zero_lt_two' ℝ)).1 h⟩⟩
 #align real.angle.two_nsmul_to_real_eq_two_mul_add_two_pi Real.Angle.two_nsmul_toReal_eq_two_mul_add_two_pi
 
-/- warning: real.angle.two_zsmul_to_real_eq_two_mul_add_two_pi -> Real.Angle.two_zsmul_toReal_eq_two_mul_add_two_pi is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) θ)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) (Real.Angle.toReal θ)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi))) (LE.le.{0} Real Real.hasLe (Real.Angle.toReal θ) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Neg.neg.{0} Real Real.hasNeg Real.pi) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))
-but is expected to have type
-  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) θ)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) (Real.Angle.toReal θ)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi))) (LE.le.{0} Real Real.instLEReal (Real.Angle.toReal θ) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Neg.neg.{0} Real Real.instNegReal Real.pi) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))
-Case conversion may be inaccurate. Consider using '#align real.angle.two_zsmul_to_real_eq_two_mul_add_two_pi Real.Angle.two_zsmul_toReal_eq_two_mul_add_two_piₓ'. -/
 theorem two_zsmul_toReal_eq_two_mul_add_two_pi {θ : Angle} :
     ((2 : ℤ) • θ).toReal = 2 * θ.toReal + 2 * π ↔ θ.toReal ≤ -π / 2 := by
   rw [two_zsmul, ← two_nsmul, two_nsmul_to_real_eq_two_mul_add_two_pi]
@@ -1431,12 +765,6 @@ theorem cos_toReal (θ : Angle) : Real.cos θ.toReal = cos θ := by
 #align real.angle.cos_to_real Real.Angle.cos_toReal
 -/
 
-/- warning: real.angle.cos_nonneg_iff_abs_to_real_le_pi_div_two -> Real.Angle.cos_nonneg_iff_abs_toReal_le_pi_div_two is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, Iff (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (Real.Angle.cos θ)) (LE.le.{0} Real Real.hasLe (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.toReal θ)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))
-but is expected to have type
-  forall {θ : Real.Angle}, Iff (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (Real.Angle.cos θ)) (LE.le.{0} Real Real.instLEReal (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.toReal θ)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))
-Case conversion may be inaccurate. Consider using '#align real.angle.cos_nonneg_iff_abs_to_real_le_pi_div_two 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 :=
   by
   nth_rw 1 [← coe_to_real θ]
@@ -1453,12 +781,6 @@ theorem cos_nonneg_iff_abs_toReal_le_pi_div_two {θ : Angle} : 0 ≤ cos θ ↔
     linarith [to_real_le_pi θ]
 #align real.angle.cos_nonneg_iff_abs_to_real_le_pi_div_two Real.Angle.cos_nonneg_iff_abs_toReal_le_pi_div_two
 
-/- warning: real.angle.cos_pos_iff_abs_to_real_lt_pi_div_two -> Real.Angle.cos_pos_iff_abs_toReal_lt_pi_div_two is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, Iff (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (Real.Angle.cos θ)) (LT.lt.{0} Real Real.hasLt (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.toReal θ)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))
-but is expected to have type
-  forall {θ : Real.Angle}, Iff (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (Real.Angle.cos θ)) (LT.lt.{0} Real Real.instLTReal (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.toReal θ)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))
-Case conversion may be inaccurate. Consider using '#align real.angle.cos_pos_iff_abs_to_real_lt_pi_div_two 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 :=
   by
   rw [lt_iff_le_and_ne, lt_iff_le_and_ne, cos_nonneg_iff_abs_to_real_le_pi_div_two, ←
@@ -1467,22 +789,10 @@ theorem cos_pos_iff_abs_toReal_lt_pi_div_two {θ : Angle} : 0 < cos θ ↔ |θ.t
   rw [Ne.def, Ne.def, not_iff_not, @eq_comm ℝ 0, abs_to_real_eq_pi_div_two_iff, cos_eq_zero_iff]
 #align real.angle.cos_pos_iff_abs_to_real_lt_pi_div_two Real.Angle.cos_pos_iff_abs_toReal_lt_pi_div_two
 
-/- warning: real.angle.cos_neg_iff_pi_div_two_lt_abs_to_real -> Real.Angle.cos_neg_iff_pi_div_two_lt_abs_toReal is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, Iff (LT.lt.{0} Real Real.hasLt (Real.Angle.cos θ) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (LT.lt.{0} Real Real.hasLt (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.toReal θ)))
-but is expected to have type
-  forall {θ : Real.Angle}, Iff (LT.lt.{0} Real Real.instLTReal (Real.Angle.cos θ) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (LT.lt.{0} Real Real.instLTReal (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.toReal θ)))
-Case conversion may be inaccurate. Consider using '#align real.angle.cos_neg_iff_pi_div_two_lt_abs_to_real 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| := by
   rw [← not_le, ← not_le, not_iff_not, cos_nonneg_iff_abs_to_real_le_pi_div_two]
 #align real.angle.cos_neg_iff_pi_div_two_lt_abs_to_real Real.Angle.cos_neg_iff_pi_div_two_lt_abs_toReal
 
-/- warning: real.angle.abs_cos_eq_abs_sin_of_two_nsmul_add_two_nsmul_eq_pi -> Real.Angle.abs_cos_eq_abs_sin_of_two_nsmul_add_two_nsmul_eq_pi is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) θ) (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) ψ)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) -> (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.cos θ)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.sin ψ)))
-but is expected to have type
-  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) θ) (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) ψ)) (Real.Angle.coe Real.pi)) -> (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.cos θ)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.sin ψ)))
-Case conversion may be inaccurate. Consider using '#align real.angle.abs_cos_eq_abs_sin_of_two_nsmul_add_two_nsmul_eq_pi 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 ψ| :=
   by
@@ -1490,12 +800,6 @@ theorem abs_cos_eq_abs_sin_of_two_nsmul_add_two_nsmul_eq_pi {θ ψ : Angle}
   rcases h with (rfl | rfl) <;> simp [cos_pi_div_two_sub]
 #align real.angle.abs_cos_eq_abs_sin_of_two_nsmul_add_two_nsmul_eq_pi Real.Angle.abs_cos_eq_abs_sin_of_two_nsmul_add_two_nsmul_eq_pi
 
-/- warning: real.angle.abs_cos_eq_abs_sin_of_two_zsmul_add_two_zsmul_eq_pi -> Real.Angle.abs_cos_eq_abs_sin_of_two_zsmul_add_two_zsmul_eq_pi is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) θ) (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) ψ)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) -> (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.cos θ)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.sin ψ)))
-but is expected to have type
-  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) θ) (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) ψ)) (Real.Angle.coe Real.pi)) -> (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.cos θ)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.sin ψ)))
-Case conversion may be inaccurate. Consider using '#align real.angle.abs_cos_eq_abs_sin_of_two_zsmul_add_two_zsmul_eq_pi 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 ψ| :=
   by
@@ -1510,53 +814,23 @@ def tan (θ : Angle) : ℝ :=
 #align real.angle.tan Real.Angle.tan
 -/
 
-/- warning: real.angle.tan_eq_sin_div_cos -> Real.Angle.tan_eq_sin_div_cos is a dubious translation:
-lean 3 declaration is
-  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.tan θ) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Real.Angle.sin θ) (Real.Angle.cos θ))
-but is expected to have type
-  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.tan θ) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Real.Angle.sin θ) (Real.Angle.cos θ))
-Case conversion may be inaccurate. Consider using '#align real.angle.tan_eq_sin_div_cos Real.Angle.tan_eq_sin_div_cosₓ'. -/
 theorem tan_eq_sin_div_cos (θ : Angle) : tan θ = sin θ / cos θ :=
   rfl
 #align real.angle.tan_eq_sin_div_cos Real.Angle.tan_eq_sin_div_cos
 
-/- warning: real.angle.tan_coe -> Real.Angle.tan_coe is a dubious translation:
-lean 3 declaration is
-  forall (x : Real), Eq.{1} Real (Real.Angle.tan ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) x)) (Real.tan x)
-but is expected to have type
-  forall (x : Real), Eq.{1} Real (Real.Angle.tan (Real.Angle.coe x)) (Real.tan x)
-Case conversion may be inaccurate. Consider using '#align real.angle.tan_coe Real.Angle.tan_coeₓ'. -/
 @[simp]
 theorem tan_coe (x : ℝ) : tan (x : Angle) = Real.tan x := by
   rw [tan, sin_coe, cos_coe, Real.tan_eq_sin_div_cos]
 #align real.angle.tan_coe Real.Angle.tan_coe
 
-/- warning: real.angle.tan_zero -> Real.Angle.tan_zero is a dubious translation:
-lean 3 declaration is
-  Eq.{1} Real (Real.Angle.tan (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))
-but is expected to have type
-  Eq.{1} Real (Real.Angle.tan (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))
-Case conversion may be inaccurate. Consider using '#align real.angle.tan_zero Real.Angle.tan_zeroₓ'. -/
 @[simp]
 theorem tan_zero : tan (0 : Angle) = 0 := by rw [← coe_zero, tan_coe, Real.tan_zero]
 #align real.angle.tan_zero Real.Angle.tan_zero
 
-/- warning: real.angle.tan_coe_pi -> Real.Angle.tan_coe_pi is a dubious translation:
-lean 3 declaration is
-  Eq.{1} Real (Real.Angle.tan ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))
-but is expected to have type
-  Eq.{1} Real (Real.Angle.tan (Real.Angle.coe Real.pi)) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))
-Case conversion may be inaccurate. Consider using '#align real.angle.tan_coe_pi Real.Angle.tan_coe_piₓ'. -/
 @[simp]
 theorem tan_coe_pi : tan (π : Angle) = 0 := by rw [tan_eq_sin_div_cos, sin_coe_pi, zero_div]
 #align real.angle.tan_coe_pi Real.Angle.tan_coe_pi
 
-/- warning: real.angle.tan_periodic -> Real.Angle.tan_periodic is a dubious translation:
-lean 3 declaration is
-  Function.Periodic.{0, 0} Real.Angle Real (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))) Real.Angle.tan ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)
-but is expected to have type
-  Function.Periodic.{0, 0} Real.Angle Real (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) Real.Angle.tan (Real.Angle.coe Real.pi)
-Case conversion may be inaccurate. Consider using '#align real.angle.tan_periodic Real.Angle.tan_periodicₓ'. -/
 theorem tan_periodic : Function.Periodic tan (π : Angle) :=
   by
   intro θ
@@ -1565,23 +839,11 @@ theorem tan_periodic : Function.Periodic tan (π : Angle) :=
   exact Real.tan_periodic θ
 #align real.angle.tan_periodic Real.Angle.tan_periodic
 
-/- warning: real.angle.tan_add_pi -> Real.Angle.tan_add_pi is a dubious translation:
-lean 3 declaration is
-  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.tan (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi))) (Real.Angle.tan θ)
-but is expected to have type
-  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.tan (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) θ (Real.Angle.coe Real.pi))) (Real.Angle.tan θ)
-Case conversion may be inaccurate. Consider using '#align real.angle.tan_add_pi Real.Angle.tan_add_piₓ'. -/
 @[simp]
 theorem tan_add_pi (θ : Angle) : tan (θ + π) = tan θ :=
   tan_periodic θ
 #align real.angle.tan_add_pi Real.Angle.tan_add_pi
 
-/- warning: real.angle.tan_sub_pi -> Real.Angle.tan_sub_pi is a dubious translation:
-lean 3 declaration is
-  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.tan (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toHasSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi))) (Real.Angle.tan θ)
-but is expected to have type
-  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.tan (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) θ (Real.Angle.coe Real.pi))) (Real.Angle.tan θ)
-Case conversion may be inaccurate. Consider using '#align real.angle.tan_sub_pi Real.Angle.tan_sub_piₓ'. -/
 @[simp]
 theorem tan_sub_pi (θ : Angle) : tan (θ - π) = tan θ :=
   tan_periodic.sub_eq θ
@@ -1594,12 +856,6 @@ theorem tan_toReal (θ : Angle) : Real.tan θ.toReal = tan θ := by
 #align real.angle.tan_to_real Real.Angle.tan_toReal
 -/
 
-/- warning: real.angle.tan_eq_of_two_nsmul_eq -> Real.Angle.tan_eq_of_two_nsmul_eq is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) θ) (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) ψ)) -> (Eq.{1} Real (Real.Angle.tan θ) (Real.Angle.tan ψ))
-but is expected to have type
-  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) θ) (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) ψ)) -> (Eq.{1} Real (Real.Angle.tan θ) (Real.Angle.tan ψ))
-Case conversion may be inaccurate. Consider using '#align real.angle.tan_eq_of_two_nsmul_eq Real.Angle.tan_eq_of_two_nsmul_eqₓ'. -/
 theorem tan_eq_of_two_nsmul_eq {θ ψ : Angle} (h : (2 : ℕ) • θ = (2 : ℕ) • ψ) : tan θ = tan ψ :=
   by
   rw [two_nsmul_eq_iff] at h
@@ -1608,24 +864,12 @@ theorem tan_eq_of_two_nsmul_eq {θ ψ : Angle} (h : (2 : ℕ) • θ = (2 : ℕ)
   · exact tan_add_pi _
 #align real.angle.tan_eq_of_two_nsmul_eq Real.Angle.tan_eq_of_two_nsmul_eq
 
-/- warning: real.angle.tan_eq_of_two_zsmul_eq -> Real.Angle.tan_eq_of_two_zsmul_eq is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) θ) (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) ψ)) -> (Eq.{1} Real (Real.Angle.tan θ) (Real.Angle.tan ψ))
-but is expected to have type
-  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) θ) (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) ψ)) -> (Eq.{1} Real (Real.Angle.tan θ) (Real.Angle.tan ψ))
-Case conversion may be inaccurate. Consider using '#align real.angle.tan_eq_of_two_zsmul_eq Real.Angle.tan_eq_of_two_zsmul_eqₓ'. -/
 theorem tan_eq_of_two_zsmul_eq {θ ψ : Angle} (h : (2 : ℤ) • θ = (2 : ℤ) • ψ) : tan θ = tan ψ :=
   by
   simp_rw [two_zsmul, ← two_nsmul] at h
   exact tan_eq_of_two_nsmul_eq h
 #align real.angle.tan_eq_of_two_zsmul_eq Real.Angle.tan_eq_of_two_zsmul_eq
 
-/- warning: real.angle.tan_eq_inv_of_two_nsmul_add_two_nsmul_eq_pi -> Real.Angle.tan_eq_inv_of_two_nsmul_add_two_nsmul_eq_pi is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) θ) (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) ψ)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) -> (Eq.{1} Real (Real.Angle.tan ψ) (Inv.inv.{0} Real Real.hasInv (Real.Angle.tan θ)))
-but is expected to have type
-  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) θ) (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) ψ)) (Real.Angle.coe Real.pi)) -> (Eq.{1} Real (Real.Angle.tan ψ) (Inv.inv.{0} Real Real.instInvReal (Real.Angle.tan θ)))
-Case conversion may be inaccurate. Consider using '#align real.angle.tan_eq_inv_of_two_nsmul_add_two_nsmul_eq_pi 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 θ)⁻¹ :=
   by
@@ -1640,12 +884,6 @@ theorem tan_eq_inv_of_two_nsmul_add_two_nsmul_eq_pi {θ ψ : Angle}
   exact real.tan_periodic.int_mul _ _
 #align real.angle.tan_eq_inv_of_two_nsmul_add_two_nsmul_eq_pi Real.Angle.tan_eq_inv_of_two_nsmul_add_two_nsmul_eq_pi
 
-/- warning: real.angle.tan_eq_inv_of_two_zsmul_add_two_zsmul_eq_pi -> Real.Angle.tan_eq_inv_of_two_zsmul_add_two_zsmul_eq_pi is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) θ) (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) ψ)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) -> (Eq.{1} Real (Real.Angle.tan ψ) (Inv.inv.{0} Real Real.hasInv (Real.Angle.tan θ)))
-but is expected to have type
-  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) θ) (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) ψ)) (Real.Angle.coe Real.pi)) -> (Eq.{1} Real (Real.Angle.tan ψ) (Inv.inv.{0} Real Real.instInvReal (Real.Angle.tan θ)))
-Case conversion may be inaccurate. Consider using '#align real.angle.tan_eq_inv_of_two_zsmul_add_two_zsmul_eq_pi 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 θ)⁻¹ :=
   by
@@ -1662,116 +900,50 @@ def sign (θ : Angle) : SignType :=
 #align real.angle.sign Real.Angle.sign
 -/
 
-/- warning: real.angle.sign_zero -> Real.Angle.sign_zero is a dubious translation:
-lean 3 declaration is
-  Eq.{1} SignType (Real.Angle.sign (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (OfNat.ofNat.{0} SignType 0 (OfNat.mk.{0} SignType 0 (Zero.zero.{0} SignType SignType.hasZero)))
-but is expected to have type
-  Eq.{1} SignType (Real.Angle.sign (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (OfNat.ofNat.{0} SignType 0 (Zero.toOfNat0.{0} SignType SignType.instZeroSignType))
-Case conversion may be inaccurate. Consider using '#align real.angle.sign_zero Real.Angle.sign_zeroₓ'. -/
 @[simp]
 theorem sign_zero : (0 : Angle).sign = 0 := by rw [SignType.sign, sin_zero, sign_zero]
 #align real.angle.sign_zero Real.Angle.sign_zero
 
-/- warning: real.angle.sign_coe_pi -> Real.Angle.sign_coe_pi is a dubious translation:
-lean 3 declaration is
-  Eq.{1} SignType (Real.Angle.sign ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) (OfNat.ofNat.{0} SignType 0 (OfNat.mk.{0} SignType 0 (Zero.zero.{0} SignType SignType.hasZero)))
-but is expected to have type
-  Eq.{1} SignType (Real.Angle.sign (Real.Angle.coe Real.pi)) (OfNat.ofNat.{0} SignType 0 (Zero.toOfNat0.{0} SignType SignType.instZeroSignType))
-Case conversion may be inaccurate. Consider using '#align real.angle.sign_coe_pi Real.Angle.sign_coe_piₓ'. -/
 @[simp]
 theorem sign_coe_pi : (π : Angle).sign = 0 := by rw [SignType.sign, sin_coe_pi, _root_.sign_zero]
 #align real.angle.sign_coe_pi Real.Angle.sign_coe_pi
 
-/- warning: real.angle.sign_neg -> Real.Angle.sign_neg is a dubious translation:
-lean 3 declaration is
-  forall (θ : Real.Angle), Eq.{1} SignType (Real.Angle.sign (Neg.neg.{0} Real.Angle (SubNegMonoid.toHasNeg.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) θ)) (Neg.neg.{0} SignType SignType.hasNeg (Real.Angle.sign θ))
-but is expected to have type
-  forall (θ : Real.Angle), Eq.{1} SignType (Real.Angle.sign (Neg.neg.{0} Real.Angle (NegZeroClass.toNeg.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) θ)) (Neg.neg.{0} SignType SignType.instNegSignType (Real.Angle.sign θ))
-Case conversion may be inaccurate. Consider using '#align real.angle.sign_neg Real.Angle.sign_negₓ'. -/
 @[simp]
 theorem sign_neg (θ : Angle) : (-θ).sign = -θ.sign := by
   simp_rw [SignType.sign, sin_neg, Left.sign_neg]
 #align real.angle.sign_neg Real.Angle.sign_neg
 
-/- warning: real.angle.sign_antiperiodic -> Real.Angle.sign_antiperiodic is a dubious translation:
-lean 3 declaration is
-  Function.Antiperiodic.{0, 0} Real.Angle SignType (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))) SignType.hasNeg Real.Angle.sign ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)
-but is expected to have type
-  Function.Antiperiodic.{0, 0} Real.Angle SignType (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) SignType.instNegSignType Real.Angle.sign (Real.Angle.coe Real.pi)
-Case conversion may be inaccurate. Consider using '#align real.angle.sign_antiperiodic Real.Angle.sign_antiperiodicₓ'. -/
 theorem sign_antiperiodic : Function.Antiperiodic sign (π : Angle) := fun θ => by
   rw [SignType.sign, SignType.sign, sin_add_pi, Left.sign_neg]
 #align real.angle.sign_antiperiodic Real.Angle.sign_antiperiodic
 
-/- warning: real.angle.sign_add_pi -> Real.Angle.sign_add_pi is a dubious translation:
-lean 3 declaration is
-  forall (θ : Real.Angle), Eq.{1} SignType (Real.Angle.sign (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi))) (Neg.neg.{0} SignType SignType.hasNeg (Real.Angle.sign θ))
-but is expected to have type
-  forall (θ : Real.Angle), Eq.{1} SignType (Real.Angle.sign (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) θ (Real.Angle.coe Real.pi))) (Neg.neg.{0} SignType SignType.instNegSignType (Real.Angle.sign θ))
-Case conversion may be inaccurate. Consider using '#align real.angle.sign_add_pi Real.Angle.sign_add_piₓ'. -/
 @[simp]
 theorem sign_add_pi (θ : Angle) : (θ + π).sign = -θ.sign :=
   sign_antiperiodic θ
 #align real.angle.sign_add_pi Real.Angle.sign_add_pi
 
-/- warning: real.angle.sign_pi_add -> Real.Angle.sign_pi_add is a dubious translation:
-lean 3 declaration is
-  forall (θ : Real.Angle), Eq.{1} SignType (Real.Angle.sign (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi) θ)) (Neg.neg.{0} SignType SignType.hasNeg (Real.Angle.sign θ))
-but is expected to have type
-  forall (θ : Real.Angle), Eq.{1} SignType (Real.Angle.sign (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) (Real.Angle.coe Real.pi) θ)) (Neg.neg.{0} SignType SignType.instNegSignType (Real.Angle.sign θ))
-Case conversion may be inaccurate. Consider using '#align real.angle.sign_pi_add Real.Angle.sign_pi_addₓ'. -/
 @[simp]
 theorem sign_pi_add (θ : Angle) : ((π : Angle) + θ).sign = -θ.sign := by rw [add_comm, sign_add_pi]
 #align real.angle.sign_pi_add Real.Angle.sign_pi_add
 
-/- warning: real.angle.sign_sub_pi -> Real.Angle.sign_sub_pi is a dubious translation:
-lean 3 declaration is
-  forall (θ : Real.Angle), Eq.{1} SignType (Real.Angle.sign (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toHasSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi))) (Neg.neg.{0} SignType SignType.hasNeg (Real.Angle.sign θ))
-but is expected to have type
-  forall (θ : Real.Angle), Eq.{1} SignType (Real.Angle.sign (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) θ (Real.Angle.coe Real.pi))) (Neg.neg.{0} SignType SignType.instNegSignType (Real.Angle.sign θ))
-Case conversion may be inaccurate. Consider using '#align real.angle.sign_sub_pi Real.Angle.sign_sub_piₓ'. -/
 @[simp]
 theorem sign_sub_pi (θ : Angle) : (θ - π).sign = -θ.sign :=
   sign_antiperiodic.sub_eq θ
 #align real.angle.sign_sub_pi Real.Angle.sign_sub_pi
 
-/- warning: real.angle.sign_pi_sub -> Real.Angle.sign_pi_sub is a dubious translation:
-lean 3 declaration is
-  forall (θ : Real.Angle), Eq.{1} SignType (Real.Angle.sign (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toHasSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi) θ)) (Real.Angle.sign θ)
-but is expected to have type
-  forall (θ : Real.Angle), Eq.{1} SignType (Real.Angle.sign (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (Real.Angle.coe Real.pi) θ)) (Real.Angle.sign θ)
-Case conversion may be inaccurate. Consider using '#align real.angle.sign_pi_sub Real.Angle.sign_pi_subₓ'. -/
 @[simp]
 theorem sign_pi_sub (θ : Angle) : ((π : Angle) - θ).sign = θ.sign := by
   simp [sign_antiperiodic.sub_eq']
 #align real.angle.sign_pi_sub Real.Angle.sign_pi_sub
 
-/- warning: real.angle.sign_eq_zero_iff -> Real.Angle.sign_eq_zero_iff is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, Iff (Eq.{1} SignType (Real.Angle.sign θ) (OfNat.ofNat.{0} SignType 0 (OfNat.mk.{0} SignType 0 (Zero.zero.{0} SignType SignType.hasZero)))) (Or (Eq.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)))
-but is expected to have type
-  forall {θ : Real.Angle}, Iff (Eq.{1} SignType (Real.Angle.sign θ) (OfNat.ofNat.{0} SignType 0 (Zero.toOfNat0.{0} SignType SignType.instZeroSignType))) (Or (Eq.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (Eq.{1} Real.Angle θ (Real.Angle.coe Real.pi)))
-Case conversion may be inaccurate. Consider using '#align real.angle.sign_eq_zero_iff Real.Angle.sign_eq_zero_iffₓ'. -/
 theorem sign_eq_zero_iff {θ : Angle} : θ.sign = 0 ↔ θ = 0 ∨ θ = π := by
   rw [SignType.sign, sign_eq_zero_iff, sin_eq_zero_iff]
 #align real.angle.sign_eq_zero_iff Real.Angle.sign_eq_zero_iff
 
-/- warning: real.angle.sign_ne_zero_iff -> Real.Angle.sign_ne_zero_iff is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, Iff (Ne.{1} SignType (Real.Angle.sign θ) (OfNat.ofNat.{0} SignType 0 (OfNat.mk.{0} SignType 0 (Zero.zero.{0} SignType SignType.hasZero)))) (And (Ne.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (Ne.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)))
-but is expected to have type
-  forall {θ : Real.Angle}, Iff (Ne.{1} SignType (Real.Angle.sign θ) (OfNat.ofNat.{0} SignType 0 (Zero.toOfNat0.{0} SignType SignType.instZeroSignType))) (And (Ne.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (Ne.{1} Real.Angle θ (Real.Angle.coe Real.pi)))
-Case conversion may be inaccurate. Consider using '#align real.angle.sign_ne_zero_iff Real.Angle.sign_ne_zero_iffₓ'. -/
 theorem sign_ne_zero_iff {θ : Angle} : θ.sign ≠ 0 ↔ θ ≠ 0 ∧ θ ≠ π := by
   rw [← not_or, ← sign_eq_zero_iff]
 #align real.angle.sign_ne_zero_iff Real.Angle.sign_ne_zero_iff
 
-/- warning: real.angle.to_real_neg_iff_sign_neg -> Real.Angle.toReal_neg_iff_sign_neg is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, Iff (LT.lt.{0} Real Real.hasLt (Real.Angle.toReal θ) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (Eq.{1} SignType (Real.Angle.sign θ) (Neg.neg.{0} SignType SignType.hasNeg (OfNat.ofNat.{0} SignType 1 (OfNat.mk.{0} SignType 1 (One.one.{0} SignType SignType.hasOne)))))
-but is expected to have type
-  forall {θ : Real.Angle}, Iff (LT.lt.{0} Real Real.instLTReal (Real.Angle.toReal θ) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (Eq.{1} SignType (Real.Angle.sign θ) (Neg.neg.{0} SignType SignType.instNegSignType (OfNat.ofNat.{0} SignType 1 (One.toOfNat1.{0} SignType SignType.instOneSignType))))
-Case conversion may be inaccurate. Consider using '#align real.angle.to_real_neg_iff_sign_neg Real.Angle.toReal_neg_iff_sign_negₓ'. -/
 theorem toReal_neg_iff_sign_neg {θ : Angle} : θ.toReal < 0 ↔ θ.sign = -1 :=
   by
   rw [SignType.sign, ← sin_to_real, sign_eq_neg_one_iff]
@@ -1784,12 +956,6 @@ theorem toReal_neg_iff_sign_neg {θ : Angle} : θ.toReal < 0 ↔ θ.sign = -1 :=
         False.elim (hn.not_le (sin_nonneg_of_nonneg_of_le_pi h.le (to_real_le_pi θ)))⟩
 #align real.angle.to_real_neg_iff_sign_neg Real.Angle.toReal_neg_iff_sign_neg
 
-/- warning: real.angle.to_real_nonneg_iff_sign_nonneg -> Real.Angle.toReal_nonneg_iff_sign_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, Iff (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (Real.Angle.toReal θ)) (LE.le.{0} SignType SignType.hasLe (OfNat.ofNat.{0} SignType 0 (OfNat.mk.{0} SignType 0 (Zero.zero.{0} SignType SignType.hasZero))) (Real.Angle.sign θ))
-but is expected to have type
-  forall {θ : Real.Angle}, Iff (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (Real.Angle.toReal θ)) (LE.le.{0} SignType SignType.instLESignType (OfNat.ofNat.{0} SignType 0 (Zero.toOfNat0.{0} SignType SignType.instZeroSignType)) (Real.Angle.sign θ))
-Case conversion may be inaccurate. Consider using '#align real.angle.to_real_nonneg_iff_sign_nonneg Real.Angle.toReal_nonneg_iff_sign_nonnegₓ'. -/
 theorem toReal_nonneg_iff_sign_nonneg {θ : Angle} : 0 ≤ θ.toReal ↔ 0 ≤ θ.sign :=
   by
   rcases lt_trichotomy θ.to_real 0 with (h | h | h)
@@ -1802,12 +968,6 @@ theorem toReal_nonneg_iff_sign_nonneg {θ : Angle} : 0 ≤ θ.toReal ↔ 0 ≤ 
     exact sin_nonneg_of_nonneg_of_le_pi h.le (to_real_le_pi θ)
 #align real.angle.to_real_nonneg_iff_sign_nonneg Real.Angle.toReal_nonneg_iff_sign_nonneg
 
-/- warning: real.angle.sign_to_real -> Real.Angle.sign_toReal is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, (Ne.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) -> (Eq.{1} SignType (coeFn.{1, 1} (OrderHom.{0, 0} Real SignType Real.preorder (PartialOrder.toPreorder.{0} SignType (SemilatticeInf.toPartialOrder.{0} SignType (Lattice.toSemilatticeInf.{0} SignType (LinearOrder.toLattice.{0} SignType SignType.linearOrder))))) (fun (_x : OrderHom.{0, 0} Real SignType Real.preorder (PartialOrder.toPreorder.{0} SignType (SemilatticeInf.toPartialOrder.{0} SignType (Lattice.toSemilatticeInf.{0} SignType (LinearOrder.toLattice.{0} SignType SignType.linearOrder))))) => Real -> SignType) (OrderHom.hasCoeToFun.{0, 0} Real SignType Real.preorder (PartialOrder.toPreorder.{0} SignType (SemilatticeInf.toPartialOrder.{0} SignType (Lattice.toSemilatticeInf.{0} SignType (LinearOrder.toLattice.{0} SignType SignType.linearOrder))))) (SignType.sign.{0} Real Real.hasZero Real.preorder (fun (a : Real) (b : Real) => Real.decidableLT a b)) (Real.Angle.toReal θ)) (Real.Angle.sign θ))
-but is expected to have type
-  forall {θ : Real.Angle}, (Ne.{1} Real.Angle θ (Real.Angle.coe Real.pi)) -> (Eq.{1} SignType (OrderHom.toFun.{0, 0} Real SignType Real.instPreorderReal (PartialOrder.toPreorder.{0} SignType (SemilatticeInf.toPartialOrder.{0} SignType (Lattice.toSemilatticeInf.{0} SignType (DistribLattice.toLattice.{0} SignType (instDistribLattice.{0} SignType SignType.instLinearOrderSignType))))) (SignType.sign.{0} Real Real.instZeroReal Real.instPreorderReal (fun (a : Real) (b : Real) => Real.decidableLT a b)) (Real.Angle.toReal θ)) (Real.Angle.sign θ))
-Case conversion may be inaccurate. Consider using '#align real.angle.sign_to_real Real.Angle.sign_toRealₓ'. -/
 @[simp]
 theorem sign_toReal {θ : Angle} (h : θ ≠ π) : SignType.sign θ.toReal = θ.sign :=
   by
@@ -1820,22 +980,10 @@ theorem sign_toReal {θ : Angle} (h : θ ≠ π) : SignType.sign θ.toReal = θ.
         (sin_pos_of_pos_of_lt_pi ht ((to_real_le_pi θ).lt_of_ne (to_real_eq_pi_iff.not.2 h)))]
 #align real.angle.sign_to_real Real.Angle.sign_toReal
 
-/- warning: real.angle.coe_abs_to_real_of_sign_nonneg -> Real.Angle.coe_abs_toReal_of_sign_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, (LE.le.{0} SignType SignType.hasLe (OfNat.ofNat.{0} SignType 0 (OfNat.mk.{0} SignType 0 (Zero.zero.{0} SignType SignType.hasZero))) (Real.Angle.sign θ)) -> (Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.toReal θ))) θ)
-but is expected to have type
-  forall {θ : Real.Angle}, (LE.le.{0} SignType SignType.instLESignType (OfNat.ofNat.{0} SignType 0 (Zero.toOfNat0.{0} SignType SignType.instZeroSignType)) (Real.Angle.sign θ)) -> (Eq.{1} Real.Angle (Real.Angle.coe (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.toReal θ))) θ)
-Case conversion may be inaccurate. Consider using '#align real.angle.coe_abs_to_real_of_sign_nonneg Real.Angle.coe_abs_toReal_of_sign_nonnegₓ'. -/
 theorem coe_abs_toReal_of_sign_nonneg {θ : Angle} (h : 0 ≤ θ.sign) : ↑(|θ.toReal|) = θ := by
   rw [abs_eq_self.2 (to_real_nonneg_iff_sign_nonneg.2 h), coe_to_real]
 #align real.angle.coe_abs_to_real_of_sign_nonneg Real.Angle.coe_abs_toReal_of_sign_nonneg
 
-/- warning: real.angle.neg_coe_abs_to_real_of_sign_nonpos -> Real.Angle.neg_coe_abs_toReal_of_sign_nonpos is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, (LE.le.{0} SignType SignType.hasLe (Real.Angle.sign θ) (OfNat.ofNat.{0} SignType 0 (OfNat.mk.{0} SignType 0 (Zero.zero.{0} SignType SignType.hasZero)))) -> (Eq.{1} Real.Angle (Neg.neg.{0} Real.Angle (SubNegMonoid.toHasNeg.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.toReal θ)))) θ)
-but is expected to have type
-  forall {θ : Real.Angle}, (LE.le.{0} SignType SignType.instLESignType (Real.Angle.sign θ) (OfNat.ofNat.{0} SignType 0 (Zero.toOfNat0.{0} SignType SignType.instZeroSignType))) -> (Eq.{1} Real.Angle (Neg.neg.{0} Real.Angle (NegZeroClass.toNeg.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (Real.Angle.coe (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.toReal θ)))) θ)
-Case conversion may be inaccurate. Consider using '#align real.angle.neg_coe_abs_to_real_of_sign_nonpos Real.Angle.neg_coe_abs_toReal_of_sign_nonposₓ'. -/
 theorem neg_coe_abs_toReal_of_sign_nonpos {θ : Angle} (h : θ.sign ≤ 0) : -↑(|θ.toReal|) = θ :=
   by
   rw [SignType.nonpos_iff] at h
@@ -1845,12 +993,6 @@ theorem neg_coe_abs_toReal_of_sign_nonpos {θ : Angle} (h : θ.sign ≤ 0) : -
     rcases h with (rfl | rfl) <;> simp [abs_of_pos Real.pi_pos]
 #align real.angle.neg_coe_abs_to_real_of_sign_nonpos Real.Angle.neg_coe_abs_toReal_of_sign_nonpos
 
-/- warning: real.angle.eq_iff_sign_eq_and_abs_to_real_eq -> Real.Angle.eq_iff_sign_eq_and_abs_toReal_eq is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle} {ψ : Real.Angle}, Iff (Eq.{1} Real.Angle θ ψ) (And (Eq.{1} SignType (Real.Angle.sign θ) (Real.Angle.sign ψ)) (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.toReal θ)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.toReal ψ))))
-but is expected to have type
-  forall {θ : Real.Angle} {ψ : Real.Angle}, Iff (Eq.{1} Real.Angle θ ψ) (And (Eq.{1} SignType (Real.Angle.sign θ) (Real.Angle.sign ψ)) (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.toReal θ)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.toReal ψ))))
-Case conversion may be inaccurate. Consider using '#align real.angle.eq_iff_sign_eq_and_abs_to_real_eq Real.Angle.eq_iff_sign_eq_and_abs_toReal_eqₓ'. -/
 theorem eq_iff_sign_eq_and_abs_toReal_eq {θ ψ : Angle} :
     θ = ψ ↔ θ.sign = ψ.sign ∧ |θ.toReal| = |ψ.toReal| :=
   by
@@ -1871,56 +1013,26 @@ theorem eq_iff_sign_eq_and_abs_toReal_eq {θ ψ : Angle} :
         rw [hr, hs]
 #align real.angle.eq_iff_sign_eq_and_abs_to_real_eq Real.Angle.eq_iff_sign_eq_and_abs_toReal_eq
 
-/- warning: real.angle.eq_iff_abs_to_real_eq_of_sign_eq -> Real.Angle.eq_iff_abs_toReal_eq_of_sign_eq is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} SignType (Real.Angle.sign θ) (Real.Angle.sign ψ)) -> (Iff (Eq.{1} Real.Angle θ ψ) (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.toReal θ)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.toReal ψ))))
-but is expected to have type
-  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} SignType (Real.Angle.sign θ) (Real.Angle.sign ψ)) -> (Iff (Eq.{1} Real.Angle θ ψ) (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.toReal θ)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.toReal ψ))))
-Case conversion may be inaccurate. Consider using '#align real.angle.eq_iff_abs_to_real_eq_of_sign_eq 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| := by simpa [h] using @eq_iff_sign_eq_and_abs_to_real_eq θ ψ
 #align real.angle.eq_iff_abs_to_real_eq_of_sign_eq Real.Angle.eq_iff_abs_toReal_eq_of_sign_eq
 
-/- warning: real.angle.sign_coe_pi_div_two -> Real.Angle.sign_coe_pi_div_two is a dubious translation:
-lean 3 declaration is
-  Eq.{1} SignType (Real.Angle.sign ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))) (OfNat.ofNat.{0} SignType 1 (OfNat.mk.{0} SignType 1 (One.one.{0} SignType SignType.hasOne)))
-but is expected to have type
-  Eq.{1} SignType (Real.Angle.sign (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))) (OfNat.ofNat.{0} SignType 1 (One.toOfNat1.{0} SignType SignType.instOneSignType))
-Case conversion may be inaccurate. Consider using '#align real.angle.sign_coe_pi_div_two Real.Angle.sign_coe_pi_div_twoₓ'. -/
 @[simp]
 theorem sign_coe_pi_div_two : (↑(π / 2) : Angle).sign = 1 := by
   rw [SignType.sign, sin_coe, sin_pi_div_two, sign_one]
 #align real.angle.sign_coe_pi_div_two Real.Angle.sign_coe_pi_div_two
 
-/- warning: real.angle.sign_coe_neg_pi_div_two -> Real.Angle.sign_coe_neg_pi_div_two is a dubious translation:
-lean 3 declaration is
-  Eq.{1} SignType (Real.Angle.sign ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Neg.neg.{0} Real Real.hasNeg Real.pi) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))) (Neg.neg.{0} SignType SignType.hasNeg (OfNat.ofNat.{0} SignType 1 (OfNat.mk.{0} SignType 1 (One.one.{0} SignType SignType.hasOne))))
-but is expected to have type
-  Eq.{1} SignType (Real.Angle.sign (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Neg.neg.{0} Real Real.instNegReal Real.pi) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))) (Neg.neg.{0} SignType SignType.instNegSignType (OfNat.ofNat.{0} SignType 1 (One.toOfNat1.{0} SignType SignType.instOneSignType)))
-Case conversion may be inaccurate. Consider using '#align real.angle.sign_coe_neg_pi_div_two Real.Angle.sign_coe_neg_pi_div_twoₓ'. -/
 @[simp]
 theorem sign_coe_neg_pi_div_two : (↑(-π / 2) : Angle).sign = -1 := by
   rw [SignType.sign, sin_coe, neg_div, Real.sin_neg, sin_pi_div_two, Left.sign_neg, sign_one]
 #align real.angle.sign_coe_neg_pi_div_two Real.Angle.sign_coe_neg_pi_div_two
 
-/- warning: real.angle.sign_coe_nonneg_of_nonneg_of_le_pi -> Real.Angle.sign_coe_nonneg_of_nonneg_of_le_pi is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real}, (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) θ) -> (LE.le.{0} Real Real.hasLe θ Real.pi) -> (LE.le.{0} SignType SignType.hasLe (OfNat.ofNat.{0} SignType 0 (OfNat.mk.{0} SignType 0 (Zero.zero.{0} SignType SignType.hasZero))) (Real.Angle.sign ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ)))
-but is expected to have type
-  forall {θ : Real}, (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) θ) -> (LE.le.{0} Real Real.instLEReal θ Real.pi) -> (LE.le.{0} SignType SignType.instLESignType (OfNat.ofNat.{0} SignType 0 (Zero.toOfNat0.{0} SignType SignType.instZeroSignType)) (Real.Angle.sign (Real.Angle.coe θ)))
-Case conversion may be inaccurate. Consider using '#align real.angle.sign_coe_nonneg_of_nonneg_of_le_pi 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 := by
   rw [SignType.sign, sign_nonneg_iff]
   exact sin_nonneg_of_nonneg_of_le_pi h0 hpi
 #align real.angle.sign_coe_nonneg_of_nonneg_of_le_pi Real.Angle.sign_coe_nonneg_of_nonneg_of_le_pi
 
-/- warning: real.angle.sign_neg_coe_nonpos_of_nonneg_of_le_pi -> Real.Angle.sign_neg_coe_nonpos_of_nonneg_of_le_pi is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real}, (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) θ) -> (LE.le.{0} Real Real.hasLe θ Real.pi) -> (LE.le.{0} SignType SignType.hasLe (Real.Angle.sign (Neg.neg.{0} Real.Angle (SubNegMonoid.toHasNeg.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ))) (OfNat.ofNat.{0} SignType 0 (OfNat.mk.{0} SignType 0 (Zero.zero.{0} SignType SignType.hasZero))))
-but is expected to have type
-  forall {θ : Real}, (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) θ) -> (LE.le.{0} Real Real.instLEReal θ Real.pi) -> (LE.le.{0} SignType SignType.instLESignType (Real.Angle.sign (Neg.neg.{0} Real.Angle (NegZeroClass.toNeg.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (Real.Angle.coe θ))) (OfNat.ofNat.{0} SignType 0 (Zero.toOfNat0.{0} SignType SignType.instZeroSignType)))
-Case conversion may be inaccurate. Consider using '#align real.angle.sign_neg_coe_nonpos_of_nonneg_of_le_pi 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 :=
   by
@@ -1928,12 +1040,6 @@ theorem sign_neg_coe_nonpos_of_nonneg_of_le_pi {θ : ℝ} (h0 : 0 ≤ θ) (hpi :
   exact sin_nonneg_of_nonneg_of_le_pi h0 hpi
 #align real.angle.sign_neg_coe_nonpos_of_nonneg_of_le_pi Real.Angle.sign_neg_coe_nonpos_of_nonneg_of_le_pi
 
-/- warning: real.angle.sign_two_nsmul_eq_sign_iff -> Real.Angle.sign_two_nsmul_eq_sign_iff is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, Iff (Eq.{1} SignType (Real.Angle.sign (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) θ)) (Real.Angle.sign θ)) (Or (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) (LT.lt.{0} Real Real.hasLt (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.toReal θ)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))))
-but is expected to have type
-  forall {θ : Real.Angle}, Iff (Eq.{1} SignType (Real.Angle.sign (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) θ)) (Real.Angle.sign θ)) (Or (Eq.{1} Real.Angle θ (Real.Angle.coe Real.pi)) (LT.lt.{0} Real Real.instLTReal (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.toReal θ)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))))
-Case conversion may be inaccurate. Consider using '#align real.angle.sign_two_nsmul_eq_sign_iff Real.Angle.sign_two_nsmul_eq_sign_iffₓ'. -/
 theorem sign_two_nsmul_eq_sign_iff {θ : Angle} :
     ((2 : ℕ) • θ).sign = θ.sign ↔ θ = π ∨ |θ.toReal| < π / 2 :=
   by
@@ -1972,33 +1078,15 @@ theorem sign_two_nsmul_eq_sign_iff {θ : Angle} :
       sign_mul, sign_pos (zero_lt_two' ℝ), one_mul]
 #align real.angle.sign_two_nsmul_eq_sign_iff Real.Angle.sign_two_nsmul_eq_sign_iff
 
-/- warning: real.angle.sign_two_zsmul_eq_sign_iff -> Real.Angle.sign_two_zsmul_eq_sign_iff is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, Iff (Eq.{1} SignType (Real.Angle.sign (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) θ)) (Real.Angle.sign θ)) (Or (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) (LT.lt.{0} Real Real.hasLt (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.toReal θ)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))))
-but is expected to have type
-  forall {θ : Real.Angle}, Iff (Eq.{1} SignType (Real.Angle.sign (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) θ)) (Real.Angle.sign θ)) (Or (Eq.{1} Real.Angle θ (Real.Angle.coe Real.pi)) (LT.lt.{0} Real Real.instLTReal (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.toReal θ)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))))
-Case conversion may be inaccurate. Consider using '#align real.angle.sign_two_zsmul_eq_sign_iff Real.Angle.sign_two_zsmul_eq_sign_iffₓ'. -/
 theorem sign_two_zsmul_eq_sign_iff {θ : Angle} :
     ((2 : ℤ) • θ).sign = θ.sign ↔ θ = π ∨ |θ.toReal| < π / 2 := by
   rw [two_zsmul, ← two_nsmul, sign_two_nsmul_eq_sign_iff]
 #align real.angle.sign_two_zsmul_eq_sign_iff Real.Angle.sign_two_zsmul_eq_sign_iff
 
-/- warning: real.angle.continuous_at_sign -> Real.Angle.continuousAt_sign is a dubious translation:
-lean 3 declaration is
-  forall {θ : Real.Angle}, (Ne.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) -> (Ne.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) -> (ContinuousAt.{0, 0} Real.Angle SignType (UniformSpace.toTopologicalSpace.{0} Real.Angle (PseudoMetricSpace.toUniformSpace.{0} Real.Angle (SeminormedAddCommGroup.toPseudoMetricSpace.{0} Real.Angle (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) SignType.topologicalSpace Real.Angle.sign θ)
-but is expected to have type
-  forall {θ : Real.Angle}, (Ne.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) -> (Ne.{1} Real.Angle θ (Real.Angle.coe Real.pi)) -> (ContinuousAt.{0, 0} Real.Angle SignType (UniformSpace.toTopologicalSpace.{0} Real.Angle (PseudoMetricSpace.toUniformSpace.{0} Real.Angle (SeminormedAddCommGroup.toPseudoMetricSpace.{0} Real.Angle (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))) instTopologicalSpaceSignType Real.Angle.sign θ)
-Case conversion may be inaccurate. Consider using '#align real.angle.continuous_at_sign Real.Angle.continuousAt_signₓ'. -/
 theorem continuousAt_sign {θ : Angle} (h0 : θ ≠ 0) (hpi : θ ≠ π) : ContinuousAt sign θ :=
   (continuousAt_sign_of_ne_zero (sin_ne_zero_iff.2 ⟨h0, hpi⟩)).comp continuous_sin.ContinuousAt
 #align real.angle.continuous_at_sign Real.Angle.continuousAt_sign
 
-/- warning: continuous_on.angle_sign_comp -> ContinuousOn.angle_sign_comp is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {f : α -> Real.Angle} {s : Set.{u1} α}, (ContinuousOn.{u1, 0} α Real.Angle _inst_1 (UniformSpace.toTopologicalSpace.{0} Real.Angle (PseudoMetricSpace.toUniformSpace.{0} Real.Angle (SeminormedAddCommGroup.toPseudoMetricSpace.{0} Real.Angle (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) f s) -> (forall (z : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) z s) -> (And (Ne.{1} Real.Angle (f z) (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (Ne.{1} Real.Angle (f z) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)))) -> (ContinuousOn.{u1, 0} α SignType _inst_1 SignType.topologicalSpace (Function.comp.{succ u1, 1, 1} α Real.Angle SignType Real.Angle.sign f) s)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {f : α -> Real.Angle} {s : Set.{u1} α}, (ContinuousOn.{u1, 0} α Real.Angle _inst_1 (UniformSpace.toTopologicalSpace.{0} Real.Angle (PseudoMetricSpace.toUniformSpace.{0} Real.Angle (SeminormedAddCommGroup.toPseudoMetricSpace.{0} Real.Angle (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))) f s) -> (forall (z : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) z s) -> (And (Ne.{1} Real.Angle (f z) (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (Ne.{1} Real.Angle (f z) (Real.Angle.coe Real.pi)))) -> (ContinuousOn.{u1, 0} α SignType _inst_1 instTopologicalSpaceSignType (Function.comp.{succ u1, 1, 1} α Real.Angle SignType Real.Angle.sign f) s)
-Case conversion may be inaccurate. Consider using '#align continuous_on.angle_sign_comp ContinuousOn.angle_sign_compₓ'. -/
 theorem 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 :=
   by
@@ -2007,12 +1095,6 @@ theorem ContinuousOn.angle_sign_comp {α : Type _} [TopologicalSpace α] {f : α
   exact continuous_at_sign (hs _ hz).1 (hs _ hz).2
 #align continuous_on.angle_sign_comp ContinuousOn.angle_sign_comp
 
-/- warning: real.angle.sign_eq_of_continuous_on -> Real.Angle.sign_eq_of_continuousOn is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {f : α -> Real.Angle} {s : Set.{u1} α} {x : α} {y : α}, (IsConnected.{u1} α _inst_1 s) -> (ContinuousOn.{u1, 0} α Real.Angle _inst_1 (UniformSpace.toTopologicalSpace.{0} Real.Angle (PseudoMetricSpace.toUniformSpace.{0} Real.Angle (SeminormedAddCommGroup.toPseudoMetricSpace.{0} Real.Angle (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) f s) -> (forall (z : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) z s) -> (And (Ne.{1} Real.Angle (f z) (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (Ne.{1} Real.Angle (f z) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)))) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) y s) -> (Eq.{1} SignType (Real.Angle.sign (f y)) (Real.Angle.sign (f x)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {f : α -> Real.Angle} {s : Set.{u1} α} {x : α} {y : α}, (IsConnected.{u1} α _inst_1 s) -> (ContinuousOn.{u1, 0} α Real.Angle _inst_1 (UniformSpace.toTopologicalSpace.{0} Real.Angle (PseudoMetricSpace.toUniformSpace.{0} Real.Angle (SeminormedAddCommGroup.toPseudoMetricSpace.{0} Real.Angle (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))) f s) -> (forall (z : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) z s) -> (And (Ne.{1} Real.Angle (f z) (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (Ne.{1} Real.Angle (f z) (Real.Angle.coe Real.pi)))) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) y s) -> (Eq.{1} SignType (Real.Angle.sign (f y)) (Real.Angle.sign (f x)))
-Case conversion may be inaccurate. Consider using '#align real.angle.sign_eq_of_continuous_on Real.Angle.sign_eq_of_continuousOnₓ'. -/
 /-- 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 α}

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -485,13 +485,10 @@ theorem sin_eq_iff_coe_eq_or_add_eq_pi {θ ψ : ℝ} :
     sin θ = sin ψ ↔ (θ : Angle) = ψ ∨ (θ : Angle) + ψ = π :=
   by
   constructor
-  · intro Hsin
-    rw [← cos_pi_div_two_sub, ← cos_pi_div_two_sub] at Hsin
+  · intro Hsin; rw [← cos_pi_div_two_sub, ← cos_pi_div_two_sub] at Hsin
     cases' cos_eq_iff_coe_eq_or_eq_neg.mp Hsin with h h
-    · left
-      rw [coe_sub, coe_sub] at h
-      exact sub_right_inj.1 h
-    right
+    · left; rw [coe_sub, coe_sub] at h; exact sub_right_inj.1 h
+    right;
     rw [coe_sub, coe_sub, eq_neg_iff_add_eq_zero, add_sub, sub_add_eq_add_sub, ← coe_add,
       add_halves, sub_sub, sub_eq_zero] at h
     exact h.symm
@@ -1857,9 +1854,7 @@ Case conversion may be inaccurate. Consider using '#align real.angle.eq_iff_sign
 theorem eq_iff_sign_eq_and_abs_toReal_eq {θ ψ : Angle} :
     θ = ψ ↔ θ.sign = ψ.sign ∧ |θ.toReal| = |ψ.toReal| :=
   by
-  refine' ⟨_, fun h => _⟩;
-  · rintro rfl
-    exact ⟨rfl, rfl⟩
+  refine' ⟨_, fun h => _⟩; · rintro rfl; exact ⟨rfl, rfl⟩
   rcases h with ⟨hs, hr⟩
   rw [abs_eq_abs] at hr
   rcases hr with (hr | hr)
@@ -1949,22 +1944,17 @@ theorem sign_two_nsmul_eq_sign_iff {θ : Angle} :
     rw [not_lt, le_abs, le_neg] at hle
     have hpi' : θ.to_real ≠ π := by simpa using hpi
     rcases hle with (hle | hle) <;> rcases hle.eq_or_lt with (heq | hlt)
-    · rw [← coe_to_real θ, ← HEq] at h
-      simpa using h
+    · rw [← coe_to_real θ, ← HEq] at h; simpa using h
     · rw [← sign_to_real hpi, sign_pos (pi_div_two_pos.trans hlt), ← sign_to_real,
         two_nsmul_to_real_eq_two_mul_sub_two_pi.2 hlt, _root_.sign_neg] at h
       · simpa using h
       · rw [← mul_sub]
         exact mul_neg_of_pos_of_neg two_pos (sub_neg.2 ((to_real_le_pi _).lt_of_ne hpi'))
-      · intro he
-        simpa [he] using h
-    · rw [← coe_to_real θ, HEq] at h
-      simpa using h
+      · intro he; simpa [he] using h
+    · rw [← coe_to_real θ, HEq] at h; simpa using h
     · rw [← sign_to_real hpi, _root_.sign_neg (hlt.trans (Left.neg_neg_iff.2 pi_div_two_pos)), ←
         sign_to_real] at h
-      swap
-      · intro he
-        simpa [he] using h
+      swap; · intro he; simpa [he] using h
       rw [← neg_div] at hlt
       rw [two_nsmul_to_real_eq_two_mul_add_two_pi.2 hlt.le, sign_pos] at h
       · simpa using h
@@ -1973,8 +1963,7 @@ theorem sign_two_nsmul_eq_sign_iff {θ : Angle} :
       by
       rw [Ne.def, two_nsmul_eq_pi_iff, not_or]
       constructor
-      · rintro rfl
-        simpa [pi_pos, div_pos, abs_of_pos] using h
+      · rintro rfl; simpa [pi_pos, div_pos, abs_of_pos] using h
       · rintro rfl
         rw [to_real_neg_pi_div_two] at h
         simpa [pi_pos, div_pos, neg_div, abs_of_pos] using h

mathlib commit https://github.com/leanprover-community/mathlib/commit/ef95945cd48c932c9e034872bd25c3c220d9c946

@@ -969,9 +969,9 @@ theorem abs_cos_eq_of_two_zsmul_eq {θ ψ : Angle} (h : (2 : ℤ) • θ = (2 :
 
 /- warning: real.angle.coe_to_Ico_mod -> Real.Angle.coe_toIcoMod is a dubious translation:
 lean 3 declaration is
-  forall (θ : Real) (ψ : Real), Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (toIcoMod.{0} Real Real.linearOrderedAddCommGroup Real.archimedean (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi) Real.two_pi_pos ψ θ)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ)
+  forall (θ : Real) (ψ : Real), Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (toIcoMod.{0} Real Real.linearOrderedAddCommGroup Real.instArchimedean (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi) Real.two_pi_pos ψ θ)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ)
 but is expected to have type
-  forall (θ : Real) (ψ : Real), Eq.{1} Real.Angle (Real.Angle.coe (toIcoMod.{0} Real Real.instLinearOrderedAddCommGroupReal Real.instArchimedeanRealOrderedAddCommMonoid (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi) Real.two_pi_pos ψ θ)) (Real.Angle.coe θ)
+  forall (θ : Real) (ψ : Real), Eq.{1} Real.Angle (Real.Angle.coe (toIcoMod.{0} Real Real.instLinearOrderedAddCommGroupReal Real.instArchimedean (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi) Real.two_pi_pos ψ θ)) (Real.Angle.coe θ)
 Case conversion may be inaccurate. Consider using '#align real.angle.coe_to_Ico_mod Real.Angle.coe_toIcoModₓ'. -/
 @[simp]
 theorem coe_toIcoMod (θ ψ : ℝ) : ↑(toIcoMod two_pi_pos ψ θ) = (θ : Angle) :=
@@ -983,9 +983,9 @@ theorem coe_toIcoMod (θ ψ : ℝ) : ↑(toIcoMod two_pi_pos ψ θ) = (θ : Angl
 
 /- warning: real.angle.coe_to_Ioc_mod -> Real.Angle.coe_toIocMod is a dubious translation:
 lean 3 declaration is
-  forall (θ : Real) (ψ : Real), Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (toIocMod.{0} Real Real.linearOrderedAddCommGroup Real.archimedean (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi) Real.two_pi_pos ψ θ)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ)
+  forall (θ : Real) (ψ : Real), Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (toIocMod.{0} Real Real.linearOrderedAddCommGroup Real.instArchimedean (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi) Real.two_pi_pos ψ θ)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ)
 but is expected to have type
-  forall (θ : Real) (ψ : Real), Eq.{1} Real.Angle (Real.Angle.coe (toIocMod.{0} Real Real.instLinearOrderedAddCommGroupReal Real.instArchimedeanRealOrderedAddCommMonoid (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi) Real.two_pi_pos ψ θ)) (Real.Angle.coe θ)
+  forall (θ : Real) (ψ : Real), Eq.{1} Real.Angle (Real.Angle.coe (toIocMod.{0} Real Real.instLinearOrderedAddCommGroupReal Real.instArchimedean (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi) Real.two_pi_pos ψ θ)) (Real.Angle.coe θ)
 Case conversion may be inaccurate. Consider using '#align real.angle.coe_to_Ioc_mod Real.Angle.coe_toIocModₓ'. -/
 @[simp]
 theorem coe_toIocMod (θ ψ : ℝ) : ↑(toIocMod two_pi_pos ψ θ) = (θ : Angle) :=
@@ -1004,9 +1004,9 @@ def toReal (θ : Angle) : ℝ :=
 
 /- warning: real.angle.to_real_coe -> Real.Angle.toReal_coe is a dubious translation:
 lean 3 declaration is
-  forall (θ : Real), Eq.{1} Real (Real.Angle.toReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ)) (toIocMod.{0} Real Real.linearOrderedAddCommGroup Real.archimedean (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi) Real.two_pi_pos (Neg.neg.{0} Real Real.hasNeg Real.pi) θ)
+  forall (θ : Real), Eq.{1} Real (Real.Angle.toReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ)) (toIocMod.{0} Real Real.linearOrderedAddCommGroup Real.instArchimedean (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi) Real.two_pi_pos (Neg.neg.{0} Real Real.hasNeg Real.pi) θ)
 but is expected to have type
-  forall (θ : Real), Eq.{1} Real (Real.Angle.toReal (Real.Angle.coe θ)) (toIocMod.{0} Real Real.instLinearOrderedAddCommGroupReal Real.instArchimedeanRealOrderedAddCommMonoid (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi) Real.two_pi_pos (Neg.neg.{0} Real Real.instNegReal Real.pi) θ)
+  forall (θ : Real), Eq.{1} Real (Real.Angle.toReal (Real.Angle.coe θ)) (toIocMod.{0} Real Real.instLinearOrderedAddCommGroupReal Real.instArchimedean (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi) Real.two_pi_pos (Neg.neg.{0} Real Real.instNegReal Real.pi) θ)
 Case conversion may be inaccurate. Consider using '#align real.angle.to_real_coe Real.Angle.toReal_coeₓ'. -/
 theorem toReal_coe (θ : ℝ) : (θ : Angle).toReal = toIocMod two_pi_pos (-π) θ :=
   rfl
@@ -1112,9 +1112,9 @@ theorem toReal_mem_Ioc (θ : Angle) : θ.toReal ∈ Set.Ioc (-π) π :=
 
 /- warning: real.angle.to_Ioc_mod_to_real -> Real.Angle.toIocMod_toReal is a dubious translation:
 lean 3 declaration is
-  forall (θ : Real.Angle), Eq.{1} Real (toIocMod.{0} Real Real.linearOrderedAddCommGroup Real.archimedean (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi) Real.two_pi_pos (Neg.neg.{0} Real Real.hasNeg Real.pi) (Real.Angle.toReal θ)) (Real.Angle.toReal θ)
+  forall (θ : Real.Angle), Eq.{1} Real (toIocMod.{0} Real Real.linearOrderedAddCommGroup Real.instArchimedean (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi) Real.two_pi_pos (Neg.neg.{0} Real Real.hasNeg Real.pi) (Real.Angle.toReal θ)) (Real.Angle.toReal θ)
 but is expected to have type
-  forall (θ : Real.Angle), Eq.{1} Real (toIocMod.{0} Real Real.instLinearOrderedAddCommGroupReal Real.instArchimedeanRealOrderedAddCommMonoid (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi) Real.two_pi_pos (Neg.neg.{0} Real Real.instNegReal Real.pi) (Real.Angle.toReal θ)) (Real.Angle.toReal θ)
+  forall (θ : Real.Angle), Eq.{1} Real (toIocMod.{0} Real Real.instLinearOrderedAddCommGroupReal Real.instArchimedean (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi) Real.two_pi_pos (Neg.neg.{0} Real Real.instNegReal Real.pi) (Real.Angle.toReal θ)) (Real.Angle.toReal θ)
 Case conversion may be inaccurate. Consider using '#align real.angle.to_Ioc_mod_to_real Real.Angle.toIocMod_toRealₓ'. -/
 @[simp]
 theorem toIocMod_toReal (θ : Angle) : toIocMod two_pi_pos (-π) θ.toReal = θ.toReal :=

mathlib commit https://github.com/leanprover-community/mathlib/commit/95a87616d63b3cb49d3fe678d416fbe9c4217bf4

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Calle Sönne
 
 ! This file was ported from Lean 3 source module analysis.special_functions.trigonometric.angle
-! leanprover-community/mathlib commit 213b0cff7bc5ab6696ee07cceec80829ce42efec
+! leanprover-community/mathlib commit 50251fd6309cca5ca2e747882ffecd2729f38c5d
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -16,6 +16,9 @@ import Mathbin.Topology.Instances.Sign
 /-!
 # The type of angles
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 In this file we define `real.angle` to be the quotient group `ℝ/2πℤ` and prove a few simple lemmas
 about trigonometric functions and angles.
 -/

mathlib commit https://github.com/leanprover-community/mathlib/commit/f8c79b0a623404854a2902b836eac32156fd7712

@@ -28,32 +28,58 @@ noncomputable section
 namespace Real
 
 /- ./././Mathport/Syntax/Translate/Command.lean:42:9: unsupported derive handler has_coe_t[has_coe_t] exprℝ() -/
+#print Real.Angle /-
 /-- The type of angles -/
 def Angle : Type :=
   AddCircle (2 * π)deriving NormedAddCommGroup, Inhabited,
   «./././Mathport/Syntax/Translate/Command.lean:42:9: unsupported derive handler has_coe_t[has_coe_t] exprℝ()»
 #align real.angle Real.Angle
+-/
 
 namespace Angle
 
 instance : CircularOrder Real.Angle :=
   @AddCircle.circularOrder _ _ _ _ _ ⟨by norm_num [pi_pos] ⟩ _
 
+/- warning: real.angle.continuous_coe -> Real.Angle.continuous_coe is a dubious translation:
+lean 3 declaration is
+  Continuous.{0, 0} Real Real.Angle (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (UniformSpace.toTopologicalSpace.{0} Real.Angle (PseudoMetricSpace.toUniformSpace.{0} Real.Angle (SeminormedAddCommGroup.toPseudoMetricSpace.{0} Real.Angle (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)))
+but is expected to have type
+  Continuous.{0, 0} Real Real.Angle (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (UniformSpace.toTopologicalSpace.{0} Real.Angle (PseudoMetricSpace.toUniformSpace.{0} Real.Angle (SeminormedAddCommGroup.toPseudoMetricSpace.{0} Real.Angle (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))) Real.Angle.coe
+Case conversion may be inaccurate. Consider using '#align real.angle.continuous_coe Real.Angle.continuous_coeₓ'. -/
 @[continuity]
 theorem continuous_coe : Continuous (coe : ℝ → Angle) :=
   continuous_quotient_mk'
 #align real.angle.continuous_coe Real.Angle.continuous_coe
 
+/- warning: real.angle.coe_hom -> Real.Angle.coeHom is a dubious translation:
+lean 3 declaration is
+  AddMonoidHom.{0, 0} Real Real.Angle (AddMonoid.toAddZeroClass.{0} Real Real.addMonoid) (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))
+but is expected to have type
+  AddMonoidHom.{0, 0} Real Real.Angle (AddMonoid.toAddZeroClass.{0} Real Real.instAddMonoidReal) (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))
+Case conversion may be inaccurate. Consider using '#align real.angle.coe_hom Real.Angle.coeHomₓ'. -/
 /-- Coercion `ℝ → angle` as an additive homomorphism. -/
 def coeHom : ℝ →+ Angle :=
   QuotientAddGroup.mk' _
 #align real.angle.coe_hom Real.Angle.coeHom
 
+/- warning: real.angle.coe_coe_hom -> Real.Angle.coe_coeHom is a dubious translation:
+lean 3 declaration is
+  Eq.{1} ((fun (_x : AddMonoidHom.{0, 0} Real Real.Angle (AddMonoid.toAddZeroClass.{0} Real Real.addMonoid) (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))) => Real -> Real.Angle) Real.Angle.coeHom) (coeFn.{1, 1} (AddMonoidHom.{0, 0} Real Real.Angle (AddMonoid.toAddZeroClass.{0} Real Real.addMonoid) (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))) (fun (_x : AddMonoidHom.{0, 0} Real Real.Angle (AddMonoid.toAddZeroClass.{0} Real Real.addMonoid) (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))) => Real -> Real.Angle) (AddMonoidHom.hasCoeToFun.{0, 0} Real Real.Angle (AddMonoid.toAddZeroClass.{0} Real Real.addMonoid) (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))) Real.Angle.coeHom) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)))
+but is expected to have type
+  Eq.{1} (forall (a : Real), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : Real) => Real.Angle) a) (FunLike.coe.{1, 1, 1} (AddMonoidHom.{0, 0} Real Real.Angle (AddMonoid.toAddZeroClass.{0} Real Real.instAddMonoidReal) (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) Real (fun (_x : Real) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : Real) => Real.Angle) _x) (AddHomClass.toFunLike.{0, 0, 0} (AddMonoidHom.{0, 0} Real Real.Angle (AddMonoid.toAddZeroClass.{0} Real Real.instAddMonoidReal) (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) Real Real.Angle (AddZeroClass.toAdd.{0} Real (AddMonoid.toAddZeroClass.{0} Real Real.instAddMonoidReal)) (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (AddMonoidHomClass.toAddHomClass.{0, 0, 0} (AddMonoidHom.{0, 0} Real Real.Angle (AddMonoid.toAddZeroClass.{0} Real Real.instAddMonoidReal) (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) Real Real.Angle (AddMonoid.toAddZeroClass.{0} Real Real.instAddMonoidReal) (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (AddMonoidHom.addMonoidHomClass.{0, 0} Real Real.Angle (AddMonoid.toAddZeroClass.{0} Real Real.instAddMonoidReal) (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))))) Real.Angle.coeHom) Real.Angle.coe
+Case conversion may be inaccurate. Consider using '#align real.angle.coe_coe_hom Real.Angle.coe_coeHomₓ'. -/
 @[simp]
 theorem coe_coeHom : (coeHom : ℝ → Angle) = coe :=
   rfl
 #align real.angle.coe_coe_hom Real.Angle.coe_coeHom
 
+/- warning: real.angle.induction_on -> Real.Angle.induction_on is a dubious translation:
+lean 3 declaration is
+  forall {p : Real.Angle -> Prop} (θ : Real.Angle), (forall (x : Real), p ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) x)) -> (p θ)
+but is expected to have type
+  forall {p : Real.Angle -> Prop} (θ : Real.Angle), (forall (x : Real), p (Real.Angle.coe x)) -> (p θ)
+Case conversion may be inaccurate. Consider using '#align real.angle.induction_on Real.Angle.induction_onₓ'. -/
 /-- An induction principle to deduce results for `angle` from those for `ℝ`, used with
 `induction θ using real.angle.induction_on`. -/
 @[elab_as_elim]
@@ -61,54 +87,120 @@ protected theorem induction_on {p : Angle → Prop} (θ : Angle) (h : ∀ x : 
   Quotient.inductionOn' θ h
 #align real.angle.induction_on Real.Angle.induction_on
 
+/- warning: real.angle.coe_zero -> Real.Angle.coe_zero is a dubious translation:
+lean 3 declaration is
+  Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))
+but is expected to have type
+  Eq.{1} Real.Angle (Real.Angle.coe (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))
+Case conversion may be inaccurate. Consider using '#align real.angle.coe_zero Real.Angle.coe_zeroₓ'. -/
 @[simp]
 theorem coe_zero : ↑(0 : ℝ) = (0 : Angle) :=
   rfl
 #align real.angle.coe_zero Real.Angle.coe_zero
 
+/- warning: real.angle.coe_add -> Real.Angle.coe_add is a dubious translation:
+lean 3 declaration is
+  forall (x : Real) (y : Real), Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) x y)) (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) x) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) y))
+but is expected to have type
+  forall (x : Real) (y : Real), Eq.{1} Real.Angle (Real.Angle.coe (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) x y)) (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) (Real.Angle.coe x) (Real.Angle.coe y))
+Case conversion may be inaccurate. Consider using '#align real.angle.coe_add Real.Angle.coe_addₓ'. -/
 @[simp]
 theorem coe_add (x y : ℝ) : ↑(x + y : ℝ) = (↑x + ↑y : Angle) :=
   rfl
 #align real.angle.coe_add Real.Angle.coe_add
 
+/- warning: real.angle.coe_neg -> Real.Angle.coe_neg is a dubious translation:
+lean 3 declaration is
+  forall (x : Real), Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (Neg.neg.{0} Real Real.hasNeg x)) (Neg.neg.{0} Real.Angle (SubNegMonoid.toHasNeg.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) x))
+but is expected to have type
+  forall (x : Real), Eq.{1} Real.Angle (Real.Angle.coe (Neg.neg.{0} Real Real.instNegReal x)) (Neg.neg.{0} Real.Angle (NegZeroClass.toNeg.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (Real.Angle.coe x))
+Case conversion may be inaccurate. Consider using '#align real.angle.coe_neg Real.Angle.coe_negₓ'. -/
 @[simp]
 theorem coe_neg (x : ℝ) : ↑(-x : ℝ) = -(↑x : Angle) :=
   rfl
 #align real.angle.coe_neg Real.Angle.coe_neg
 
+/- warning: real.angle.coe_sub -> Real.Angle.coe_sub is a dubious translation:
+lean 3 declaration is
+  forall (x : Real) (y : Real), Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) x y)) (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toHasSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) x) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) y))
+but is expected to have type
+  forall (x : Real) (y : Real), Eq.{1} Real.Angle (Real.Angle.coe (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) x y)) (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (Real.Angle.coe x) (Real.Angle.coe y))
+Case conversion may be inaccurate. Consider using '#align real.angle.coe_sub Real.Angle.coe_subₓ'. -/
 @[simp]
 theorem coe_sub (x y : ℝ) : ↑(x - y : ℝ) = (↑x - ↑y : Angle) :=
   rfl
 #align real.angle.coe_sub Real.Angle.coe_sub
 
+/- warning: real.angle.coe_nsmul -> Real.Angle.coe_nsmul is a dubious translation:
+lean 3 declaration is
+  forall (n : Nat) (x : Real), Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (SMul.smul.{0, 0} Nat Real (AddMonoid.SMul.{0} Real Real.addMonoid) n x)) (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) n ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) x))
+but is expected to have type
+  forall (n : Nat) (x : Real), Eq.{1} Real.Angle (Real.Angle.coe (HSMul.hSMul.{0, 0, 0} Nat Real Real (instHSMul.{0, 0} Nat Real (AddMonoid.SMul.{0} Real Real.instAddMonoidReal)) n x)) (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) n (Real.Angle.coe x))
+Case conversion may be inaccurate. Consider using '#align real.angle.coe_nsmul Real.Angle.coe_nsmulₓ'. -/
 theorem coe_nsmul (n : ℕ) (x : ℝ) : ↑(n • x : ℝ) = (n • ↑x : Angle) :=
   rfl
 #align real.angle.coe_nsmul Real.Angle.coe_nsmul
 
+/- warning: real.angle.coe_zsmul -> Real.Angle.coe_zsmul is a dubious translation:
+lean 3 declaration is
+  forall (z : Int) (x : Real), Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (SMul.smul.{0, 0} Int Real (SubNegMonoid.SMulInt.{0} Real (AddGroup.toSubNegMonoid.{0} Real Real.addGroup)) z x)) (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) z ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) x))
+but is expected to have type
+  forall (z : Int) (x : Real), Eq.{1} Real.Angle (Real.Angle.coe (HSMul.hSMul.{0, 0, 0} Int Real Real (instHSMul.{0, 0} Int Real (SubNegMonoid.SMulInt.{0} Real (AddGroup.toSubNegMonoid.{0} Real Real.instAddGroupReal))) z x)) (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) z (Real.Angle.coe x))
+Case conversion may be inaccurate. Consider using '#align real.angle.coe_zsmul Real.Angle.coe_zsmulₓ'. -/
 theorem coe_zsmul (z : ℤ) (x : ℝ) : ↑(z • x : ℝ) = (z • ↑x : Angle) :=
   rfl
 #align real.angle.coe_zsmul Real.Angle.coe_zsmul
 
+/- warning: real.angle.coe_nat_mul_eq_nsmul -> Real.Angle.coe_nat_mul_eq_nsmul is a dubious translation:
+lean 3 declaration is
+  forall (x : Real) (n : Nat), Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Real (HasLiftT.mk.{1, 1} Nat Real (CoeTCₓ.coe.{1, 1} Nat Real (Nat.castCoe.{0} Real Real.hasNatCast))) n) x)) (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) n ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) x))
+but is expected to have type
+  forall (x : Real) (n : Nat), Eq.{1} Real.Angle (Real.Angle.coe (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Nat.cast.{0} Real Real.natCast n) x)) (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) n (Real.Angle.coe x))
+Case conversion may be inaccurate. Consider using '#align real.angle.coe_nat_mul_eq_nsmul Real.Angle.coe_nat_mul_eq_nsmulₓ'. -/
 @[simp, norm_cast]
 theorem coe_nat_mul_eq_nsmul (x : ℝ) (n : ℕ) : ↑((n : ℝ) * x) = n • (↑x : Angle) := by
   simpa only [nsmul_eq_mul] using coe_hom.map_nsmul x n
 #align real.angle.coe_nat_mul_eq_nsmul Real.Angle.coe_nat_mul_eq_nsmul
 
+/- warning: real.angle.coe_int_mul_eq_zsmul -> Real.Angle.coe_int_mul_eq_zsmul is a dubious translation:
+lean 3 declaration is
+  forall (x : Real) (n : Int), Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Int Real (HasLiftT.mk.{1, 1} Int Real (CoeTCₓ.coe.{1, 1} Int Real (Int.castCoe.{0} Real Real.hasIntCast))) n) x)) (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) n ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) x))
+but is expected to have type
+  forall (x : Real) (n : Int), Eq.{1} Real.Angle (Real.Angle.coe (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Int.cast.{0} Real Real.intCast n) x)) (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) n (Real.Angle.coe x))
+Case conversion may be inaccurate. Consider using '#align real.angle.coe_int_mul_eq_zsmul Real.Angle.coe_int_mul_eq_zsmulₓ'. -/
 @[simp, norm_cast]
 theorem coe_int_mul_eq_zsmul (x : ℝ) (n : ℤ) : ↑((n : ℝ) * x : ℝ) = n • (↑x : Angle) := by
   simpa only [zsmul_eq_mul] using coe_hom.map_zsmul x n
 #align real.angle.coe_int_mul_eq_zsmul Real.Angle.coe_int_mul_eq_zsmul
 
+/- warning: real.angle.angle_eq_iff_two_pi_dvd_sub -> Real.Angle.angle_eq_iff_two_pi_dvd_sub is a dubious translation:
+lean 3 declaration is
+  forall {ψ : Real} {θ : Real}, Iff (Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) ψ)) (Exists.{1} Int (fun (k : Int) => Eq.{1} Real (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) θ ψ) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Int Real (HasLiftT.mk.{1, 1} Int Real (CoeTCₓ.coe.{1, 1} Int Real (Int.castCoe.{0} Real Real.hasIntCast))) k))))
+but is expected to have type
+  forall {ψ : Real} {θ : Real}, Iff (Eq.{1} Real.Angle (Real.Angle.coe θ) (Real.Angle.coe ψ)) (Exists.{1} Int (fun (k : Int) => Eq.{1} Real (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) θ ψ) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi) (Int.cast.{0} Real Real.intCast k))))
+Case conversion may be inaccurate. Consider using '#align real.angle.angle_eq_iff_two_pi_dvd_sub Real.Angle.angle_eq_iff_two_pi_dvd_subₓ'. -/
 theorem angle_eq_iff_two_pi_dvd_sub {ψ θ : ℝ} : (θ : Angle) = ψ ↔ ∃ k : ℤ, θ - ψ = 2 * π * k := by
   simp only [QuotientAddGroup.eq, AddSubgroup.zmultiples_eq_closure,
     AddSubgroup.mem_closure_singleton, zsmul_eq_mul', (sub_eq_neg_add _ _).symm, eq_comm]
 #align real.angle.angle_eq_iff_two_pi_dvd_sub Real.Angle.angle_eq_iff_two_pi_dvd_sub
 
+/- warning: real.angle.coe_two_pi -> Real.Angle.coe_two_pi is a dubious translation:
+lean 3 declaration is
+  Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi)) (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))
+but is expected to have type
+  Eq.{1} Real.Angle (Real.Angle.coe (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi)) (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))
+Case conversion may be inaccurate. Consider using '#align real.angle.coe_two_pi Real.Angle.coe_two_piₓ'. -/
 @[simp]
 theorem coe_two_pi : ↑(2 * π : ℝ) = (0 : Angle) :=
   angle_eq_iff_two_pi_dvd_sub.2 ⟨1, by rw [sub_zero, Int.cast_one, mul_one]⟩
 #align real.angle.coe_two_pi Real.Angle.coe_two_pi
 
+/- warning: real.angle.neg_coe_pi -> Real.Angle.neg_coe_pi is a dubious translation:
+lean 3 declaration is
+  Eq.{1} Real.Angle (Neg.neg.{0} Real.Angle (SubNegMonoid.toHasNeg.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)
+but is expected to have type
+  Eq.{1} Real.Angle (Neg.neg.{0} Real.Angle (NegZeroClass.toNeg.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (Real.Angle.coe Real.pi)) (Real.Angle.coe Real.pi)
+Case conversion may be inaccurate. Consider using '#align real.angle.neg_coe_pi Real.Angle.neg_coe_piₓ'. -/
 @[simp]
 theorem neg_coe_pi : -(π : Angle) = π :=
   by
@@ -117,92 +209,218 @@ theorem neg_coe_pi : -(π : Angle) = π :=
   simp [two_mul, sub_eq_add_neg]
 #align real.angle.neg_coe_pi Real.Angle.neg_coe_pi
 
+/- warning: real.angle.two_nsmul_coe_div_two -> Real.Angle.two_nsmul_coe_div_two is a dubious translation:
+lean 3 declaration is
+  forall (θ : Real), Eq.{1} Real.Angle (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) θ (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ)
+but is expected to have type
+  forall (θ : Real), Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) θ (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))) (Real.Angle.coe θ)
+Case conversion may be inaccurate. Consider using '#align real.angle.two_nsmul_coe_div_two Real.Angle.two_nsmul_coe_div_twoₓ'. -/
 @[simp]
 theorem two_nsmul_coe_div_two (θ : ℝ) : (2 : ℕ) • (↑(θ / 2) : Angle) = θ := by
   rw [← coe_nsmul, two_nsmul, add_halves]
 #align real.angle.two_nsmul_coe_div_two Real.Angle.two_nsmul_coe_div_two
 
+/- warning: real.angle.two_zsmul_coe_div_two -> Real.Angle.two_zsmul_coe_div_two is a dubious translation:
+lean 3 declaration is
+  forall (θ : Real), Eq.{1} Real.Angle (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) θ (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ)
+but is expected to have type
+  forall (θ : Real), Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) θ (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))) (Real.Angle.coe θ)
+Case conversion may be inaccurate. Consider using '#align real.angle.two_zsmul_coe_div_two Real.Angle.two_zsmul_coe_div_twoₓ'. -/
 @[simp]
 theorem two_zsmul_coe_div_two (θ : ℝ) : (2 : ℤ) • (↑(θ / 2) : Angle) = θ := by
   rw [← coe_zsmul, two_zsmul, add_halves]
 #align real.angle.two_zsmul_coe_div_two Real.Angle.two_zsmul_coe_div_two
 
+/- warning: real.angle.two_nsmul_neg_pi_div_two -> Real.Angle.two_nsmul_neg_pi_div_two is a dubious translation:
+lean 3 declaration is
+  Eq.{1} Real.Angle (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Neg.neg.{0} Real Real.hasNeg Real.pi) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)
+but is expected to have type
+  Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Neg.neg.{0} Real Real.instNegReal Real.pi) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))) (Real.Angle.coe Real.pi)
+Case conversion may be inaccurate. Consider using '#align real.angle.two_nsmul_neg_pi_div_two Real.Angle.two_nsmul_neg_pi_div_twoₓ'. -/
 @[simp]
 theorem two_nsmul_neg_pi_div_two : (2 : ℕ) • (↑(-π / 2) : Angle) = π := by
   rw [two_nsmul_coe_div_two, coe_neg, neg_coe_pi]
 #align real.angle.two_nsmul_neg_pi_div_two Real.Angle.two_nsmul_neg_pi_div_two
 
+/- warning: real.angle.two_zsmul_neg_pi_div_two -> Real.Angle.two_zsmul_neg_pi_div_two is a dubious translation:
+lean 3 declaration is
+  Eq.{1} Real.Angle (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Neg.neg.{0} Real Real.hasNeg Real.pi) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)
+but is expected to have type
+  Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Neg.neg.{0} Real Real.instNegReal Real.pi) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))) (Real.Angle.coe Real.pi)
+Case conversion may be inaccurate. Consider using '#align real.angle.two_zsmul_neg_pi_div_two Real.Angle.two_zsmul_neg_pi_div_twoₓ'. -/
 @[simp]
 theorem two_zsmul_neg_pi_div_two : (2 : ℤ) • (↑(-π / 2) : Angle) = π := by
   rw [two_zsmul, ← two_nsmul, two_nsmul_neg_pi_div_two]
 #align real.angle.two_zsmul_neg_pi_div_two Real.Angle.two_zsmul_neg_pi_div_two
 
+/- warning: real.angle.sub_coe_pi_eq_add_coe_pi -> Real.Angle.sub_coe_pi_eq_add_coe_pi is a dubious translation:
+lean 3 declaration is
+  forall (θ : Real.Angle), Eq.{1} Real.Angle (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toHasSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi))
+but is expected to have type
+  forall (θ : Real.Angle), Eq.{1} Real.Angle (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) θ (Real.Angle.coe Real.pi)) (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) θ (Real.Angle.coe Real.pi))
+Case conversion may be inaccurate. Consider using '#align real.angle.sub_coe_pi_eq_add_coe_pi Real.Angle.sub_coe_pi_eq_add_coe_piₓ'. -/
 theorem sub_coe_pi_eq_add_coe_pi (θ : Angle) : θ - π = θ + π := by rw [sub_eq_add_neg, neg_coe_pi]
 #align real.angle.sub_coe_pi_eq_add_coe_pi Real.Angle.sub_coe_pi_eq_add_coe_pi
 
+/- warning: real.angle.two_nsmul_coe_pi -> Real.Angle.two_nsmul_coe_pi is a dubious translation:
+lean 3 declaration is
+  Eq.{1} Real.Angle (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))
+but is expected to have type
+  Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) (Real.Angle.coe Real.pi)) (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))
+Case conversion may be inaccurate. Consider using '#align real.angle.two_nsmul_coe_pi Real.Angle.two_nsmul_coe_piₓ'. -/
 @[simp]
 theorem two_nsmul_coe_pi : (2 : ℕ) • (π : Angle) = 0 := by simp [← coe_nat_mul_eq_nsmul]
 #align real.angle.two_nsmul_coe_pi Real.Angle.two_nsmul_coe_pi
 
+/- warning: real.angle.two_zsmul_coe_pi -> Real.Angle.two_zsmul_coe_pi is a dubious translation:
+lean 3 declaration is
+  Eq.{1} Real.Angle (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))
+but is expected to have type
+  Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) (Real.Angle.coe Real.pi)) (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))
+Case conversion may be inaccurate. Consider using '#align real.angle.two_zsmul_coe_pi Real.Angle.two_zsmul_coe_piₓ'. -/
 @[simp]
 theorem two_zsmul_coe_pi : (2 : ℤ) • (π : Angle) = 0 := by simp [← coe_int_mul_eq_zsmul]
 #align real.angle.two_zsmul_coe_pi Real.Angle.two_zsmul_coe_pi
 
+/- warning: real.angle.coe_pi_add_coe_pi -> Real.Angle.coe_pi_add_coe_pi is a dubious translation:
+lean 3 declaration is
+  Eq.{1} Real.Angle (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))
+but is expected to have type
+  Eq.{1} Real.Angle (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) (Real.Angle.coe Real.pi) (Real.Angle.coe Real.pi)) (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))
+Case conversion may be inaccurate. Consider using '#align real.angle.coe_pi_add_coe_pi Real.Angle.coe_pi_add_coe_piₓ'. -/
 @[simp]
 theorem coe_pi_add_coe_pi : (π : Real.Angle) + π = 0 := by rw [← two_nsmul, two_nsmul_coe_pi]
 #align real.angle.coe_pi_add_coe_pi Real.Angle.coe_pi_add_coe_pi
 
+/- warning: real.angle.zsmul_eq_iff -> Real.Angle.zsmul_eq_iff is a dubious translation:
+lean 3 declaration is
+  forall {ψ : Real.Angle} {θ : Real.Angle} {z : Int}, (Ne.{1} Int z (OfNat.ofNat.{0} Int 0 (OfNat.mk.{0} Int 0 (Zero.zero.{0} Int Int.hasZero)))) -> (Iff (Eq.{1} Real.Angle (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) z ψ) (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) z θ)) (Exists.{1} (Fin (Int.natAbs z)) (fun (k : Fin (Int.natAbs z)) => Eq.{1} Real.Angle ψ (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) θ (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Fin (Int.natAbs z)) Nat (HasLiftT.mk.{1, 1} (Fin (Int.natAbs z)) Nat (CoeTCₓ.coe.{1, 1} (Fin (Int.natAbs z)) Nat (coeBase.{1, 1} (Fin (Int.natAbs z)) Nat (Fin.coeToNat (Int.natAbs z))))) k) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Int Real (HasLiftT.mk.{1, 1} Int Real (CoeTCₓ.coe.{1, 1} Int Real (Int.castCoe.{0} Real Real.hasIntCast))) z))))))))
+but is expected to have type
+  forall {ψ : Real.Angle} {θ : Real.Angle} {z : Int}, (Ne.{1} Int z (OfNat.ofNat.{0} Int 0 (instOfNatInt 0))) -> (Iff (Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) z ψ) (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) z θ)) (Exists.{1} (Fin (Int.natAbs z)) (fun (k : Fin (Int.natAbs z)) => Eq.{1} Real.Angle ψ (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) θ (Real.Angle.coe (HSMul.hSMul.{0, 0, 0} Nat Real Real (instHSMul.{0, 0} Nat Real (AddMonoid.SMul.{0} Real Real.instAddMonoidReal)) (Fin.val (Int.natAbs z) k) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi) (Int.cast.{0} Real Real.intCast z))))))))
+Case conversion may be inaccurate. Consider using '#align real.angle.zsmul_eq_iff Real.Angle.zsmul_eq_iffₓ'. -/
 theorem zsmul_eq_iff {ψ θ : Angle} {z : ℤ} (hz : z ≠ 0) :
     z • ψ = z • θ ↔ ∃ k : Fin z.natAbs, ψ = θ + (k : ℕ) • (2 * π / z : ℝ) :=
   QuotientAddGroup.zmultiples_zsmul_eq_zsmul_iff hz
 #align real.angle.zsmul_eq_iff Real.Angle.zsmul_eq_iff
 
+/- warning: real.angle.nsmul_eq_iff -> Real.Angle.nsmul_eq_iff is a dubious translation:
+lean 3 declaration is
+  forall {ψ : Real.Angle} {θ : Real.Angle} {n : Nat}, (Ne.{1} Nat n (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) -> (Iff (Eq.{1} Real.Angle (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) n ψ) (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) n θ)) (Exists.{1} (Fin n) (fun (k : Fin n) => Eq.{1} Real.Angle ψ (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) θ (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) (Fin n) Nat (HasLiftT.mk.{1, 1} (Fin n) Nat (CoeTCₓ.coe.{1, 1} (Fin n) Nat (coeBase.{1, 1} (Fin n) Nat (Fin.coeToNat n)))) k) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Real (HasLiftT.mk.{1, 1} Nat Real (CoeTCₓ.coe.{1, 1} Nat Real (Nat.castCoe.{0} Real Real.hasNatCast))) n))))))))
+but is expected to have type
+  forall {ψ : Real.Angle} {θ : Real.Angle} {n : Nat}, (Ne.{1} Nat n (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) -> (Iff (Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) n ψ) (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) n θ)) (Exists.{1} (Fin n) (fun (k : Fin n) => Eq.{1} Real.Angle ψ (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) θ (Real.Angle.coe (HSMul.hSMul.{0, 0, 0} Nat Real Real (instHSMul.{0, 0} Nat Real (AddMonoid.SMul.{0} Real Real.instAddMonoidReal)) (Fin.val n k) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi) (Nat.cast.{0} Real Real.natCast n))))))))
+Case conversion may be inaccurate. Consider using '#align real.angle.nsmul_eq_iff Real.Angle.nsmul_eq_iffₓ'. -/
 theorem nsmul_eq_iff {ψ θ : Angle} {n : ℕ} (hz : n ≠ 0) :
     n • ψ = n • θ ↔ ∃ k : Fin n, ψ = θ + (k : ℕ) • (2 * π / n : ℝ) :=
   QuotientAddGroup.zmultiples_nsmul_eq_nsmul_iff hz
 #align real.angle.nsmul_eq_iff Real.Angle.nsmul_eq_iff
 
+/- warning: real.angle.two_zsmul_eq_iff -> Real.Angle.two_zsmul_eq_iff is a dubious translation:
+lean 3 declaration is
+  forall {ψ : Real.Angle} {θ : Real.Angle}, Iff (Eq.{1} Real.Angle (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) ψ) (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) θ)) (Or (Eq.{1} Real.Angle ψ θ) (Eq.{1} Real.Angle ψ (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi))))
+but is expected to have type
+  forall {ψ : Real.Angle} {θ : Real.Angle}, Iff (Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) ψ) (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) θ)) (Or (Eq.{1} Real.Angle ψ θ) (Eq.{1} Real.Angle ψ (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) θ (Real.Angle.coe Real.pi))))
+Case conversion may be inaccurate. Consider using '#align real.angle.two_zsmul_eq_iff Real.Angle.two_zsmul_eq_iffₓ'. -/
 theorem two_zsmul_eq_iff {ψ θ : Angle} : (2 : ℤ) • ψ = (2 : ℤ) • θ ↔ ψ = θ ∨ ψ = θ + π := by
   rw [zsmul_eq_iff two_ne_zero, Int.natAbs_bit0, Int.natAbs_one, Fin.exists_fin_two, Fin.val_zero,
     Fin.val_one, zero_smul, add_zero, one_smul, Int.cast_two,
     mul_div_cancel_left (_ : ℝ) two_ne_zero]
 #align real.angle.two_zsmul_eq_iff Real.Angle.two_zsmul_eq_iff
 
+/- warning: real.angle.two_nsmul_eq_iff -> Real.Angle.two_nsmul_eq_iff is a dubious translation:
+lean 3 declaration is
+  forall {ψ : Real.Angle} {θ : Real.Angle}, Iff (Eq.{1} Real.Angle (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) ψ) (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) θ)) (Or (Eq.{1} Real.Angle ψ θ) (Eq.{1} Real.Angle ψ (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi))))
+but is expected to have type
+  forall {ψ : Real.Angle} {θ : Real.Angle}, Iff (Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) ψ) (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) θ)) (Or (Eq.{1} Real.Angle ψ θ) (Eq.{1} Real.Angle ψ (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) θ (Real.Angle.coe Real.pi))))
+Case conversion may be inaccurate. Consider using '#align real.angle.two_nsmul_eq_iff Real.Angle.two_nsmul_eq_iffₓ'. -/
 theorem two_nsmul_eq_iff {ψ θ : Angle} : (2 : ℕ) • ψ = (2 : ℕ) • θ ↔ ψ = θ ∨ ψ = θ + π := by
   simp_rw [← coe_nat_zsmul, Int.ofNat_bit0, Int.ofNat_one, two_zsmul_eq_iff]
 #align real.angle.two_nsmul_eq_iff Real.Angle.two_nsmul_eq_iff
 
+/- warning: real.angle.two_nsmul_eq_zero_iff -> Real.Angle.two_nsmul_eq_zero_iff is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real.Angle (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) θ) (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (Or (Eq.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)))
+but is expected to have type
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) θ) (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (Or (Eq.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (Eq.{1} Real.Angle θ (Real.Angle.coe Real.pi)))
+Case conversion may be inaccurate. Consider using '#align real.angle.two_nsmul_eq_zero_iff Real.Angle.two_nsmul_eq_zero_iffₓ'. -/
 theorem two_nsmul_eq_zero_iff {θ : Angle} : (2 : ℕ) • θ = 0 ↔ θ = 0 ∨ θ = π := by
   convert two_nsmul_eq_iff <;> simp
 #align real.angle.two_nsmul_eq_zero_iff Real.Angle.two_nsmul_eq_zero_iff
 
+/- warning: real.angle.two_nsmul_ne_zero_iff -> Real.Angle.two_nsmul_ne_zero_iff is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, Iff (Ne.{1} Real.Angle (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) θ) (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (And (Ne.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (Ne.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)))
+but is expected to have type
+  forall {θ : Real.Angle}, Iff (Ne.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) θ) (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (And (Ne.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (Ne.{1} Real.Angle θ (Real.Angle.coe Real.pi)))
+Case conversion may be inaccurate. Consider using '#align real.angle.two_nsmul_ne_zero_iff Real.Angle.two_nsmul_ne_zero_iffₓ'. -/
 theorem two_nsmul_ne_zero_iff {θ : Angle} : (2 : ℕ) • θ ≠ 0 ↔ θ ≠ 0 ∧ θ ≠ π := by
   rw [← not_or, ← two_nsmul_eq_zero_iff]
 #align real.angle.two_nsmul_ne_zero_iff Real.Angle.two_nsmul_ne_zero_iff
 
+/- warning: real.angle.two_zsmul_eq_zero_iff -> Real.Angle.two_zsmul_eq_zero_iff is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real.Angle (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) θ) (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (Or (Eq.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)))
+but is expected to have type
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) θ) (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (Or (Eq.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (Eq.{1} Real.Angle θ (Real.Angle.coe Real.pi)))
+Case conversion may be inaccurate. Consider using '#align real.angle.two_zsmul_eq_zero_iff Real.Angle.two_zsmul_eq_zero_iffₓ'. -/
 theorem two_zsmul_eq_zero_iff {θ : Angle} : (2 : ℤ) • θ = 0 ↔ θ = 0 ∨ θ = π := by
   simp_rw [two_zsmul, ← two_nsmul, two_nsmul_eq_zero_iff]
 #align real.angle.two_zsmul_eq_zero_iff Real.Angle.two_zsmul_eq_zero_iff
 
+/- warning: real.angle.two_zsmul_ne_zero_iff -> Real.Angle.two_zsmul_ne_zero_iff is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, Iff (Ne.{1} Real.Angle (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) θ) (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (And (Ne.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (Ne.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)))
+but is expected to have type
+  forall {θ : Real.Angle}, Iff (Ne.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) θ) (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (And (Ne.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (Ne.{1} Real.Angle θ (Real.Angle.coe Real.pi)))
+Case conversion may be inaccurate. Consider using '#align real.angle.two_zsmul_ne_zero_iff Real.Angle.two_zsmul_ne_zero_iffₓ'. -/
 theorem two_zsmul_ne_zero_iff {θ : Angle} : (2 : ℤ) • θ ≠ 0 ↔ θ ≠ 0 ∧ θ ≠ π := by
   rw [← not_or, ← two_zsmul_eq_zero_iff]
 #align real.angle.two_zsmul_ne_zero_iff Real.Angle.two_zsmul_ne_zero_iff
 
+/- warning: real.angle.eq_neg_self_iff -> Real.Angle.eq_neg_self_iff is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real.Angle θ (Neg.neg.{0} Real.Angle (SubNegMonoid.toHasNeg.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) θ)) (Or (Eq.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)))
+but is expected to have type
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real.Angle θ (Neg.neg.{0} Real.Angle (NegZeroClass.toNeg.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) θ)) (Or (Eq.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (Eq.{1} Real.Angle θ (Real.Angle.coe Real.pi)))
+Case conversion may be inaccurate. Consider using '#align real.angle.eq_neg_self_iff Real.Angle.eq_neg_self_iffₓ'. -/
 theorem eq_neg_self_iff {θ : Angle} : θ = -θ ↔ θ = 0 ∨ θ = π := by
   rw [← add_eq_zero_iff_eq_neg, ← two_nsmul, two_nsmul_eq_zero_iff]
 #align real.angle.eq_neg_self_iff Real.Angle.eq_neg_self_iff
 
+/- warning: real.angle.ne_neg_self_iff -> Real.Angle.ne_neg_self_iff is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, Iff (Ne.{1} Real.Angle θ (Neg.neg.{0} Real.Angle (SubNegMonoid.toHasNeg.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) θ)) (And (Ne.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (Ne.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)))
+but is expected to have type
+  forall {θ : Real.Angle}, Iff (Ne.{1} Real.Angle θ (Neg.neg.{0} Real.Angle (NegZeroClass.toNeg.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) θ)) (And (Ne.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (Ne.{1} Real.Angle θ (Real.Angle.coe Real.pi)))
+Case conversion may be inaccurate. Consider using '#align real.angle.ne_neg_self_iff Real.Angle.ne_neg_self_iffₓ'. -/
 theorem ne_neg_self_iff {θ : Angle} : θ ≠ -θ ↔ θ ≠ 0 ∧ θ ≠ π := by
   rw [← not_or, ← eq_neg_self_iff.not]
 #align real.angle.ne_neg_self_iff Real.Angle.ne_neg_self_iff
 
+/- warning: real.angle.neg_eq_self_iff -> Real.Angle.neg_eq_self_iff is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real.Angle (Neg.neg.{0} Real.Angle (SubNegMonoid.toHasNeg.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) θ) θ) (Or (Eq.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)))
+but is expected to have type
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real.Angle (Neg.neg.{0} Real.Angle (NegZeroClass.toNeg.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) θ) θ) (Or (Eq.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (Eq.{1} Real.Angle θ (Real.Angle.coe Real.pi)))
+Case conversion may be inaccurate. Consider using '#align real.angle.neg_eq_self_iff Real.Angle.neg_eq_self_iffₓ'. -/
 theorem neg_eq_self_iff {θ : Angle} : -θ = θ ↔ θ = 0 ∨ θ = π := by rw [eq_comm, eq_neg_self_iff]
 #align real.angle.neg_eq_self_iff Real.Angle.neg_eq_self_iff
 
+/- warning: real.angle.neg_ne_self_iff -> Real.Angle.neg_ne_self_iff is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, Iff (Ne.{1} Real.Angle (Neg.neg.{0} Real.Angle (SubNegMonoid.toHasNeg.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) θ) θ) (And (Ne.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (Ne.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)))
+but is expected to have type
+  forall {θ : Real.Angle}, Iff (Ne.{1} Real.Angle (Neg.neg.{0} Real.Angle (NegZeroClass.toNeg.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) θ) θ) (And (Ne.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (Ne.{1} Real.Angle θ (Real.Angle.coe Real.pi)))
+Case conversion may be inaccurate. Consider using '#align real.angle.neg_ne_self_iff Real.Angle.neg_ne_self_iffₓ'. -/
 theorem neg_ne_self_iff {θ : Angle} : -θ ≠ θ ↔ θ ≠ 0 ∧ θ ≠ π := by
   rw [← not_or, ← neg_eq_self_iff.not]
 #align real.angle.neg_ne_self_iff Real.Angle.neg_ne_self_iff
 
+/- warning: real.angle.two_nsmul_eq_pi_iff -> Real.Angle.two_nsmul_eq_pi_iff is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real.Angle (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) θ) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) (Or (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))) (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Neg.neg.{0} Real Real.hasNeg Real.pi) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))))
+but is expected to have type
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) θ) (Real.Angle.coe Real.pi)) (Or (Eq.{1} Real.Angle θ (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))) (Eq.{1} Real.Angle θ (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Neg.neg.{0} Real Real.instNegReal Real.pi) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))))
+Case conversion may be inaccurate. Consider using '#align real.angle.two_nsmul_eq_pi_iff Real.Angle.two_nsmul_eq_pi_iffₓ'. -/
 theorem two_nsmul_eq_pi_iff {θ : Angle} : (2 : ℕ) • θ = π ↔ θ = (π / 2 : ℝ) ∨ θ = (-π / 2 : ℝ) :=
   by
   have h : (π : angle) = (2 : ℕ) • (π / 2 : ℝ) := by rw [two_nsmul, ← coe_add, add_halves]
@@ -213,10 +431,22 @@ theorem two_nsmul_eq_pi_iff {θ : Angle} : (2 : ℕ) • θ = π ↔ θ = (π /
     add_halves, ← two_mul, coe_two_pi]
 #align real.angle.two_nsmul_eq_pi_iff Real.Angle.two_nsmul_eq_pi_iff
 
+/- warning: real.angle.two_zsmul_eq_pi_iff -> Real.Angle.two_zsmul_eq_pi_iff is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real.Angle (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) θ) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) (Or (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))) (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Neg.neg.{0} Real Real.hasNeg Real.pi) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))))
+but is expected to have type
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) θ) (Real.Angle.coe Real.pi)) (Or (Eq.{1} Real.Angle θ (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))) (Eq.{1} Real.Angle θ (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Neg.neg.{0} Real Real.instNegReal Real.pi) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))))
+Case conversion may be inaccurate. Consider using '#align real.angle.two_zsmul_eq_pi_iff Real.Angle.two_zsmul_eq_pi_iffₓ'. -/
 theorem two_zsmul_eq_pi_iff {θ : Angle} : (2 : ℤ) • θ = π ↔ θ = (π / 2 : ℝ) ∨ θ = (-π / 2 : ℝ) := by
   rw [two_zsmul, ← two_nsmul, two_nsmul_eq_pi_iff]
 #align real.angle.two_zsmul_eq_pi_iff Real.Angle.two_zsmul_eq_pi_iff
 
+/- warning: real.angle.cos_eq_iff_coe_eq_or_eq_neg -> Real.Angle.cos_eq_iff_coe_eq_or_eq_neg is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real} {ψ : Real}, Iff (Eq.{1} Real (Real.cos θ) (Real.cos ψ)) (Or (Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) ψ)) (Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ) (Neg.neg.{0} Real.Angle (SubNegMonoid.toHasNeg.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) ψ))))
+but is expected to have type
+  forall {θ : Real} {ψ : Real}, Iff (Eq.{1} Real (Real.cos θ) (Real.cos ψ)) (Or (Eq.{1} Real.Angle (Real.Angle.coe θ) (Real.Angle.coe ψ)) (Eq.{1} Real.Angle (Real.Angle.coe θ) (Neg.neg.{0} Real.Angle (NegZeroClass.toNeg.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (Real.Angle.coe ψ))))
+Case conversion may be inaccurate. Consider using '#align real.angle.cos_eq_iff_coe_eq_or_eq_neg Real.Angle.cos_eq_iff_coe_eq_or_eq_negₓ'. -/
 theorem cos_eq_iff_coe_eq_or_eq_neg {θ ψ : ℝ} :
     cos θ = cos ψ ↔ (θ : Angle) = ψ ∨ (θ : Angle) = -ψ :=
   by
@@ -242,6 +472,12 @@ theorem cos_eq_iff_coe_eq_or_eq_neg {θ ψ : ℝ} :
       MulZeroClass.zero_mul]
 #align real.angle.cos_eq_iff_coe_eq_or_eq_neg Real.Angle.cos_eq_iff_coe_eq_or_eq_neg
 
+/- warning: real.angle.sin_eq_iff_coe_eq_or_add_eq_pi -> Real.Angle.sin_eq_iff_coe_eq_or_add_eq_pi is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real} {ψ : Real}, Iff (Eq.{1} Real (Real.sin θ) (Real.sin ψ)) (Or (Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) ψ)) (Eq.{1} Real.Angle (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) ψ)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)))
+but is expected to have type
+  forall {θ : Real} {ψ : Real}, Iff (Eq.{1} Real (Real.sin θ) (Real.sin ψ)) (Or (Eq.{1} Real.Angle (Real.Angle.coe θ) (Real.Angle.coe ψ)) (Eq.{1} Real.Angle (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) (Real.Angle.coe θ) (Real.Angle.coe ψ)) (Real.Angle.coe Real.pi)))
+Case conversion may be inaccurate. Consider using '#align real.angle.sin_eq_iff_coe_eq_or_add_eq_pi Real.Angle.sin_eq_iff_coe_eq_or_add_eq_piₓ'. -/
 theorem sin_eq_iff_coe_eq_or_add_eq_pi {θ ψ : ℝ} :
     sin θ = sin ψ ↔ (θ : Angle) = ψ ∨ (θ : Angle) + ψ = π :=
   by
@@ -268,6 +504,12 @@ theorem sin_eq_iff_coe_eq_or_add_eq_pi {θ ψ : ℝ} :
       MulZeroClass.mul_zero]
 #align real.angle.sin_eq_iff_coe_eq_or_add_eq_pi Real.Angle.sin_eq_iff_coe_eq_or_add_eq_pi
 
+/- warning: real.angle.cos_sin_inj -> Real.Angle.cos_sin_inj is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real} {ψ : Real}, (Eq.{1} Real (Real.cos θ) (Real.cos ψ)) -> (Eq.{1} Real (Real.sin θ) (Real.sin ψ)) -> (Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) ψ))
+but is expected to have type
+  forall {θ : Real} {ψ : Real}, (Eq.{1} Real (Real.cos θ) (Real.cos ψ)) -> (Eq.{1} Real (Real.sin θ) (Real.sin ψ)) -> (Eq.{1} Real.Angle (Real.Angle.coe θ) (Real.Angle.coe ψ))
+Case conversion may be inaccurate. Consider using '#align real.angle.cos_sin_inj Real.Angle.cos_sin_injₓ'. -/
 theorem cos_sin_inj {θ ψ : ℝ} (Hcos : cos θ = cos ψ) (Hsin : sin θ = sin ψ) : (θ : Angle) = ψ :=
   by
   cases' cos_eq_iff_coe_eq_or_eq_neg.mp Hcos with hc hc; · exact hc
@@ -282,36 +524,70 @@ theorem cos_sin_inj {θ ψ : ℝ} (Hcos : cos θ = cos ψ) (Hsin : sin θ = sin
   exact absurd this one_ne_zero
 #align real.angle.cos_sin_inj Real.Angle.cos_sin_inj
 
+#print Real.Angle.sin /-
 /-- The sine of a `real.angle`. -/
 def sin (θ : Angle) : ℝ :=
   sin_periodic.lift θ
 #align real.angle.sin Real.Angle.sin
+-/
 
+/- warning: real.angle.sin_coe -> Real.Angle.sin_coe is a dubious translation:
+lean 3 declaration is
+  forall (x : Real), Eq.{1} Real (Real.Angle.sin ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) x)) (Real.sin x)
+but is expected to have type
+  forall (x : Real), Eq.{1} Real (Real.Angle.sin (Real.Angle.coe x)) (Real.sin x)
+Case conversion may be inaccurate. Consider using '#align real.angle.sin_coe Real.Angle.sin_coeₓ'. -/
 @[simp]
 theorem sin_coe (x : ℝ) : sin (x : Angle) = Real.sin x :=
   rfl
 #align real.angle.sin_coe Real.Angle.sin_coe
 
+/- warning: real.angle.continuous_sin -> Real.Angle.continuous_sin is a dubious translation:
+lean 3 declaration is
+  Continuous.{0, 0} Real.Angle Real (UniformSpace.toTopologicalSpace.{0} Real.Angle (PseudoMetricSpace.toUniformSpace.{0} Real.Angle (SeminormedAddCommGroup.toPseudoMetricSpace.{0} Real.Angle (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) Real.Angle.sin
+but is expected to have type
+  Continuous.{0, 0} Real.Angle Real (UniformSpace.toTopologicalSpace.{0} Real.Angle (PseudoMetricSpace.toUniformSpace.{0} Real.Angle (SeminormedAddCommGroup.toPseudoMetricSpace.{0} Real.Angle (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))) (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) Real.Angle.sin
+Case conversion may be inaccurate. Consider using '#align real.angle.continuous_sin Real.Angle.continuous_sinₓ'. -/
 @[continuity]
 theorem continuous_sin : Continuous sin :=
   Real.continuous_sin.quotient_liftOn' _
 #align real.angle.continuous_sin Real.Angle.continuous_sin
 
+#print Real.Angle.cos /-
 /-- The cosine of a `real.angle`. -/
 def cos (θ : Angle) : ℝ :=
   cos_periodic.lift θ
 #align real.angle.cos Real.Angle.cos
+-/
 
+/- warning: real.angle.cos_coe -> Real.Angle.cos_coe is a dubious translation:
+lean 3 declaration is
+  forall (x : Real), Eq.{1} Real (Real.Angle.cos ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) x)) (Real.cos x)
+but is expected to have type
+  forall (x : Real), Eq.{1} Real (Real.Angle.cos (Real.Angle.coe x)) (Real.cos x)
+Case conversion may be inaccurate. Consider using '#align real.angle.cos_coe Real.Angle.cos_coeₓ'. -/
 @[simp]
 theorem cos_coe (x : ℝ) : cos (x : Angle) = Real.cos x :=
   rfl
 #align real.angle.cos_coe Real.Angle.cos_coe
 
+/- warning: real.angle.continuous_cos -> Real.Angle.continuous_cos is a dubious translation:
+lean 3 declaration is
+  Continuous.{0, 0} Real.Angle Real (UniformSpace.toTopologicalSpace.{0} Real.Angle (PseudoMetricSpace.toUniformSpace.{0} Real.Angle (SeminormedAddCommGroup.toPseudoMetricSpace.{0} Real.Angle (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) Real.Angle.cos
+but is expected to have type
+  Continuous.{0, 0} Real.Angle Real (UniformSpace.toTopologicalSpace.{0} Real.Angle (PseudoMetricSpace.toUniformSpace.{0} Real.Angle (SeminormedAddCommGroup.toPseudoMetricSpace.{0} Real.Angle (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))) (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) Real.Angle.cos
+Case conversion may be inaccurate. Consider using '#align real.angle.continuous_cos Real.Angle.continuous_cosₓ'. -/
 @[continuity]
 theorem continuous_cos : Continuous cos :=
   Real.continuous_cos.quotient_liftOn' _
 #align real.angle.continuous_cos Real.Angle.continuous_cos
 
+/- warning: real.angle.cos_eq_real_cos_iff_eq_or_eq_neg -> Real.Angle.cos_eq_real_cos_iff_eq_or_eq_neg is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle} {ψ : Real}, Iff (Eq.{1} Real (Real.Angle.cos θ) (Real.cos ψ)) (Or (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) ψ)) (Eq.{1} Real.Angle θ (Neg.neg.{0} Real.Angle (SubNegMonoid.toHasNeg.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) ψ))))
+but is expected to have type
+  forall {θ : Real.Angle} {ψ : Real}, Iff (Eq.{1} Real (Real.Angle.cos θ) (Real.cos ψ)) (Or (Eq.{1} Real.Angle θ (Real.Angle.coe ψ)) (Eq.{1} Real.Angle θ (Neg.neg.{0} Real.Angle (NegZeroClass.toNeg.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (Real.Angle.coe ψ))))
+Case conversion may be inaccurate. Consider using '#align real.angle.cos_eq_real_cos_iff_eq_or_eq_neg Real.Angle.cos_eq_real_cos_iff_eq_or_eq_negₓ'. -/
 theorem cos_eq_real_cos_iff_eq_or_eq_neg {θ : Angle} {ψ : ℝ} :
     cos θ = Real.cos ψ ↔ θ = ψ ∨ θ = -ψ :=
   by
@@ -319,12 +595,24 @@ theorem cos_eq_real_cos_iff_eq_or_eq_neg {θ : Angle} {ψ : ℝ} :
   exact cos_eq_iff_coe_eq_or_eq_neg
 #align real.angle.cos_eq_real_cos_iff_eq_or_eq_neg Real.Angle.cos_eq_real_cos_iff_eq_or_eq_neg
 
+/- warning: real.angle.cos_eq_iff_eq_or_eq_neg -> Real.Angle.cos_eq_iff_eq_or_eq_neg is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle} {ψ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.cos θ) (Real.Angle.cos ψ)) (Or (Eq.{1} Real.Angle θ ψ) (Eq.{1} Real.Angle θ (Neg.neg.{0} Real.Angle (SubNegMonoid.toHasNeg.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) ψ)))
+but is expected to have type
+  forall {θ : Real.Angle} {ψ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.cos θ) (Real.Angle.cos ψ)) (Or (Eq.{1} Real.Angle θ ψ) (Eq.{1} Real.Angle θ (Neg.neg.{0} Real.Angle (NegZeroClass.toNeg.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) ψ)))
+Case conversion may be inaccurate. Consider using '#align real.angle.cos_eq_iff_eq_or_eq_neg Real.Angle.cos_eq_iff_eq_or_eq_negₓ'. -/
 theorem cos_eq_iff_eq_or_eq_neg {θ ψ : Angle} : cos θ = cos ψ ↔ θ = ψ ∨ θ = -ψ :=
   by
   induction ψ using Real.Angle.induction_on
   exact cos_eq_real_cos_iff_eq_or_eq_neg
 #align real.angle.cos_eq_iff_eq_or_eq_neg Real.Angle.cos_eq_iff_eq_or_eq_neg
 
+/- warning: real.angle.sin_eq_real_sin_iff_eq_or_add_eq_pi -> Real.Angle.sin_eq_real_sin_iff_eq_or_add_eq_pi is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle} {ψ : Real}, Iff (Eq.{1} Real (Real.Angle.sin θ) (Real.sin ψ)) (Or (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) ψ)) (Eq.{1} Real.Angle (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) ψ)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)))
+but is expected to have type
+  forall {θ : Real.Angle} {ψ : Real}, Iff (Eq.{1} Real (Real.Angle.sin θ) (Real.sin ψ)) (Or (Eq.{1} Real.Angle θ (Real.Angle.coe ψ)) (Eq.{1} Real.Angle (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) θ (Real.Angle.coe ψ)) (Real.Angle.coe Real.pi)))
+Case conversion may be inaccurate. Consider using '#align real.angle.sin_eq_real_sin_iff_eq_or_add_eq_pi Real.Angle.sin_eq_real_sin_iff_eq_or_add_eq_piₓ'. -/
 theorem sin_eq_real_sin_iff_eq_or_add_eq_pi {θ : Angle} {ψ : ℝ} :
     sin θ = Real.sin ψ ↔ θ = ψ ∨ θ + ψ = π :=
   by
@@ -332,20 +620,44 @@ theorem sin_eq_real_sin_iff_eq_or_add_eq_pi {θ : Angle} {ψ : ℝ} :
   exact sin_eq_iff_coe_eq_or_add_eq_pi
 #align real.angle.sin_eq_real_sin_iff_eq_or_add_eq_pi Real.Angle.sin_eq_real_sin_iff_eq_or_add_eq_pi
 
+/- warning: real.angle.sin_eq_iff_eq_or_add_eq_pi -> Real.Angle.sin_eq_iff_eq_or_add_eq_pi is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle} {ψ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.sin θ) (Real.Angle.sin ψ)) (Or (Eq.{1} Real.Angle θ ψ) (Eq.{1} Real.Angle (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) θ ψ) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)))
+but is expected to have type
+  forall {θ : Real.Angle} {ψ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.sin θ) (Real.Angle.sin ψ)) (Or (Eq.{1} Real.Angle θ ψ) (Eq.{1} Real.Angle (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) θ ψ) (Real.Angle.coe Real.pi)))
+Case conversion may be inaccurate. Consider using '#align real.angle.sin_eq_iff_eq_or_add_eq_pi Real.Angle.sin_eq_iff_eq_or_add_eq_piₓ'. -/
 theorem sin_eq_iff_eq_or_add_eq_pi {θ ψ : Angle} : sin θ = sin ψ ↔ θ = ψ ∨ θ + ψ = π :=
   by
   induction ψ using Real.Angle.induction_on
   exact sin_eq_real_sin_iff_eq_or_add_eq_pi
 #align real.angle.sin_eq_iff_eq_or_add_eq_pi Real.Angle.sin_eq_iff_eq_or_add_eq_pi
 
+/- warning: real.angle.sin_zero -> Real.Angle.sin_zero is a dubious translation:
+lean 3 declaration is
+  Eq.{1} Real (Real.Angle.sin (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))
+but is expected to have type
+  Eq.{1} Real (Real.Angle.sin (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))
+Case conversion may be inaccurate. Consider using '#align real.angle.sin_zero Real.Angle.sin_zeroₓ'. -/
 @[simp]
 theorem sin_zero : sin (0 : Angle) = 0 := by rw [← coe_zero, sin_coe, Real.sin_zero]
 #align real.angle.sin_zero Real.Angle.sin_zero
 
+/- warning: real.angle.sin_coe_pi -> Real.Angle.sin_coe_pi is a dubious translation:
+lean 3 declaration is
+  Eq.{1} Real (Real.Angle.sin ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))
+but is expected to have type
+  Eq.{1} Real (Real.Angle.sin (Real.Angle.coe Real.pi)) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))
+Case conversion may be inaccurate. Consider using '#align real.angle.sin_coe_pi Real.Angle.sin_coe_piₓ'. -/
 @[simp]
 theorem sin_coe_pi : sin (π : Angle) = 0 := by rw [sin_coe, Real.sin_pi]
 #align real.angle.sin_coe_pi Real.Angle.sin_coe_pi
 
+/- warning: real.angle.sin_eq_zero_iff -> Real.Angle.sin_eq_zero_iff is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.sin θ) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (Or (Eq.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)))
+but is expected to have type
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.sin θ) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (Or (Eq.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (Eq.{1} Real.Angle θ (Real.Angle.coe Real.pi)))
+Case conversion may be inaccurate. Consider using '#align real.angle.sin_eq_zero_iff Real.Angle.sin_eq_zero_iffₓ'. -/
 theorem sin_eq_zero_iff {θ : Angle} : sin θ = 0 ↔ θ = 0 ∨ θ = π :=
   by
   nth_rw 1 [← sin_zero]
@@ -353,10 +665,22 @@ theorem sin_eq_zero_iff {θ : Angle} : sin θ = 0 ↔ θ = 0 ∨ θ = π :=
   simp
 #align real.angle.sin_eq_zero_iff Real.Angle.sin_eq_zero_iff
 
+/- warning: real.angle.sin_ne_zero_iff -> Real.Angle.sin_ne_zero_iff is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, Iff (Ne.{1} Real (Real.Angle.sin θ) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (And (Ne.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (Ne.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)))
+but is expected to have type
+  forall {θ : Real.Angle}, Iff (Ne.{1} Real (Real.Angle.sin θ) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (And (Ne.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (Ne.{1} Real.Angle θ (Real.Angle.coe Real.pi)))
+Case conversion may be inaccurate. Consider using '#align real.angle.sin_ne_zero_iff Real.Angle.sin_ne_zero_iffₓ'. -/
 theorem sin_ne_zero_iff {θ : Angle} : sin θ ≠ 0 ↔ θ ≠ 0 ∧ θ ≠ π := by
   rw [← not_or, ← sin_eq_zero_iff]
 #align real.angle.sin_ne_zero_iff Real.Angle.sin_ne_zero_iff
 
+/- warning: real.angle.sin_neg -> Real.Angle.sin_neg is a dubious translation:
+lean 3 declaration is
+  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.sin (Neg.neg.{0} Real.Angle (SubNegMonoid.toHasNeg.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) θ)) (Neg.neg.{0} Real Real.hasNeg (Real.Angle.sin θ))
+but is expected to have type
+  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.sin (Neg.neg.{0} Real.Angle (NegZeroClass.toNeg.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) θ)) (Neg.neg.{0} Real Real.instNegReal (Real.Angle.sin θ))
+Case conversion may be inaccurate. Consider using '#align real.angle.sin_neg Real.Angle.sin_negₓ'. -/
 @[simp]
 theorem sin_neg (θ : Angle) : sin (-θ) = -sin θ :=
   by
@@ -364,6 +688,12 @@ theorem sin_neg (θ : Angle) : sin (-θ) = -sin θ :=
   exact Real.sin_neg _
 #align real.angle.sin_neg Real.Angle.sin_neg
 
+/- warning: real.angle.sin_antiperiodic -> Real.Angle.sin_antiperiodic is a dubious translation:
+lean 3 declaration is
+  Function.Antiperiodic.{0, 0} Real.Angle Real (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))) Real.hasNeg Real.Angle.sin ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)
+but is expected to have type
+  Function.Antiperiodic.{0, 0} Real.Angle Real (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) Real.instNegReal Real.Angle.sin (Real.Angle.coe Real.pi)
+Case conversion may be inaccurate. Consider using '#align real.angle.sin_antiperiodic Real.Angle.sin_antiperiodicₓ'. -/
 theorem sin_antiperiodic : Function.Antiperiodic sin (π : Angle) :=
   by
   intro θ
@@ -371,24 +701,54 @@ theorem sin_antiperiodic : Function.Antiperiodic sin (π : Angle) :=
   exact Real.sin_antiperiodic θ
 #align real.angle.sin_antiperiodic Real.Angle.sin_antiperiodic
 
+/- warning: real.angle.sin_add_pi -> Real.Angle.sin_add_pi is a dubious translation:
+lean 3 declaration is
+  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.sin (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi))) (Neg.neg.{0} Real Real.hasNeg (Real.Angle.sin θ))
+but is expected to have type
+  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.sin (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) θ (Real.Angle.coe Real.pi))) (Neg.neg.{0} Real Real.instNegReal (Real.Angle.sin θ))
+Case conversion may be inaccurate. Consider using '#align real.angle.sin_add_pi Real.Angle.sin_add_piₓ'. -/
 @[simp]
 theorem sin_add_pi (θ : Angle) : sin (θ + π) = -sin θ :=
   sin_antiperiodic θ
 #align real.angle.sin_add_pi Real.Angle.sin_add_pi
 
+/- warning: real.angle.sin_sub_pi -> Real.Angle.sin_sub_pi is a dubious translation:
+lean 3 declaration is
+  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.sin (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toHasSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi))) (Neg.neg.{0} Real Real.hasNeg (Real.Angle.sin θ))
+but is expected to have type
+  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.sin (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) θ (Real.Angle.coe Real.pi))) (Neg.neg.{0} Real Real.instNegReal (Real.Angle.sin θ))
+Case conversion may be inaccurate. Consider using '#align real.angle.sin_sub_pi Real.Angle.sin_sub_piₓ'. -/
 @[simp]
 theorem sin_sub_pi (θ : Angle) : sin (θ - π) = -sin θ :=
   sin_antiperiodic.sub_eq θ
 #align real.angle.sin_sub_pi Real.Angle.sin_sub_pi
 
+/- warning: real.angle.cos_zero -> Real.Angle.cos_zero is a dubious translation:
+lean 3 declaration is
+  Eq.{1} Real (Real.Angle.cos (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne)))
+but is expected to have type
+  Eq.{1} Real (Real.Angle.cos (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal))
+Case conversion may be inaccurate. Consider using '#align real.angle.cos_zero Real.Angle.cos_zeroₓ'. -/
 @[simp]
 theorem cos_zero : cos (0 : Angle) = 1 := by rw [← coe_zero, cos_coe, Real.cos_zero]
 #align real.angle.cos_zero Real.Angle.cos_zero
 
+/- warning: real.angle.cos_coe_pi -> Real.Angle.cos_coe_pi is a dubious translation:
+lean 3 declaration is
+  Eq.{1} Real (Real.Angle.cos ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) (Neg.neg.{0} Real Real.hasNeg (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne))))
+but is expected to have type
+  Eq.{1} Real (Real.Angle.cos (Real.Angle.coe Real.pi)) (Neg.neg.{0} Real Real.instNegReal (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal)))
+Case conversion may be inaccurate. Consider using '#align real.angle.cos_coe_pi Real.Angle.cos_coe_piₓ'. -/
 @[simp]
 theorem cos_coe_pi : cos (π : Angle) = -1 := by rw [cos_coe, Real.cos_pi]
 #align real.angle.cos_coe_pi Real.Angle.cos_coe_pi
 
+/- warning: real.angle.cos_neg -> Real.Angle.cos_neg is a dubious translation:
+lean 3 declaration is
+  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.cos (Neg.neg.{0} Real.Angle (SubNegMonoid.toHasNeg.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) θ)) (Real.Angle.cos θ)
+but is expected to have type
+  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.cos (Neg.neg.{0} Real.Angle (NegZeroClass.toNeg.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) θ)) (Real.Angle.cos θ)
+Case conversion may be inaccurate. Consider using '#align real.angle.cos_neg Real.Angle.cos_negₓ'. -/
 @[simp]
 theorem cos_neg (θ : Angle) : cos (-θ) = cos θ :=
   by
@@ -396,6 +756,12 @@ theorem cos_neg (θ : Angle) : cos (-θ) = cos θ :=
   exact Real.cos_neg _
 #align real.angle.cos_neg Real.Angle.cos_neg
 
+/- warning: real.angle.cos_antiperiodic -> Real.Angle.cos_antiperiodic is a dubious translation:
+lean 3 declaration is
+  Function.Antiperiodic.{0, 0} Real.Angle Real (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))) Real.hasNeg Real.Angle.cos ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)
+but is expected to have type
+  Function.Antiperiodic.{0, 0} Real.Angle Real (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) Real.instNegReal Real.Angle.cos (Real.Angle.coe Real.pi)
+Case conversion may be inaccurate. Consider using '#align real.angle.cos_antiperiodic Real.Angle.cos_antiperiodicₓ'. -/
 theorem cos_antiperiodic : Function.Antiperiodic cos (π : Angle) :=
   by
   intro θ
@@ -403,20 +769,44 @@ theorem cos_antiperiodic : Function.Antiperiodic cos (π : Angle) :=
   exact Real.cos_antiperiodic θ
 #align real.angle.cos_antiperiodic Real.Angle.cos_antiperiodic
 
+/- warning: real.angle.cos_add_pi -> Real.Angle.cos_add_pi is a dubious translation:
+lean 3 declaration is
+  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.cos (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi))) (Neg.neg.{0} Real Real.hasNeg (Real.Angle.cos θ))
+but is expected to have type
+  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.cos (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) θ (Real.Angle.coe Real.pi))) (Neg.neg.{0} Real Real.instNegReal (Real.Angle.cos θ))
+Case conversion may be inaccurate. Consider using '#align real.angle.cos_add_pi Real.Angle.cos_add_piₓ'. -/
 @[simp]
 theorem cos_add_pi (θ : Angle) : cos (θ + π) = -cos θ :=
   cos_antiperiodic θ
 #align real.angle.cos_add_pi Real.Angle.cos_add_pi
 
+/- warning: real.angle.cos_sub_pi -> Real.Angle.cos_sub_pi is a dubious translation:
+lean 3 declaration is
+  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.cos (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toHasSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi))) (Neg.neg.{0} Real Real.hasNeg (Real.Angle.cos θ))
+but is expected to have type
+  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.cos (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) θ (Real.Angle.coe Real.pi))) (Neg.neg.{0} Real Real.instNegReal (Real.Angle.cos θ))
+Case conversion may be inaccurate. Consider using '#align real.angle.cos_sub_pi Real.Angle.cos_sub_piₓ'. -/
 @[simp]
 theorem cos_sub_pi (θ : Angle) : cos (θ - π) = -cos θ :=
   cos_antiperiodic.sub_eq θ
 #align real.angle.cos_sub_pi Real.Angle.cos_sub_pi
 
+/- warning: real.angle.cos_eq_zero_iff -> Real.Angle.cos_eq_zero_iff is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.cos θ) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (Or (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))) (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Neg.neg.{0} Real Real.hasNeg Real.pi) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))))
+but is expected to have type
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.cos θ) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (Or (Eq.{1} Real.Angle θ (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))) (Eq.{1} Real.Angle θ (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Neg.neg.{0} Real Real.instNegReal Real.pi) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))))
+Case conversion may be inaccurate. Consider using '#align real.angle.cos_eq_zero_iff Real.Angle.cos_eq_zero_iffₓ'. -/
 theorem cos_eq_zero_iff {θ : Angle} : cos θ = 0 ↔ θ = (π / 2 : ℝ) ∨ θ = (-π / 2 : ℝ) := by
   rw [← cos_pi_div_two, ← cos_coe, cos_eq_iff_eq_or_eq_neg, ← coe_neg, ← neg_div]
 #align real.angle.cos_eq_zero_iff Real.Angle.cos_eq_zero_iff
 
+/- warning: real.angle.sin_add -> Real.Angle.sin_add is a dubious translation:
+lean 3 declaration is
+  forall (θ₁ : Real.Angle) (θ₂ : Real.Angle), Eq.{1} Real (Real.Angle.sin (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) θ₁ θ₂)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (Real.Angle.sin θ₁) (Real.Angle.cos θ₂)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (Real.Angle.cos θ₁) (Real.Angle.sin θ₂)))
+but is expected to have type
+  forall (θ₁ : Real.Angle) (θ₂ : Real.Angle), Eq.{1} Real (Real.Angle.sin (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) θ₁ θ₂)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Real.Angle.sin θ₁) (Real.Angle.cos θ₂)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Real.Angle.cos θ₁) (Real.Angle.sin θ₂)))
+Case conversion may be inaccurate. Consider using '#align real.angle.sin_add Real.Angle.sin_addₓ'. -/
 theorem sin_add (θ₁ θ₂ : Real.Angle) : sin (θ₁ + θ₂) = sin θ₁ * cos θ₂ + cos θ₁ * sin θ₂ :=
   by
   induction θ₁ using Real.Angle.induction_on
@@ -424,6 +814,12 @@ theorem sin_add (θ₁ θ₂ : Real.Angle) : sin (θ₁ + θ₂) = sin θ₁ * c
   exact Real.sin_add θ₁ θ₂
 #align real.angle.sin_add Real.Angle.sin_add
 
+/- warning: real.angle.cos_add -> Real.Angle.cos_add is a dubious translation:
+lean 3 declaration is
+  forall (θ₁ : Real.Angle) (θ₂ : Real.Angle), Eq.{1} Real (Real.Angle.cos (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) θ₁ θ₂)) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (Real.Angle.cos θ₁) (Real.Angle.cos θ₂)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (Real.Angle.sin θ₁) (Real.Angle.sin θ₂)))
+but is expected to have type
+  forall (θ₁ : Real.Angle) (θ₂ : Real.Angle), Eq.{1} Real (Real.Angle.cos (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) θ₁ θ₂)) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Real.Angle.cos θ₁) (Real.Angle.cos θ₂)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Real.Angle.sin θ₁) (Real.Angle.sin θ₂)))
+Case conversion may be inaccurate. Consider using '#align real.angle.cos_add Real.Angle.cos_addₓ'. -/
 theorem cos_add (θ₁ θ₂ : Real.Angle) : cos (θ₁ + θ₂) = cos θ₁ * cos θ₂ - sin θ₁ * sin θ₂ :=
   by
   induction θ₂ using Real.Angle.induction_on
@@ -431,6 +827,12 @@ theorem cos_add (θ₁ θ₂ : Real.Angle) : cos (θ₁ + θ₂) = cos θ₁ * c
   exact Real.cos_add θ₁ θ₂
 #align real.angle.cos_add Real.Angle.cos_add
 
+/- warning: real.angle.cos_sq_add_sin_sq -> Real.Angle.cos_sq_add_sin_sq is a dubious translation:
+lean 3 declaration is
+  forall (θ : Real.Angle), Eq.{1} Real (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (HPow.hPow.{0, 0, 0} Real Nat Real (instHPow.{0, 0} Real Nat (Monoid.Pow.{0} Real Real.monoid)) (Real.Angle.cos θ) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))) (HPow.hPow.{0, 0, 0} Real Nat Real (instHPow.{0, 0} Real Nat (Monoid.Pow.{0} Real Real.monoid)) (Real.Angle.sin θ) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))))) (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne)))
+but is expected to have type
+  forall (θ : Real.Angle), Eq.{1} Real (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (HPow.hPow.{0, 0, 0} Real Nat Real (instHPow.{0, 0} Real Nat (Monoid.Pow.{0} Real Real.instMonoidReal)) (Real.Angle.cos θ) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))) (HPow.hPow.{0, 0, 0} Real Nat Real (instHPow.{0, 0} Real Nat (Monoid.Pow.{0} Real Real.instMonoidReal)) (Real.Angle.sin θ) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))) (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal))
+Case conversion may be inaccurate. Consider using '#align real.angle.cos_sq_add_sin_sq Real.Angle.cos_sq_add_sin_sqₓ'. -/
 @[simp]
 theorem cos_sq_add_sin_sq (θ : Real.Angle) : cos θ ^ 2 + sin θ ^ 2 = 1 :=
   by
@@ -438,42 +840,84 @@ theorem cos_sq_add_sin_sq (θ : Real.Angle) : cos θ ^ 2 + sin θ ^ 2 = 1 :=
   exact Real.cos_sq_add_sin_sq θ
 #align real.angle.cos_sq_add_sin_sq Real.Angle.cos_sq_add_sin_sq
 
+/- warning: real.angle.sin_add_pi_div_two -> Real.Angle.sin_add_pi_div_two is a dubious translation:
+lean 3 declaration is
+  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.sin (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))))) (Real.Angle.cos θ)
+but is expected to have type
+  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.sin (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) θ (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))))) (Real.Angle.cos θ)
+Case conversion may be inaccurate. Consider using '#align real.angle.sin_add_pi_div_two Real.Angle.sin_add_pi_div_twoₓ'. -/
 theorem sin_add_pi_div_two (θ : Angle) : sin (θ + ↑(π / 2)) = cos θ :=
   by
   induction θ using Real.Angle.induction_on
   exact sin_add_pi_div_two _
 #align real.angle.sin_add_pi_div_two Real.Angle.sin_add_pi_div_two
 
+/- warning: real.angle.sin_sub_pi_div_two -> Real.Angle.sin_sub_pi_div_two is a dubious translation:
+lean 3 declaration is
+  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.sin (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toHasSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))))) (Neg.neg.{0} Real Real.hasNeg (Real.Angle.cos θ))
+but is expected to have type
+  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.sin (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) θ (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))))) (Neg.neg.{0} Real Real.instNegReal (Real.Angle.cos θ))
+Case conversion may be inaccurate. Consider using '#align real.angle.sin_sub_pi_div_two Real.Angle.sin_sub_pi_div_twoₓ'. -/
 theorem sin_sub_pi_div_two (θ : Angle) : sin (θ - ↑(π / 2)) = -cos θ :=
   by
   induction θ using Real.Angle.induction_on
   exact sin_sub_pi_div_two _
 #align real.angle.sin_sub_pi_div_two Real.Angle.sin_sub_pi_div_two
 
+/- warning: real.angle.sin_pi_div_two_sub -> Real.Angle.sin_pi_div_two_sub is a dubious translation:
+lean 3 declaration is
+  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.sin (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toHasSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))) θ)) (Real.Angle.cos θ)
+but is expected to have type
+  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.sin (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))) θ)) (Real.Angle.cos θ)
+Case conversion may be inaccurate. Consider using '#align real.angle.sin_pi_div_two_sub Real.Angle.sin_pi_div_two_subₓ'. -/
 theorem sin_pi_div_two_sub (θ : Angle) : sin (↑(π / 2) - θ) = cos θ :=
   by
   induction θ using Real.Angle.induction_on
   exact sin_pi_div_two_sub _
 #align real.angle.sin_pi_div_two_sub Real.Angle.sin_pi_div_two_sub
 
+/- warning: real.angle.cos_add_pi_div_two -> Real.Angle.cos_add_pi_div_two is a dubious translation:
+lean 3 declaration is
+  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.cos (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))))) (Neg.neg.{0} Real Real.hasNeg (Real.Angle.sin θ))
+but is expected to have type
+  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.cos (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) θ (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))))) (Neg.neg.{0} Real Real.instNegReal (Real.Angle.sin θ))
+Case conversion may be inaccurate. Consider using '#align real.angle.cos_add_pi_div_two Real.Angle.cos_add_pi_div_twoₓ'. -/
 theorem cos_add_pi_div_two (θ : Angle) : cos (θ + ↑(π / 2)) = -sin θ :=
   by
   induction θ using Real.Angle.induction_on
   exact cos_add_pi_div_two _
 #align real.angle.cos_add_pi_div_two Real.Angle.cos_add_pi_div_two
 
+/- warning: real.angle.cos_sub_pi_div_two -> Real.Angle.cos_sub_pi_div_two is a dubious translation:
+lean 3 declaration is
+  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.cos (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toHasSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))))) (Real.Angle.sin θ)
+but is expected to have type
+  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.cos (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) θ (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))))) (Real.Angle.sin θ)
+Case conversion may be inaccurate. Consider using '#align real.angle.cos_sub_pi_div_two Real.Angle.cos_sub_pi_div_twoₓ'. -/
 theorem cos_sub_pi_div_two (θ : Angle) : cos (θ - ↑(π / 2)) = sin θ :=
   by
   induction θ using Real.Angle.induction_on
   exact cos_sub_pi_div_two _
 #align real.angle.cos_sub_pi_div_two Real.Angle.cos_sub_pi_div_two
 
+/- warning: real.angle.cos_pi_div_two_sub -> Real.Angle.cos_pi_div_two_sub is a dubious translation:
+lean 3 declaration is
+  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.cos (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toHasSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))) θ)) (Real.Angle.sin θ)
+but is expected to have type
+  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.cos (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))) θ)) (Real.Angle.sin θ)
+Case conversion may be inaccurate. Consider using '#align real.angle.cos_pi_div_two_sub Real.Angle.cos_pi_div_two_subₓ'. -/
 theorem cos_pi_div_two_sub (θ : Angle) : cos (↑(π / 2) - θ) = sin θ :=
   by
   induction θ using Real.Angle.induction_on
   exact cos_pi_div_two_sub _
 #align real.angle.cos_pi_div_two_sub Real.Angle.cos_pi_div_two_sub
 
+/- warning: real.angle.abs_sin_eq_of_two_nsmul_eq -> Real.Angle.abs_sin_eq_of_two_nsmul_eq is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) θ) (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) ψ)) -> (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.sin θ)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.sin ψ)))
+but is expected to have type
+  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) θ) (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) ψ)) -> (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.sin θ)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.sin ψ)))
+Case conversion may be inaccurate. Consider using '#align real.angle.abs_sin_eq_of_two_nsmul_eq Real.Angle.abs_sin_eq_of_two_nsmul_eqₓ'. -/
 theorem abs_sin_eq_of_two_nsmul_eq {θ ψ : Angle} (h : (2 : ℕ) • θ = (2 : ℕ) • ψ) :
     |sin θ| = |sin ψ| := by
   rw [two_nsmul_eq_iff] at h
@@ -482,12 +926,24 @@ theorem abs_sin_eq_of_two_nsmul_eq {θ ψ : Angle} (h : (2 : ℕ) • θ = (2 :
   · rw [sin_add_pi, abs_neg]
 #align real.angle.abs_sin_eq_of_two_nsmul_eq Real.Angle.abs_sin_eq_of_two_nsmul_eq
 
+/- warning: real.angle.abs_sin_eq_of_two_zsmul_eq -> Real.Angle.abs_sin_eq_of_two_zsmul_eq is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) θ) (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) ψ)) -> (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.sin θ)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.sin ψ)))
+but is expected to have type
+  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) θ) (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) ψ)) -> (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.sin θ)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.sin ψ)))
+Case conversion may be inaccurate. Consider using '#align real.angle.abs_sin_eq_of_two_zsmul_eq Real.Angle.abs_sin_eq_of_two_zsmul_eqₓ'. -/
 theorem abs_sin_eq_of_two_zsmul_eq {θ ψ : Angle} (h : (2 : ℤ) • θ = (2 : ℤ) • ψ) :
     |sin θ| = |sin ψ| := by
   simp_rw [two_zsmul, ← two_nsmul] at h
   exact abs_sin_eq_of_two_nsmul_eq h
 #align real.angle.abs_sin_eq_of_two_zsmul_eq Real.Angle.abs_sin_eq_of_two_zsmul_eq
 
+/- warning: real.angle.abs_cos_eq_of_two_nsmul_eq -> Real.Angle.abs_cos_eq_of_two_nsmul_eq is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) θ) (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) ψ)) -> (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.cos θ)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.cos ψ)))
+but is expected to have type
+  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) θ) (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) ψ)) -> (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.cos θ)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.cos ψ)))
+Case conversion may be inaccurate. Consider using '#align real.angle.abs_cos_eq_of_two_nsmul_eq Real.Angle.abs_cos_eq_of_two_nsmul_eqₓ'. -/
 theorem abs_cos_eq_of_two_nsmul_eq {θ ψ : Angle} (h : (2 : ℕ) • θ = (2 : ℕ) • ψ) :
     |cos θ| = |cos ψ| := by
   rw [two_nsmul_eq_iff] at h
@@ -496,12 +952,24 @@ theorem abs_cos_eq_of_two_nsmul_eq {θ ψ : Angle} (h : (2 : ℕ) • θ = (2 :
   · rw [cos_add_pi, abs_neg]
 #align real.angle.abs_cos_eq_of_two_nsmul_eq Real.Angle.abs_cos_eq_of_two_nsmul_eq
 
+/- warning: real.angle.abs_cos_eq_of_two_zsmul_eq -> Real.Angle.abs_cos_eq_of_two_zsmul_eq is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) θ) (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) ψ)) -> (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.cos θ)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.cos ψ)))
+but is expected to have type
+  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) θ) (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) ψ)) -> (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.cos θ)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.cos ψ)))
+Case conversion may be inaccurate. Consider using '#align real.angle.abs_cos_eq_of_two_zsmul_eq Real.Angle.abs_cos_eq_of_two_zsmul_eqₓ'. -/
 theorem abs_cos_eq_of_two_zsmul_eq {θ ψ : Angle} (h : (2 : ℤ) • θ = (2 : ℤ) • ψ) :
     |cos θ| = |cos ψ| := by
   simp_rw [two_zsmul, ← two_nsmul] at h
   exact abs_cos_eq_of_two_nsmul_eq h
 #align real.angle.abs_cos_eq_of_two_zsmul_eq Real.Angle.abs_cos_eq_of_two_zsmul_eq
 
+/- warning: real.angle.coe_to_Ico_mod -> Real.Angle.coe_toIcoMod is a dubious translation:
+lean 3 declaration is
+  forall (θ : Real) (ψ : Real), Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (toIcoMod.{0} Real Real.linearOrderedAddCommGroup Real.archimedean (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi) Real.two_pi_pos ψ θ)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ)
+but is expected to have type
+  forall (θ : Real) (ψ : Real), Eq.{1} Real.Angle (Real.Angle.coe (toIcoMod.{0} Real Real.instLinearOrderedAddCommGroupReal Real.instArchimedeanRealOrderedAddCommMonoid (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi) Real.two_pi_pos ψ θ)) (Real.Angle.coe θ)
+Case conversion may be inaccurate. Consider using '#align real.angle.coe_to_Ico_mod Real.Angle.coe_toIcoModₓ'. -/
 @[simp]
 theorem coe_toIcoMod (θ ψ : ℝ) : ↑(toIcoMod two_pi_pos ψ θ) = (θ : Angle) :=
   by
@@ -510,6 +978,12 @@ theorem coe_toIcoMod (θ ψ : ℝ) : ↑(toIcoMod two_pi_pos ψ θ) = (θ : Angl
   rw [toIcoMod_sub_self, zsmul_eq_mul, mul_comm]
 #align real.angle.coe_to_Ico_mod Real.Angle.coe_toIcoMod
 
+/- warning: real.angle.coe_to_Ioc_mod -> Real.Angle.coe_toIocMod is a dubious translation:
+lean 3 declaration is
+  forall (θ : Real) (ψ : Real), Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (toIocMod.{0} Real Real.linearOrderedAddCommGroup Real.archimedean (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi) Real.two_pi_pos ψ θ)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ)
+but is expected to have type
+  forall (θ : Real) (ψ : Real), Eq.{1} Real.Angle (Real.Angle.coe (toIocMod.{0} Real Real.instLinearOrderedAddCommGroupReal Real.instArchimedeanRealOrderedAddCommMonoid (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi) Real.two_pi_pos ψ θ)) (Real.Angle.coe θ)
+Case conversion may be inaccurate. Consider using '#align real.angle.coe_to_Ioc_mod Real.Angle.coe_toIocModₓ'. -/
 @[simp]
 theorem coe_toIocMod (θ ψ : ℝ) : ↑(toIocMod two_pi_pos ψ θ) = (θ : Angle) :=
   by
@@ -518,25 +992,46 @@ theorem coe_toIocMod (θ ψ : ℝ) : ↑(toIocMod two_pi_pos ψ θ) = (θ : Angl
   rw [toIocMod_sub_self, zsmul_eq_mul, mul_comm]
 #align real.angle.coe_to_Ioc_mod Real.Angle.coe_toIocMod
 
+#print Real.Angle.toReal /-
 /-- Convert a `real.angle` to a real number in the interval `Ioc (-π) π`. -/
 def toReal (θ : Angle) : ℝ :=
   (toIocMod_periodic two_pi_pos (-π)).lift θ
 #align real.angle.to_real Real.Angle.toReal
+-/
 
+/- warning: real.angle.to_real_coe -> Real.Angle.toReal_coe is a dubious translation:
+lean 3 declaration is
+  forall (θ : Real), Eq.{1} Real (Real.Angle.toReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ)) (toIocMod.{0} Real Real.linearOrderedAddCommGroup Real.archimedean (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi) Real.two_pi_pos (Neg.neg.{0} Real Real.hasNeg Real.pi) θ)
+but is expected to have type
+  forall (θ : Real), Eq.{1} Real (Real.Angle.toReal (Real.Angle.coe θ)) (toIocMod.{0} Real Real.instLinearOrderedAddCommGroupReal Real.instArchimedeanRealOrderedAddCommMonoid (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi) Real.two_pi_pos (Neg.neg.{0} Real Real.instNegReal Real.pi) θ)
+Case conversion may be inaccurate. Consider using '#align real.angle.to_real_coe Real.Angle.toReal_coeₓ'. -/
 theorem toReal_coe (θ : ℝ) : (θ : Angle).toReal = toIocMod two_pi_pos (-π) θ :=
   rfl
 #align real.angle.to_real_coe Real.Angle.toReal_coe
 
+/- warning: real.angle.to_real_coe_eq_self_iff -> Real.Angle.toReal_coe_eq_self_iff is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real}, Iff (Eq.{1} Real (Real.Angle.toReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ)) θ) (And (LT.lt.{0} Real Real.hasLt (Neg.neg.{0} Real Real.hasNeg Real.pi) θ) (LE.le.{0} Real Real.hasLe θ Real.pi))
+but is expected to have type
+  forall {θ : Real}, Iff (Eq.{1} Real (Real.Angle.toReal (Real.Angle.coe θ)) θ) (And (LT.lt.{0} Real Real.instLTReal (Neg.neg.{0} Real Real.instNegReal Real.pi) θ) (LE.le.{0} Real Real.instLEReal θ Real.pi))
+Case conversion may be inaccurate. Consider using '#align real.angle.to_real_coe_eq_self_iff Real.Angle.toReal_coe_eq_self_iffₓ'. -/
 theorem toReal_coe_eq_self_iff {θ : ℝ} : (θ : Angle).toReal = θ ↔ -π < θ ∧ θ ≤ π :=
   by
   rw [to_real_coe, toIocMod_eq_self two_pi_pos]
   ring_nf
 #align real.angle.to_real_coe_eq_self_iff Real.Angle.toReal_coe_eq_self_iff
 
+/- warning: real.angle.to_real_coe_eq_self_iff_mem_Ioc -> Real.Angle.toReal_coe_eq_self_iff_mem_Ioc is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real}, Iff (Eq.{1} Real (Real.Angle.toReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ)) θ) (Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) θ (Set.Ioc.{0} Real Real.preorder (Neg.neg.{0} Real Real.hasNeg Real.pi) Real.pi))
+but is expected to have type
+  forall {θ : Real}, Iff (Eq.{1} Real (Real.Angle.toReal (Real.Angle.coe θ)) θ) (Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) θ (Set.Ioc.{0} Real Real.instPreorderReal (Neg.neg.{0} Real Real.instNegReal Real.pi) Real.pi))
+Case conversion may be inaccurate. Consider using '#align real.angle.to_real_coe_eq_self_iff_mem_Ioc Real.Angle.toReal_coe_eq_self_iff_mem_Iocₓ'. -/
 theorem toReal_coe_eq_self_iff_mem_Ioc {θ : ℝ} : (θ : Angle).toReal = θ ↔ θ ∈ Set.Ioc (-π) π := by
   rw [to_real_coe_eq_self_iff, ← Set.mem_Ioc]
 #align real.angle.to_real_coe_eq_self_iff_mem_Ioc Real.Angle.toReal_coe_eq_self_iff_mem_Ioc
 
+#print Real.Angle.toReal_injective /-
 theorem toReal_injective : Function.Injective toReal :=
   by
   intro θ ψ h
@@ -545,12 +1040,21 @@ theorem toReal_injective : Function.Injective toReal :=
   simpa [to_real_coe, toIocMod_eq_toIocMod, zsmul_eq_mul, mul_comm _ (2 * π), ←
     angle_eq_iff_two_pi_dvd_sub, eq_comm] using h
 #align real.angle.to_real_injective Real.Angle.toReal_injective
+-/
 
+#print Real.Angle.toReal_inj /-
 @[simp]
 theorem toReal_inj {θ ψ : Angle} : θ.toReal = ψ.toReal ↔ θ = ψ :=
   toReal_injective.eq_iff
 #align real.angle.to_real_inj Real.Angle.toReal_inj
+-/
 
+/- warning: real.angle.coe_to_real -> Real.Angle.coe_toReal is a dubious translation:
+lean 3 declaration is
+  forall (θ : Real.Angle), Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (Real.Angle.toReal θ)) θ
+but is expected to have type
+  forall (θ : Real.Angle), Eq.{1} Real.Angle (Real.Angle.coe (Real.Angle.toReal θ)) θ
+Case conversion may be inaccurate. Consider using '#align real.angle.coe_to_real Real.Angle.coe_toRealₓ'. -/
 @[simp]
 theorem coe_toReal (θ : Angle) : (θ.toReal : Angle) = θ :=
   by
@@ -558,12 +1062,24 @@ theorem coe_toReal (θ : Angle) : (θ.toReal : Angle) = θ :=
   exact coe_to_Ioc_mod _ _
 #align real.angle.coe_to_real Real.Angle.coe_toReal
 
+/- warning: real.angle.neg_pi_lt_to_real -> Real.Angle.neg_pi_lt_toReal is a dubious translation:
+lean 3 declaration is
+  forall (θ : Real.Angle), LT.lt.{0} Real Real.hasLt (Neg.neg.{0} Real Real.hasNeg Real.pi) (Real.Angle.toReal θ)
+but is expected to have type
+  forall (θ : Real.Angle), LT.lt.{0} Real Real.instLTReal (Neg.neg.{0} Real Real.instNegReal Real.pi) (Real.Angle.toReal θ)
+Case conversion may be inaccurate. Consider using '#align real.angle.neg_pi_lt_to_real Real.Angle.neg_pi_lt_toRealₓ'. -/
 theorem neg_pi_lt_toReal (θ : Angle) : -π < θ.toReal :=
   by
   induction θ using Real.Angle.induction_on
   exact left_lt_toIocMod _ _ _
 #align real.angle.neg_pi_lt_to_real Real.Angle.neg_pi_lt_toReal
 
+/- warning: real.angle.to_real_le_pi -> Real.Angle.toReal_le_pi is a dubious translation:
+lean 3 declaration is
+  forall (θ : Real.Angle), LE.le.{0} Real Real.hasLe (Real.Angle.toReal θ) Real.pi
+but is expected to have type
+  forall (θ : Real.Angle), LE.le.{0} Real Real.instLEReal (Real.Angle.toReal θ) Real.pi
+Case conversion may be inaccurate. Consider using '#align real.angle.to_real_le_pi Real.Angle.toReal_le_piₓ'. -/
 theorem toReal_le_pi (θ : Angle) : θ.toReal ≤ π :=
   by
   induction θ using Real.Angle.induction_on
@@ -571,14 +1087,32 @@ theorem toReal_le_pi (θ : Angle) : θ.toReal ≤ π :=
   ring
 #align real.angle.to_real_le_pi Real.Angle.toReal_le_pi
 
+/- warning: real.angle.abs_to_real_le_pi -> Real.Angle.abs_toReal_le_pi is a dubious translation:
+lean 3 declaration is
+  forall (θ : Real.Angle), LE.le.{0} Real Real.hasLe (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.toReal θ)) Real.pi
+but is expected to have type
+  forall (θ : Real.Angle), LE.le.{0} Real Real.instLEReal (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.toReal θ)) Real.pi
+Case conversion may be inaccurate. Consider using '#align real.angle.abs_to_real_le_pi Real.Angle.abs_toReal_le_piₓ'. -/
 theorem abs_toReal_le_pi (θ : Angle) : |θ.toReal| ≤ π :=
   abs_le.2 ⟨(neg_pi_lt_toReal _).le, toReal_le_pi _⟩
 #align real.angle.abs_to_real_le_pi Real.Angle.abs_toReal_le_pi
 
+/- warning: real.angle.to_real_mem_Ioc -> Real.Angle.toReal_mem_Ioc is a dubious translation:
+lean 3 declaration is
+  forall (θ : Real.Angle), Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) (Real.Angle.toReal θ) (Set.Ioc.{0} Real Real.preorder (Neg.neg.{0} Real Real.hasNeg Real.pi) Real.pi)
+but is expected to have type
+  forall (θ : Real.Angle), Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) (Real.Angle.toReal θ) (Set.Ioc.{0} Real Real.instPreorderReal (Neg.neg.{0} Real Real.instNegReal Real.pi) Real.pi)
+Case conversion may be inaccurate. Consider using '#align real.angle.to_real_mem_Ioc Real.Angle.toReal_mem_Iocₓ'. -/
 theorem toReal_mem_Ioc (θ : Angle) : θ.toReal ∈ Set.Ioc (-π) π :=
   ⟨neg_pi_lt_toReal _, toReal_le_pi _⟩
 #align real.angle.to_real_mem_Ioc Real.Angle.toReal_mem_Ioc
 
+/- warning: real.angle.to_Ioc_mod_to_real -> Real.Angle.toIocMod_toReal is a dubious translation:
+lean 3 declaration is
+  forall (θ : Real.Angle), Eq.{1} Real (toIocMod.{0} Real Real.linearOrderedAddCommGroup Real.archimedean (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi) Real.two_pi_pos (Neg.neg.{0} Real Real.hasNeg Real.pi) (Real.Angle.toReal θ)) (Real.Angle.toReal θ)
+but is expected to have type
+  forall (θ : Real.Angle), Eq.{1} Real (toIocMod.{0} Real Real.instLinearOrderedAddCommGroupReal Real.instArchimedeanRealOrderedAddCommMonoid (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi) Real.two_pi_pos (Neg.neg.{0} Real Real.instNegReal Real.pi) (Real.Angle.toReal θ)) (Real.Angle.toReal θ)
+Case conversion may be inaccurate. Consider using '#align real.angle.to_Ioc_mod_to_real Real.Angle.toIocMod_toRealₓ'. -/
 @[simp]
 theorem toIocMod_toReal (θ : Angle) : toIocMod two_pi_pos (-π) θ.toReal = θ.toReal :=
   by
@@ -587,6 +1121,12 @@ theorem toIocMod_toReal (θ : Angle) : toIocMod two_pi_pos (-π) θ.toReal = θ.
   exact toIocMod_toIocMod _ _ _ _
 #align real.angle.to_Ioc_mod_to_real Real.Angle.toIocMod_toReal
 
+/- warning: real.angle.to_real_zero -> Real.Angle.toReal_zero is a dubious translation:
+lean 3 declaration is
+  Eq.{1} Real (Real.Angle.toReal (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))
+but is expected to have type
+  Eq.{1} Real (Real.Angle.toReal (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))
+Case conversion may be inaccurate. Consider using '#align real.angle.to_real_zero Real.Angle.toReal_zeroₓ'. -/
 @[simp]
 theorem toReal_zero : (0 : Angle).toReal = 0 :=
   by
@@ -594,6 +1134,12 @@ theorem toReal_zero : (0 : Angle).toReal = 0 :=
   exact ⟨Left.neg_neg_iff.2 Real.pi_pos, real.pi_pos.le⟩
 #align real.angle.to_real_zero Real.Angle.toReal_zero
 
+/- warning: real.angle.to_real_eq_zero_iff -> Real.Angle.toReal_eq_zero_iff is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal θ) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (Eq.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))))))
+but is expected to have type
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal θ) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (Eq.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))))))
+Case conversion may be inaccurate. Consider using '#align real.angle.to_real_eq_zero_iff Real.Angle.toReal_eq_zero_iffₓ'. -/
 @[simp]
 theorem toReal_eq_zero_iff {θ : Angle} : θ.toReal = 0 ↔ θ = 0 :=
   by
@@ -601,6 +1147,12 @@ theorem toReal_eq_zero_iff {θ : Angle} : θ.toReal = 0 ↔ θ = 0 :=
   exact to_real_inj
 #align real.angle.to_real_eq_zero_iff Real.Angle.toReal_eq_zero_iff
 
+/- warning: real.angle.to_real_pi -> Real.Angle.toReal_pi is a dubious translation:
+lean 3 declaration is
+  Eq.{1} Real (Real.Angle.toReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) Real.pi
+but is expected to have type
+  Eq.{1} Real (Real.Angle.toReal (Real.Angle.coe Real.pi)) Real.pi
+Case conversion may be inaccurate. Consider using '#align real.angle.to_real_pi Real.Angle.toReal_piₓ'. -/
 @[simp]
 theorem toReal_pi : (π : Angle).toReal = π :=
   by
@@ -608,54 +1160,114 @@ theorem toReal_pi : (π : Angle).toReal = π :=
   exact ⟨Left.neg_lt_self Real.pi_pos, le_refl _⟩
 #align real.angle.to_real_pi Real.Angle.toReal_pi
 
+/- warning: real.angle.to_real_eq_pi_iff -> Real.Angle.toReal_eq_pi_iff is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal θ) Real.pi) (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi))
+but is expected to have type
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal θ) Real.pi) (Eq.{1} Real.Angle θ (Real.Angle.coe Real.pi))
+Case conversion may be inaccurate. Consider using '#align real.angle.to_real_eq_pi_iff Real.Angle.toReal_eq_pi_iffₓ'. -/
 @[simp]
 theorem toReal_eq_pi_iff {θ : Angle} : θ.toReal = π ↔ θ = π := by rw [← to_real_inj, to_real_pi]
 #align real.angle.to_real_eq_pi_iff Real.Angle.toReal_eq_pi_iff
 
+/- warning: real.angle.pi_ne_zero -> Real.Angle.pi_ne_zero is a dubious translation:
+lean 3 declaration is
+  Ne.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi) (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))
+but is expected to have type
+  Ne.{1} Real.Angle (Real.Angle.coe Real.pi) (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))
+Case conversion may be inaccurate. Consider using '#align real.angle.pi_ne_zero Real.Angle.pi_ne_zeroₓ'. -/
 theorem pi_ne_zero : (π : Angle) ≠ 0 :=
   by
   rw [← to_real_injective.ne_iff, to_real_pi, to_real_zero]
   exact pi_ne_zero
 #align real.angle.pi_ne_zero Real.Angle.pi_ne_zero
 
+/- warning: real.angle.to_real_pi_div_two -> Real.Angle.toReal_pi_div_two is a dubious translation:
+lean 3 declaration is
+  Eq.{1} Real (Real.Angle.toReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))
+but is expected to have type
+  Eq.{1} Real (Real.Angle.toReal (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))
+Case conversion may be inaccurate. Consider using '#align real.angle.to_real_pi_div_two Real.Angle.toReal_pi_div_twoₓ'. -/
 @[simp]
 theorem toReal_pi_div_two : ((π / 2 : ℝ) : Angle).toReal = π / 2 :=
   toReal_coe_eq_self_iff.2 <| by constructor <;> linarith [pi_pos]
 #align real.angle.to_real_pi_div_two Real.Angle.toReal_pi_div_two
 
+/- warning: real.angle.to_real_eq_pi_div_two_iff -> Real.Angle.toReal_eq_pi_div_two_iff is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal θ) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))) (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))))
+but is expected to have type
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal θ) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))) (Eq.{1} Real.Angle θ (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))))
+Case conversion may be inaccurate. Consider using '#align real.angle.to_real_eq_pi_div_two_iff Real.Angle.toReal_eq_pi_div_two_iffₓ'. -/
 @[simp]
 theorem toReal_eq_pi_div_two_iff {θ : Angle} : θ.toReal = π / 2 ↔ θ = (π / 2 : ℝ) := by
   rw [← to_real_inj, to_real_pi_div_two]
 #align real.angle.to_real_eq_pi_div_two_iff Real.Angle.toReal_eq_pi_div_two_iff
 
+/- warning: real.angle.to_real_neg_pi_div_two -> Real.Angle.toReal_neg_pi_div_two is a dubious translation:
+lean 3 declaration is
+  Eq.{1} Real (Real.Angle.toReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Neg.neg.{0} Real Real.hasNeg Real.pi) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Neg.neg.{0} Real Real.hasNeg Real.pi) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))
+but is expected to have type
+  Eq.{1} Real (Real.Angle.toReal (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Neg.neg.{0} Real Real.instNegReal Real.pi) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Neg.neg.{0} Real Real.instNegReal Real.pi) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))
+Case conversion may be inaccurate. Consider using '#align real.angle.to_real_neg_pi_div_two Real.Angle.toReal_neg_pi_div_twoₓ'. -/
 @[simp]
 theorem toReal_neg_pi_div_two : ((-π / 2 : ℝ) : Angle).toReal = -π / 2 :=
   toReal_coe_eq_self_iff.2 <| by constructor <;> linarith [pi_pos]
 #align real.angle.to_real_neg_pi_div_two Real.Angle.toReal_neg_pi_div_two
 
+/- warning: real.angle.to_real_eq_neg_pi_div_two_iff -> Real.Angle.toReal_eq_neg_pi_div_two_iff is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal θ) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Neg.neg.{0} Real Real.hasNeg Real.pi) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))) (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Neg.neg.{0} Real Real.hasNeg Real.pi) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))))
+but is expected to have type
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal θ) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Neg.neg.{0} Real Real.instNegReal Real.pi) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))) (Eq.{1} Real.Angle θ (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Neg.neg.{0} Real Real.instNegReal Real.pi) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))))
+Case conversion may be inaccurate. Consider using '#align real.angle.to_real_eq_neg_pi_div_two_iff Real.Angle.toReal_eq_neg_pi_div_two_iffₓ'. -/
 @[simp]
 theorem toReal_eq_neg_pi_div_two_iff {θ : Angle} : θ.toReal = -π / 2 ↔ θ = (-π / 2 : ℝ) := by
   rw [← to_real_inj, to_real_neg_pi_div_two]
 #align real.angle.to_real_eq_neg_pi_div_two_iff Real.Angle.toReal_eq_neg_pi_div_two_iff
 
+/- warning: real.angle.pi_div_two_ne_zero -> Real.Angle.pi_div_two_ne_zero is a dubious translation:
+lean 3 declaration is
+  Ne.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))) (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))
+but is expected to have type
+  Ne.{1} Real.Angle (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))) (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))
+Case conversion may be inaccurate. Consider using '#align real.angle.pi_div_two_ne_zero Real.Angle.pi_div_two_ne_zeroₓ'. -/
 theorem pi_div_two_ne_zero : ((π / 2 : ℝ) : Angle) ≠ 0 :=
   by
   rw [← to_real_injective.ne_iff, to_real_pi_div_two, to_real_zero]
   exact div_ne_zero Real.pi_ne_zero two_ne_zero
 #align real.angle.pi_div_two_ne_zero Real.Angle.pi_div_two_ne_zero
 
+/- warning: real.angle.neg_pi_div_two_ne_zero -> Real.Angle.neg_pi_div_two_ne_zero is a dubious translation:
+lean 3 declaration is
+  Ne.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Neg.neg.{0} Real Real.hasNeg Real.pi) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))) (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))
+but is expected to have type
+  Ne.{1} Real.Angle (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Neg.neg.{0} Real Real.instNegReal Real.pi) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))) (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))
+Case conversion may be inaccurate. Consider using '#align real.angle.neg_pi_div_two_ne_zero Real.Angle.neg_pi_div_two_ne_zeroₓ'. -/
 theorem neg_pi_div_two_ne_zero : ((-π / 2 : ℝ) : Angle) ≠ 0 :=
   by
   rw [← to_real_injective.ne_iff, to_real_neg_pi_div_two, to_real_zero]
   exact div_ne_zero (neg_ne_zero.2 Real.pi_ne_zero) two_ne_zero
 #align real.angle.neg_pi_div_two_ne_zero Real.Angle.neg_pi_div_two_ne_zero
 
+/- warning: real.angle.abs_to_real_coe_eq_self_iff -> Real.Angle.abs_toReal_coe_eq_self_iff is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real}, Iff (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.toReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ))) θ) (And (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) θ) (LE.le.{0} Real Real.hasLe θ Real.pi))
+but is expected to have type
+  forall {θ : Real}, Iff (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.toReal (Real.Angle.coe θ))) θ) (And (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) θ) (LE.le.{0} Real Real.instLEReal θ Real.pi))
+Case conversion may be inaccurate. Consider using '#align real.angle.abs_to_real_coe_eq_self_iff Real.Angle.abs_toReal_coe_eq_self_iffₓ'. -/
 theorem abs_toReal_coe_eq_self_iff {θ : ℝ} : |(θ : Angle).toReal| = θ ↔ 0 ≤ θ ∧ θ ≤ π :=
   ⟨fun h => h ▸ ⟨abs_nonneg _, abs_toReal_le_pi _⟩, fun h =>
     (toReal_coe_eq_self_iff.2 ⟨(Left.neg_neg_iff.2 Real.pi_pos).trans_le h.1, h.2⟩).symm ▸
       abs_eq_self.2 h.1⟩
 #align real.angle.abs_to_real_coe_eq_self_iff Real.Angle.abs_toReal_coe_eq_self_iff
 
+/- warning: real.angle.abs_to_real_neg_coe_eq_self_iff -> Real.Angle.abs_toReal_neg_coe_eq_self_iff is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real}, Iff (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.toReal (Neg.neg.{0} Real.Angle (SubNegMonoid.toHasNeg.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ)))) θ) (And (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) θ) (LE.le.{0} Real Real.hasLe θ Real.pi))
+but is expected to have type
+  forall {θ : Real}, Iff (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.toReal (Neg.neg.{0} Real.Angle (NegZeroClass.toNeg.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (Real.Angle.coe θ)))) θ) (And (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) θ) (LE.le.{0} Real Real.instLEReal θ Real.pi))
+Case conversion may be inaccurate. Consider using '#align real.angle.abs_to_real_neg_coe_eq_self_iff Real.Angle.abs_toReal_neg_coe_eq_self_iffₓ'. -/
 theorem abs_toReal_neg_coe_eq_self_iff {θ : ℝ} : |(-θ : Angle).toReal| = θ ↔ 0 ≤ θ ∧ θ ≤ π :=
   by
   refine' ⟨fun h => h ▸ ⟨abs_nonneg _, abs_to_real_le_pi _⟩, fun h => _⟩
@@ -666,12 +1278,24 @@ theorem abs_toReal_neg_coe_eq_self_iff {θ : ℝ} : |(-θ : Angle).toReal| = θ
     abs_neg, abs_eq_self.2 h.1]
 #align real.angle.abs_to_real_neg_coe_eq_self_iff Real.Angle.abs_toReal_neg_coe_eq_self_iff
 
+/- warning: real.angle.abs_to_real_eq_pi_div_two_iff -> Real.Angle.abs_toReal_eq_pi_div_two_iff is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.toReal θ)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))) (Or (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))) (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Neg.neg.{0} Real Real.hasNeg Real.pi) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))))
+but is expected to have type
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.toReal θ)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))) (Or (Eq.{1} Real.Angle θ (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))) (Eq.{1} Real.Angle θ (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Neg.neg.{0} Real Real.instNegReal Real.pi) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))))
+Case conversion may be inaccurate. Consider using '#align real.angle.abs_to_real_eq_pi_div_two_iff Real.Angle.abs_toReal_eq_pi_div_two_iffₓ'. -/
 theorem abs_toReal_eq_pi_div_two_iff {θ : Angle} :
     |θ.toReal| = π / 2 ↔ θ = (π / 2 : ℝ) ∨ θ = (-π / 2 : ℝ) := by
   rw [abs_eq (div_nonneg real.pi_pos.le two_pos.le), ← neg_div, to_real_eq_pi_div_two_iff,
     to_real_eq_neg_pi_div_two_iff]
 #align real.angle.abs_to_real_eq_pi_div_two_iff Real.Angle.abs_toReal_eq_pi_div_two_iff
 
+/- warning: real.angle.nsmul_to_real_eq_mul -> Real.Angle.nsmul_toReal_eq_mul is a dubious translation:
+lean 3 declaration is
+  forall {n : Nat}, (Ne.{1} Nat n (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) -> (forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) n θ)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Real (HasLiftT.mk.{1, 1} Nat Real (CoeTCₓ.coe.{1, 1} Nat Real (Nat.castCoe.{0} Real Real.hasNatCast))) n) (Real.Angle.toReal θ))) (Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) (Real.Angle.toReal θ) (Set.Ioc.{0} Real Real.preorder (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Neg.neg.{0} Real Real.hasNeg Real.pi) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Real (HasLiftT.mk.{1, 1} Nat Real (CoeTCₓ.coe.{1, 1} Nat Real (Nat.castCoe.{0} Real Real.hasNatCast))) n)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Real (HasLiftT.mk.{1, 1} Nat Real (CoeTCₓ.coe.{1, 1} Nat Real (Nat.castCoe.{0} Real Real.hasNatCast))) n)))))
+but is expected to have type
+  forall {n : Nat}, (Ne.{1} Nat n (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) -> (forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) n θ)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Nat.cast.{0} Real Real.natCast n) (Real.Angle.toReal θ))) (Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) (Real.Angle.toReal θ) (Set.Ioc.{0} Real Real.instPreorderReal (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Neg.neg.{0} Real Real.instNegReal Real.pi) (Nat.cast.{0} Real Real.natCast n)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (Nat.cast.{0} Real Real.natCast n)))))
+Case conversion may be inaccurate. Consider using '#align real.angle.nsmul_to_real_eq_mul Real.Angle.nsmul_toReal_eq_mulₓ'. -/
 theorem nsmul_toReal_eq_mul {n : ℕ} (h : n ≠ 0) {θ : Angle} :
     (n • θ).toReal = n * θ.toReal ↔ θ.toReal ∈ Set.Ioc (-π / n) (π / n) :=
   by
@@ -681,16 +1305,34 @@ theorem nsmul_toReal_eq_mul {n : ℕ} (h : n ≠ 0) {θ : Angle} :
     le_div_iff' h']
 #align real.angle.nsmul_to_real_eq_mul Real.Angle.nsmul_toReal_eq_mul
 
+/- warning: real.angle.two_nsmul_to_real_eq_two_mul -> Real.Angle.two_nsmul_toReal_eq_two_mul is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) θ)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) (Real.Angle.toReal θ))) (Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) (Real.Angle.toReal θ) (Set.Ioc.{0} Real Real.preorder (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Neg.neg.{0} Real Real.hasNeg Real.pi) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))))
+but is expected to have type
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) θ)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) (Real.Angle.toReal θ))) (Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) (Real.Angle.toReal θ) (Set.Ioc.{0} Real Real.instPreorderReal (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Neg.neg.{0} Real Real.instNegReal Real.pi) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))))
+Case conversion may be inaccurate. Consider using '#align real.angle.two_nsmul_to_real_eq_two_mul Real.Angle.two_nsmul_toReal_eq_two_mulₓ'. -/
 theorem two_nsmul_toReal_eq_two_mul {θ : Angle} :
     ((2 : ℕ) • θ).toReal = 2 * θ.toReal ↔ θ.toReal ∈ Set.Ioc (-π / 2) (π / 2) := by
   exact_mod_cast nsmul_to_real_eq_mul two_ne_zero
 #align real.angle.two_nsmul_to_real_eq_two_mul Real.Angle.two_nsmul_toReal_eq_two_mul
 
+/- warning: real.angle.two_zsmul_to_real_eq_two_mul -> Real.Angle.two_zsmul_toReal_eq_two_mul is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) θ)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) (Real.Angle.toReal θ))) (Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) (Real.Angle.toReal θ) (Set.Ioc.{0} Real Real.preorder (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Neg.neg.{0} Real Real.hasNeg Real.pi) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))))
+but is expected to have type
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) θ)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) (Real.Angle.toReal θ))) (Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) (Real.Angle.toReal θ) (Set.Ioc.{0} Real Real.instPreorderReal (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Neg.neg.{0} Real Real.instNegReal Real.pi) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))))
+Case conversion may be inaccurate. Consider using '#align real.angle.two_zsmul_to_real_eq_two_mul Real.Angle.two_zsmul_toReal_eq_two_mulₓ'. -/
 theorem two_zsmul_toReal_eq_two_mul {θ : Angle} :
     ((2 : ℤ) • θ).toReal = 2 * θ.toReal ↔ θ.toReal ∈ Set.Ioc (-π / 2) (π / 2) := by
   rw [two_zsmul, ← two_nsmul, two_nsmul_to_real_eq_two_mul]
 #align real.angle.two_zsmul_to_real_eq_two_mul Real.Angle.two_zsmul_toReal_eq_two_mul
 
+/- warning: real.angle.to_real_coe_eq_self_sub_two_mul_int_mul_pi_iff -> Real.Angle.toReal_coe_eq_self_sub_two_mul_int_mul_pi_iff is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real} {k : Int}, Iff (Eq.{1} Real (Real.Angle.toReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ)) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) θ (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Int Real (HasLiftT.mk.{1, 1} Int Real (CoeTCₓ.coe.{1, 1} Int Real (Int.castCoe.{0} Real Real.hasIntCast))) k)) Real.pi))) (Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) θ (Set.Ioc.{0} Real Real.preorder (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Int Real (HasLiftT.mk.{1, 1} Int Real (CoeTCₓ.coe.{1, 1} Int Real (Int.castCoe.{0} Real Real.hasIntCast))) k)) (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne)))) Real.pi) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Int Real (HasLiftT.mk.{1, 1} Int Real (CoeTCₓ.coe.{1, 1} Int Real (Int.castCoe.{0} Real Real.hasIntCast))) k)) (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne)))) Real.pi)))
+but is expected to have type
+  forall {θ : Real} {k : Int}, Iff (Eq.{1} Real (Real.Angle.toReal (Real.Angle.coe θ)) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) θ (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) (Int.cast.{0} Real Real.intCast k)) Real.pi))) (Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) θ (Set.Ioc.{0} Real Real.instPreorderReal (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) (Int.cast.{0} Real Real.intCast k)) (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal))) Real.pi) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) (Int.cast.{0} Real Real.intCast k)) (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal))) Real.pi)))
+Case conversion may be inaccurate. Consider using '#align real.angle.to_real_coe_eq_self_sub_two_mul_int_mul_pi_iff Real.Angle.toReal_coe_eq_self_sub_two_mul_int_mul_pi_iffₓ'. -/
 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) * π) :=
   by
@@ -699,16 +1341,34 @@ theorem toReal_coe_eq_self_sub_two_mul_int_mul_pi_iff {θ : ℝ} {k : ℤ} :
   exact ⟨fun h => ⟨by linarith, by linarith⟩, fun h => ⟨by linarith, by linarith⟩⟩
 #align real.angle.to_real_coe_eq_self_sub_two_mul_int_mul_pi_iff Real.Angle.toReal_coe_eq_self_sub_two_mul_int_mul_pi_iff
 
+/- warning: real.angle.to_real_coe_eq_self_sub_two_pi_iff -> Real.Angle.toReal_coe_eq_self_sub_two_pi_iff is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real}, Iff (Eq.{1} Real (Real.Angle.toReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ)) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) θ (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi))) (Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) θ (Set.Ioc.{0} Real Real.preorder Real.pi (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 3 (OfNat.mk.{0} Real 3 (bit1.{0} Real Real.hasOne Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi)))
+but is expected to have type
+  forall {θ : Real}, Iff (Eq.{1} Real (Real.Angle.toReal (Real.Angle.coe θ)) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) θ (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi))) (Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) θ (Set.Ioc.{0} Real Real.instPreorderReal Real.pi (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 3 (instOfNat.{0} Real 3 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))))) Real.pi)))
+Case conversion may be inaccurate. Consider using '#align real.angle.to_real_coe_eq_self_sub_two_pi_iff Real.Angle.toReal_coe_eq_self_sub_two_pi_iffₓ'. -/
 theorem toReal_coe_eq_self_sub_two_pi_iff {θ : ℝ} :
     (θ : Angle).toReal = θ - 2 * π ↔ θ ∈ Set.Ioc π (3 * π) := by
   convert@to_real_coe_eq_self_sub_two_mul_int_mul_pi_iff θ 1 <;> norm_num
 #align real.angle.to_real_coe_eq_self_sub_two_pi_iff Real.Angle.toReal_coe_eq_self_sub_two_pi_iff
 
+/- warning: real.angle.to_real_coe_eq_self_add_two_pi_iff -> Real.Angle.toReal_coe_eq_self_add_two_pi_iff is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real}, Iff (Eq.{1} Real (Real.Angle.toReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) θ (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi))) (Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) θ (Set.Ioc.{0} Real Real.preorder (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (Neg.neg.{0} Real Real.hasNeg (OfNat.ofNat.{0} Real 3 (OfNat.mk.{0} Real 3 (bit1.{0} Real Real.hasOne Real.hasAdd (One.one.{0} Real Real.hasOne))))) Real.pi) (Neg.neg.{0} Real Real.hasNeg Real.pi)))
+but is expected to have type
+  forall {θ : Real}, Iff (Eq.{1} Real (Real.Angle.toReal (Real.Angle.coe θ)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) θ (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi))) (Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) θ (Set.Ioc.{0} Real Real.instPreorderReal (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Neg.neg.{0} Real Real.instNegReal (OfNat.ofNat.{0} Real 3 (instOfNat.{0} Real 3 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))))) Real.pi) (Neg.neg.{0} Real Real.instNegReal Real.pi)))
+Case conversion may be inaccurate. Consider using '#align real.angle.to_real_coe_eq_self_add_two_pi_iff Real.Angle.toReal_coe_eq_self_add_two_pi_iffₓ'. -/
 theorem toReal_coe_eq_self_add_two_pi_iff {θ : ℝ} :
     (θ : Angle).toReal = θ + 2 * π ↔ θ ∈ Set.Ioc (-3 * π) (-π) := by
   convert@to_real_coe_eq_self_sub_two_mul_int_mul_pi_iff θ (-1) <;> norm_num
 #align real.angle.to_real_coe_eq_self_add_two_pi_iff Real.Angle.toReal_coe_eq_self_add_two_pi_iff
 
+/- warning: real.angle.two_nsmul_to_real_eq_two_mul_sub_two_pi -> Real.Angle.two_nsmul_toReal_eq_two_mul_sub_two_pi is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) θ)) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) (Real.Angle.toReal θ)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi))) (LT.lt.{0} Real Real.hasLt (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))) (Real.Angle.toReal θ))
+but is expected to have type
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) θ)) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) (Real.Angle.toReal θ)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi))) (LT.lt.{0} Real Real.instLTReal (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))) (Real.Angle.toReal θ))
+Case conversion may be inaccurate. Consider using '#align real.angle.two_nsmul_to_real_eq_two_mul_sub_two_pi Real.Angle.two_nsmul_toReal_eq_two_mul_sub_two_piₓ'. -/
 theorem two_nsmul_toReal_eq_two_mul_sub_two_pi {θ : Angle} :
     ((2 : ℕ) • θ).toReal = 2 * θ.toReal - 2 * π ↔ π / 2 < θ.toReal :=
   by
@@ -719,11 +1379,23 @@ theorem two_nsmul_toReal_eq_two_mul_sub_two_pi {θ : Angle} :
       ⟨(div_lt_iff' (zero_lt_two' ℝ)).1 h, by linarith [pi_pos, to_real_le_pi θ]⟩⟩
 #align real.angle.two_nsmul_to_real_eq_two_mul_sub_two_pi Real.Angle.two_nsmul_toReal_eq_two_mul_sub_two_pi
 
+/- warning: real.angle.two_zsmul_to_real_eq_two_mul_sub_two_pi -> Real.Angle.two_zsmul_toReal_eq_two_mul_sub_two_pi is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) θ)) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) (Real.Angle.toReal θ)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi))) (LT.lt.{0} Real Real.hasLt (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))) (Real.Angle.toReal θ))
+but is expected to have type
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) θ)) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) (Real.Angle.toReal θ)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi))) (LT.lt.{0} Real Real.instLTReal (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))) (Real.Angle.toReal θ))
+Case conversion may be inaccurate. Consider using '#align real.angle.two_zsmul_to_real_eq_two_mul_sub_two_pi Real.Angle.two_zsmul_toReal_eq_two_mul_sub_two_piₓ'. -/
 theorem two_zsmul_toReal_eq_two_mul_sub_two_pi {θ : Angle} :
     ((2 : ℤ) • θ).toReal = 2 * θ.toReal - 2 * π ↔ π / 2 < θ.toReal := by
   rw [two_zsmul, ← two_nsmul, two_nsmul_to_real_eq_two_mul_sub_two_pi]
 #align real.angle.two_zsmul_to_real_eq_two_mul_sub_two_pi Real.Angle.two_zsmul_toReal_eq_two_mul_sub_two_pi
 
+/- warning: real.angle.two_nsmul_to_real_eq_two_mul_add_two_pi -> Real.Angle.two_nsmul_toReal_eq_two_mul_add_two_pi is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) θ)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) (Real.Angle.toReal θ)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi))) (LE.le.{0} Real Real.hasLe (Real.Angle.toReal θ) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Neg.neg.{0} Real Real.hasNeg Real.pi) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))
+but is expected to have type
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) θ)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) (Real.Angle.toReal θ)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi))) (LE.le.{0} Real Real.instLEReal (Real.Angle.toReal θ) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Neg.neg.{0} Real Real.instNegReal Real.pi) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))
+Case conversion may be inaccurate. Consider using '#align real.angle.two_nsmul_to_real_eq_two_mul_add_two_pi Real.Angle.two_nsmul_toReal_eq_two_mul_add_two_piₓ'. -/
 theorem two_nsmul_toReal_eq_two_mul_add_two_pi {θ : Angle} :
     ((2 : ℕ) • θ).toReal = 2 * θ.toReal + 2 * π ↔ θ.toReal ≤ -π / 2 :=
   by
@@ -734,21 +1406,37 @@ theorem two_nsmul_toReal_eq_two_mul_add_two_pi {θ : Angle} :
       ⟨by linarith [pi_pos, neg_pi_lt_to_real θ], (le_div_iff' (zero_lt_two' ℝ)).1 h⟩⟩
 #align real.angle.two_nsmul_to_real_eq_two_mul_add_two_pi Real.Angle.two_nsmul_toReal_eq_two_mul_add_two_pi
 
+/- warning: real.angle.two_zsmul_to_real_eq_two_mul_add_two_pi -> Real.Angle.two_zsmul_toReal_eq_two_mul_add_two_pi is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) θ)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) (Real.Angle.toReal θ)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))) Real.pi))) (LE.le.{0} Real Real.hasLe (Real.Angle.toReal θ) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Neg.neg.{0} Real Real.hasNeg Real.pi) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))
+but is expected to have type
+  forall {θ : Real.Angle}, Iff (Eq.{1} Real (Real.Angle.toReal (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) θ)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) (Real.Angle.toReal θ)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))) Real.pi))) (LE.le.{0} Real Real.instLEReal (Real.Angle.toReal θ) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Neg.neg.{0} Real Real.instNegReal Real.pi) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))
+Case conversion may be inaccurate. Consider using '#align real.angle.two_zsmul_to_real_eq_two_mul_add_two_pi Real.Angle.two_zsmul_toReal_eq_two_mul_add_two_piₓ'. -/
 theorem two_zsmul_toReal_eq_two_mul_add_two_pi {θ : Angle} :
     ((2 : ℤ) • θ).toReal = 2 * θ.toReal + 2 * π ↔ θ.toReal ≤ -π / 2 := by
   rw [two_zsmul, ← two_nsmul, two_nsmul_to_real_eq_two_mul_add_two_pi]
 #align real.angle.two_zsmul_to_real_eq_two_mul_add_two_pi Real.Angle.two_zsmul_toReal_eq_two_mul_add_two_pi
 
+#print Real.Angle.sin_toReal /-
 @[simp]
 theorem sin_toReal (θ : Angle) : Real.sin θ.toReal = sin θ := by
   conv_rhs => rw [← coe_to_real θ, sin_coe]
 #align real.angle.sin_to_real Real.Angle.sin_toReal
+-/
 
+#print Real.Angle.cos_toReal /-
 @[simp]
 theorem cos_toReal (θ : Angle) : Real.cos θ.toReal = cos θ := by
   conv_rhs => rw [← coe_to_real θ, cos_coe]
 #align real.angle.cos_to_real Real.Angle.cos_toReal
+-/
 
+/- warning: real.angle.cos_nonneg_iff_abs_to_real_le_pi_div_two -> Real.Angle.cos_nonneg_iff_abs_toReal_le_pi_div_two is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, Iff (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (Real.Angle.cos θ)) (LE.le.{0} Real Real.hasLe (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.toReal θ)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))
+but is expected to have type
+  forall {θ : Real.Angle}, Iff (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (Real.Angle.cos θ)) (LE.le.{0} Real Real.instLEReal (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.toReal θ)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))
+Case conversion may be inaccurate. Consider using '#align real.angle.cos_nonneg_iff_abs_to_real_le_pi_div_two 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 :=
   by
   nth_rw 1 [← coe_to_real θ]
@@ -765,6 +1453,12 @@ theorem cos_nonneg_iff_abs_toReal_le_pi_div_two {θ : Angle} : 0 ≤ cos θ ↔
     linarith [to_real_le_pi θ]
 #align real.angle.cos_nonneg_iff_abs_to_real_le_pi_div_two Real.Angle.cos_nonneg_iff_abs_toReal_le_pi_div_two
 
+/- warning: real.angle.cos_pos_iff_abs_to_real_lt_pi_div_two -> Real.Angle.cos_pos_iff_abs_toReal_lt_pi_div_two is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, Iff (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (Real.Angle.cos θ)) (LT.lt.{0} Real Real.hasLt (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.toReal θ)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))
+but is expected to have type
+  forall {θ : Real.Angle}, Iff (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (Real.Angle.cos θ)) (LT.lt.{0} Real Real.instLTReal (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.toReal θ)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))
+Case conversion may be inaccurate. Consider using '#align real.angle.cos_pos_iff_abs_to_real_lt_pi_div_two 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 :=
   by
   rw [lt_iff_le_and_ne, lt_iff_le_and_ne, cos_nonneg_iff_abs_to_real_le_pi_div_two, ←
@@ -773,10 +1467,22 @@ theorem cos_pos_iff_abs_toReal_lt_pi_div_two {θ : Angle} : 0 < cos θ ↔ |θ.t
   rw [Ne.def, Ne.def, not_iff_not, @eq_comm ℝ 0, abs_to_real_eq_pi_div_two_iff, cos_eq_zero_iff]
 #align real.angle.cos_pos_iff_abs_to_real_lt_pi_div_two Real.Angle.cos_pos_iff_abs_toReal_lt_pi_div_two
 
+/- warning: real.angle.cos_neg_iff_pi_div_two_lt_abs_to_real -> Real.Angle.cos_neg_iff_pi_div_two_lt_abs_toReal is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, Iff (LT.lt.{0} Real Real.hasLt (Real.Angle.cos θ) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (LT.lt.{0} Real Real.hasLt (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.toReal θ)))
+but is expected to have type
+  forall {θ : Real.Angle}, Iff (LT.lt.{0} Real Real.instLTReal (Real.Angle.cos θ) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (LT.lt.{0} Real Real.instLTReal (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.toReal θ)))
+Case conversion may be inaccurate. Consider using '#align real.angle.cos_neg_iff_pi_div_two_lt_abs_to_real 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| := by
   rw [← not_le, ← not_le, not_iff_not, cos_nonneg_iff_abs_to_real_le_pi_div_two]
 #align real.angle.cos_neg_iff_pi_div_two_lt_abs_to_real Real.Angle.cos_neg_iff_pi_div_two_lt_abs_toReal
 
+/- warning: real.angle.abs_cos_eq_abs_sin_of_two_nsmul_add_two_nsmul_eq_pi -> Real.Angle.abs_cos_eq_abs_sin_of_two_nsmul_add_two_nsmul_eq_pi is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) θ) (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) ψ)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) -> (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.cos θ)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.sin ψ)))
+but is expected to have type
+  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) θ) (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) ψ)) (Real.Angle.coe Real.pi)) -> (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.cos θ)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.sin ψ)))
+Case conversion may be inaccurate. Consider using '#align real.angle.abs_cos_eq_abs_sin_of_two_nsmul_add_two_nsmul_eq_pi 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 ψ| :=
   by
@@ -784,6 +1490,12 @@ theorem abs_cos_eq_abs_sin_of_two_nsmul_add_two_nsmul_eq_pi {θ ψ : Angle}
   rcases h with (rfl | rfl) <;> simp [cos_pi_div_two_sub]
 #align real.angle.abs_cos_eq_abs_sin_of_two_nsmul_add_two_nsmul_eq_pi Real.Angle.abs_cos_eq_abs_sin_of_two_nsmul_add_two_nsmul_eq_pi
 
+/- warning: real.angle.abs_cos_eq_abs_sin_of_two_zsmul_add_two_zsmul_eq_pi -> Real.Angle.abs_cos_eq_abs_sin_of_two_zsmul_add_two_zsmul_eq_pi is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) θ) (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) ψ)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) -> (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.cos θ)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.sin ψ)))
+but is expected to have type
+  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) θ) (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) ψ)) (Real.Angle.coe Real.pi)) -> (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.cos θ)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.sin ψ)))
+Case conversion may be inaccurate. Consider using '#align real.angle.abs_cos_eq_abs_sin_of_two_zsmul_add_two_zsmul_eq_pi 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 ψ| :=
   by
@@ -791,28 +1503,60 @@ theorem abs_cos_eq_abs_sin_of_two_zsmul_add_two_zsmul_eq_pi {θ ψ : Angle}
   exact abs_cos_eq_abs_sin_of_two_nsmul_add_two_nsmul_eq_pi h
 #align real.angle.abs_cos_eq_abs_sin_of_two_zsmul_add_two_zsmul_eq_pi Real.Angle.abs_cos_eq_abs_sin_of_two_zsmul_add_two_zsmul_eq_pi
 
+#print Real.Angle.tan /-
 /-- The tangent of a `real.angle`. -/
 def tan (θ : Angle) : ℝ :=
   sin θ / cos θ
 #align real.angle.tan Real.Angle.tan
+-/
 
+/- warning: real.angle.tan_eq_sin_div_cos -> Real.Angle.tan_eq_sin_div_cos is a dubious translation:
+lean 3 declaration is
+  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.tan θ) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Real.Angle.sin θ) (Real.Angle.cos θ))
+but is expected to have type
+  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.tan θ) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Real.Angle.sin θ) (Real.Angle.cos θ))
+Case conversion may be inaccurate. Consider using '#align real.angle.tan_eq_sin_div_cos Real.Angle.tan_eq_sin_div_cosₓ'. -/
 theorem tan_eq_sin_div_cos (θ : Angle) : tan θ = sin θ / cos θ :=
   rfl
 #align real.angle.tan_eq_sin_div_cos Real.Angle.tan_eq_sin_div_cos
 
+/- warning: real.angle.tan_coe -> Real.Angle.tan_coe is a dubious translation:
+lean 3 declaration is
+  forall (x : Real), Eq.{1} Real (Real.Angle.tan ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) x)) (Real.tan x)
+but is expected to have type
+  forall (x : Real), Eq.{1} Real (Real.Angle.tan (Real.Angle.coe x)) (Real.tan x)
+Case conversion may be inaccurate. Consider using '#align real.angle.tan_coe Real.Angle.tan_coeₓ'. -/
 @[simp]
 theorem tan_coe (x : ℝ) : tan (x : Angle) = Real.tan x := by
   rw [tan, sin_coe, cos_coe, Real.tan_eq_sin_div_cos]
 #align real.angle.tan_coe Real.Angle.tan_coe
 
+/- warning: real.angle.tan_zero -> Real.Angle.tan_zero is a dubious translation:
+lean 3 declaration is
+  Eq.{1} Real (Real.Angle.tan (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))
+but is expected to have type
+  Eq.{1} Real (Real.Angle.tan (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))
+Case conversion may be inaccurate. Consider using '#align real.angle.tan_zero Real.Angle.tan_zeroₓ'. -/
 @[simp]
 theorem tan_zero : tan (0 : Angle) = 0 := by rw [← coe_zero, tan_coe, Real.tan_zero]
 #align real.angle.tan_zero Real.Angle.tan_zero
 
+/- warning: real.angle.tan_coe_pi -> Real.Angle.tan_coe_pi is a dubious translation:
+lean 3 declaration is
+  Eq.{1} Real (Real.Angle.tan ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))
+but is expected to have type
+  Eq.{1} Real (Real.Angle.tan (Real.Angle.coe Real.pi)) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))
+Case conversion may be inaccurate. Consider using '#align real.angle.tan_coe_pi Real.Angle.tan_coe_piₓ'. -/
 @[simp]
 theorem tan_coe_pi : tan (π : Angle) = 0 := by rw [tan_eq_sin_div_cos, sin_coe_pi, zero_div]
 #align real.angle.tan_coe_pi Real.Angle.tan_coe_pi
 
+/- warning: real.angle.tan_periodic -> Real.Angle.tan_periodic is a dubious translation:
+lean 3 declaration is
+  Function.Periodic.{0, 0} Real.Angle Real (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))) Real.Angle.tan ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)
+but is expected to have type
+  Function.Periodic.{0, 0} Real.Angle Real (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) Real.Angle.tan (Real.Angle.coe Real.pi)
+Case conversion may be inaccurate. Consider using '#align real.angle.tan_periodic Real.Angle.tan_periodicₓ'. -/
 theorem tan_periodic : Function.Periodic tan (π : Angle) :=
   by
   intro θ
@@ -821,21 +1565,41 @@ theorem tan_periodic : Function.Periodic tan (π : Angle) :=
   exact Real.tan_periodic θ
 #align real.angle.tan_periodic Real.Angle.tan_periodic
 
+/- warning: real.angle.tan_add_pi -> Real.Angle.tan_add_pi is a dubious translation:
+lean 3 declaration is
+  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.tan (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi))) (Real.Angle.tan θ)
+but is expected to have type
+  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.tan (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) θ (Real.Angle.coe Real.pi))) (Real.Angle.tan θ)
+Case conversion may be inaccurate. Consider using '#align real.angle.tan_add_pi Real.Angle.tan_add_piₓ'. -/
 @[simp]
 theorem tan_add_pi (θ : Angle) : tan (θ + π) = tan θ :=
   tan_periodic θ
 #align real.angle.tan_add_pi Real.Angle.tan_add_pi
 
+/- warning: real.angle.tan_sub_pi -> Real.Angle.tan_sub_pi is a dubious translation:
+lean 3 declaration is
+  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.tan (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toHasSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi))) (Real.Angle.tan θ)
+but is expected to have type
+  forall (θ : Real.Angle), Eq.{1} Real (Real.Angle.tan (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) θ (Real.Angle.coe Real.pi))) (Real.Angle.tan θ)
+Case conversion may be inaccurate. Consider using '#align real.angle.tan_sub_pi Real.Angle.tan_sub_piₓ'. -/
 @[simp]
 theorem tan_sub_pi (θ : Angle) : tan (θ - π) = tan θ :=
   tan_periodic.sub_eq θ
 #align real.angle.tan_sub_pi Real.Angle.tan_sub_pi
 
+#print Real.Angle.tan_toReal /-
 @[simp]
 theorem tan_toReal (θ : Angle) : Real.tan θ.toReal = tan θ := by
   conv_rhs => rw [← coe_to_real θ, tan_coe]
 #align real.angle.tan_to_real Real.Angle.tan_toReal
+-/
 
+/- warning: real.angle.tan_eq_of_two_nsmul_eq -> Real.Angle.tan_eq_of_two_nsmul_eq is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) θ) (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) ψ)) -> (Eq.{1} Real (Real.Angle.tan θ) (Real.Angle.tan ψ))
+but is expected to have type
+  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) θ) (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) ψ)) -> (Eq.{1} Real (Real.Angle.tan θ) (Real.Angle.tan ψ))
+Case conversion may be inaccurate. Consider using '#align real.angle.tan_eq_of_two_nsmul_eq Real.Angle.tan_eq_of_two_nsmul_eqₓ'. -/
 theorem tan_eq_of_two_nsmul_eq {θ ψ : Angle} (h : (2 : ℕ) • θ = (2 : ℕ) • ψ) : tan θ = tan ψ :=
   by
   rw [two_nsmul_eq_iff] at h
@@ -844,12 +1608,24 @@ theorem tan_eq_of_two_nsmul_eq {θ ψ : Angle} (h : (2 : ℕ) • θ = (2 : ℕ)
   · exact tan_add_pi _
 #align real.angle.tan_eq_of_two_nsmul_eq Real.Angle.tan_eq_of_two_nsmul_eq
 
+/- warning: real.angle.tan_eq_of_two_zsmul_eq -> Real.Angle.tan_eq_of_two_zsmul_eq is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) θ) (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) ψ)) -> (Eq.{1} Real (Real.Angle.tan θ) (Real.Angle.tan ψ))
+but is expected to have type
+  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) θ) (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) ψ)) -> (Eq.{1} Real (Real.Angle.tan θ) (Real.Angle.tan ψ))
+Case conversion may be inaccurate. Consider using '#align real.angle.tan_eq_of_two_zsmul_eq Real.Angle.tan_eq_of_two_zsmul_eqₓ'. -/
 theorem tan_eq_of_two_zsmul_eq {θ ψ : Angle} (h : (2 : ℤ) • θ = (2 : ℤ) • ψ) : tan θ = tan ψ :=
   by
   simp_rw [two_zsmul, ← two_nsmul] at h
   exact tan_eq_of_two_nsmul_eq h
 #align real.angle.tan_eq_of_two_zsmul_eq Real.Angle.tan_eq_of_two_zsmul_eq
 
+/- warning: real.angle.tan_eq_inv_of_two_nsmul_add_two_nsmul_eq_pi -> Real.Angle.tan_eq_inv_of_two_nsmul_add_two_nsmul_eq_pi is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) θ) (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) ψ)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) -> (Eq.{1} Real (Real.Angle.tan ψ) (Inv.inv.{0} Real Real.hasInv (Real.Angle.tan θ)))
+but is expected to have type
+  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) θ) (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) ψ)) (Real.Angle.coe Real.pi)) -> (Eq.{1} Real (Real.Angle.tan ψ) (Inv.inv.{0} Real Real.instInvReal (Real.Angle.tan θ)))
+Case conversion may be inaccurate. Consider using '#align real.angle.tan_eq_inv_of_two_nsmul_add_two_nsmul_eq_pi 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 θ)⁻¹ :=
   by
@@ -864,6 +1640,12 @@ theorem tan_eq_inv_of_two_nsmul_add_two_nsmul_eq_pi {θ ψ : Angle}
   exact real.tan_periodic.int_mul _ _
 #align real.angle.tan_eq_inv_of_two_nsmul_add_two_nsmul_eq_pi Real.Angle.tan_eq_inv_of_two_nsmul_add_two_nsmul_eq_pi
 
+/- warning: real.angle.tan_eq_inv_of_two_zsmul_add_two_zsmul_eq_pi -> Real.Angle.tan_eq_inv_of_two_zsmul_add_two_zsmul_eq_pi is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) θ) (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) ψ)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) -> (Eq.{1} Real (Real.Angle.tan ψ) (Inv.inv.{0} Real Real.hasInv (Real.Angle.tan θ)))
+but is expected to have type
+  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} Real.Angle (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) θ) (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) ψ)) (Real.Angle.coe Real.pi)) -> (Eq.{1} Real (Real.Angle.tan ψ) (Inv.inv.{0} Real Real.instInvReal (Real.Angle.tan θ)))
+Case conversion may be inaccurate. Consider using '#align real.angle.tan_eq_inv_of_two_zsmul_add_two_zsmul_eq_pi 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 θ)⁻¹ :=
   by
@@ -871,57 +1653,125 @@ theorem tan_eq_inv_of_two_zsmul_add_two_zsmul_eq_pi {θ ψ : Angle}
   exact tan_eq_inv_of_two_nsmul_add_two_nsmul_eq_pi h
 #align real.angle.tan_eq_inv_of_two_zsmul_add_two_zsmul_eq_pi Real.Angle.tan_eq_inv_of_two_zsmul_add_two_zsmul_eq_pi
 
+#print Real.Angle.sign /-
 /-- 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 :=
   SignType.sign (sin θ)
 #align real.angle.sign Real.Angle.sign
+-/
 
+/- warning: real.angle.sign_zero -> Real.Angle.sign_zero is a dubious translation:
+lean 3 declaration is
+  Eq.{1} SignType (Real.Angle.sign (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (OfNat.ofNat.{0} SignType 0 (OfNat.mk.{0} SignType 0 (Zero.zero.{0} SignType SignType.hasZero)))
+but is expected to have type
+  Eq.{1} SignType (Real.Angle.sign (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (OfNat.ofNat.{0} SignType 0 (Zero.toOfNat0.{0} SignType SignType.instZeroSignType))
+Case conversion may be inaccurate. Consider using '#align real.angle.sign_zero Real.Angle.sign_zeroₓ'. -/
 @[simp]
 theorem sign_zero : (0 : Angle).sign = 0 := by rw [SignType.sign, sin_zero, sign_zero]
 #align real.angle.sign_zero Real.Angle.sign_zero
 
+/- warning: real.angle.sign_coe_pi -> Real.Angle.sign_coe_pi is a dubious translation:
+lean 3 declaration is
+  Eq.{1} SignType (Real.Angle.sign ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) (OfNat.ofNat.{0} SignType 0 (OfNat.mk.{0} SignType 0 (Zero.zero.{0} SignType SignType.hasZero)))
+but is expected to have type
+  Eq.{1} SignType (Real.Angle.sign (Real.Angle.coe Real.pi)) (OfNat.ofNat.{0} SignType 0 (Zero.toOfNat0.{0} SignType SignType.instZeroSignType))
+Case conversion may be inaccurate. Consider using '#align real.angle.sign_coe_pi Real.Angle.sign_coe_piₓ'. -/
 @[simp]
 theorem sign_coe_pi : (π : Angle).sign = 0 := by rw [SignType.sign, sin_coe_pi, _root_.sign_zero]
 #align real.angle.sign_coe_pi Real.Angle.sign_coe_pi
 
+/- warning: real.angle.sign_neg -> Real.Angle.sign_neg is a dubious translation:
+lean 3 declaration is
+  forall (θ : Real.Angle), Eq.{1} SignType (Real.Angle.sign (Neg.neg.{0} Real.Angle (SubNegMonoid.toHasNeg.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) θ)) (Neg.neg.{0} SignType SignType.hasNeg (Real.Angle.sign θ))
+but is expected to have type
+  forall (θ : Real.Angle), Eq.{1} SignType (Real.Angle.sign (Neg.neg.{0} Real.Angle (NegZeroClass.toNeg.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) θ)) (Neg.neg.{0} SignType SignType.instNegSignType (Real.Angle.sign θ))
+Case conversion may be inaccurate. Consider using '#align real.angle.sign_neg Real.Angle.sign_negₓ'. -/
 @[simp]
 theorem sign_neg (θ : Angle) : (-θ).sign = -θ.sign := by
   simp_rw [SignType.sign, sin_neg, Left.sign_neg]
 #align real.angle.sign_neg Real.Angle.sign_neg
 
+/- warning: real.angle.sign_antiperiodic -> Real.Angle.sign_antiperiodic is a dubious translation:
+lean 3 declaration is
+  Function.Antiperiodic.{0, 0} Real.Angle SignType (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))) SignType.hasNeg Real.Angle.sign ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)
+but is expected to have type
+  Function.Antiperiodic.{0, 0} Real.Angle SignType (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) SignType.instNegSignType Real.Angle.sign (Real.Angle.coe Real.pi)
+Case conversion may be inaccurate. Consider using '#align real.angle.sign_antiperiodic Real.Angle.sign_antiperiodicₓ'. -/
 theorem sign_antiperiodic : Function.Antiperiodic sign (π : Angle) := fun θ => by
   rw [SignType.sign, SignType.sign, sin_add_pi, Left.sign_neg]
 #align real.angle.sign_antiperiodic Real.Angle.sign_antiperiodic
 
+/- warning: real.angle.sign_add_pi -> Real.Angle.sign_add_pi is a dubious translation:
+lean 3 declaration is
+  forall (θ : Real.Angle), Eq.{1} SignType (Real.Angle.sign (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi))) (Neg.neg.{0} SignType SignType.hasNeg (Real.Angle.sign θ))
+but is expected to have type
+  forall (θ : Real.Angle), Eq.{1} SignType (Real.Angle.sign (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) θ (Real.Angle.coe Real.pi))) (Neg.neg.{0} SignType SignType.instNegSignType (Real.Angle.sign θ))
+Case conversion may be inaccurate. Consider using '#align real.angle.sign_add_pi Real.Angle.sign_add_piₓ'. -/
 @[simp]
 theorem sign_add_pi (θ : Angle) : (θ + π).sign = -θ.sign :=
   sign_antiperiodic θ
 #align real.angle.sign_add_pi Real.Angle.sign_add_pi
 
+/- warning: real.angle.sign_pi_add -> Real.Angle.sign_pi_add is a dubious translation:
+lean 3 declaration is
+  forall (θ : Real.Angle), Eq.{1} SignType (Real.Angle.sign (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toHasAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi) θ)) (Neg.neg.{0} SignType SignType.hasNeg (Real.Angle.sign θ))
+but is expected to have type
+  forall (θ : Real.Angle), Eq.{1} SignType (Real.Angle.sign (HAdd.hAdd.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHAdd.{0} Real.Angle (AddZeroClass.toAdd.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))) (Real.Angle.coe Real.pi) θ)) (Neg.neg.{0} SignType SignType.instNegSignType (Real.Angle.sign θ))
+Case conversion may be inaccurate. Consider using '#align real.angle.sign_pi_add Real.Angle.sign_pi_addₓ'. -/
 @[simp]
 theorem sign_pi_add (θ : Angle) : ((π : Angle) + θ).sign = -θ.sign := by rw [add_comm, sign_add_pi]
 #align real.angle.sign_pi_add Real.Angle.sign_pi_add
 
+/- warning: real.angle.sign_sub_pi -> Real.Angle.sign_sub_pi is a dubious translation:
+lean 3 declaration is
+  forall (θ : Real.Angle), Eq.{1} SignType (Real.Angle.sign (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toHasSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi))) (Neg.neg.{0} SignType SignType.hasNeg (Real.Angle.sign θ))
+but is expected to have type
+  forall (θ : Real.Angle), Eq.{1} SignType (Real.Angle.sign (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) θ (Real.Angle.coe Real.pi))) (Neg.neg.{0} SignType SignType.instNegSignType (Real.Angle.sign θ))
+Case conversion may be inaccurate. Consider using '#align real.angle.sign_sub_pi Real.Angle.sign_sub_piₓ'. -/
 @[simp]
 theorem sign_sub_pi (θ : Angle) : (θ - π).sign = -θ.sign :=
   sign_antiperiodic.sub_eq θ
 #align real.angle.sign_sub_pi Real.Angle.sign_sub_pi
 
+/- warning: real.angle.sign_pi_sub -> Real.Angle.sign_pi_sub is a dubious translation:
+lean 3 declaration is
+  forall (θ : Real.Angle), Eq.{1} SignType (Real.Angle.sign (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toHasSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi) θ)) (Real.Angle.sign θ)
+but is expected to have type
+  forall (θ : Real.Angle), Eq.{1} SignType (Real.Angle.sign (HSub.hSub.{0, 0, 0} Real.Angle Real.Angle Real.Angle (instHSub.{0} Real.Angle (SubNegMonoid.toSub.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (Real.Angle.coe Real.pi) θ)) (Real.Angle.sign θ)
+Case conversion may be inaccurate. Consider using '#align real.angle.sign_pi_sub Real.Angle.sign_pi_subₓ'. -/
 @[simp]
 theorem sign_pi_sub (θ : Angle) : ((π : Angle) - θ).sign = θ.sign := by
   simp [sign_antiperiodic.sub_eq']
 #align real.angle.sign_pi_sub Real.Angle.sign_pi_sub
 
+/- warning: real.angle.sign_eq_zero_iff -> Real.Angle.sign_eq_zero_iff is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, Iff (Eq.{1} SignType (Real.Angle.sign θ) (OfNat.ofNat.{0} SignType 0 (OfNat.mk.{0} SignType 0 (Zero.zero.{0} SignType SignType.hasZero)))) (Or (Eq.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)))
+but is expected to have type
+  forall {θ : Real.Angle}, Iff (Eq.{1} SignType (Real.Angle.sign θ) (OfNat.ofNat.{0} SignType 0 (Zero.toOfNat0.{0} SignType SignType.instZeroSignType))) (Or (Eq.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (Eq.{1} Real.Angle θ (Real.Angle.coe Real.pi)))
+Case conversion may be inaccurate. Consider using '#align real.angle.sign_eq_zero_iff Real.Angle.sign_eq_zero_iffₓ'. -/
 theorem sign_eq_zero_iff {θ : Angle} : θ.sign = 0 ↔ θ = 0 ∨ θ = π := by
   rw [SignType.sign, sign_eq_zero_iff, sin_eq_zero_iff]
 #align real.angle.sign_eq_zero_iff Real.Angle.sign_eq_zero_iff
 
+/- warning: real.angle.sign_ne_zero_iff -> Real.Angle.sign_ne_zero_iff is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, Iff (Ne.{1} SignType (Real.Angle.sign θ) (OfNat.ofNat.{0} SignType 0 (OfNat.mk.{0} SignType 0 (Zero.zero.{0} SignType SignType.hasZero)))) (And (Ne.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (Ne.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)))
+but is expected to have type
+  forall {θ : Real.Angle}, Iff (Ne.{1} SignType (Real.Angle.sign θ) (OfNat.ofNat.{0} SignType 0 (Zero.toOfNat0.{0} SignType SignType.instZeroSignType))) (And (Ne.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (Ne.{1} Real.Angle θ (Real.Angle.coe Real.pi)))
+Case conversion may be inaccurate. Consider using '#align real.angle.sign_ne_zero_iff Real.Angle.sign_ne_zero_iffₓ'. -/
 theorem sign_ne_zero_iff {θ : Angle} : θ.sign ≠ 0 ↔ θ ≠ 0 ∧ θ ≠ π := by
   rw [← not_or, ← sign_eq_zero_iff]
 #align real.angle.sign_ne_zero_iff Real.Angle.sign_ne_zero_iff
 
+/- warning: real.angle.to_real_neg_iff_sign_neg -> Real.Angle.toReal_neg_iff_sign_neg is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, Iff (LT.lt.{0} Real Real.hasLt (Real.Angle.toReal θ) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (Eq.{1} SignType (Real.Angle.sign θ) (Neg.neg.{0} SignType SignType.hasNeg (OfNat.ofNat.{0} SignType 1 (OfNat.mk.{0} SignType 1 (One.one.{0} SignType SignType.hasOne)))))
+but is expected to have type
+  forall {θ : Real.Angle}, Iff (LT.lt.{0} Real Real.instLTReal (Real.Angle.toReal θ) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (Eq.{1} SignType (Real.Angle.sign θ) (Neg.neg.{0} SignType SignType.instNegSignType (OfNat.ofNat.{0} SignType 1 (One.toOfNat1.{0} SignType SignType.instOneSignType))))
+Case conversion may be inaccurate. Consider using '#align real.angle.to_real_neg_iff_sign_neg Real.Angle.toReal_neg_iff_sign_negₓ'. -/
 theorem toReal_neg_iff_sign_neg {θ : Angle} : θ.toReal < 0 ↔ θ.sign = -1 :=
   by
   rw [SignType.sign, ← sin_to_real, sign_eq_neg_one_iff]
@@ -934,6 +1784,12 @@ theorem toReal_neg_iff_sign_neg {θ : Angle} : θ.toReal < 0 ↔ θ.sign = -1 :=
         False.elim (hn.not_le (sin_nonneg_of_nonneg_of_le_pi h.le (to_real_le_pi θ)))⟩
 #align real.angle.to_real_neg_iff_sign_neg Real.Angle.toReal_neg_iff_sign_neg
 
+/- warning: real.angle.to_real_nonneg_iff_sign_nonneg -> Real.Angle.toReal_nonneg_iff_sign_nonneg is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, Iff (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (Real.Angle.toReal θ)) (LE.le.{0} SignType SignType.hasLe (OfNat.ofNat.{0} SignType 0 (OfNat.mk.{0} SignType 0 (Zero.zero.{0} SignType SignType.hasZero))) (Real.Angle.sign θ))
+but is expected to have type
+  forall {θ : Real.Angle}, Iff (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (Real.Angle.toReal θ)) (LE.le.{0} SignType SignType.instLESignType (OfNat.ofNat.{0} SignType 0 (Zero.toOfNat0.{0} SignType SignType.instZeroSignType)) (Real.Angle.sign θ))
+Case conversion may be inaccurate. Consider using '#align real.angle.to_real_nonneg_iff_sign_nonneg Real.Angle.toReal_nonneg_iff_sign_nonnegₓ'. -/
 theorem toReal_nonneg_iff_sign_nonneg {θ : Angle} : 0 ≤ θ.toReal ↔ 0 ≤ θ.sign :=
   by
   rcases lt_trichotomy θ.to_real 0 with (h | h | h)
@@ -946,6 +1802,12 @@ theorem toReal_nonneg_iff_sign_nonneg {θ : Angle} : 0 ≤ θ.toReal ↔ 0 ≤ 
     exact sin_nonneg_of_nonneg_of_le_pi h.le (to_real_le_pi θ)
 #align real.angle.to_real_nonneg_iff_sign_nonneg Real.Angle.toReal_nonneg_iff_sign_nonneg
 
+/- warning: real.angle.sign_to_real -> Real.Angle.sign_toReal is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, (Ne.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) -> (Eq.{1} SignType (coeFn.{1, 1} (OrderHom.{0, 0} Real SignType Real.preorder (PartialOrder.toPreorder.{0} SignType (SemilatticeInf.toPartialOrder.{0} SignType (Lattice.toSemilatticeInf.{0} SignType (LinearOrder.toLattice.{0} SignType SignType.linearOrder))))) (fun (_x : OrderHom.{0, 0} Real SignType Real.preorder (PartialOrder.toPreorder.{0} SignType (SemilatticeInf.toPartialOrder.{0} SignType (Lattice.toSemilatticeInf.{0} SignType (LinearOrder.toLattice.{0} SignType SignType.linearOrder))))) => Real -> SignType) (OrderHom.hasCoeToFun.{0, 0} Real SignType Real.preorder (PartialOrder.toPreorder.{0} SignType (SemilatticeInf.toPartialOrder.{0} SignType (Lattice.toSemilatticeInf.{0} SignType (LinearOrder.toLattice.{0} SignType SignType.linearOrder))))) (SignType.sign.{0} Real Real.hasZero Real.preorder (fun (a : Real) (b : Real) => Real.decidableLT a b)) (Real.Angle.toReal θ)) (Real.Angle.sign θ))
+but is expected to have type
+  forall {θ : Real.Angle}, (Ne.{1} Real.Angle θ (Real.Angle.coe Real.pi)) -> (Eq.{1} SignType (OrderHom.toFun.{0, 0} Real SignType Real.instPreorderReal (PartialOrder.toPreorder.{0} SignType (SemilatticeInf.toPartialOrder.{0} SignType (Lattice.toSemilatticeInf.{0} SignType (DistribLattice.toLattice.{0} SignType (instDistribLattice.{0} SignType SignType.instLinearOrderSignType))))) (SignType.sign.{0} Real Real.instZeroReal Real.instPreorderReal (fun (a : Real) (b : Real) => Real.decidableLT a b)) (Real.Angle.toReal θ)) (Real.Angle.sign θ))
+Case conversion may be inaccurate. Consider using '#align real.angle.sign_to_real Real.Angle.sign_toRealₓ'. -/
 @[simp]
 theorem sign_toReal {θ : Angle} (h : θ ≠ π) : SignType.sign θ.toReal = θ.sign :=
   by
@@ -958,10 +1820,22 @@ theorem sign_toReal {θ : Angle} (h : θ ≠ π) : SignType.sign θ.toReal = θ.
         (sin_pos_of_pos_of_lt_pi ht ((to_real_le_pi θ).lt_of_ne (to_real_eq_pi_iff.not.2 h)))]
 #align real.angle.sign_to_real Real.Angle.sign_toReal
 
+/- warning: real.angle.coe_abs_to_real_of_sign_nonneg -> Real.Angle.coe_abs_toReal_of_sign_nonneg is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, (LE.le.{0} SignType SignType.hasLe (OfNat.ofNat.{0} SignType 0 (OfNat.mk.{0} SignType 0 (Zero.zero.{0} SignType SignType.hasZero))) (Real.Angle.sign θ)) -> (Eq.{1} Real.Angle ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.toReal θ))) θ)
+but is expected to have type
+  forall {θ : Real.Angle}, (LE.le.{0} SignType SignType.instLESignType (OfNat.ofNat.{0} SignType 0 (Zero.toOfNat0.{0} SignType SignType.instZeroSignType)) (Real.Angle.sign θ)) -> (Eq.{1} Real.Angle (Real.Angle.coe (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.toReal θ))) θ)
+Case conversion may be inaccurate. Consider using '#align real.angle.coe_abs_to_real_of_sign_nonneg Real.Angle.coe_abs_toReal_of_sign_nonnegₓ'. -/
 theorem coe_abs_toReal_of_sign_nonneg {θ : Angle} (h : 0 ≤ θ.sign) : ↑(|θ.toReal|) = θ := by
   rw [abs_eq_self.2 (to_real_nonneg_iff_sign_nonneg.2 h), coe_to_real]
 #align real.angle.coe_abs_to_real_of_sign_nonneg Real.Angle.coe_abs_toReal_of_sign_nonneg
 
+/- warning: real.angle.neg_coe_abs_to_real_of_sign_nonpos -> Real.Angle.neg_coe_abs_toReal_of_sign_nonpos is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, (LE.le.{0} SignType SignType.hasLe (Real.Angle.sign θ) (OfNat.ofNat.{0} SignType 0 (OfNat.mk.{0} SignType 0 (Zero.zero.{0} SignType SignType.hasZero)))) -> (Eq.{1} Real.Angle (Neg.neg.{0} Real.Angle (SubNegMonoid.toHasNeg.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.toReal θ)))) θ)
+but is expected to have type
+  forall {θ : Real.Angle}, (LE.le.{0} SignType SignType.instLESignType (Real.Angle.sign θ) (OfNat.ofNat.{0} SignType 0 (Zero.toOfNat0.{0} SignType SignType.instZeroSignType))) -> (Eq.{1} Real.Angle (Neg.neg.{0} Real.Angle (NegZeroClass.toNeg.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (Real.Angle.coe (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.toReal θ)))) θ)
+Case conversion may be inaccurate. Consider using '#align real.angle.neg_coe_abs_to_real_of_sign_nonpos Real.Angle.neg_coe_abs_toReal_of_sign_nonposₓ'. -/
 theorem neg_coe_abs_toReal_of_sign_nonpos {θ : Angle} (h : θ.sign ≤ 0) : -↑(|θ.toReal|) = θ :=
   by
   rw [SignType.nonpos_iff] at h
@@ -971,6 +1845,12 @@ theorem neg_coe_abs_toReal_of_sign_nonpos {θ : Angle} (h : θ.sign ≤ 0) : -
     rcases h with (rfl | rfl) <;> simp [abs_of_pos Real.pi_pos]
 #align real.angle.neg_coe_abs_to_real_of_sign_nonpos Real.Angle.neg_coe_abs_toReal_of_sign_nonpos
 
+/- warning: real.angle.eq_iff_sign_eq_and_abs_to_real_eq -> Real.Angle.eq_iff_sign_eq_and_abs_toReal_eq is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle} {ψ : Real.Angle}, Iff (Eq.{1} Real.Angle θ ψ) (And (Eq.{1} SignType (Real.Angle.sign θ) (Real.Angle.sign ψ)) (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.toReal θ)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.toReal ψ))))
+but is expected to have type
+  forall {θ : Real.Angle} {ψ : Real.Angle}, Iff (Eq.{1} Real.Angle θ ψ) (And (Eq.{1} SignType (Real.Angle.sign θ) (Real.Angle.sign ψ)) (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.toReal θ)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.toReal ψ))))
+Case conversion may be inaccurate. Consider using '#align real.angle.eq_iff_sign_eq_and_abs_to_real_eq Real.Angle.eq_iff_sign_eq_and_abs_toReal_eqₓ'. -/
 theorem eq_iff_sign_eq_and_abs_toReal_eq {θ ψ : Angle} :
     θ = ψ ↔ θ.sign = ψ.sign ∧ |θ.toReal| = |ψ.toReal| :=
   by
@@ -993,26 +1873,56 @@ theorem eq_iff_sign_eq_and_abs_toReal_eq {θ ψ : Angle} :
         rw [hr, hs]
 #align real.angle.eq_iff_sign_eq_and_abs_to_real_eq Real.Angle.eq_iff_sign_eq_and_abs_toReal_eq
 
+/- warning: real.angle.eq_iff_abs_to_real_eq_of_sign_eq -> Real.Angle.eq_iff_abs_toReal_eq_of_sign_eq is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} SignType (Real.Angle.sign θ) (Real.Angle.sign ψ)) -> (Iff (Eq.{1} Real.Angle θ ψ) (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.toReal θ)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.toReal ψ))))
+but is expected to have type
+  forall {θ : Real.Angle} {ψ : Real.Angle}, (Eq.{1} SignType (Real.Angle.sign θ) (Real.Angle.sign ψ)) -> (Iff (Eq.{1} Real.Angle θ ψ) (Eq.{1} Real (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.toReal θ)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.toReal ψ))))
+Case conversion may be inaccurate. Consider using '#align real.angle.eq_iff_abs_to_real_eq_of_sign_eq 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| := by simpa [h] using @eq_iff_sign_eq_and_abs_to_real_eq θ ψ
 #align real.angle.eq_iff_abs_to_real_eq_of_sign_eq Real.Angle.eq_iff_abs_toReal_eq_of_sign_eq
 
+/- warning: real.angle.sign_coe_pi_div_two -> Real.Angle.sign_coe_pi_div_two is a dubious translation:
+lean 3 declaration is
+  Eq.{1} SignType (Real.Angle.sign ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))) (OfNat.ofNat.{0} SignType 1 (OfNat.mk.{0} SignType 1 (One.one.{0} SignType SignType.hasOne)))
+but is expected to have type
+  Eq.{1} SignType (Real.Angle.sign (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))) (OfNat.ofNat.{0} SignType 1 (One.toOfNat1.{0} SignType SignType.instOneSignType))
+Case conversion may be inaccurate. Consider using '#align real.angle.sign_coe_pi_div_two Real.Angle.sign_coe_pi_div_twoₓ'. -/
 @[simp]
 theorem sign_coe_pi_div_two : (↑(π / 2) : Angle).sign = 1 := by
   rw [SignType.sign, sin_coe, sin_pi_div_two, sign_one]
 #align real.angle.sign_coe_pi_div_two Real.Angle.sign_coe_pi_div_two
 
+/- warning: real.angle.sign_coe_neg_pi_div_two -> Real.Angle.sign_coe_neg_pi_div_two is a dubious translation:
+lean 3 declaration is
+  Eq.{1} SignType (Real.Angle.sign ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (Neg.neg.{0} Real Real.hasNeg Real.pi) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))))) (Neg.neg.{0} SignType SignType.hasNeg (OfNat.ofNat.{0} SignType 1 (OfNat.mk.{0} SignType 1 (One.one.{0} SignType SignType.hasOne))))
+but is expected to have type
+  Eq.{1} SignType (Real.Angle.sign (Real.Angle.coe (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (Neg.neg.{0} Real Real.instNegReal Real.pi) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))))) (Neg.neg.{0} SignType SignType.instNegSignType (OfNat.ofNat.{0} SignType 1 (One.toOfNat1.{0} SignType SignType.instOneSignType)))
+Case conversion may be inaccurate. Consider using '#align real.angle.sign_coe_neg_pi_div_two Real.Angle.sign_coe_neg_pi_div_twoₓ'. -/
 @[simp]
 theorem sign_coe_neg_pi_div_two : (↑(-π / 2) : Angle).sign = -1 := by
   rw [SignType.sign, sin_coe, neg_div, Real.sin_neg, sin_pi_div_two, Left.sign_neg, sign_one]
 #align real.angle.sign_coe_neg_pi_div_two Real.Angle.sign_coe_neg_pi_div_two
 
+/- warning: real.angle.sign_coe_nonneg_of_nonneg_of_le_pi -> Real.Angle.sign_coe_nonneg_of_nonneg_of_le_pi is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real}, (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) θ) -> (LE.le.{0} Real Real.hasLe θ Real.pi) -> (LE.le.{0} SignType SignType.hasLe (OfNat.ofNat.{0} SignType 0 (OfNat.mk.{0} SignType 0 (Zero.zero.{0} SignType SignType.hasZero))) (Real.Angle.sign ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ)))
+but is expected to have type
+  forall {θ : Real}, (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) θ) -> (LE.le.{0} Real Real.instLEReal θ Real.pi) -> (LE.le.{0} SignType SignType.instLESignType (OfNat.ofNat.{0} SignType 0 (Zero.toOfNat0.{0} SignType SignType.instZeroSignType)) (Real.Angle.sign (Real.Angle.coe θ)))
+Case conversion may be inaccurate. Consider using '#align real.angle.sign_coe_nonneg_of_nonneg_of_le_pi 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 := by
   rw [SignType.sign, sign_nonneg_iff]
   exact sin_nonneg_of_nonneg_of_le_pi h0 hpi
 #align real.angle.sign_coe_nonneg_of_nonneg_of_le_pi Real.Angle.sign_coe_nonneg_of_nonneg_of_le_pi
 
+/- warning: real.angle.sign_neg_coe_nonpos_of_nonneg_of_le_pi -> Real.Angle.sign_neg_coe_nonpos_of_nonneg_of_le_pi is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real}, (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) θ) -> (LE.le.{0} Real Real.hasLe θ Real.pi) -> (LE.le.{0} SignType SignType.hasLe (Real.Angle.sign (Neg.neg.{0} Real.Angle (SubNegMonoid.toHasNeg.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) θ))) (OfNat.ofNat.{0} SignType 0 (OfNat.mk.{0} SignType 0 (Zero.zero.{0} SignType SignType.hasZero))))
+but is expected to have type
+  forall {θ : Real}, (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) θ) -> (LE.le.{0} Real Real.instLEReal θ Real.pi) -> (LE.le.{0} SignType SignType.instLESignType (Real.Angle.sign (Neg.neg.{0} Real.Angle (NegZeroClass.toNeg.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (Real.Angle.coe θ))) (OfNat.ofNat.{0} SignType 0 (Zero.toOfNat0.{0} SignType SignType.instZeroSignType)))
+Case conversion may be inaccurate. Consider using '#align real.angle.sign_neg_coe_nonpos_of_nonneg_of_le_pi 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 :=
   by
@@ -1020,6 +1930,12 @@ theorem sign_neg_coe_nonpos_of_nonneg_of_le_pi {θ : ℝ} (h0 : 0 ≤ θ) (hpi :
   exact sin_nonneg_of_nonneg_of_le_pi h0 hpi
 #align real.angle.sign_neg_coe_nonpos_of_nonneg_of_le_pi Real.Angle.sign_neg_coe_nonpos_of_nonneg_of_le_pi
 
+/- warning: real.angle.sign_two_nsmul_eq_sign_iff -> Real.Angle.sign_two_nsmul_eq_sign_iff is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, Iff (Eq.{1} SignType (Real.Angle.sign (SMul.smul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup))))) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne)))) θ)) (Real.Angle.sign θ)) (Or (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) (LT.lt.{0} Real Real.hasLt (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.toReal θ)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))))
+but is expected to have type
+  forall {θ : Real.Angle}, Iff (Eq.{1} SignType (Real.Angle.sign (HSMul.hSMul.{0, 0, 0} Nat Real.Angle Real.Angle (instHSMul.{0, 0} Nat Real.Angle (AddMonoid.SMul.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))))) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)) θ)) (Real.Angle.sign θ)) (Or (Eq.{1} Real.Angle θ (Real.Angle.coe Real.pi)) (LT.lt.{0} Real Real.instLTReal (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.toReal θ)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))))
+Case conversion may be inaccurate. Consider using '#align real.angle.sign_two_nsmul_eq_sign_iff Real.Angle.sign_two_nsmul_eq_sign_iffₓ'. -/
 theorem sign_two_nsmul_eq_sign_iff {θ : Angle} :
     ((2 : ℕ) • θ).sign = θ.sign ↔ θ = π ∨ |θ.toReal| < π / 2 :=
   by
@@ -1064,15 +1980,33 @@ theorem sign_two_nsmul_eq_sign_iff {θ : Angle} :
       sign_mul, sign_pos (zero_lt_two' ℝ), one_mul]
 #align real.angle.sign_two_nsmul_eq_sign_iff Real.Angle.sign_two_nsmul_eq_sign_iff
 
+/- warning: real.angle.sign_two_zsmul_eq_sign_iff -> Real.Angle.sign_two_zsmul_eq_sign_iff is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, Iff (Eq.{1} SignType (Real.Angle.sign (SMul.smul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) (OfNat.ofNat.{0} Int 2 (OfNat.mk.{0} Int 2 (bit0.{0} Int Int.hasAdd (One.one.{0} Int Int.hasOne)))) θ)) (Real.Angle.sign θ)) (Or (Eq.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) (LT.lt.{0} Real Real.hasLt (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (Real.Angle.toReal θ)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) Real.pi (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne)))))))
+but is expected to have type
+  forall {θ : Real.Angle}, Iff (Eq.{1} SignType (Real.Angle.sign (HSMul.hSMul.{0, 0, 0} Int Real.Angle Real.Angle (instHSMul.{0, 0} Int Real.Angle (SubNegMonoid.SMulInt.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))) (OfNat.ofNat.{0} Int 2 (instOfNatInt 2)) θ)) (Real.Angle.sign θ)) (Or (Eq.{1} Real.Angle θ (Real.Angle.coe Real.pi)) (LT.lt.{0} Real Real.instLTReal (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (Real.Angle.toReal θ)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) Real.pi (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))))
+Case conversion may be inaccurate. Consider using '#align real.angle.sign_two_zsmul_eq_sign_iff Real.Angle.sign_two_zsmul_eq_sign_iffₓ'. -/
 theorem sign_two_zsmul_eq_sign_iff {θ : Angle} :
     ((2 : ℤ) • θ).sign = θ.sign ↔ θ = π ∨ |θ.toReal| < π / 2 := by
   rw [two_zsmul, ← two_nsmul, sign_two_nsmul_eq_sign_iff]
 #align real.angle.sign_two_zsmul_eq_sign_iff Real.Angle.sign_two_zsmul_eq_sign_iff
 
+/- warning: real.angle.continuous_at_sign -> Real.Angle.continuousAt_sign is a dubious translation:
+lean 3 declaration is
+  forall {θ : Real.Angle}, (Ne.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) -> (Ne.{1} Real.Angle θ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)) -> (ContinuousAt.{0, 0} Real.Angle SignType (UniformSpace.toTopologicalSpace.{0} Real.Angle (PseudoMetricSpace.toUniformSpace.{0} Real.Angle (SeminormedAddCommGroup.toPseudoMetricSpace.{0} Real.Angle (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) SignType.topologicalSpace Real.Angle.sign θ)
+but is expected to have type
+  forall {θ : Real.Angle}, (Ne.{1} Real.Angle θ (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) -> (Ne.{1} Real.Angle θ (Real.Angle.coe Real.pi)) -> (ContinuousAt.{0, 0} Real.Angle SignType (UniformSpace.toTopologicalSpace.{0} Real.Angle (PseudoMetricSpace.toUniformSpace.{0} Real.Angle (SeminormedAddCommGroup.toPseudoMetricSpace.{0} Real.Angle (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))) instTopologicalSpaceSignType Real.Angle.sign θ)
+Case conversion may be inaccurate. Consider using '#align real.angle.continuous_at_sign Real.Angle.continuousAt_signₓ'. -/
 theorem continuousAt_sign {θ : Angle} (h0 : θ ≠ 0) (hpi : θ ≠ π) : ContinuousAt sign θ :=
   (continuousAt_sign_of_ne_zero (sin_ne_zero_iff.2 ⟨h0, hpi⟩)).comp continuous_sin.ContinuousAt
 #align real.angle.continuous_at_sign Real.Angle.continuousAt_sign
 
+/- warning: continuous_on.angle_sign_comp -> ContinuousOn.angle_sign_comp is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {f : α -> Real.Angle} {s : Set.{u1} α}, (ContinuousOn.{u1, 0} α Real.Angle _inst_1 (UniformSpace.toTopologicalSpace.{0} Real.Angle (PseudoMetricSpace.toUniformSpace.{0} Real.Angle (SeminormedAddCommGroup.toPseudoMetricSpace.{0} Real.Angle (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) f s) -> (forall (z : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) z s) -> (And (Ne.{1} Real.Angle (f z) (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (Ne.{1} Real.Angle (f z) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)))) -> (ContinuousOn.{u1, 0} α SignType _inst_1 SignType.topologicalSpace (Function.comp.{succ u1, 1, 1} α Real.Angle SignType Real.Angle.sign f) s)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {f : α -> Real.Angle} {s : Set.{u1} α}, (ContinuousOn.{u1, 0} α Real.Angle _inst_1 (UniformSpace.toTopologicalSpace.{0} Real.Angle (PseudoMetricSpace.toUniformSpace.{0} Real.Angle (SeminormedAddCommGroup.toPseudoMetricSpace.{0} Real.Angle (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))) f s) -> (forall (z : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) z s) -> (And (Ne.{1} Real.Angle (f z) (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (Ne.{1} Real.Angle (f z) (Real.Angle.coe Real.pi)))) -> (ContinuousOn.{u1, 0} α SignType _inst_1 instTopologicalSpaceSignType (Function.comp.{succ u1, 1, 1} α Real.Angle SignType Real.Angle.sign f) s)
+Case conversion may be inaccurate. Consider using '#align continuous_on.angle_sign_comp ContinuousOn.angle_sign_compₓ'. -/
 theorem 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 :=
   by
@@ -1081,6 +2015,12 @@ theorem ContinuousOn.angle_sign_comp {α : Type _} [TopologicalSpace α] {f : α
   exact continuous_at_sign (hs _ hz).1 (hs _ hz).2
 #align continuous_on.angle_sign_comp ContinuousOn.angle_sign_comp
 
+/- warning: real.angle.sign_eq_of_continuous_on -> Real.Angle.sign_eq_of_continuousOn is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {f : α -> Real.Angle} {s : Set.{u1} α} {x : α} {y : α}, (IsConnected.{u1} α _inst_1 s) -> (ContinuousOn.{u1, 0} α Real.Angle _inst_1 (UniformSpace.toTopologicalSpace.{0} Real.Angle (PseudoMetricSpace.toUniformSpace.{0} Real.Angle (SeminormedAddCommGroup.toPseudoMetricSpace.{0} Real.Angle (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))) f s) -> (forall (z : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) z s) -> (And (Ne.{1} Real.Angle (f z) (OfNat.ofNat.{0} Real.Angle 0 (OfNat.mk.{0} Real.Angle 0 (Zero.zero.{0} Real.Angle (AddZeroClass.toHasZero.{0} Real.Angle (AddMonoid.toAddZeroClass.{0} Real.Angle (SubNegMonoid.toAddMonoid.{0} Real.Angle (AddGroup.toSubNegMonoid.{0} Real.Angle (NormedAddGroup.toAddGroup.{0} Real.Angle (NormedAddCommGroup.toNormedAddGroup.{0} Real.Angle Real.Angle.normedAddCommGroup)))))))))) (Ne.{1} Real.Angle (f z) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Real Real.Angle (HasLiftT.mk.{1, 1} Real Real.Angle (CoeTCₓ.coe.{1, 1} Real Real.Angle Real.Angle.hasCoeT)) Real.pi)))) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) y s) -> (Eq.{1} SignType (Real.Angle.sign (f y)) (Real.Angle.sign (f x)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : TopologicalSpace.{u1} α] {f : α -> Real.Angle} {s : Set.{u1} α} {x : α} {y : α}, (IsConnected.{u1} α _inst_1 s) -> (ContinuousOn.{u1, 0} α Real.Angle _inst_1 (UniformSpace.toTopologicalSpace.{0} Real.Angle (PseudoMetricSpace.toUniformSpace.{0} Real.Angle (SeminormedAddCommGroup.toPseudoMetricSpace.{0} Real.Angle (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle)))) f s) -> (forall (z : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) z s) -> (And (Ne.{1} Real.Angle (f z) (OfNat.ofNat.{0} Real.Angle 0 (Zero.toOfNat0.{0} Real.Angle (NegZeroClass.toZero.{0} Real.Angle (SubNegZeroMonoid.toNegZeroClass.{0} Real.Angle (SubtractionMonoid.toSubNegZeroMonoid.{0} Real.Angle (SubtractionCommMonoid.toSubtractionMonoid.{0} Real.Angle (AddCommGroup.toDivisionAddCommMonoid.{0} Real.Angle (NormedAddCommGroup.toAddCommGroup.{0} Real.Angle Real.Angle.instNormedAddCommGroupAngle))))))))) (Ne.{1} Real.Angle (f z) (Real.Angle.coe Real.pi)))) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) y s) -> (Eq.{1} SignType (Real.Angle.sign (f y)) (Real.Angle.sign (f x)))
+Case conversion may be inaccurate. Consider using '#align real.angle.sign_eq_of_continuous_on Real.Angle.sign_eq_of_continuousOnₓ'. -/
 /-- 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 α}

mathlib commit https://github.com/leanprover-community/mathlib/commit/0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8

@@ -154,12 +154,12 @@ theorem coe_pi_add_coe_pi : (π : Real.Angle) + π = 0 := by rw [← two_nsmul,
 
 theorem zsmul_eq_iff {ψ θ : Angle} {z : ℤ} (hz : z ≠ 0) :
     z • ψ = z • θ ↔ ∃ k : Fin z.natAbs, ψ = θ + (k : ℕ) • (2 * π / z : ℝ) :=
-  quotientAddGroup.zmultiples_zsmul_eq_zsmul_iff hz
+  QuotientAddGroup.zmultiples_zsmul_eq_zsmul_iff hz
 #align real.angle.zsmul_eq_iff Real.Angle.zsmul_eq_iff
 
 theorem nsmul_eq_iff {ψ θ : Angle} {n : ℕ} (hz : n ≠ 0) :
     n • ψ = n • θ ↔ ∃ k : Fin n, ψ = θ + (k : ℕ) • (2 * π / n : ℝ) :=
-  quotientAddGroup.zmultiples_nsmul_eq_nsmul_iff hz
+  QuotientAddGroup.zmultiples_nsmul_eq_nsmul_iff hz
 #align real.angle.nsmul_eq_iff Real.Angle.nsmul_eq_iff
 
 theorem two_zsmul_eq_iff {ψ θ : Angle} : (2 : ℤ) • ψ = (2 : ℤ) • θ ↔ ψ = θ ∨ ψ = θ + π := by

mathlib commit https://github.com/leanprover-community/mathlib/commit/2f8347015b12b0864dfaf366ec4909eb70c78740

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Calle Sönne
 
 ! This file was ported from Lean 3 source module analysis.special_functions.trigonometric.angle
-! leanprover-community/mathlib commit 2c1d8ca2812b64f88992a5294ea3dba144755cd1
+! leanprover-community/mathlib commit 213b0cff7bc5ab6696ee07cceec80829ce42efec
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -36,6 +36,9 @@ def Angle : Type :=
 
 namespace Angle
 
+instance : CircularOrder Real.Angle :=
+  @AddCircle.circularOrder _ _ _ _ _ ⟨by norm_num [pi_pos] ⟩ _
+
 @[continuity]
 theorem continuous_coe : Continuous (coe : ℝ → Angle) :=
   continuous_quotient_mk'

mathlib commit https://github.com/leanprover-community/mathlib/commit/28b2a92f2996d28e580450863c130955de0ed398

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Calle Sönne
 
 ! This file was ported from Lean 3 source module analysis.special_functions.trigonometric.angle
-! leanprover-community/mathlib commit 213b0cff7bc5ab6696ee07cceec80829ce42efec
+! leanprover-community/mathlib commit 2c1d8ca2812b64f88992a5294ea3dba144755cd1
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -36,9 +36,6 @@ def Angle : Type :=
 
 namespace Angle
 
-instance : CircularOrder Real.Angle :=
-  @AddCircle.circularOrder _ _ _ _ _ ⟨by norm_num [pi_pos] ⟩ _
-
 @[continuity]
 theorem continuous_coe : Continuous (coe : ℝ → Angle) :=
   continuous_quotient_mk'

mathlib commit https://github.com/leanprover-community/mathlib/commit/2f8347015b12b0864dfaf366ec4909eb70c78740

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Calle Sönne
 
 ! This file was ported from Lean 3 source module analysis.special_functions.trigonometric.angle
-! leanprover-community/mathlib commit 2c1d8ca2812b64f88992a5294ea3dba144755cd1
+! leanprover-community/mathlib commit 213b0cff7bc5ab6696ee07cceec80829ce42efec
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -36,6 +36,9 @@ def Angle : Type :=
 
 namespace Angle
 
+instance : CircularOrder Real.Angle :=
+  @AddCircle.circularOrder _ _ _ _ _ ⟨by norm_num [pi_pos] ⟩ _
+
 @[continuity]
 theorem continuous_coe : Continuous (coe : ℝ → Angle) :=
   continuous_quotient_mk'

mathlib commit https://github.com/leanprover-community/mathlib/commit/36b8aa61ea7c05727161f96a0532897bd72aedab

@@ -4,14 +4,13 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Calle Sönne
 
 ! This file was ported from Lean 3 source module analysis.special_functions.trigonometric.angle
-! leanprover-community/mathlib commit 2196ab363eb097c008d4497125e0dde23fb36db2
+! leanprover-community/mathlib commit 2c1d8ca2812b64f88992a5294ea3dba144755cd1
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
 import Mathbin.Analysis.SpecialFunctions.Trigonometric.Basic
 import Mathbin.Analysis.Normed.Group.AddCircle
 import Mathbin.Algebra.CharZero.Quotient
-import Mathbin.Algebra.Order.ToIntervalMod
 import Mathbin.Topology.Instances.Sign
 
 /-!
@@ -501,27 +500,27 @@ theorem abs_cos_eq_of_two_zsmul_eq {θ ψ : Angle} (h : (2 : ℤ) • θ = (2 :
 #align real.angle.abs_cos_eq_of_two_zsmul_eq Real.Angle.abs_cos_eq_of_two_zsmul_eq
 
 @[simp]
-theorem coe_toIcoMod (θ ψ : ℝ) : ↑(toIcoMod ψ two_pi_pos θ) = (θ : Angle) :=
+theorem coe_toIcoMod (θ ψ : ℝ) : ↑(toIcoMod two_pi_pos ψ θ) = (θ : Angle) :=
   by
   rw [angle_eq_iff_two_pi_dvd_sub]
-  refine' ⟨-toIcoDiv ψ two_pi_pos θ, _⟩
+  refine' ⟨-toIcoDiv two_pi_pos ψ θ, _⟩
   rw [toIcoMod_sub_self, zsmul_eq_mul, mul_comm]
 #align real.angle.coe_to_Ico_mod Real.Angle.coe_toIcoMod
 
 @[simp]
-theorem coe_toIocMod (θ ψ : ℝ) : ↑(toIocMod ψ two_pi_pos θ) = (θ : Angle) :=
+theorem coe_toIocMod (θ ψ : ℝ) : ↑(toIocMod two_pi_pos ψ θ) = (θ : Angle) :=
   by
   rw [angle_eq_iff_two_pi_dvd_sub]
-  refine' ⟨-toIocDiv ψ two_pi_pos θ, _⟩
+  refine' ⟨-toIocDiv two_pi_pos ψ θ, _⟩
   rw [toIocMod_sub_self, zsmul_eq_mul, mul_comm]
 #align real.angle.coe_to_Ioc_mod Real.Angle.coe_toIocMod
 
 /-- Convert a `real.angle` to a real number in the interval `Ioc (-π) π`. -/
 def toReal (θ : Angle) : ℝ :=
-  (toIocMod_periodic (-π) two_pi_pos).lift θ
+  (toIocMod_periodic two_pi_pos (-π)).lift θ
 #align real.angle.to_real Real.Angle.toReal
 
-theorem toReal_coe (θ : ℝ) : (θ : Angle).toReal = toIocMod (-π) two_pi_pos θ :=
+theorem toReal_coe (θ : ℝ) : (θ : Angle).toReal = toIocMod two_pi_pos (-π) θ :=
   rfl
 #align real.angle.to_real_coe Real.Angle.toReal_coe
 
@@ -559,13 +558,13 @@ theorem coe_toReal (θ : Angle) : (θ.toReal : Angle) = θ :=
 theorem neg_pi_lt_toReal (θ : Angle) : -π < θ.toReal :=
   by
   induction θ using Real.Angle.induction_on
-  exact left_lt_toIocMod _ two_pi_pos _
+  exact left_lt_toIocMod _ _ _
 #align real.angle.neg_pi_lt_to_real Real.Angle.neg_pi_lt_toReal
 
 theorem toReal_le_pi (θ : Angle) : θ.toReal ≤ π :=
   by
   induction θ using Real.Angle.induction_on
-  convert toIocMod_le_right _ two_pi_pos _
+  convert toIocMod_le_right two_pi_pos _ _
   ring
 #align real.angle.to_real_le_pi Real.Angle.toReal_le_pi
 
@@ -578,7 +577,7 @@ theorem toReal_mem_Ioc (θ : Angle) : θ.toReal ∈ Set.Ioc (-π) π :=
 #align real.angle.to_real_mem_Ioc Real.Angle.toReal_mem_Ioc
 
 @[simp]
-theorem toIocMod_toReal (θ : Angle) : toIocMod (-π) two_pi_pos θ.toReal = θ.toReal :=
+theorem toIocMod_toReal (θ : Angle) : toIocMod two_pi_pos (-π) θ.toReal = θ.toReal :=
   by
   induction θ using Real.Angle.induction_on
   rw [to_real_coe]

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce7e9d53d4bbc38065db3b595cd5bd73c323bc1d

@@ -699,12 +699,12 @@ theorem toReal_coe_eq_self_sub_two_mul_int_mul_pi_iff {θ : ℝ} {k : ℤ} :
 
 theorem toReal_coe_eq_self_sub_two_pi_iff {θ : ℝ} :
     (θ : Angle).toReal = θ - 2 * π ↔ θ ∈ Set.Ioc π (3 * π) := by
-  convert @to_real_coe_eq_self_sub_two_mul_int_mul_pi_iff θ 1 <;> norm_num
+  convert@to_real_coe_eq_self_sub_two_mul_int_mul_pi_iff θ 1 <;> norm_num
 #align real.angle.to_real_coe_eq_self_sub_two_pi_iff Real.Angle.toReal_coe_eq_self_sub_two_pi_iff
 
 theorem toReal_coe_eq_self_add_two_pi_iff {θ : ℝ} :
     (θ : Angle).toReal = θ + 2 * π ↔ θ ∈ Set.Ioc (-3 * π) (-π) := by
-  convert @to_real_coe_eq_self_sub_two_mul_int_mul_pi_iff θ (-1) <;> norm_num
+  convert@to_real_coe_eq_self_sub_two_mul_int_mul_pi_iff θ (-1) <;> norm_num
 #align real.angle.to_real_coe_eq_self_add_two_pi_iff Real.Angle.toReal_coe_eq_self_add_two_pi_iff
 
 theorem two_nsmul_toReal_eq_two_mul_sub_two_pi {θ : Angle} :

mathlib commit https://github.com/leanprover-community/mathlib/commit/2196ab363eb097c008d4497125e0dde23fb36db2

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Calle Sönne
 
 ! This file was ported from Lean 3 source module analysis.special_functions.trigonometric.angle
-! leanprover-community/mathlib commit a0ed43b3a5734e36d5af48cbe3332732988bfdbc
+! leanprover-community/mathlib commit 2196ab363eb097c008d4497125e0dde23fb36db2
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -980,8 +980,8 @@ theorem eq_iff_sign_eq_and_abs_toReal_eq {θ ψ : Angle} :
   rcases hr with (hr | hr)
   · exact to_real_injective hr
   · by_cases h : θ = π
-    · rw [h, to_real_pi, eq_neg_iff_eq_neg] at hr
-      exact False.elim ((neg_pi_lt_to_real ψ).Ne hr.symm)
+    · rw [h, to_real_pi, ← neg_eq_iff_eq_neg] at hr
+      exact False.elim ((neg_pi_lt_to_real ψ).Ne hr)
     · by_cases h' : ψ = π
       · rw [h', to_real_pi] at hr
         exact False.elim ((neg_pi_lt_to_real θ).Ne hr.symm)

mathlib commit https://github.com/leanprover-community/mathlib/commit/3180fab693e2cee3bff62675571264cb8778b212

@@ -234,9 +234,10 @@ theorem cos_eq_iff_coe_eq_or_eq_neg {θ ψ : ℝ} :
   · rw [angle_eq_iff_two_pi_dvd_sub, ← coe_neg, angle_eq_iff_two_pi_dvd_sub]
     rintro (⟨k, H⟩ | ⟨k, H⟩)
     rw [← sub_eq_zero, cos_sub_cos, H, mul_assoc 2 π k, mul_div_cancel_left _ (two_ne_zero' ℝ),
-      mul_comm π _, sin_int_mul_pi, mul_zero]
+      mul_comm π _, sin_int_mul_pi, MulZeroClass.mul_zero]
     rw [← sub_eq_zero, cos_sub_cos, ← sub_neg_eq_add, H, mul_assoc 2 π k,
-      mul_div_cancel_left _ (two_ne_zero' ℝ), mul_comm π _, sin_int_mul_pi, mul_zero, zero_mul]
+      mul_div_cancel_left _ (two_ne_zero' ℝ), mul_comm π _, sin_int_mul_pi, MulZeroClass.mul_zero,
+      MulZeroClass.zero_mul]
 #align real.angle.cos_eq_iff_coe_eq_or_eq_neg Real.Angle.cos_eq_iff_coe_eq_or_eq_neg
 
 theorem sin_eq_iff_coe_eq_or_add_eq_pi {θ ψ : ℝ} :
@@ -256,13 +257,13 @@ theorem sin_eq_iff_coe_eq_or_add_eq_pi {θ ψ : ℝ} :
   · rw [angle_eq_iff_two_pi_dvd_sub, ← eq_sub_iff_add_eq, ← coe_sub, angle_eq_iff_two_pi_dvd_sub]
     rintro (⟨k, H⟩ | ⟨k, H⟩)
     rw [← sub_eq_zero, sin_sub_sin, H, mul_assoc 2 π k, mul_div_cancel_left _ (two_ne_zero' ℝ),
-      mul_comm π _, sin_int_mul_pi, mul_zero, zero_mul]
+      mul_comm π _, sin_int_mul_pi, MulZeroClass.mul_zero, MulZeroClass.zero_mul]
     have H' : θ + ψ = 2 * k * π + π := by
       rwa [← sub_add, sub_add_eq_add_sub, sub_eq_iff_eq_add, mul_assoc, mul_comm π _, ←
         mul_assoc] at H
     rw [← sub_eq_zero, sin_sub_sin, H', add_div, mul_assoc 2 _ π,
       mul_div_cancel_left _ (two_ne_zero' ℝ), cos_add_pi_div_two, sin_int_mul_pi, neg_zero,
-      mul_zero]
+      MulZeroClass.mul_zero]
 #align real.angle.sin_eq_iff_coe_eq_or_add_eq_pi Real.Angle.sin_eq_iff_coe_eq_or_add_eq_pi
 
 theorem cos_sin_inj {θ ψ : ℝ} (Hcos : cos θ = cos ψ) (Hsin : sin θ = sin ψ) : (θ : Angle) = ψ :=

mathlib commit https://github.com/leanprover-community/mathlib/commit/bd9851ca476957ea4549eb19b40e7b5ade9428cc

A PR accompanying #12339.

Zulip discussion

@@ -254,8 +254,8 @@ theorem cos_eq_iff_coe_eq_or_eq_neg {θ ψ : ℝ} :
         zero_add]
   · rw [angle_eq_iff_two_pi_dvd_sub, ← coe_neg, angle_eq_iff_two_pi_dvd_sub]
     rintro (⟨k, H⟩ | ⟨k, H⟩)
-    rw [← sub_eq_zero, cos_sub_cos, H, mul_assoc 2 π k, mul_div_cancel_left₀ _ (two_ne_zero' ℝ),
-      mul_comm π _, sin_int_mul_pi, mul_zero]
+    · rw [← sub_eq_zero, cos_sub_cos, H, mul_assoc 2 π k, mul_div_cancel_left₀ _ (two_ne_zero' ℝ),
+        mul_comm π _, sin_int_mul_pi, mul_zero]
     rw [← sub_eq_zero, cos_sub_cos, ← sub_neg_eq_add, H, mul_assoc 2 π k,
       mul_div_cancel_left₀ _ (two_ne_zero' ℝ), mul_comm π _, sin_int_mul_pi, mul_zero,
       zero_mul]
@@ -276,8 +276,8 @@ theorem sin_eq_iff_coe_eq_or_add_eq_pi {θ ψ : ℝ} :
     exact h.symm
   · rw [angle_eq_iff_two_pi_dvd_sub, ← eq_sub_iff_add_eq, ← coe_sub, angle_eq_iff_two_pi_dvd_sub]
     rintro (⟨k, H⟩ | ⟨k, H⟩)
-    rw [← sub_eq_zero, sin_sub_sin, H, mul_assoc 2 π k, mul_div_cancel_left₀ _ (two_ne_zero' ℝ),
-      mul_comm π _, sin_int_mul_pi, mul_zero, zero_mul]
+    · rw [← sub_eq_zero, sin_sub_sin, H, mul_assoc 2 π k, mul_div_cancel_left₀ _ (two_ne_zero' ℝ),
+        mul_comm π _, sin_int_mul_pi, mul_zero, zero_mul]
     have H' : θ + ψ = 2 * k * π + π := by
       rwa [← sub_add, sub_add_eq_add_sub, sub_eq_iff_eq_add, mul_assoc, mul_comm π _, ←
         mul_assoc] at H

This renames

• Int.cast_ofNat to Int.cast_natCast
• Int.int_cast_ofNat to Int.cast_ofNat

I think the history here is that this lemma was previously about Int.ofNat, before we globally fixed the simp-normal form to be Nat.cast.

Since the Int.cast_ofNat name is repurposed, it can't be deprecated. Int.int_cast_ofNat is such a wonky name that it was probably never used.

@@ -293,7 +293,7 @@ theorem cos_sin_inj {θ ψ : ℝ} (Hcos : cos θ = cos ψ) (Hsin : sin θ = sin
   obtain ⟨n, hn⟩ : ∃ n, n • _ = _ := QuotientAddGroup.leftRel_apply.mp (Quotient.exact' hc)
   rw [← neg_one_mul, add_zero, ← sub_eq_zero, zsmul_eq_mul, ← mul_assoc, ← sub_mul, mul_eq_zero,
     eq_false (ne_of_gt pi_pos), or_false_iff, sub_neg_eq_add, ← Int.cast_zero, ← Int.cast_one,
-    ← Int.int_cast_ofNat, ← Int.cast_mul, ← Int.cast_add, Int.cast_inj] at hn
+    ← Int.cast_ofNat, ← Int.cast_mul, ← Int.cast_add, Int.cast_inj] at hn
   have : (n * 2 + 1) % (2 : ℤ) = 0 % (2 : ℤ) := congr_arg (· % (2 : ℤ)) hn
   rw [add_comm, Int.add_mul_emod_self] at this
   exact absurd this one_ne_zero

@@ -750,7 +750,7 @@ theorem cos_pos_iff_abs_toReal_lt_pi_div_two {θ : Angle} : 0 < cos θ ↔ |θ.t
   rw [lt_iff_le_and_ne, lt_iff_le_and_ne, cos_nonneg_iff_abs_toReal_le_pi_div_two, ←
     and_congr_right]
   rintro -
-  rw [Ne.def, Ne.def, not_iff_not, @eq_comm ℝ 0, abs_toReal_eq_pi_div_two_iff, cos_eq_zero_iff]
+  rw [Ne, Ne, not_iff_not, @eq_comm ℝ 0, abs_toReal_eq_pi_div_two_iff, cos_eq_zero_iff]
 #align real.angle.cos_pos_iff_abs_to_real_lt_pi_div_two Real.Angle.cos_pos_iff_abs_toReal_lt_pi_div_two
 
 theorem cos_neg_iff_pi_div_two_lt_abs_toReal {θ : Angle} : cos θ < 0 ↔ π / 2 < |θ.toReal| := by
@@ -1016,7 +1016,7 @@ theorem sign_two_nsmul_eq_sign_iff {θ : Angle} :
       · simp at h
       · linarith [neg_pi_lt_toReal θ]
   · have hpi' : (2 : ℕ) • θ ≠ π := by
-      rw [Ne.def, two_nsmul_eq_pi_iff, not_or]
+      rw [Ne, two_nsmul_eq_pi_iff, not_or]
       constructor
       · rintro rfl
         simp [pi_pos, div_pos, abs_of_pos] at h

Lemma names around cancellation of multiplication and division are a mess.

This PR renames a handful of them according to the following table (each big row contains the multiplicative statement, then the three rows contain the GroupWithZero lemma name, the Group lemma, the AddGroup lemma name).

| Statement | New name | Old name | |

@@ -185,7 +185,7 @@ theorem two_zsmul_eq_iff {ψ θ : Angle} : (2 : ℤ) • ψ = (2 : ℤ) • θ 
   have : Int.natAbs 2 = 2 := rfl
   rw [zsmul_eq_iff two_ne_zero, this, Fin.exists_fin_two, Fin.val_zero,
     Fin.val_one, zero_smul, add_zero, one_smul, Int.cast_two,
-    mul_div_cancel_left (_ : ℝ) two_ne_zero]
+    mul_div_cancel_left₀ (_ : ℝ) two_ne_zero]
 #align real.angle.two_zsmul_eq_iff Real.Angle.two_zsmul_eq_iff
 
 theorem two_nsmul_eq_iff {ψ θ : Angle} : (2 : ℕ) • ψ = (2 : ℕ) • θ ↔ ψ = θ ∨ ψ = θ + ↑π := by
@@ -254,10 +254,10 @@ theorem cos_eq_iff_coe_eq_or_eq_neg {θ ψ : ℝ} :
         zero_add]
   · rw [angle_eq_iff_two_pi_dvd_sub, ← coe_neg, angle_eq_iff_two_pi_dvd_sub]
     rintro (⟨k, H⟩ | ⟨k, H⟩)
-    rw [← sub_eq_zero, cos_sub_cos, H, mul_assoc 2 π k, mul_div_cancel_left _ (two_ne_zero' ℝ),
+    rw [← sub_eq_zero, cos_sub_cos, H, mul_assoc 2 π k, mul_div_cancel_left₀ _ (two_ne_zero' ℝ),
       mul_comm π _, sin_int_mul_pi, mul_zero]
     rw [← sub_eq_zero, cos_sub_cos, ← sub_neg_eq_add, H, mul_assoc 2 π k,
-      mul_div_cancel_left _ (two_ne_zero' ℝ), mul_comm π _, sin_int_mul_pi, mul_zero,
+      mul_div_cancel_left₀ _ (two_ne_zero' ℝ), mul_comm π _, sin_int_mul_pi, mul_zero,
       zero_mul]
 #align real.angle.cos_eq_iff_coe_eq_or_eq_neg Real.Angle.cos_eq_iff_coe_eq_or_eq_neg
 
@@ -276,13 +276,13 @@ theorem sin_eq_iff_coe_eq_or_add_eq_pi {θ ψ : ℝ} :
     exact h.symm
   · rw [angle_eq_iff_two_pi_dvd_sub, ← eq_sub_iff_add_eq, ← coe_sub, angle_eq_iff_two_pi_dvd_sub]
     rintro (⟨k, H⟩ | ⟨k, H⟩)
-    rw [← sub_eq_zero, sin_sub_sin, H, mul_assoc 2 π k, mul_div_cancel_left _ (two_ne_zero' ℝ),
+    rw [← sub_eq_zero, sin_sub_sin, H, mul_assoc 2 π k, mul_div_cancel_left₀ _ (two_ne_zero' ℝ),
       mul_comm π _, sin_int_mul_pi, mul_zero, zero_mul]
     have H' : θ + ψ = 2 * k * π + π := by
       rwa [← sub_add, sub_add_eq_add_sub, sub_eq_iff_eq_add, mul_assoc, mul_comm π _, ←
         mul_assoc] at H
     rw [← sub_eq_zero, sin_sub_sin, H', add_div, mul_assoc 2 _ π,
-      mul_div_cancel_left _ (two_ne_zero' ℝ), cos_add_pi_div_two, sin_int_mul_pi, neg_zero,
+      mul_div_cancel_left₀ _ (two_ne_zero' ℝ), cos_add_pi_div_two, sin_int_mul_pi, neg_zero,
       mul_zero]
 #align real.angle.sin_eq_iff_coe_eq_or_add_eq_pi Real.Angle.sin_eq_iff_coe_eq_or_add_eq_pi
 

... and add a deprecated alias for the old name. This is mostly just me discovering the power of F2

@@ -189,7 +189,7 @@ theorem two_zsmul_eq_iff {ψ θ : Angle} : (2 : ℤ) • ψ = (2 : ℤ) • θ 
 #align real.angle.two_zsmul_eq_iff Real.Angle.two_zsmul_eq_iff
 
 theorem two_nsmul_eq_iff {ψ θ : Angle} : (2 : ℕ) • ψ = (2 : ℕ) • θ ↔ ψ = θ ∨ ψ = θ + ↑π := by
-  simp_rw [← coe_nat_zsmul, Nat.cast_ofNat, two_zsmul_eq_iff]
+  simp_rw [← natCast_zsmul, Nat.cast_ofNat, two_zsmul_eq_iff]
 #align real.angle.two_nsmul_eq_iff Real.Angle.two_nsmul_eq_iff
 
 theorem two_nsmul_eq_zero_iff {θ : Angle} : (2 : ℕ) • θ = 0 ↔ θ = 0 ∨ θ = π := by

Classifies by adding issue number #10618 to porting notes claiming

@[simp] can prove

@@ -144,12 +144,12 @@ theorem two_zsmul_coe_div_two (θ : ℝ) : (2 : ℤ) • (↑(θ / 2) : Angle) =
   rw [← coe_zsmul, two_zsmul, add_halves]
 #align real.angle.two_zsmul_coe_div_two Real.Angle.two_zsmul_coe_div_two
 
--- Porting note: @[simp] can prove it
+-- Porting note (#10618): @[simp] can prove it
 theorem two_nsmul_neg_pi_div_two : (2 : ℕ) • (↑(-π / 2) : Angle) = π := by
   rw [two_nsmul_coe_div_two, coe_neg, neg_coe_pi]
 #align real.angle.two_nsmul_neg_pi_div_two Real.Angle.two_nsmul_neg_pi_div_two
 
--- Porting note: @[simp] can prove it
+-- Porting note (#10618): @[simp] can prove it
 theorem two_zsmul_neg_pi_div_two : (2 : ℤ) • (↑(-π / 2) : Angle) = π := by
   rw [two_zsmul, ← two_nsmul, two_nsmul_neg_pi_div_two]
 #align real.angle.two_zsmul_neg_pi_div_two Real.Angle.two_zsmul_neg_pi_div_two
@@ -355,7 +355,7 @@ theorem sin_eq_iff_eq_or_add_eq_pi {θ ψ : Angle} : sin θ = sin ψ ↔ θ = ψ
 theorem sin_zero : sin (0 : Angle) = 0 := by rw [← coe_zero, sin_coe, Real.sin_zero]
 #align real.angle.sin_zero Real.Angle.sin_zero
 
--- Porting note: @[simp] can prove it
+-- Porting note (#10618): @[simp] can prove it
 theorem sin_coe_pi : sin (π : Angle) = 0 := by rw [sin_coe, Real.sin_pi]
 #align real.angle.sin_coe_pi Real.Angle.sin_coe_pi
 
@@ -395,7 +395,7 @@ theorem sin_sub_pi (θ : Angle) : sin (θ - π) = -sin θ :=
 theorem cos_zero : cos (0 : Angle) = 1 := by rw [← coe_zero, cos_coe, Real.cos_zero]
 #align real.angle.cos_zero Real.Angle.cos_zero
 
--- Porting note: @[simp] can prove it
+-- Porting note (#10618): @[simp] can prove it
 theorem cos_coe_pi : cos (π : Angle) = -1 := by rw [cos_coe, Real.cos_pi]
 #align real.angle.cos_coe_pi Real.Angle.cos_coe_pi
 
@@ -787,7 +787,7 @@ theorem tan_coe (x : ℝ) : tan (x : Angle) = Real.tan x := by
 theorem tan_zero : tan (0 : Angle) = 0 := by rw [← coe_zero, tan_coe, Real.tan_zero]
 #align real.angle.tan_zero Real.Angle.tan_zero
 
--- Porting note: @[simp] can now prove it
+-- Porting note (#10618): @[simp] can now prove it
 theorem tan_coe_pi : tan (π : Angle) = 0 := by rw [tan_coe, Real.tan_pi]
 #align real.angle.tan_coe_pi Real.Angle.tan_coe_pi
 

This is a very large PR, but it has been reviewed piecemeal already in PRs to the bump/v4.7.0 branch as we update to intermediate nightlies.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Kyle Miller <kmill31415@gmail.com> Co-authored-by: damiano <adomani@gmail.com>

@@ -689,7 +689,8 @@ theorem toReal_coe_eq_self_sub_two_pi_iff {θ : ℝ} :
 
 theorem toReal_coe_eq_self_add_two_pi_iff {θ : ℝ} :
     (θ : Angle).toReal = θ + 2 * π ↔ θ ∈ Set.Ioc (-3 * π) (-π) := by
-  convert @toReal_coe_eq_self_sub_two_mul_int_mul_pi_iff θ (-1) using 2 <;> norm_num
+  convert @toReal_coe_eq_self_sub_two_mul_int_mul_pi_iff θ (-1) using 2 <;>
+    set_option tactic.skipAssignedInstances false in norm_num
 #align real.angle.to_real_coe_eq_self_add_two_pi_iff Real.Angle.toReal_coe_eq_self_add_two_pi_iff
 
 theorem two_nsmul_toReal_eq_two_mul_sub_two_pi {θ : Angle} :

Classifies by adding issue number (#10754) to porting notes claiming added instance.

@@ -32,15 +32,15 @@ def Angle : Type :=
 
 namespace Angle
 
--- Porting note: added due to missing instances due to no deriving
+-- Porting note (#10754): added due to missing instances due to no deriving
 instance : NormedAddCommGroup Angle :=
   inferInstanceAs (NormedAddCommGroup (AddCircle (2 * π)))
 
--- Porting note: added due to missing instances due to no deriving
+-- Porting note (#10754): added due to missing instances due to no deriving
 instance : Inhabited Angle :=
   inferInstanceAs (Inhabited (AddCircle (2 * π)))
 
--- Porting note: added due to missing instances due to no deriving
+-- Porting note (#10754): added due to missing instances due to no deriving
 -- also, without this, a plain `QuotientAddGroup.mk`
 -- causes coerced terms to be of type `ℝ ⧸ AddSubgroup.zmultiples (2 * π)`
 /-- The canonical map from `ℝ` to the quotient `Angle`. -/

Co-authored-by: Moritz Firsching <firsching@google.com>

@@ -229,7 +229,7 @@ theorem two_nsmul_eq_pi_iff {θ : Angle} : (2 : ℕ) • θ = π ↔ θ = (π /
   rw [coe_nsmul, two_nsmul_eq_iff]
   -- Porting note: `congr` didn't simplify the goal of iff of `Or`s
   convert Iff.rfl
-  rw [add_comm, ← coe_add, ← sub_eq_zero, ← coe_sub, neg_div, ←neg_sub, sub_neg_eq_add, add_assoc,
+  rw [add_comm, ← coe_add, ← sub_eq_zero, ← coe_sub, neg_div, ← neg_sub, sub_neg_eq_add, add_assoc,
     add_halves, ← two_mul, coe_neg, coe_two_pi, neg_zero]
 #align real.angle.two_nsmul_eq_pi_iff Real.Angle.two_nsmul_eq_pi_iff
 

We still have the exact_mod_cast tactic, used in a few places, which somehow (?) works a little bit harder to prevent the expected type influencing the elaboration of the term. I would like to get to the bottom of this, and it will be easier once the only usages of exact_mod_cast are the ones that don't work using the term elaborator by itself.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -660,14 +660,14 @@ theorem abs_toReal_eq_pi_div_two_iff {θ : Angle} :
 theorem nsmul_toReal_eq_mul {n : ℕ} (h : n ≠ 0) {θ : Angle} :
     (n • θ).toReal = n * θ.toReal ↔ θ.toReal ∈ Set.Ioc (-π / n) (π / n) := by
   nth_rw 1 [← coe_toReal θ]
-  have h' : 0 < (n : ℝ) := by exact_mod_cast Nat.pos_of_ne_zero h
+  have h' : 0 < (n : ℝ) := mod_cast Nat.pos_of_ne_zero h
   rw [← coe_nsmul, nsmul_eq_mul, toReal_coe_eq_self_iff, Set.mem_Ioc, div_lt_iff' h',
     le_div_iff' h']
 #align real.angle.nsmul_to_real_eq_mul Real.Angle.nsmul_toReal_eq_mul
 
 theorem two_nsmul_toReal_eq_two_mul {θ : Angle} :
-    ((2 : ℕ) • θ).toReal = 2 * θ.toReal ↔ θ.toReal ∈ Set.Ioc (-π / 2) (π / 2) := by
-  exact_mod_cast nsmul_toReal_eq_mul two_ne_zero
+    ((2 : ℕ) • θ).toReal = 2 * θ.toReal ↔ θ.toReal ∈ Set.Ioc (-π / 2) (π / 2) :=
+  mod_cast nsmul_toReal_eq_mul two_ne_zero
 #align real.angle.two_nsmul_to_real_eq_two_mul Real.Angle.two_nsmul_toReal_eq_two_mul
 
 theorem two_zsmul_toReal_eq_two_mul {θ : Angle} :

PR contents

This is the supremum of

• #8284
• #8056
• #8023
• #8332
• #8226 (already approved)
• #7834 (already approved)

along with some minor fixes from failures on nightly-testing as Mathlib master is merged into it.

Note that some PRs for changes that are already compatible with the current toolchain and will be necessary have already been split out: #8380.

I am hopeful that in future we will be able to progressively merge adaptation PRs into a bump/v4.X.0 branch, so we never end up with a "big merge" like this. However one of these adaptation PRs (#8056) predates my new scheme for combined CI, and it wasn't possible to keep that PR viable in the meantime.

Lean PRs involved in this bump

In particular this includes adjustments for the Lean PRs

• leanprover/lean4#2778
• leanprover/lean4#2790
• leanprover/lean4#2783
• leanprover/lean4#2825
• leanprover/lean4#2722

leanprover/lean4#2778

We can get rid of all the

local macro_rules | `($x ^ $y) => `(HPow.hPow $x $y) -- Porting note: See issue [lean4#2220](https://github.com/leanprover/lean4/pull/2220)

macros across Mathlib (and in any projects that want to write natural number powers of reals).

leanprover/lean4#2722

Changes the default behaviour of simp to (config := {decide := false}). This makes simp (and consequentially norm_num) less powerful, but also more consistent, and less likely to blow up in long failures. This requires a variety of changes: changing some previously by simp or norm_num to decide or rfl, or adding (config := {decide := true}).

leanprover/lean4#2783

This changed the behaviour of simp so that simp [f] will only unfold "fully applied" occurrences of f. The old behaviour can be recovered with simp (config := { unfoldPartialApp := true }). We may in future add a syntax for this, e.g. simp [!f]; please provide feedback! In the meantime, we have made the following changes:

• switching to using explicit lemmas that have the intended level of application
• (config := { unfoldPartialApp := true }) in some places, to recover the old behaviour
• Using @[eqns] to manually adjust the equation lemmas for a particular definition, recovering the old behaviour just for that definition. See #8371, where we do this for Function.comp and Function.flip.

This change in Lean may require further changes down the line (e.g. adding the !f syntax, and/or upstreaming the special treatment for Function.comp and Function.flip, and/or removing this special treatment). Please keep an open and skeptical mind about these changes!

Co-authored-by: leanprover-community-mathlib4-bot <leanprover-community-mathlib4-bot@users.noreply.github.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Mauricio Collares <mauricio@collares.org>

@@ -184,7 +184,7 @@ theorem two_zsmul_eq_iff {ψ θ : Angle} : (2 : ℤ) • ψ = (2 : ℤ) • θ 
   -- Porting note: no `Int.natAbs_bit0` anymore
   have : Int.natAbs 2 = 2 := rfl
   rw [zsmul_eq_iff two_ne_zero, this, Fin.exists_fin_two, Fin.val_zero,
-    Fin.val_one, zero_smul, coe_zero, add_zero, one_smul, Int.cast_two,
+    Fin.val_one, zero_smul, add_zero, one_smul, Int.cast_two,
     mul_div_cancel_left (_ : ℝ) two_ne_zero]
 #align real.angle.two_zsmul_eq_iff Real.Angle.two_zsmul_eq_iff
 
@@ -224,7 +224,7 @@ theorem neg_ne_self_iff {θ : Angle} : -θ ≠ θ ↔ θ ≠ 0 ∧ θ ≠ π :=
 #align real.angle.neg_ne_self_iff Real.Angle.neg_ne_self_iff
 
 theorem two_nsmul_eq_pi_iff {θ : Angle} : (2 : ℕ) • θ = π ↔ θ = (π / 2 : ℝ) ∨ θ = (-π / 2 : ℝ) := by
-  have h : (π : Angle) = (2 : ℕ) • (π / 2 : ℝ) := by rw [two_nsmul, add_halves]
+  have h : (π : Angle) = ((2 : ℕ) • (π / 2 : ℝ) :) := by rw [two_nsmul, add_halves]
   nth_rw 1 [h]
   rw [coe_nsmul, two_nsmul_eq_iff]
   -- Porting note: `congr` didn't simplify the goal of iff of `Or`s

This is a refactor of AddCircle, changing it from a def to an abbrev. This fixes issues arising from a deriving statement that failed during the port, and allows for much better inference of instances.

Co-authored-by: Heather Macbeth <25316162+hrmacbeth@users.noreply.github.com>

@@ -50,7 +50,8 @@ protected def coe (r : ℝ) : Angle := QuotientAddGroup.mk r
 instance : Coe ℝ Angle := ⟨Angle.coe⟩
 
 instance : CircularOrder Real.Angle :=
-  @AddCircle.instCircularOrderAddCircle _ _ _ _ _ ⟨by norm_num [pi_pos]⟩ _
+  QuotientAddGroup.circularOrder (hp' := ⟨by norm_num [pi_pos]⟩)
+
 
 @[continuity]
 theorem continuous_coe : Continuous ((↑) : ℝ → Angle) :=

norm_num was passing the wrong syntax node to elabSimpArgs when elaborating, which essentially had the effect of ignoring all arguments it was passed, i.e. norm_num [add_comm] would not try to commute addition in the simp step. The fix itself is very simple (though not obvious to debug!), probably using TSyntax more would help avoid such issues in future.

Due to this bug many norm_num [blah] became rw [blah]; norm_num or similar, sometimes with porting notes, sometimes not, we fix these porting notes and other regressions during the port also.

Interestingly cancel_denoms uses norm_num [<- mul_assoc] internally, so cancel_denoms also got stronger with this change.

@@ -50,8 +50,7 @@ protected def coe (r : ℝ) : Angle := QuotientAddGroup.mk r
 instance : Coe ℝ Angle := ⟨Angle.coe⟩
 
 instance : CircularOrder Real.Angle :=
-  -- Porting note: `norm_num` didn't use `pi_pos` when supplied
-  @AddCircle.instCircularOrderAddCircle _ _ _ _ _ ⟨by norm_num; exact pi_pos⟩ _
+  @AddCircle.instCircularOrderAddCircle _ _ _ _ _ ⟨by norm_num [pi_pos]⟩ _
 
 @[continuity]
 theorem continuous_coe : Continuous ((↑) : ℝ → Angle) :=

Search&replace MulZeroClass.mul_zero -> mul_zero, MulZeroClass.zero_mul -> zero_mul.

These were introduced by Mathport, as the full name of mul_zero is actually MulZeroClass.mul_zero (it's exported with the short name).

@@ -255,10 +255,10 @@ theorem cos_eq_iff_coe_eq_or_eq_neg {θ ψ : ℝ} :
   · rw [angle_eq_iff_two_pi_dvd_sub, ← coe_neg, angle_eq_iff_two_pi_dvd_sub]
     rintro (⟨k, H⟩ | ⟨k, H⟩)
     rw [← sub_eq_zero, cos_sub_cos, H, mul_assoc 2 π k, mul_div_cancel_left _ (two_ne_zero' ℝ),
-      mul_comm π _, sin_int_mul_pi, MulZeroClass.mul_zero]
+      mul_comm π _, sin_int_mul_pi, mul_zero]
     rw [← sub_eq_zero, cos_sub_cos, ← sub_neg_eq_add, H, mul_assoc 2 π k,
-      mul_div_cancel_left _ (two_ne_zero' ℝ), mul_comm π _, sin_int_mul_pi, MulZeroClass.mul_zero,
-      MulZeroClass.zero_mul]
+      mul_div_cancel_left _ (two_ne_zero' ℝ), mul_comm π _, sin_int_mul_pi, mul_zero,
+      zero_mul]
 #align real.angle.cos_eq_iff_coe_eq_or_eq_neg Real.Angle.cos_eq_iff_coe_eq_or_eq_neg
 
 theorem sin_eq_iff_coe_eq_or_add_eq_pi {θ ψ : ℝ} :
@@ -277,13 +277,13 @@ theorem sin_eq_iff_coe_eq_or_add_eq_pi {θ ψ : ℝ} :
   · rw [angle_eq_iff_two_pi_dvd_sub, ← eq_sub_iff_add_eq, ← coe_sub, angle_eq_iff_two_pi_dvd_sub]
     rintro (⟨k, H⟩ | ⟨k, H⟩)
     rw [← sub_eq_zero, sin_sub_sin, H, mul_assoc 2 π k, mul_div_cancel_left _ (two_ne_zero' ℝ),
-      mul_comm π _, sin_int_mul_pi, MulZeroClass.mul_zero, MulZeroClass.zero_mul]
+      mul_comm π _, sin_int_mul_pi, mul_zero, zero_mul]
     have H' : θ + ψ = 2 * k * π + π := by
       rwa [← sub_add, sub_add_eq_add_sub, sub_eq_iff_eq_add, mul_assoc, mul_comm π _, ←
         mul_assoc] at H
     rw [← sub_eq_zero, sin_sub_sin, H', add_div, mul_assoc 2 _ π,
       mul_div_cancel_left _ (two_ne_zero' ℝ), cos_add_pi_div_two, sin_int_mul_pi, neg_zero,
-      MulZeroClass.mul_zero]
+      mul_zero]
 #align real.angle.sin_eq_iff_coe_eq_or_add_eq_pi Real.Angle.sin_eq_iff_coe_eq_or_add_eq_pi
 
 theorem cos_sin_inj {θ ψ : ℝ} (Hcos : cos θ = cos ψ) (Hsin : sin θ = sin ψ) : (θ : Angle) = ψ := by

@@ -58,7 +58,7 @@ theorem continuous_coe : Continuous ((↑) : ℝ → Angle) :=
   continuous_quotient_mk'
 #align real.angle.continuous_coe Real.Angle.continuous_coe
 
-/-- Coercion `ℝ → angle` as an additive homomorphism. -/
+/-- Coercion `ℝ → Angle` as an additive homomorphism. -/
 def coeHom : ℝ →+ Angle :=
   QuotientAddGroup.mk' _
 #align real.angle.coe_hom Real.Angle.coeHom

We remove all possible occurences of Type _ and Sort _ in favor of Type* and Sort*.

This has nice performance benefits.

@@ -1036,7 +1036,7 @@ theorem continuousAt_sign {θ : Angle} (h0 : θ ≠ 0) (hpi : θ ≠ π) : Conti
   (continuousAt_sign_of_ne_zero (sin_ne_zero_iff.2 ⟨h0, hpi⟩)).comp continuous_sin.continuousAt
 #align real.angle.continuous_at_sign Real.Angle.continuousAt_sign
 
-theorem _root_.ContinuousOn.angle_sign_comp {α : Type _} [TopologicalSpace α] {f : α → Angle}
+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 := by
   refine' (ContinuousAt.continuousOn fun θ hθ => _).comp hf (Set.mapsTo_image f s)
@@ -1046,7 +1046,7 @@ theorem _root_.ContinuousOn.angle_sign_comp {α : Type _} [TopologicalSpace α]
 
 /-- 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 α}
+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 :=
   (hc.image _ (hf.angle_sign_comp hs)).isPreconnected.subsingleton (Set.mem_image_of_mem _ hy)

• depends on: #5966

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -2,17 +2,14 @@
 Copyright (c) 2019 Calle Sönne. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Calle Sönne
-
-! This file was ported from Lean 3 source module analysis.special_functions.trigonometric.angle
-! leanprover-community/mathlib commit 213b0cff7bc5ab6696ee07cceec80829ce42efec
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic
 import Mathlib.Analysis.Normed.Group.AddCircle
 import Mathlib.Algebra.CharZero.Quotient
 import Mathlib.Topology.Instances.Sign
 
+#align_import analysis.special_functions.trigonometric.angle from "leanprover-community/mathlib"@"213b0cff7bc5ab6696ee07cceec80829ce42efec"
+
 /-!
 # The type of angles
 

Grepping for [^ .:{-] [^ :] and reviewing the results. Once I started I couldn't stop. :-)

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -296,7 +296,7 @@ theorem cos_sin_inj {θ ψ : ℝ} (Hcos : cos θ = cos ψ) (Hsin : sin θ = sin
   obtain ⟨n, hn⟩ : ∃ n, n • _ = _ := QuotientAddGroup.leftRel_apply.mp (Quotient.exact' hc)
   rw [← neg_one_mul, add_zero, ← sub_eq_zero, zsmul_eq_mul, ← mul_assoc, ← sub_mul, mul_eq_zero,
     eq_false (ne_of_gt pi_pos), or_false_iff, sub_neg_eq_add, ← Int.cast_zero, ← Int.cast_one,
-    ← Int.int_cast_ofNat,  ← Int.cast_mul, ← Int.cast_add, Int.cast_inj] at hn
+    ← Int.int_cast_ofNat, ← Int.cast_mul, ← Int.cast_add, Int.cast_inj] at hn
   have : (n * 2 + 1) % (2 : ℤ) = 0 % (2 : ℤ) := congr_arg (· % (2 : ℤ)) hn
   rw [add_comm, Int.add_mul_emod_self] at this
   exact absurd this one_ne_zero

@@ -929,11 +929,11 @@ theorem sign_toReal {θ : Angle} (h : θ ≠ π) : SignType.sign θ.toReal = θ.
         (sin_pos_of_pos_of_lt_pi ht ((toReal_le_pi θ).lt_of_ne (toReal_eq_pi_iff.not.2 h)))]
 #align real.angle.sign_to_real Real.Angle.sign_toReal
 
-theorem coe_abs_toReal_of_sign_nonneg {θ : Angle} (h : 0 ≤ θ.sign) : ↑(|θ.toReal|) = θ := by
+theorem coe_abs_toReal_of_sign_nonneg {θ : Angle} (h : 0 ≤ θ.sign) : ↑|θ.toReal| = θ := by
   rw [abs_eq_self.2 (toReal_nonneg_iff_sign_nonneg.2 h), coe_toReal]
 #align real.angle.coe_abs_to_real_of_sign_nonneg Real.Angle.coe_abs_toReal_of_sign_nonneg
 
-theorem neg_coe_abs_toReal_of_sign_nonpos {θ : Angle} (h : θ.sign ≤ 0) : -↑(|θ.toReal|) = θ := by
+theorem neg_coe_abs_toReal_of_sign_nonpos {θ : Angle} (h : θ.sign ≤ 0) : -↑|θ.toReal| = θ := by
   rw [SignType.nonpos_iff] at h
   rcases h with (h | h)
   · rw [abs_of_neg (toReal_neg_iff_sign_neg.2 h), coe_neg, neg_neg, coe_toReal]

I wrote a script to find lines that contain an odd number of backticks

@@ -119,7 +119,7 @@ theorem coe_int_mul_eq_zsmul (x : ℝ) (n : ℤ) : ↑((n : ℝ) * x : ℝ) = n
 theorem angle_eq_iff_two_pi_dvd_sub {ψ θ : ℝ} : (θ : Angle) = ψ ↔ ∃ k : ℤ, θ - ψ = 2 * π * k := by
   simp only [QuotientAddGroup.eq, AddSubgroup.zmultiples_eq_closure,
     AddSubgroup.mem_closure_singleton, zsmul_eq_mul', (sub_eq_neg_add _ _).symm, eq_comm]
-  -- Porting note: added `rw`, `simp [Angle.coe, QuotientAddGroup.eq] doesn't fire otherwise
+  -- Porting note: added `rw`, `simp [Angle.coe, QuotientAddGroup.eq]` doesn't fire otherwise
   rw [Angle.coe, Angle.coe, QuotientAddGroup.eq]
   simp only [AddSubgroup.zmultiples_eq_closure,
     AddSubgroup.mem_closure_singleton, zsmul_eq_mul', (sub_eq_neg_add _ _).symm, eq_comm]

• Run a non-interactive version of fix-comments.py on all files.
• Go through the diff and manually add/discard/edit chunks.

@@ -771,7 +771,7 @@ theorem abs_cos_eq_abs_sin_of_two_zsmul_add_two_zsmul_eq_pi {θ ψ : Angle}
   exact abs_cos_eq_abs_sin_of_two_nsmul_add_two_nsmul_eq_pi h
 #align real.angle.abs_cos_eq_abs_sin_of_two_zsmul_add_two_zsmul_eq_pi Real.Angle.abs_cos_eq_abs_sin_of_two_zsmul_add_two_zsmul_eq_pi
 
-/-- The tangent of a `real.angle`. -/
+/-- The tangent of a `Real.Angle`. -/
 def tan (θ : Angle) : ℝ :=
   sin θ / cos θ
 #align real.angle.tan Real.Angle.tan
@@ -846,7 +846,7 @@ theorem tan_eq_inv_of_two_zsmul_add_two_zsmul_eq_pi {θ ψ : Angle}
   exact tan_eq_inv_of_two_nsmul_add_two_nsmul_eq_pi h
 #align real.angle.tan_eq_inv_of_two_zsmul_add_two_zsmul_eq_pi Real.Angle.tan_eq_inv_of_two_zsmul_add_two_zsmul_eq_pi
 
-/-- The sign of a `real.angle` is `0` if the angle is `0` or `π`, `1` if the angle is strictly
+/-- 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 :=

Co-authored-by: ChrisHughes24 <chrishughes24@gmail.com>