analysis.normed_space.ray ⟷ Mathlib.Analysis.NormedSpace.Ray

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

@@ -46,9 +46,9 @@ theorem norm_sub (h : SameRay ℝ x y) : ‖x - y‖ = |‖x‖ - ‖y‖| :=
   by
   rcases h.exists_eq_smul with ⟨u, a, b, ha, hb, -, rfl, rfl⟩
   wlog hab : b ≤ a
-  · rw [SameRay.sameRay_comm] at h ; rw [norm_sub_rev, abs_sub_comm]
+  · rw [SameRay.sameRay_comm] at h; rw [norm_sub_rev, abs_sub_comm]
     exact this u b a hb ha h (le_of_not_le hab)
-  rw [← sub_nonneg] at hab 
+  rw [← sub_nonneg] at hab
   rw [← sub_smul, norm_smul_of_nonneg hab, norm_smul_of_nonneg ha, norm_smul_of_nonneg hb, ←
     sub_mul, abs_of_nonneg (mul_nonneg hab (norm_nonneg _))]
 #align same_ray.norm_sub SameRay.norm_sub
@@ -74,7 +74,7 @@ theorem norm_injOn_ray_left (hx : x ≠ 0) : {y | SameRay ℝ x y}.InjOn norm :=
   rcases hy.exists_nonneg_left hx with ⟨r, hr, rfl⟩
   rcases hz.exists_nonneg_left hx with ⟨s, hs, rfl⟩
   rw [norm_smul, norm_smul, mul_left_inj' (norm_ne_zero_iff.2 hx), norm_of_nonneg hr,
-    norm_of_nonneg hs] at h 
+    norm_of_nonneg hs] at h
   rw [h]
 #align norm_inj_on_ray_left norm_injOn_ray_left
 -/
@@ -123,7 +123,7 @@ theorem sameRay_iff_inv_norm_smul_eq : SameRay ℝ x y ↔ x = 0 ∨ y = 0 ∨ 
 theorem sameRay_iff_of_norm_eq (h : ‖x‖ = ‖y‖) : SameRay ℝ x y ↔ x = y :=
   by
   obtain rfl | hy := eq_or_ne y 0
-  · rw [norm_zero, norm_eq_zero] at h 
+  · rw [norm_zero, norm_eq_zero] at h
     exact iff_of_true (SameRay.zero_right _) h
   · exact ⟨fun hxy => norm_injOn_ray_right hy hxy SameRay.rfl h, fun hxy => hxy ▸ SameRay.rfl⟩
 #align same_ray_iff_of_norm_eq sameRay_iff_of_norm_eq

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

@@ -88,8 +88,9 @@ theorem norm_injOn_ray_right (hy : y ≠ 0) : {x | SameRay ℝ x y}.InjOn norm :
 #print sameRay_iff_norm_smul_eq /-
 theorem sameRay_iff_norm_smul_eq : SameRay ℝ x y ↔ ‖x‖ • y = ‖y‖ • x :=
   ⟨SameRay.norm_smul_eq, fun h =>
-    or_iff_not_imp_left.2 fun hx =>
-      or_iff_not_imp_left.2 fun hy => ⟨‖y‖, ‖x‖, norm_pos_iff.2 hy, norm_pos_iff.2 hx, h.symm⟩⟩
+    Classical.or_iff_not_imp_left.2 fun hx =>
+      Classical.or_iff_not_imp_left.2 fun hy =>
+        ⟨‖y‖, ‖x‖, norm_pos_iff.2 hy, norm_pos_iff.2 hx, h.symm⟩⟩
 #align same_ray_iff_norm_smul_eq sameRay_iff_norm_smul_eq
 -/
 

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

@@ -3,8 +3,8 @@ Copyright (c) 2022 Yury Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov, Yaël Dillies
 -/
-import Mathbin.LinearAlgebra.Ray
-import Mathbin.Analysis.NormedSpace.Basic
+import LinearAlgebra.Ray
+import Analysis.NormedSpace.Basic
 
 #align_import analysis.normed_space.ray from "leanprover-community/mathlib"@"9a48a083b390d9b84a71efbdc4e8dfa26a687104"
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/32a7e535287f9c73f2e4d2aef306a39190f0b504

@@ -103,7 +103,7 @@ theorem sameRay_iff_inv_norm_smul_eq_of_ne (hx : x ≠ 0) (hy : y ≠ 0) :
 #align same_ray_iff_inv_norm_smul_eq_of_ne sameRay_iff_inv_norm_smul_eq_of_ne
 -/
 
-alias sameRay_iff_inv_norm_smul_eq_of_ne ↔ SameRay.inv_norm_smul_eq _
+alias ⟨SameRay.inv_norm_smul_eq, _⟩ := sameRay_iff_inv_norm_smul_eq_of_ne
 #align same_ray.inv_norm_smul_eq SameRay.inv_norm_smul_eq
 
 #print sameRay_iff_inv_norm_smul_eq /-

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

@@ -2,15 +2,12 @@
 Copyright (c) 2022 Yury Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov, Yaël Dillies
-
-! This file was ported from Lean 3 source module analysis.normed_space.ray
-! leanprover-community/mathlib commit 9a48a083b390d9b84a71efbdc4e8dfa26a687104
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.LinearAlgebra.Ray
 import Mathbin.Analysis.NormedSpace.Basic
 
+#align_import analysis.normed_space.ray from "leanprover-community/mathlib"@"9a48a083b390d9b84a71efbdc4e8dfa26a687104"
+
 /-!
 # Rays in a real normed vector space
 

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

@@ -32,6 +32,7 @@ namespace SameRay
 
 variable {x y : E}
 
+#print SameRay.norm_add /-
 /-- If `x` and `y` are on the same ray, then the triangle inequality becomes the equality: the norm
 of `x + y` is the sum of the norms of `x` and `y`. The converse is true for a strictly convex
 space. -/
@@ -41,7 +42,9 @@ theorem norm_add (h : SameRay ℝ x y) : ‖x + y‖ = ‖x‖ + ‖y‖ :=
   rw [← add_smul, norm_smul_of_nonneg (add_nonneg ha hb), norm_smul_of_nonneg ha,
     norm_smul_of_nonneg hb, add_mul]
 #align same_ray.norm_add SameRay.norm_add
+-/
 
+#print SameRay.norm_sub /-
 theorem norm_sub (h : SameRay ℝ x y) : ‖x - y‖ = |‖x‖ - ‖y‖| :=
   by
   rcases h.exists_eq_smul with ⟨u, a, b, ha, hb, -, rfl, rfl⟩
@@ -52,6 +55,7 @@ theorem norm_sub (h : SameRay ℝ x y) : ‖x - y‖ = |‖x‖ - ‖y‖| :=
   rw [← sub_smul, norm_smul_of_nonneg hab, norm_smul_of_nonneg ha, norm_smul_of_nonneg hb, ←
     sub_mul, abs_of_nonneg (mul_nonneg hab (norm_nonneg _))]
 #align same_ray.norm_sub SameRay.norm_sub
+-/
 
 #print SameRay.norm_smul_eq /-
 theorem norm_smul_eq (h : SameRay ℝ x y) : ‖x‖ • y = ‖y‖ • x :=
@@ -66,6 +70,7 @@ end SameRay
 
 variable {x y : F}
 
+#print norm_injOn_ray_left /-
 theorem norm_injOn_ray_left (hx : x ≠ 0) : {y | SameRay ℝ x y}.InjOn norm :=
   by
   rintro y hy z hz h
@@ -75,10 +80,13 @@ theorem norm_injOn_ray_left (hx : x ≠ 0) : {y | SameRay ℝ x y}.InjOn norm :=
     norm_of_nonneg hs] at h 
   rw [h]
 #align norm_inj_on_ray_left norm_injOn_ray_left
+-/
 
+#print norm_injOn_ray_right /-
 theorem norm_injOn_ray_right (hy : y ≠ 0) : {x | SameRay ℝ x y}.InjOn norm := by
   simpa only [SameRay.sameRay_comm] using norm_injOn_ray_left hy
 #align norm_inj_on_ray_right norm_injOn_ray_right
+-/
 
 #print sameRay_iff_norm_smul_eq /-
 theorem sameRay_iff_norm_smul_eq : SameRay ℝ x y ↔ ‖x‖ • y = ‖y‖ • x :=
@@ -88,6 +96,7 @@ theorem sameRay_iff_norm_smul_eq : SameRay ℝ x y ↔ ‖x‖ • y = ‖y‖ 
 #align same_ray_iff_norm_smul_eq sameRay_iff_norm_smul_eq
 -/
 
+#print sameRay_iff_inv_norm_smul_eq_of_ne /-
 /-- Two nonzero vectors `x y` in a real normed space are on the same ray if and only if the unit
 vectors `‖x‖⁻¹ • x` and `‖y‖⁻¹ • y` are equal. -/
 theorem sameRay_iff_inv_norm_smul_eq_of_ne (hx : x ≠ 0) (hy : y ≠ 0) :
@@ -95,10 +104,12 @@ theorem sameRay_iff_inv_norm_smul_eq_of_ne (hx : x ≠ 0) (hy : y ≠ 0) :
   rw [inv_smul_eq_iff₀, smul_comm, eq_comm, inv_smul_eq_iff₀, sameRay_iff_norm_smul_eq] <;>
     rwa [norm_ne_zero_iff]
 #align same_ray_iff_inv_norm_smul_eq_of_ne sameRay_iff_inv_norm_smul_eq_of_ne
+-/
 
 alias sameRay_iff_inv_norm_smul_eq_of_ne ↔ SameRay.inv_norm_smul_eq _
 #align same_ray.inv_norm_smul_eq SameRay.inv_norm_smul_eq
 
+#print sameRay_iff_inv_norm_smul_eq /-
 /-- Two vectors `x y` in a real normed space are on the ray if and only if one of them is zero or
 the unit vectors `‖x‖⁻¹ • x` and `‖y‖⁻¹ • y` are equal. -/
 theorem sameRay_iff_inv_norm_smul_eq : SameRay ℝ x y ↔ x = 0 ∨ y = 0 ∨ ‖x‖⁻¹ • x = ‖y‖⁻¹ • y :=
@@ -107,6 +118,7 @@ theorem sameRay_iff_inv_norm_smul_eq : SameRay ℝ x y ↔ x = 0 ∨ y = 0 ∨ 
   rcases eq_or_ne y 0 with (rfl | hy); · simp [SameRay.zero_right]
   simp only [sameRay_iff_inv_norm_smul_eq_of_ne hx hy, *, false_or_iff]
 #align same_ray_iff_inv_norm_smul_eq sameRay_iff_inv_norm_smul_eq
+-/
 
 #print sameRay_iff_of_norm_eq /-
 /-- Two vectors of the same norm are on the same ray if and only if they are equal. -/

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

@@ -66,7 +66,7 @@ end SameRay
 
 variable {x y : F}
 
-theorem norm_injOn_ray_left (hx : x ≠ 0) : { y | SameRay ℝ x y }.InjOn norm :=
+theorem norm_injOn_ray_left (hx : x ≠ 0) : {y | SameRay ℝ x y}.InjOn norm :=
   by
   rintro y hy z hz h
   rcases hy.exists_nonneg_left hx with ⟨r, hr, rfl⟩
@@ -76,7 +76,7 @@ theorem norm_injOn_ray_left (hx : x ≠ 0) : { y | SameRay ℝ x y }.InjOn norm
   rw [h]
 #align norm_inj_on_ray_left norm_injOn_ray_left
 
-theorem norm_injOn_ray_right (hy : y ≠ 0) : { x | SameRay ℝ x y }.InjOn norm := by
+theorem norm_injOn_ray_right (hy : y ≠ 0) : {x | SameRay ℝ x y}.InjOn norm := by
   simpa only [SameRay.sameRay_comm] using norm_injOn_ray_left hy
 #align norm_inj_on_ray_right norm_injOn_ray_right
 

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

@@ -46,9 +46,9 @@ theorem norm_sub (h : SameRay ℝ x y) : ‖x - y‖ = |‖x‖ - ‖y‖| :=
   by
   rcases h.exists_eq_smul with ⟨u, a, b, ha, hb, -, rfl, rfl⟩
   wlog hab : b ≤ a
-  · rw [SameRay.sameRay_comm] at h; rw [norm_sub_rev, abs_sub_comm]
+  · rw [SameRay.sameRay_comm] at h ; rw [norm_sub_rev, abs_sub_comm]
     exact this u b a hb ha h (le_of_not_le hab)
-  rw [← sub_nonneg] at hab
+  rw [← sub_nonneg] at hab 
   rw [← sub_smul, norm_smul_of_nonneg hab, norm_smul_of_nonneg ha, norm_smul_of_nonneg hb, ←
     sub_mul, abs_of_nonneg (mul_nonneg hab (norm_nonneg _))]
 #align same_ray.norm_sub SameRay.norm_sub
@@ -72,7 +72,7 @@ theorem norm_injOn_ray_left (hx : x ≠ 0) : { y | SameRay ℝ x y }.InjOn norm
   rcases hy.exists_nonneg_left hx with ⟨r, hr, rfl⟩
   rcases hz.exists_nonneg_left hx with ⟨s, hs, rfl⟩
   rw [norm_smul, norm_smul, mul_left_inj' (norm_ne_zero_iff.2 hx), norm_of_nonneg hr,
-    norm_of_nonneg hs] at h
+    norm_of_nonneg hs] at h 
   rw [h]
 #align norm_inj_on_ray_left norm_injOn_ray_left
 
@@ -113,7 +113,7 @@ theorem sameRay_iff_inv_norm_smul_eq : SameRay ℝ x y ↔ x = 0 ∨ y = 0 ∨ 
 theorem sameRay_iff_of_norm_eq (h : ‖x‖ = ‖y‖) : SameRay ℝ x y ↔ x = y :=
   by
   obtain rfl | hy := eq_or_ne y 0
-  · rw [norm_zero, norm_eq_zero] at h
+  · rw [norm_zero, norm_eq_zero] at h 
     exact iff_of_true (SameRay.zero_right _) h
   · exact ⟨fun hxy => norm_injOn_ray_right hy hxy SameRay.rfl h, fun hxy => hxy ▸ SameRay.rfl⟩
 #align same_ray_iff_of_norm_eq sameRay_iff_of_norm_eq

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

@@ -32,12 +32,6 @@ namespace SameRay
 
 variable {x y : E}
 
-/- warning: same_ray.norm_add -> SameRay.norm_add is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {x : E} {y : E}, (SameRay.{0, u1} Real Real.strictOrderedCommSemiring E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2) x y) -> (Eq.{1} Real (Norm.norm.{u1} E (SeminormedAddCommGroup.toHasNorm.{u1} E _inst_1) (HAdd.hAdd.{u1, u1, u1} E E E (instHAdd.{u1} E (AddZeroClass.toHasAdd.{u1} E (AddMonoid.toAddZeroClass.{u1} E (SubNegMonoid.toAddMonoid.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u1} E _inst_1))))))) x y)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Norm.norm.{u1} E (SeminormedAddCommGroup.toHasNorm.{u1} E _inst_1) x) (Norm.norm.{u1} E (SeminormedAddCommGroup.toHasNorm.{u1} E _inst_1) y)))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {x : E} {y : E}, (SameRay.{0, u1} Real Real.strictOrderedCommSemiring E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2) x y) -> (Eq.{1} Real (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) (HAdd.hAdd.{u1, u1, u1} E E E (instHAdd.{u1} E (AddZeroClass.toAdd.{u1} E (AddMonoid.toAddZeroClass.{u1} E (SubNegMonoid.toAddMonoid.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u1} E _inst_1))))))) x y)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) x) (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) y)))
-Case conversion may be inaccurate. Consider using '#align same_ray.norm_add SameRay.norm_addₓ'. -/
 /-- If `x` and `y` are on the same ray, then the triangle inequality becomes the equality: the norm
 of `x + y` is the sum of the norms of `x` and `y`. The converse is true for a strictly convex
 space. -/
@@ -48,12 +42,6 @@ theorem norm_add (h : SameRay ℝ x y) : ‖x + y‖ = ‖x‖ + ‖y‖ :=
     norm_smul_of_nonneg hb, add_mul]
 #align same_ray.norm_add SameRay.norm_add
 
-/- warning: same_ray.norm_sub -> SameRay.norm_sub is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {x : E} {y : E}, (SameRay.{0, u1} Real Real.strictOrderedCommSemiring E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2) x y) -> (Eq.{1} Real (Norm.norm.{u1} E (SeminormedAddCommGroup.toHasNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toHasSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u1} E _inst_1))))) x y)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) (Norm.norm.{u1} E (SeminormedAddCommGroup.toHasNorm.{u1} E _inst_1) x) (Norm.norm.{u1} E (SeminormedAddCommGroup.toHasNorm.{u1} E _inst_1) y))))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {x : E} {y : E}, (SameRay.{0, u1} Real Real.strictOrderedCommSemiring E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2) x y) -> (Eq.{1} Real (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u1} E _inst_1))))) x y)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) x) (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) y))))
-Case conversion may be inaccurate. Consider using '#align same_ray.norm_sub SameRay.norm_subₓ'. -/
 theorem norm_sub (h : SameRay ℝ x y) : ‖x - y‖ = |‖x‖ - ‖y‖| :=
   by
   rcases h.exists_eq_smul with ⟨u, a, b, ha, hb, -, rfl, rfl⟩
@@ -78,12 +66,6 @@ end SameRay
 
 variable {x y : F}
 
-/- warning: norm_inj_on_ray_left -> norm_injOn_ray_left is a dubious translation:
-lean 3 declaration is
-  forall {F : Type.{u1}} [_inst_3 : NormedAddCommGroup.{u1} F] [_inst_4 : NormedSpace.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)] {x : F}, (Ne.{succ u1} F x (OfNat.ofNat.{u1} F 0 (OfNat.mk.{u1} F 0 (Zero.zero.{u1} F (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (SubNegMonoid.toAddMonoid.{u1} F (AddGroup.toSubNegMonoid.{u1} F (NormedAddGroup.toAddGroup.{u1} F (NormedAddCommGroup.toNormedAddGroup.{u1} F _inst_3)))))))))) -> (Set.InjOn.{u1, 0} F Real (Norm.norm.{u1} F (NormedAddCommGroup.toHasNorm.{u1} F _inst_3)) (setOf.{u1} F (fun (y : F) => SameRay.{0, u1} Real Real.strictOrderedCommSemiring F (AddCommGroup.toAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4) x y)))
-but is expected to have type
-  forall {F : Type.{u1}} [_inst_3 : NormedAddCommGroup.{u1} F] [_inst_4 : NormedSpace.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)] {x : F}, (Ne.{succ u1} F x (OfNat.ofNat.{u1} F 0 (Zero.toOfNat0.{u1} F (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3))))))))) -> (Set.InjOn.{u1, 0} F Real (Norm.norm.{u1} F (NormedAddCommGroup.toNorm.{u1} F _inst_3)) (setOf.{u1} F (fun (y : F) => SameRay.{0, u1} Real Real.strictOrderedCommSemiring F (AddCommGroup.toAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4) x y)))
-Case conversion may be inaccurate. Consider using '#align norm_inj_on_ray_left norm_injOn_ray_leftₓ'. -/
 theorem norm_injOn_ray_left (hx : x ≠ 0) : { y | SameRay ℝ x y }.InjOn norm :=
   by
   rintro y hy z hz h
@@ -94,12 +76,6 @@ theorem norm_injOn_ray_left (hx : x ≠ 0) : { y | SameRay ℝ x y }.InjOn norm
   rw [h]
 #align norm_inj_on_ray_left norm_injOn_ray_left
 
-/- warning: norm_inj_on_ray_right -> norm_injOn_ray_right is a dubious translation:
-lean 3 declaration is
-  forall {F : Type.{u1}} [_inst_3 : NormedAddCommGroup.{u1} F] [_inst_4 : NormedSpace.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)] {y : F}, (Ne.{succ u1} F y (OfNat.ofNat.{u1} F 0 (OfNat.mk.{u1} F 0 (Zero.zero.{u1} F (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (SubNegMonoid.toAddMonoid.{u1} F (AddGroup.toSubNegMonoid.{u1} F (NormedAddGroup.toAddGroup.{u1} F (NormedAddCommGroup.toNormedAddGroup.{u1} F _inst_3)))))))))) -> (Set.InjOn.{u1, 0} F Real (Norm.norm.{u1} F (NormedAddCommGroup.toHasNorm.{u1} F _inst_3)) (setOf.{u1} F (fun (x : F) => SameRay.{0, u1} Real Real.strictOrderedCommSemiring F (AddCommGroup.toAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4) x y)))
-but is expected to have type
-  forall {F : Type.{u1}} [_inst_3 : NormedAddCommGroup.{u1} F] [_inst_4 : NormedSpace.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)] {y : F}, (Ne.{succ u1} F y (OfNat.ofNat.{u1} F 0 (Zero.toOfNat0.{u1} F (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3))))))))) -> (Set.InjOn.{u1, 0} F Real (Norm.norm.{u1} F (NormedAddCommGroup.toNorm.{u1} F _inst_3)) (setOf.{u1} F (fun (x : F) => SameRay.{0, u1} Real Real.strictOrderedCommSemiring F (AddCommGroup.toAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4) x y)))
-Case conversion may be inaccurate. Consider using '#align norm_inj_on_ray_right norm_injOn_ray_rightₓ'. -/
 theorem norm_injOn_ray_right (hy : y ≠ 0) : { x | SameRay ℝ x y }.InjOn norm := by
   simpa only [SameRay.sameRay_comm] using norm_injOn_ray_left hy
 #align norm_inj_on_ray_right norm_injOn_ray_right
@@ -112,12 +88,6 @@ theorem sameRay_iff_norm_smul_eq : SameRay ℝ x y ↔ ‖x‖ • y = ‖y‖ 
 #align same_ray_iff_norm_smul_eq sameRay_iff_norm_smul_eq
 -/
 
-/- warning: same_ray_iff_inv_norm_smul_eq_of_ne -> sameRay_iff_inv_norm_smul_eq_of_ne is a dubious translation:
-lean 3 declaration is
-  forall {F : Type.{u1}} [_inst_3 : NormedAddCommGroup.{u1} F] [_inst_4 : NormedSpace.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)] {x : F} {y : F}, (Ne.{succ u1} F x (OfNat.ofNat.{u1} F 0 (OfNat.mk.{u1} F 0 (Zero.zero.{u1} F (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (SubNegMonoid.toAddMonoid.{u1} F (AddGroup.toSubNegMonoid.{u1} F (NormedAddGroup.toAddGroup.{u1} F (NormedAddCommGroup.toNormedAddGroup.{u1} F _inst_3)))))))))) -> (Ne.{succ u1} F y (OfNat.ofNat.{u1} F 0 (OfNat.mk.{u1} F 0 (Zero.zero.{u1} F (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (SubNegMonoid.toAddMonoid.{u1} F (AddGroup.toSubNegMonoid.{u1} F (NormedAddGroup.toAddGroup.{u1} F (NormedAddCommGroup.toNormedAddGroup.{u1} F _inst_3)))))))))) -> (Iff (SameRay.{0, u1} Real Real.strictOrderedCommSemiring F (AddCommGroup.toAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4) x y) (Eq.{succ u1} F (SMul.smul.{0, u1} Real F (SMulZeroClass.toHasSmul.{0, u1} Real F (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (SMulWithZero.toSmulZeroClass.{0, u1} Real F (MulZeroClass.toHasZero.{0} Real (MulZeroOneClass.toMulZeroClass.{0} Real (MonoidWithZero.toMulZeroOneClass.{0} Real (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))))))) (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real F (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField))))) (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (Module.toMulActionWithZero.{0, u1} Real F (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))) (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3))) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4))))) (Inv.inv.{0} Real Real.hasInv (Norm.norm.{u1} F (NormedAddCommGroup.toHasNorm.{u1} F _inst_3) x)) x) (SMul.smul.{0, u1} Real F (SMulZeroClass.toHasSmul.{0, u1} Real F (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (SMulWithZero.toSmulZeroClass.{0, u1} Real F (MulZeroClass.toHasZero.{0} Real (MulZeroOneClass.toMulZeroClass.{0} Real (MonoidWithZero.toMulZeroOneClass.{0} Real (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))))))) (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real F (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField))))) (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (Module.toMulActionWithZero.{0, u1} Real F (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))) (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3))) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4))))) (Inv.inv.{0} Real Real.hasInv (Norm.norm.{u1} F (NormedAddCommGroup.toHasNorm.{u1} F _inst_3) y)) y)))
-but is expected to have type
-  forall {F : Type.{u1}} [_inst_3 : NormedAddCommGroup.{u1} F] [_inst_4 : NormedSpace.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)] {x : F} {y : F}, (Ne.{succ u1} F x (OfNat.ofNat.{u1} F 0 (Zero.toOfNat0.{u1} F (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3))))))))) -> (Ne.{succ u1} F y (OfNat.ofNat.{u1} F 0 (Zero.toOfNat0.{u1} F (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3))))))))) -> (Iff (SameRay.{0, u1} Real Real.strictOrderedCommSemiring F (AddCommGroup.toAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4) x y) (Eq.{succ u1} F (HSMul.hSMul.{0, u1, u1} Real F F (instHSMul.{0, u1} Real F (SMulZeroClass.toSMul.{0, u1} Real F (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (SMulWithZero.toSMulZeroClass.{0, u1} Real F Real.instZeroReal (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real F Real.instMonoidWithZeroReal (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (Module.toMulActionWithZero.{0, u1} Real F Real.semiring (AddCommGroup.toAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4)))))) (Inv.inv.{0} Real Real.instInvReal (Norm.norm.{u1} F (NormedAddCommGroup.toNorm.{u1} F _inst_3) x)) x) (HSMul.hSMul.{0, u1, u1} Real F F (instHSMul.{0, u1} Real F (SMulZeroClass.toSMul.{0, u1} Real F (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (SMulWithZero.toSMulZeroClass.{0, u1} Real F Real.instZeroReal (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real F Real.instMonoidWithZeroReal (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (Module.toMulActionWithZero.{0, u1} Real F Real.semiring (AddCommGroup.toAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4)))))) (Inv.inv.{0} Real Real.instInvReal (Norm.norm.{u1} F (NormedAddCommGroup.toNorm.{u1} F _inst_3) y)) y)))
-Case conversion may be inaccurate. Consider using '#align same_ray_iff_inv_norm_smul_eq_of_ne sameRay_iff_inv_norm_smul_eq_of_neₓ'. -/
 /-- Two nonzero vectors `x y` in a real normed space are on the same ray if and only if the unit
 vectors `‖x‖⁻¹ • x` and `‖y‖⁻¹ • y` are equal. -/
 theorem sameRay_iff_inv_norm_smul_eq_of_ne (hx : x ≠ 0) (hy : y ≠ 0) :
@@ -126,21 +96,9 @@ theorem sameRay_iff_inv_norm_smul_eq_of_ne (hx : x ≠ 0) (hy : y ≠ 0) :
     rwa [norm_ne_zero_iff]
 #align same_ray_iff_inv_norm_smul_eq_of_ne sameRay_iff_inv_norm_smul_eq_of_ne
 
-/- warning: same_ray.inv_norm_smul_eq -> SameRay.inv_norm_smul_eq is a dubious translation:
-lean 3 declaration is
-  forall {F : Type.{u1}} [_inst_3 : NormedAddCommGroup.{u1} F] [_inst_4 : NormedSpace.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)] {x : F} {y : F}, (Ne.{succ u1} F x (OfNat.ofNat.{u1} F 0 (OfNat.mk.{u1} F 0 (Zero.zero.{u1} F (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (SubNegMonoid.toAddMonoid.{u1} F (AddGroup.toSubNegMonoid.{u1} F (NormedAddGroup.toAddGroup.{u1} F (NormedAddCommGroup.toNormedAddGroup.{u1} F _inst_3)))))))))) -> (Ne.{succ u1} F y (OfNat.ofNat.{u1} F 0 (OfNat.mk.{u1} F 0 (Zero.zero.{u1} F (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (SubNegMonoid.toAddMonoid.{u1} F (AddGroup.toSubNegMonoid.{u1} F (NormedAddGroup.toAddGroup.{u1} F (NormedAddCommGroup.toNormedAddGroup.{u1} F _inst_3)))))))))) -> (SameRay.{0, u1} Real Real.strictOrderedCommSemiring F (AddCommGroup.toAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4) x y) -> (Eq.{succ u1} F (SMul.smul.{0, u1} Real F (SMulZeroClass.toHasSmul.{0, u1} Real F (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (SMulWithZero.toSmulZeroClass.{0, u1} Real F (MulZeroClass.toHasZero.{0} Real (MulZeroOneClass.toMulZeroClass.{0} Real (MonoidWithZero.toMulZeroOneClass.{0} Real (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))))))) (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real F (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField))))) (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (Module.toMulActionWithZero.{0, u1} Real F (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))) (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3))) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4))))) (Inv.inv.{0} Real Real.hasInv (Norm.norm.{u1} F (NormedAddCommGroup.toHasNorm.{u1} F _inst_3) x)) x) (SMul.smul.{0, u1} Real F (SMulZeroClass.toHasSmul.{0, u1} Real F (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (SMulWithZero.toSmulZeroClass.{0, u1} Real F (MulZeroClass.toHasZero.{0} Real (MulZeroOneClass.toMulZeroClass.{0} Real (MonoidWithZero.toMulZeroOneClass.{0} Real (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))))))) (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real F (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField))))) (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (Module.toMulActionWithZero.{0, u1} Real F (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))) (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3))) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4))))) (Inv.inv.{0} Real Real.hasInv (Norm.norm.{u1} F (NormedAddCommGroup.toHasNorm.{u1} F _inst_3) y)) y))
-but is expected to have type
-  forall {F : Type.{u1}} [_inst_3 : NormedAddCommGroup.{u1} F] [_inst_4 : NormedSpace.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)] {x : F} {y : F}, (Ne.{succ u1} F x (OfNat.ofNat.{u1} F 0 (Zero.toOfNat0.{u1} F (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3))))))))) -> (Ne.{succ u1} F y (OfNat.ofNat.{u1} F 0 (Zero.toOfNat0.{u1} F (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3))))))))) -> (SameRay.{0, u1} Real Real.strictOrderedCommSemiring F (AddCommGroup.toAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4) x y) -> (Eq.{succ u1} F (HSMul.hSMul.{0, u1, u1} Real F F (instHSMul.{0, u1} Real F (SMulZeroClass.toSMul.{0, u1} Real F (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (SMulWithZero.toSMulZeroClass.{0, u1} Real F Real.instZeroReal (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real F Real.instMonoidWithZeroReal (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (Module.toMulActionWithZero.{0, u1} Real F Real.semiring (AddCommGroup.toAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4)))))) (Inv.inv.{0} Real Real.instInvReal (Norm.norm.{u1} F (NormedAddCommGroup.toNorm.{u1} F _inst_3) x)) x) (HSMul.hSMul.{0, u1, u1} Real F F (instHSMul.{0, u1} Real F (SMulZeroClass.toSMul.{0, u1} Real F (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (SMulWithZero.toSMulZeroClass.{0, u1} Real F Real.instZeroReal (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real F Real.instMonoidWithZeroReal (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (Module.toMulActionWithZero.{0, u1} Real F Real.semiring (AddCommGroup.toAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4)))))) (Inv.inv.{0} Real Real.instInvReal (Norm.norm.{u1} F (NormedAddCommGroup.toNorm.{u1} F _inst_3) y)) y))
-Case conversion may be inaccurate. Consider using '#align same_ray.inv_norm_smul_eq SameRay.inv_norm_smul_eqₓ'. -/
 alias sameRay_iff_inv_norm_smul_eq_of_ne ↔ SameRay.inv_norm_smul_eq _
 #align same_ray.inv_norm_smul_eq SameRay.inv_norm_smul_eq
 
-/- warning: same_ray_iff_inv_norm_smul_eq -> sameRay_iff_inv_norm_smul_eq is a dubious translation:
-lean 3 declaration is
-  forall {F : Type.{u1}} [_inst_3 : NormedAddCommGroup.{u1} F] [_inst_4 : NormedSpace.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)] {x : F} {y : F}, Iff (SameRay.{0, u1} Real Real.strictOrderedCommSemiring F (AddCommGroup.toAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4) x y) (Or (Eq.{succ u1} F x (OfNat.ofNat.{u1} F 0 (OfNat.mk.{u1} F 0 (Zero.zero.{u1} F (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (SubNegMonoid.toAddMonoid.{u1} F (AddGroup.toSubNegMonoid.{u1} F (NormedAddGroup.toAddGroup.{u1} F (NormedAddCommGroup.toNormedAddGroup.{u1} F _inst_3)))))))))) (Or (Eq.{succ u1} F y (OfNat.ofNat.{u1} F 0 (OfNat.mk.{u1} F 0 (Zero.zero.{u1} F (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (SubNegMonoid.toAddMonoid.{u1} F (AddGroup.toSubNegMonoid.{u1} F (NormedAddGroup.toAddGroup.{u1} F (NormedAddCommGroup.toNormedAddGroup.{u1} F _inst_3)))))))))) (Eq.{succ u1} F (SMul.smul.{0, u1} Real F (SMulZeroClass.toHasSmul.{0, u1} Real F (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (SMulWithZero.toSmulZeroClass.{0, u1} Real F (MulZeroClass.toHasZero.{0} Real (MulZeroOneClass.toMulZeroClass.{0} Real (MonoidWithZero.toMulZeroOneClass.{0} Real (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))))))) (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real F (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField))))) (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (Module.toMulActionWithZero.{0, u1} Real F (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))) (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3))) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4))))) (Inv.inv.{0} Real Real.hasInv (Norm.norm.{u1} F (NormedAddCommGroup.toHasNorm.{u1} F _inst_3) x)) x) (SMul.smul.{0, u1} Real F (SMulZeroClass.toHasSmul.{0, u1} Real F (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (SMulWithZero.toSmulZeroClass.{0, u1} Real F (MulZeroClass.toHasZero.{0} Real (MulZeroOneClass.toMulZeroClass.{0} Real (MonoidWithZero.toMulZeroOneClass.{0} Real (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))))))) (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real F (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField))))) (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (Module.toMulActionWithZero.{0, u1} Real F (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))) (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3))) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4))))) (Inv.inv.{0} Real Real.hasInv (Norm.norm.{u1} F (NormedAddCommGroup.toHasNorm.{u1} F _inst_3) y)) y))))
-but is expected to have type
-  forall {F : Type.{u1}} [_inst_3 : NormedAddCommGroup.{u1} F] [_inst_4 : NormedSpace.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)] {x : F} {y : F}, Iff (SameRay.{0, u1} Real Real.strictOrderedCommSemiring F (AddCommGroup.toAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4) x y) (Or (Eq.{succ u1} F x (OfNat.ofNat.{u1} F 0 (Zero.toOfNat0.{u1} F (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3))))))))) (Or (Eq.{succ u1} F y (OfNat.ofNat.{u1} F 0 (Zero.toOfNat0.{u1} F (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3))))))))) (Eq.{succ u1} F (HSMul.hSMul.{0, u1, u1} Real F F (instHSMul.{0, u1} Real F (SMulZeroClass.toSMul.{0, u1} Real F (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (SMulWithZero.toSMulZeroClass.{0, u1} Real F Real.instZeroReal (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real F Real.instMonoidWithZeroReal (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (Module.toMulActionWithZero.{0, u1} Real F Real.semiring (AddCommGroup.toAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4)))))) (Inv.inv.{0} Real Real.instInvReal (Norm.norm.{u1} F (NormedAddCommGroup.toNorm.{u1} F _inst_3) x)) x) (HSMul.hSMul.{0, u1, u1} Real F F (instHSMul.{0, u1} Real F (SMulZeroClass.toSMul.{0, u1} Real F (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (SMulWithZero.toSMulZeroClass.{0, u1} Real F Real.instZeroReal (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real F Real.instMonoidWithZeroReal (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (Module.toMulActionWithZero.{0, u1} Real F Real.semiring (AddCommGroup.toAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4)))))) (Inv.inv.{0} Real Real.instInvReal (Norm.norm.{u1} F (NormedAddCommGroup.toNorm.{u1} F _inst_3) y)) y))))
-Case conversion may be inaccurate. Consider using '#align same_ray_iff_inv_norm_smul_eq sameRay_iff_inv_norm_smul_eqₓ'. -/
 /-- Two vectors `x y` in a real normed space are on the ray if and only if one of them is zero or
 the unit vectors `‖x‖⁻¹ • x` and `‖y‖⁻¹ • y` are equal. -/
 theorem sameRay_iff_inv_norm_smul_eq : SameRay ℝ x y ↔ x = 0 ∨ y = 0 ∨ ‖x‖⁻¹ • x = ‖y‖⁻¹ • y :=

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

@@ -58,8 +58,7 @@ theorem norm_sub (h : SameRay ℝ x y) : ‖x - y‖ = |‖x‖ - ‖y‖| :=
   by
   rcases h.exists_eq_smul with ⟨u, a, b, ha, hb, -, rfl, rfl⟩
   wlog hab : b ≤ a
-  · rw [SameRay.sameRay_comm] at h
-    rw [norm_sub_rev, abs_sub_comm]
+  · rw [SameRay.sameRay_comm] at h; rw [norm_sub_rev, abs_sub_comm]
     exact this u b a hb ha h (le_of_not_le hab)
   rw [← sub_nonneg] at hab
   rw [← sub_smul, norm_smul_of_nonneg hab, norm_smul_of_nonneg ha, norm_smul_of_nonneg hb, ←

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

@@ -50,9 +50,9 @@ theorem norm_add (h : SameRay ℝ x y) : ‖x + y‖ = ‖x‖ + ‖y‖ :=
 
 /- warning: same_ray.norm_sub -> SameRay.norm_sub is a dubious translation:
 lean 3 declaration is
-  forall {E : Type.{u_1}} [_inst_1 : SeminormedAddCommGroup.{u_1} E] [_inst_2 : NormedSpace.{0, u_1} Real E Real.normedField _inst_1] {x : E} {y : E}, (SameRay.{0, u_1} Real Real.strictOrderedCommSemiring E (AddCommGroup.toAddCommMonoid.{u_1} E (SeminormedAddCommGroup.toAddCommGroup.{u_1} E _inst_1)) (NormedSpace.toModule.{0, u_1} Real E Real.normedField _inst_1 _inst_2) x y) -> (Eq.{1} Real (Norm.norm.{u_1} E (SeminormedAddCommGroup.toHasNorm.{u_1} E _inst_1) (HSub.hSub.{u_1, u_1, u_1} E E E (instHSub.{u_1} E (SubNegMonoid.toHasSub.{u_1} E (AddGroup.toSubNegMonoid.{u_1} E (SeminormedAddGroup.toAddGroup.{u_1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u_1} E _inst_1))))) x y)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) (Norm.norm.{u_1} E (SeminormedAddCommGroup.toHasNorm.{u_1} E _inst_1) x) (Norm.norm.{u_1} E (SeminormedAddCommGroup.toHasNorm.{u_1} E _inst_1) y))))
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {x : E} {y : E}, (SameRay.{0, u1} Real Real.strictOrderedCommSemiring E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2) x y) -> (Eq.{1} Real (Norm.norm.{u1} E (SeminormedAddCommGroup.toHasNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toHasSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u1} E _inst_1))))) x y)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) (Norm.norm.{u1} E (SeminormedAddCommGroup.toHasNorm.{u1} E _inst_1) x) (Norm.norm.{u1} E (SeminormedAddCommGroup.toHasNorm.{u1} E _inst_1) y))))
 but is expected to have type
-  forall {E : Type.{u_1}} [_inst_1 : SeminormedAddCommGroup.{u_1} E] [_inst_2 : NormedSpace.{0, u_1} Real E Real.normedField _inst_1] {x : Type.{u_2}} [y : NormedAddCommGroup.{u_2} x] [h : NormedSpace.{0, u_2} Real x Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u_2} x y)] {x : E} {y : E}, (SameRay.{0, u_1} Real Real.strictOrderedCommSemiring E (AddCommGroup.toAddCommMonoid.{u_1} E (SeminormedAddCommGroup.toAddCommGroup.{u_1} E _inst_1)) (NormedSpace.toModule.{0, u_1} Real E Real.normedField _inst_1 _inst_2) x y) -> (Eq.{1} Real (Norm.norm.{u_1} E (SeminormedAddCommGroup.toNorm.{u_1} E _inst_1) (HSub.hSub.{u_1, u_1, u_1} E E E (instHSub.{u_1} E (SubNegMonoid.toSub.{u_1} E (AddGroup.toSubNegMonoid.{u_1} E (SeminormedAddGroup.toAddGroup.{u_1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u_1} E _inst_1))))) x y)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) (Norm.norm.{u_1} E (SeminormedAddCommGroup.toNorm.{u_1} E _inst_1) x) (Norm.norm.{u_1} E (SeminormedAddCommGroup.toNorm.{u_1} E _inst_1) y))))
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {x : E} {y : E}, (SameRay.{0, u1} Real Real.strictOrderedCommSemiring E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2) x y) -> (Eq.{1} Real (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u1} E _inst_1))))) x y)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) x) (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) y))))
 Case conversion may be inaccurate. Consider using '#align same_ray.norm_sub SameRay.norm_subₓ'. -/
 theorem norm_sub (h : SameRay ℝ x y) : ‖x - y‖ = |‖x‖ - ‖y‖| :=
   by

mathlib commit https://github.com/leanprover-community/mathlib/commit/7ebf83ed9c262adbf983ef64d5e8c2ae94b625f4

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov, Yaël Dillies
 
 ! This file was ported from Lean 3 source module analysis.normed_space.ray
-! leanprover-community/mathlib commit 92ca63f0fb391a9ca5f22d2409a6080e786d99f7
+! leanprover-community/mathlib commit 9a48a083b390d9b84a71efbdc4e8dfa26a687104
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -14,6 +14,9 @@ import Mathbin.Analysis.NormedSpace.Basic
 /-!
 # Rays in a real normed vector space
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 In this file we prove some lemmas about the `same_ray` predicate in case of a real normed space. In
 this case, for two vectors `x y` in the same ray, the norm of their sum is equal to the sum of their
 norms and `‖y‖ • x = ‖x‖ • y`.

mathlib commit https://github.com/leanprover-community/mathlib/commit/039ef89bef6e58b32b62898dd48e9d1a4312bb65

@@ -29,6 +29,12 @@ namespace SameRay
 
 variable {x y : E}
 
+/- warning: same_ray.norm_add -> SameRay.norm_add is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {x : E} {y : E}, (SameRay.{0, u1} Real Real.strictOrderedCommSemiring E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2) x y) -> (Eq.{1} Real (Norm.norm.{u1} E (SeminormedAddCommGroup.toHasNorm.{u1} E _inst_1) (HAdd.hAdd.{u1, u1, u1} E E E (instHAdd.{u1} E (AddZeroClass.toHasAdd.{u1} E (AddMonoid.toAddZeroClass.{u1} E (SubNegMonoid.toAddMonoid.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u1} E _inst_1))))))) x y)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Norm.norm.{u1} E (SeminormedAddCommGroup.toHasNorm.{u1} E _inst_1) x) (Norm.norm.{u1} E (SeminormedAddCommGroup.toHasNorm.{u1} E _inst_1) y)))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {x : E} {y : E}, (SameRay.{0, u1} Real Real.strictOrderedCommSemiring E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2) x y) -> (Eq.{1} Real (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) (HAdd.hAdd.{u1, u1, u1} E E E (instHAdd.{u1} E (AddZeroClass.toAdd.{u1} E (AddMonoid.toAddZeroClass.{u1} E (SubNegMonoid.toAddMonoid.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u1} E _inst_1))))))) x y)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) x) (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) y)))
+Case conversion may be inaccurate. Consider using '#align same_ray.norm_add SameRay.norm_addₓ'. -/
 /-- If `x` and `y` are on the same ray, then the triangle inequality becomes the equality: the norm
 of `x + y` is the sum of the norms of `x` and `y`. The converse is true for a strictly convex
 space. -/
@@ -39,6 +45,12 @@ theorem norm_add (h : SameRay ℝ x y) : ‖x + y‖ = ‖x‖ + ‖y‖ :=
     norm_smul_of_nonneg hb, add_mul]
 #align same_ray.norm_add SameRay.norm_add
 
+/- warning: same_ray.norm_sub -> SameRay.norm_sub is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u_1}} [_inst_1 : SeminormedAddCommGroup.{u_1} E] [_inst_2 : NormedSpace.{0, u_1} Real E Real.normedField _inst_1] {x : E} {y : E}, (SameRay.{0, u_1} Real Real.strictOrderedCommSemiring E (AddCommGroup.toAddCommMonoid.{u_1} E (SeminormedAddCommGroup.toAddCommGroup.{u_1} E _inst_1)) (NormedSpace.toModule.{0, u_1} Real E Real.normedField _inst_1 _inst_2) x y) -> (Eq.{1} Real (Norm.norm.{u_1} E (SeminormedAddCommGroup.toHasNorm.{u_1} E _inst_1) (HSub.hSub.{u_1, u_1, u_1} E E E (instHSub.{u_1} E (SubNegMonoid.toHasSub.{u_1} E (AddGroup.toSubNegMonoid.{u_1} E (SeminormedAddGroup.toAddGroup.{u_1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u_1} E _inst_1))))) x y)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) (Norm.norm.{u_1} E (SeminormedAddCommGroup.toHasNorm.{u_1} E _inst_1) x) (Norm.norm.{u_1} E (SeminormedAddCommGroup.toHasNorm.{u_1} E _inst_1) y))))
+but is expected to have type
+  forall {E : Type.{u_1}} [_inst_1 : SeminormedAddCommGroup.{u_1} E] [_inst_2 : NormedSpace.{0, u_1} Real E Real.normedField _inst_1] {x : Type.{u_2}} [y : NormedAddCommGroup.{u_2} x] [h : NormedSpace.{0, u_2} Real x Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u_2} x y)] {x : E} {y : E}, (SameRay.{0, u_1} Real Real.strictOrderedCommSemiring E (AddCommGroup.toAddCommMonoid.{u_1} E (SeminormedAddCommGroup.toAddCommGroup.{u_1} E _inst_1)) (NormedSpace.toModule.{0, u_1} Real E Real.normedField _inst_1 _inst_2) x y) -> (Eq.{1} Real (Norm.norm.{u_1} E (SeminormedAddCommGroup.toNorm.{u_1} E _inst_1) (HSub.hSub.{u_1, u_1, u_1} E E E (instHSub.{u_1} E (SubNegMonoid.toSub.{u_1} E (AddGroup.toSubNegMonoid.{u_1} E (SeminormedAddGroup.toAddGroup.{u_1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u_1} E _inst_1))))) x y)) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) (Norm.norm.{u_1} E (SeminormedAddCommGroup.toNorm.{u_1} E _inst_1) x) (Norm.norm.{u_1} E (SeminormedAddCommGroup.toNorm.{u_1} E _inst_1) y))))
+Case conversion may be inaccurate. Consider using '#align same_ray.norm_sub SameRay.norm_subₓ'. -/
 theorem norm_sub (h : SameRay ℝ x y) : ‖x - y‖ = |‖x‖ - ‖y‖| :=
   by
   rcases h.exists_eq_smul with ⟨u, a, b, ha, hb, -, rfl, rfl⟩
@@ -51,17 +63,25 @@ theorem norm_sub (h : SameRay ℝ x y) : ‖x - y‖ = |‖x‖ - ‖y‖| :=
     sub_mul, abs_of_nonneg (mul_nonneg hab (norm_nonneg _))]
 #align same_ray.norm_sub SameRay.norm_sub
 
+#print SameRay.norm_smul_eq /-
 theorem norm_smul_eq (h : SameRay ℝ x y) : ‖x‖ • y = ‖y‖ • x :=
   by
   rcases h.exists_eq_smul with ⟨u, a, b, ha, hb, -, rfl, rfl⟩
   simp only [norm_smul_of_nonneg, *, mul_smul, smul_comm ‖u‖]
   apply smul_comm
 #align same_ray.norm_smul_eq SameRay.norm_smul_eq
+-/
 
 end SameRay
 
 variable {x y : F}
 
+/- warning: norm_inj_on_ray_left -> norm_injOn_ray_left is a dubious translation:
+lean 3 declaration is
+  forall {F : Type.{u1}} [_inst_3 : NormedAddCommGroup.{u1} F] [_inst_4 : NormedSpace.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)] {x : F}, (Ne.{succ u1} F x (OfNat.ofNat.{u1} F 0 (OfNat.mk.{u1} F 0 (Zero.zero.{u1} F (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (SubNegMonoid.toAddMonoid.{u1} F (AddGroup.toSubNegMonoid.{u1} F (NormedAddGroup.toAddGroup.{u1} F (NormedAddCommGroup.toNormedAddGroup.{u1} F _inst_3)))))))))) -> (Set.InjOn.{u1, 0} F Real (Norm.norm.{u1} F (NormedAddCommGroup.toHasNorm.{u1} F _inst_3)) (setOf.{u1} F (fun (y : F) => SameRay.{0, u1} Real Real.strictOrderedCommSemiring F (AddCommGroup.toAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4) x y)))
+but is expected to have type
+  forall {F : Type.{u1}} [_inst_3 : NormedAddCommGroup.{u1} F] [_inst_4 : NormedSpace.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)] {x : F}, (Ne.{succ u1} F x (OfNat.ofNat.{u1} F 0 (Zero.toOfNat0.{u1} F (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3))))))))) -> (Set.InjOn.{u1, 0} F Real (Norm.norm.{u1} F (NormedAddCommGroup.toNorm.{u1} F _inst_3)) (setOf.{u1} F (fun (y : F) => SameRay.{0, u1} Real Real.strictOrderedCommSemiring F (AddCommGroup.toAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4) x y)))
+Case conversion may be inaccurate. Consider using '#align norm_inj_on_ray_left norm_injOn_ray_leftₓ'. -/
 theorem norm_injOn_ray_left (hx : x ≠ 0) : { y | SameRay ℝ x y }.InjOn norm :=
   by
   rintro y hy z hz h
@@ -72,16 +92,30 @@ theorem norm_injOn_ray_left (hx : x ≠ 0) : { y | SameRay ℝ x y }.InjOn norm
   rw [h]
 #align norm_inj_on_ray_left norm_injOn_ray_left
 
+/- warning: norm_inj_on_ray_right -> norm_injOn_ray_right is a dubious translation:
+lean 3 declaration is
+  forall {F : Type.{u1}} [_inst_3 : NormedAddCommGroup.{u1} F] [_inst_4 : NormedSpace.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)] {y : F}, (Ne.{succ u1} F y (OfNat.ofNat.{u1} F 0 (OfNat.mk.{u1} F 0 (Zero.zero.{u1} F (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (SubNegMonoid.toAddMonoid.{u1} F (AddGroup.toSubNegMonoid.{u1} F (NormedAddGroup.toAddGroup.{u1} F (NormedAddCommGroup.toNormedAddGroup.{u1} F _inst_3)))))))))) -> (Set.InjOn.{u1, 0} F Real (Norm.norm.{u1} F (NormedAddCommGroup.toHasNorm.{u1} F _inst_3)) (setOf.{u1} F (fun (x : F) => SameRay.{0, u1} Real Real.strictOrderedCommSemiring F (AddCommGroup.toAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4) x y)))
+but is expected to have type
+  forall {F : Type.{u1}} [_inst_3 : NormedAddCommGroup.{u1} F] [_inst_4 : NormedSpace.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)] {y : F}, (Ne.{succ u1} F y (OfNat.ofNat.{u1} F 0 (Zero.toOfNat0.{u1} F (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3))))))))) -> (Set.InjOn.{u1, 0} F Real (Norm.norm.{u1} F (NormedAddCommGroup.toNorm.{u1} F _inst_3)) (setOf.{u1} F (fun (x : F) => SameRay.{0, u1} Real Real.strictOrderedCommSemiring F (AddCommGroup.toAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4) x y)))
+Case conversion may be inaccurate. Consider using '#align norm_inj_on_ray_right norm_injOn_ray_rightₓ'. -/
 theorem norm_injOn_ray_right (hy : y ≠ 0) : { x | SameRay ℝ x y }.InjOn norm := by
   simpa only [SameRay.sameRay_comm] using norm_injOn_ray_left hy
 #align norm_inj_on_ray_right norm_injOn_ray_right
 
+#print sameRay_iff_norm_smul_eq /-
 theorem sameRay_iff_norm_smul_eq : SameRay ℝ x y ↔ ‖x‖ • y = ‖y‖ • x :=
   ⟨SameRay.norm_smul_eq, fun h =>
     or_iff_not_imp_left.2 fun hx =>
       or_iff_not_imp_left.2 fun hy => ⟨‖y‖, ‖x‖, norm_pos_iff.2 hy, norm_pos_iff.2 hx, h.symm⟩⟩
 #align same_ray_iff_norm_smul_eq sameRay_iff_norm_smul_eq
+-/
 
+/- warning: same_ray_iff_inv_norm_smul_eq_of_ne -> sameRay_iff_inv_norm_smul_eq_of_ne is a dubious translation:
+lean 3 declaration is
+  forall {F : Type.{u1}} [_inst_3 : NormedAddCommGroup.{u1} F] [_inst_4 : NormedSpace.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)] {x : F} {y : F}, (Ne.{succ u1} F x (OfNat.ofNat.{u1} F 0 (OfNat.mk.{u1} F 0 (Zero.zero.{u1} F (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (SubNegMonoid.toAddMonoid.{u1} F (AddGroup.toSubNegMonoid.{u1} F (NormedAddGroup.toAddGroup.{u1} F (NormedAddCommGroup.toNormedAddGroup.{u1} F _inst_3)))))))))) -> (Ne.{succ u1} F y (OfNat.ofNat.{u1} F 0 (OfNat.mk.{u1} F 0 (Zero.zero.{u1} F (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (SubNegMonoid.toAddMonoid.{u1} F (AddGroup.toSubNegMonoid.{u1} F (NormedAddGroup.toAddGroup.{u1} F (NormedAddCommGroup.toNormedAddGroup.{u1} F _inst_3)))))))))) -> (Iff (SameRay.{0, u1} Real Real.strictOrderedCommSemiring F (AddCommGroup.toAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4) x y) (Eq.{succ u1} F (SMul.smul.{0, u1} Real F (SMulZeroClass.toHasSmul.{0, u1} Real F (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (SMulWithZero.toSmulZeroClass.{0, u1} Real F (MulZeroClass.toHasZero.{0} Real (MulZeroOneClass.toMulZeroClass.{0} Real (MonoidWithZero.toMulZeroOneClass.{0} Real (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))))))) (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real F (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField))))) (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (Module.toMulActionWithZero.{0, u1} Real F (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))) (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3))) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4))))) (Inv.inv.{0} Real Real.hasInv (Norm.norm.{u1} F (NormedAddCommGroup.toHasNorm.{u1} F _inst_3) x)) x) (SMul.smul.{0, u1} Real F (SMulZeroClass.toHasSmul.{0, u1} Real F (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (SMulWithZero.toSmulZeroClass.{0, u1} Real F (MulZeroClass.toHasZero.{0} Real (MulZeroOneClass.toMulZeroClass.{0} Real (MonoidWithZero.toMulZeroOneClass.{0} Real (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))))))) (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real F (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField))))) (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (Module.toMulActionWithZero.{0, u1} Real F (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))) (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3))) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4))))) (Inv.inv.{0} Real Real.hasInv (Norm.norm.{u1} F (NormedAddCommGroup.toHasNorm.{u1} F _inst_3) y)) y)))
+but is expected to have type
+  forall {F : Type.{u1}} [_inst_3 : NormedAddCommGroup.{u1} F] [_inst_4 : NormedSpace.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)] {x : F} {y : F}, (Ne.{succ u1} F x (OfNat.ofNat.{u1} F 0 (Zero.toOfNat0.{u1} F (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3))))))))) -> (Ne.{succ u1} F y (OfNat.ofNat.{u1} F 0 (Zero.toOfNat0.{u1} F (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3))))))))) -> (Iff (SameRay.{0, u1} Real Real.strictOrderedCommSemiring F (AddCommGroup.toAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4) x y) (Eq.{succ u1} F (HSMul.hSMul.{0, u1, u1} Real F F (instHSMul.{0, u1} Real F (SMulZeroClass.toSMul.{0, u1} Real F (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (SMulWithZero.toSMulZeroClass.{0, u1} Real F Real.instZeroReal (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real F Real.instMonoidWithZeroReal (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (Module.toMulActionWithZero.{0, u1} Real F Real.semiring (AddCommGroup.toAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4)))))) (Inv.inv.{0} Real Real.instInvReal (Norm.norm.{u1} F (NormedAddCommGroup.toNorm.{u1} F _inst_3) x)) x) (HSMul.hSMul.{0, u1, u1} Real F F (instHSMul.{0, u1} Real F (SMulZeroClass.toSMul.{0, u1} Real F (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (SMulWithZero.toSMulZeroClass.{0, u1} Real F Real.instZeroReal (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real F Real.instMonoidWithZeroReal (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (Module.toMulActionWithZero.{0, u1} Real F Real.semiring (AddCommGroup.toAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4)))))) (Inv.inv.{0} Real Real.instInvReal (Norm.norm.{u1} F (NormedAddCommGroup.toNorm.{u1} F _inst_3) y)) y)))
+Case conversion may be inaccurate. Consider using '#align same_ray_iff_inv_norm_smul_eq_of_ne sameRay_iff_inv_norm_smul_eq_of_neₓ'. -/
 /-- Two nonzero vectors `x y` in a real normed space are on the same ray if and only if the unit
 vectors `‖x‖⁻¹ • x` and `‖y‖⁻¹ • y` are equal. -/
 theorem sameRay_iff_inv_norm_smul_eq_of_ne (hx : x ≠ 0) (hy : y ≠ 0) :
@@ -90,9 +124,21 @@ theorem sameRay_iff_inv_norm_smul_eq_of_ne (hx : x ≠ 0) (hy : y ≠ 0) :
     rwa [norm_ne_zero_iff]
 #align same_ray_iff_inv_norm_smul_eq_of_ne sameRay_iff_inv_norm_smul_eq_of_ne
 
+/- warning: same_ray.inv_norm_smul_eq -> SameRay.inv_norm_smul_eq is a dubious translation:
+lean 3 declaration is
+  forall {F : Type.{u1}} [_inst_3 : NormedAddCommGroup.{u1} F] [_inst_4 : NormedSpace.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)] {x : F} {y : F}, (Ne.{succ u1} F x (OfNat.ofNat.{u1} F 0 (OfNat.mk.{u1} F 0 (Zero.zero.{u1} F (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (SubNegMonoid.toAddMonoid.{u1} F (AddGroup.toSubNegMonoid.{u1} F (NormedAddGroup.toAddGroup.{u1} F (NormedAddCommGroup.toNormedAddGroup.{u1} F _inst_3)))))))))) -> (Ne.{succ u1} F y (OfNat.ofNat.{u1} F 0 (OfNat.mk.{u1} F 0 (Zero.zero.{u1} F (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (SubNegMonoid.toAddMonoid.{u1} F (AddGroup.toSubNegMonoid.{u1} F (NormedAddGroup.toAddGroup.{u1} F (NormedAddCommGroup.toNormedAddGroup.{u1} F _inst_3)))))))))) -> (SameRay.{0, u1} Real Real.strictOrderedCommSemiring F (AddCommGroup.toAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4) x y) -> (Eq.{succ u1} F (SMul.smul.{0, u1} Real F (SMulZeroClass.toHasSmul.{0, u1} Real F (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (SMulWithZero.toSmulZeroClass.{0, u1} Real F (MulZeroClass.toHasZero.{0} Real (MulZeroOneClass.toMulZeroClass.{0} Real (MonoidWithZero.toMulZeroOneClass.{0} Real (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))))))) (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real F (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField))))) (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (Module.toMulActionWithZero.{0, u1} Real F (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))) (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3))) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4))))) (Inv.inv.{0} Real Real.hasInv (Norm.norm.{u1} F (NormedAddCommGroup.toHasNorm.{u1} F _inst_3) x)) x) (SMul.smul.{0, u1} Real F (SMulZeroClass.toHasSmul.{0, u1} Real F (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (SMulWithZero.toSmulZeroClass.{0, u1} Real F (MulZeroClass.toHasZero.{0} Real (MulZeroOneClass.toMulZeroClass.{0} Real (MonoidWithZero.toMulZeroOneClass.{0} Real (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))))))) (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real F (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField))))) (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (Module.toMulActionWithZero.{0, u1} Real F (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))) (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3))) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4))))) (Inv.inv.{0} Real Real.hasInv (Norm.norm.{u1} F (NormedAddCommGroup.toHasNorm.{u1} F _inst_3) y)) y))
+but is expected to have type
+  forall {F : Type.{u1}} [_inst_3 : NormedAddCommGroup.{u1} F] [_inst_4 : NormedSpace.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)] {x : F} {y : F}, (Ne.{succ u1} F x (OfNat.ofNat.{u1} F 0 (Zero.toOfNat0.{u1} F (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3))))))))) -> (Ne.{succ u1} F y (OfNat.ofNat.{u1} F 0 (Zero.toOfNat0.{u1} F (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3))))))))) -> (SameRay.{0, u1} Real Real.strictOrderedCommSemiring F (AddCommGroup.toAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4) x y) -> (Eq.{succ u1} F (HSMul.hSMul.{0, u1, u1} Real F F (instHSMul.{0, u1} Real F (SMulZeroClass.toSMul.{0, u1} Real F (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (SMulWithZero.toSMulZeroClass.{0, u1} Real F Real.instZeroReal (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real F Real.instMonoidWithZeroReal (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (Module.toMulActionWithZero.{0, u1} Real F Real.semiring (AddCommGroup.toAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4)))))) (Inv.inv.{0} Real Real.instInvReal (Norm.norm.{u1} F (NormedAddCommGroup.toNorm.{u1} F _inst_3) x)) x) (HSMul.hSMul.{0, u1, u1} Real F F (instHSMul.{0, u1} Real F (SMulZeroClass.toSMul.{0, u1} Real F (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (SMulWithZero.toSMulZeroClass.{0, u1} Real F Real.instZeroReal (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real F Real.instMonoidWithZeroReal (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (Module.toMulActionWithZero.{0, u1} Real F Real.semiring (AddCommGroup.toAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4)))))) (Inv.inv.{0} Real Real.instInvReal (Norm.norm.{u1} F (NormedAddCommGroup.toNorm.{u1} F _inst_3) y)) y))
+Case conversion may be inaccurate. Consider using '#align same_ray.inv_norm_smul_eq SameRay.inv_norm_smul_eqₓ'. -/
 alias sameRay_iff_inv_norm_smul_eq_of_ne ↔ SameRay.inv_norm_smul_eq _
 #align same_ray.inv_norm_smul_eq SameRay.inv_norm_smul_eq
 
+/- warning: same_ray_iff_inv_norm_smul_eq -> sameRay_iff_inv_norm_smul_eq is a dubious translation:
+lean 3 declaration is
+  forall {F : Type.{u1}} [_inst_3 : NormedAddCommGroup.{u1} F] [_inst_4 : NormedSpace.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)] {x : F} {y : F}, Iff (SameRay.{0, u1} Real Real.strictOrderedCommSemiring F (AddCommGroup.toAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4) x y) (Or (Eq.{succ u1} F x (OfNat.ofNat.{u1} F 0 (OfNat.mk.{u1} F 0 (Zero.zero.{u1} F (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (SubNegMonoid.toAddMonoid.{u1} F (AddGroup.toSubNegMonoid.{u1} F (NormedAddGroup.toAddGroup.{u1} F (NormedAddCommGroup.toNormedAddGroup.{u1} F _inst_3)))))))))) (Or (Eq.{succ u1} F y (OfNat.ofNat.{u1} F 0 (OfNat.mk.{u1} F 0 (Zero.zero.{u1} F (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (SubNegMonoid.toAddMonoid.{u1} F (AddGroup.toSubNegMonoid.{u1} F (NormedAddGroup.toAddGroup.{u1} F (NormedAddCommGroup.toNormedAddGroup.{u1} F _inst_3)))))))))) (Eq.{succ u1} F (SMul.smul.{0, u1} Real F (SMulZeroClass.toHasSmul.{0, u1} Real F (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (SMulWithZero.toSmulZeroClass.{0, u1} Real F (MulZeroClass.toHasZero.{0} Real (MulZeroOneClass.toMulZeroClass.{0} Real (MonoidWithZero.toMulZeroOneClass.{0} Real (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))))))) (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real F (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField))))) (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (Module.toMulActionWithZero.{0, u1} Real F (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))) (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3))) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4))))) (Inv.inv.{0} Real Real.hasInv (Norm.norm.{u1} F (NormedAddCommGroup.toHasNorm.{u1} F _inst_3) x)) x) (SMul.smul.{0, u1} Real F (SMulZeroClass.toHasSmul.{0, u1} Real F (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (SMulWithZero.toSmulZeroClass.{0, u1} Real F (MulZeroClass.toHasZero.{0} Real (MulZeroOneClass.toMulZeroClass.{0} Real (MonoidWithZero.toMulZeroOneClass.{0} Real (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))))))) (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real F (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField))))) (AddZeroClass.toHasZero.{u1} F (AddMonoid.toAddZeroClass.{u1} F (AddCommMonoid.toAddMonoid.{u1} F (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)))))) (Module.toMulActionWithZero.{0, u1} Real F (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))) (AddCommGroup.toAddCommMonoid.{u1} F (SeminormedAddCommGroup.toAddCommGroup.{u1} F (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3))) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4))))) (Inv.inv.{0} Real Real.hasInv (Norm.norm.{u1} F (NormedAddCommGroup.toHasNorm.{u1} F _inst_3) y)) y))))
+but is expected to have type
+  forall {F : Type.{u1}} [_inst_3 : NormedAddCommGroup.{u1} F] [_inst_4 : NormedSpace.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3)] {x : F} {y : F}, Iff (SameRay.{0, u1} Real Real.strictOrderedCommSemiring F (AddCommGroup.toAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4) x y) (Or (Eq.{succ u1} F x (OfNat.ofNat.{u1} F 0 (Zero.toOfNat0.{u1} F (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3))))))))) (Or (Eq.{succ u1} F y (OfNat.ofNat.{u1} F 0 (Zero.toOfNat0.{u1} F (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3))))))))) (Eq.{succ u1} F (HSMul.hSMul.{0, u1, u1} Real F F (instHSMul.{0, u1} Real F (SMulZeroClass.toSMul.{0, u1} Real F (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (SMulWithZero.toSMulZeroClass.{0, u1} Real F Real.instZeroReal (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real F Real.instMonoidWithZeroReal (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (Module.toMulActionWithZero.{0, u1} Real F Real.semiring (AddCommGroup.toAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4)))))) (Inv.inv.{0} Real Real.instInvReal (Norm.norm.{u1} F (NormedAddCommGroup.toNorm.{u1} F _inst_3) x)) x) (HSMul.hSMul.{0, u1, u1} Real F F (instHSMul.{0, u1} Real F (SMulZeroClass.toSMul.{0, u1} Real F (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (SMulWithZero.toSMulZeroClass.{0, u1} Real F Real.instZeroReal (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real F Real.instMonoidWithZeroReal (NegZeroClass.toZero.{u1} F (SubNegZeroMonoid.toNegZeroClass.{u1} F (SubtractionMonoid.toSubNegZeroMonoid.{u1} F (SubtractionCommMonoid.toSubtractionMonoid.{u1} F (AddCommGroup.toDivisionAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)))))) (Module.toMulActionWithZero.{0, u1} Real F Real.semiring (AddCommGroup.toAddCommMonoid.{u1} F (NormedAddCommGroup.toAddCommGroup.{u1} F _inst_3)) (NormedSpace.toModule.{0, u1} Real F Real.normedField (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} F _inst_3) _inst_4)))))) (Inv.inv.{0} Real Real.instInvReal (Norm.norm.{u1} F (NormedAddCommGroup.toNorm.{u1} F _inst_3) y)) y))))
+Case conversion may be inaccurate. Consider using '#align same_ray_iff_inv_norm_smul_eq sameRay_iff_inv_norm_smul_eqₓ'. -/
 /-- Two vectors `x y` in a real normed space are on the ray if and only if one of them is zero or
 the unit vectors `‖x‖⁻¹ • x` and `‖y‖⁻¹ • y` are equal. -/
 theorem sameRay_iff_inv_norm_smul_eq : SameRay ℝ x y ↔ x = 0 ∨ y = 0 ∨ ‖x‖⁻¹ • x = ‖y‖⁻¹ • y :=
@@ -102,6 +148,7 @@ theorem sameRay_iff_inv_norm_smul_eq : SameRay ℝ x y ↔ x = 0 ∨ y = 0 ∨ 
   simp only [sameRay_iff_inv_norm_smul_eq_of_ne hx hy, *, false_or_iff]
 #align same_ray_iff_inv_norm_smul_eq sameRay_iff_inv_norm_smul_eq
 
+#print sameRay_iff_of_norm_eq /-
 /-- Two vectors of the same norm are on the same ray if and only if they are equal. -/
 theorem sameRay_iff_of_norm_eq (h : ‖x‖ = ‖y‖) : SameRay ℝ x y ↔ x = y :=
   by
@@ -110,18 +157,25 @@ theorem sameRay_iff_of_norm_eq (h : ‖x‖ = ‖y‖) : SameRay ℝ x y ↔ x =
     exact iff_of_true (SameRay.zero_right _) h
   · exact ⟨fun hxy => norm_injOn_ray_right hy hxy SameRay.rfl h, fun hxy => hxy ▸ SameRay.rfl⟩
 #align same_ray_iff_of_norm_eq sameRay_iff_of_norm_eq
+-/
 
+#print not_sameRay_iff_of_norm_eq /-
 theorem not_sameRay_iff_of_norm_eq (h : ‖x‖ = ‖y‖) : ¬SameRay ℝ x y ↔ x ≠ y :=
   (sameRay_iff_of_norm_eq h).Not
 #align not_same_ray_iff_of_norm_eq not_sameRay_iff_of_norm_eq
+-/
 
+#print SameRay.eq_of_norm_eq /-
 /-- If two points on the same ray have the same norm, then they are equal. -/
 theorem SameRay.eq_of_norm_eq (h : SameRay ℝ x y) (hn : ‖x‖ = ‖y‖) : x = y :=
   (sameRay_iff_of_norm_eq hn).mp h
 #align same_ray.eq_of_norm_eq SameRay.eq_of_norm_eq
+-/
 
+#print SameRay.norm_eq_iff /-
 /-- The norms of two vectors on the same ray are equal if and only if they are equal. -/
 theorem SameRay.norm_eq_iff (h : SameRay ℝ x y) : ‖x‖ = ‖y‖ ↔ x = y :=
   ⟨h.eq_of_norm_eq, fun h => h ▸ rfl⟩
 #align same_ray.norm_eq_iff SameRay.norm_eq_iff
+-/
 

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

@@ -43,7 +43,7 @@ theorem norm_sub (h : SameRay ℝ x y) : ‖x - y‖ = |‖x‖ - ‖y‖| :=
   by
   rcases h.exists_eq_smul with ⟨u, a, b, ha, hb, -, rfl, rfl⟩
   wlog hab : b ≤ a
-  · rw [sameRay_comm] at h
+  · rw [SameRay.sameRay_comm] at h
     rw [norm_sub_rev, abs_sub_comm]
     exact this u b a hb ha h (le_of_not_le hab)
   rw [← sub_nonneg] at hab
@@ -73,7 +73,7 @@ theorem norm_injOn_ray_left (hx : x ≠ 0) : { y | SameRay ℝ x y }.InjOn norm
 #align norm_inj_on_ray_left norm_injOn_ray_left
 
 theorem norm_injOn_ray_right (hy : y ≠ 0) : { x | SameRay ℝ x y }.InjOn norm := by
-  simpa only [sameRay_comm] using norm_injOn_ray_left hy
+  simpa only [SameRay.sameRay_comm] using norm_injOn_ray_left hy
 #align norm_inj_on_ray_right norm_injOn_ray_right
 
 theorem sameRay_iff_norm_smul_eq : SameRay ℝ x y ↔ ‖x‖ • y = ‖y‖ • x :=

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

This way we don't switch between general normed spaces and real normed spaces back and forth throughout the file.

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov, Yaël Dillies
 -/
 import Mathlib.LinearAlgebra.Ray
-import Mathlib.Analysis.NormedSpace.Basic
+import Mathlib.Analysis.NormedSpace.Real
 
 #align_import analysis.normed_space.ray from "leanprover-community/mathlib"@"92ca63f0fb391a9ca5f22d2409a6080e786d99f7"
 

We have turned to Type* instead of Type _, but many of them remained in mathlib because the straight replacement did not work. In general, having Type _ before the colon is a code smell, though, as it hides which types should be in the same universe and which shouldn't, and is not very robust.

This PR replaces most of the remaining Type _ before the colon (except those in category theory) by Type* or Type u. This has uncovered a few bugs (where declarations were not as polymorphic as they should be).

I had to increase heartbeats at two places when replacing Type _ by Type*, but I think it's worth it as it's really more robust.

@@ -19,8 +19,8 @@ norms and `‖y‖ • x = ‖x‖ • y`.
 
 open Real
 
-variable {E : Type*} [SeminormedAddCommGroup E] [NormedSpace ℝ E] {F : Type _}
-  [NormedAddCommGroup F] [NormedSpace ℝ F]
+variable {E : Type*} [SeminormedAddCommGroup E] [NormedSpace ℝ E] {F : Type*}
+[NormedAddCommGroup F] [NormedSpace ℝ F]
 
 namespace SameRay
 
@@ -37,11 +37,10 @@ theorem norm_add (h : SameRay ℝ x y) : ‖x + y‖ = ‖x‖ + ‖y‖ := by
 
 theorem norm_sub (h : SameRay ℝ x y) : ‖x - y‖ = |‖x‖ - ‖y‖| := by
   rcases h.exists_eq_smul with ⟨u, a, b, ha, hb, -, rfl, rfl⟩
-  wlog hab : b ≤ a with H
+  wlog hab : b ≤ a generalizing a b with H
   · rw [SameRay.sameRay_comm] at h
     rw [norm_sub_rev, abs_sub_comm]
-    have := @H E _ _ ℝ
-    exact this u b a hb ha h (le_of_not_le hab)
+    exact H b a hb ha h (le_of_not_le hab)
   rw [← sub_nonneg] at hab
   rw [← sub_smul, norm_smul_of_nonneg hab, norm_smul_of_nonneg ha, norm_smul_of_nonneg hb, ←
     sub_mul, abs_of_nonneg (mul_nonneg hab (norm_nonneg _))]

@@ -84,7 +84,7 @@ theorem sameRay_iff_inv_norm_smul_eq_of_ne (hx : x ≠ 0) (hy : y ≠ 0) :
     rwa [norm_ne_zero_iff]
 #align same_ray_iff_inv_norm_smul_eq_of_ne sameRay_iff_inv_norm_smul_eq_of_ne
 
-alias sameRay_iff_inv_norm_smul_eq_of_ne ↔ SameRay.inv_norm_smul_eq _
+alias ⟨SameRay.inv_norm_smul_eq, _⟩ := sameRay_iff_inv_norm_smul_eq_of_ne
 #align same_ray.inv_norm_smul_eq SameRay.inv_norm_smul_eq
 
 /-- Two vectors `x y` in a real normed space are on the ray if and only if one of them is zero or

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

This has nice performance benefits.

@@ -19,7 +19,7 @@ norms and `‖y‖ • x = ‖x‖ • y`.
 
 open Real
 
-variable {E : Type _} [SeminormedAddCommGroup E] [NormedSpace ℝ E] {F : Type _}
+variable {E : Type*} [SeminormedAddCommGroup E] [NormedSpace ℝ E] {F : Type _}
   [NormedAddCommGroup F] [NormedSpace ℝ F]
 
 namespace SameRay

• depends on: #5966

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

@@ -2,15 +2,12 @@
 Copyright (c) 2022 Yury Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov, Yaël Dillies
-
-! This file was ported from Lean 3 source module analysis.normed_space.ray
-! leanprover-community/mathlib commit 92ca63f0fb391a9ca5f22d2409a6080e786d99f7
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.LinearAlgebra.Ray
 import Mathlib.Analysis.NormedSpace.Basic
 
+#align_import analysis.normed_space.ray from "leanprover-community/mathlib"@"92ca63f0fb391a9ca5f22d2409a6080e786d99f7"
+
 /-!
 # Rays in a real normed vector space
 

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

@@ -14,7 +14,7 @@ import Mathlib.Analysis.NormedSpace.Basic
 /-!
 # Rays in a real normed vector space
 
-In this file we prove some lemmas about the `same_ray` predicate in case of a real normed space. In
+In this file we prove some lemmas about the `SameRay` predicate in case of a real normed space. In
 this case, for two vectors `x y` in the same ray, the norm of their sum is equal to the sum of their
 norms and `‖y‖ • x = ‖x‖ • y`.
 -/

Co-authored-by: Eric Rodriguez <37984851+ericrbg@users.noreply.github.com>

@@ -43,7 +43,7 @@ theorem norm_sub (h : SameRay ℝ x y) : ‖x - y‖ = |‖x‖ - ‖y‖| := by
   wlog hab : b ≤ a with H
   · rw [SameRay.sameRay_comm] at h
     rw [norm_sub_rev, abs_sub_comm]
-    have := @H E _ _ F
+    have := @H E _ _ ℝ
     exact this u b a hb ha h (le_of_not_le hab)
   rw [← sub_nonneg] at hab
   rw [← sub_smul, norm_smul_of_nonneg hab, norm_smul_of_nonneg ha, norm_smul_of_nonneg hb, ←

This makes a mathlib4 version of mathlib3's tactic.basic, now called Mathlib.Tactic.Common, which imports all tactics which do not have significant theory requirements, and then is imported all across the base of the hierarchy.

This ensures that all common tactics are available nearly everywhere in the library, rather than having to be imported one-by-one as you need them.

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

@@ -10,7 +10,6 @@ Authors: Yury Kudryashov, Yaël Dillies
 -/
 import Mathlib.LinearAlgebra.Ray
 import Mathlib.Analysis.NormedSpace.Basic
-import Mathlib.Tactic.WLOG
 
 /-!
 # Rays in a real normed vector space

• feat: port Analysis.NormedSpace.Ray
• Initial file copy from mathport
• automated fixes
• nearly done

Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com>