algebra.add_torsor ⟷ Mathlib.Algebra.AddTorsor

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

@@ -3,7 +3,7 @@ Copyright (c) 2020 Joseph Myers. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Joseph Myers, Yury Kudryashov
 -/
-import Data.Set.Pointwise.Smul
+import Data.Set.Pointwise.SMul
 
 #align_import algebra.add_torsor from "leanprover-community/mathlib"@"3e32bc908f617039c74c06ea9a897e30c30803c2"
 
@@ -68,7 +68,7 @@ instance addGroupIsAddTorsor (G : Type _) [AddGroup G] : AddTorsor G G
     where
   vsub := Sub.sub
   vsub_vadd' := sub_add_cancel
-  vadd_vsub' := add_sub_cancel
+  vadd_vsub' := add_sub_cancel_right
 #align add_group_is_add_torsor addGroupIsAddTorsor
 -/
 
@@ -315,7 +315,7 @@ theorem vsub_sub_vsub_cancel_left (p1 p2 p3 : P) : p3 -ᵥ p2 - (p3 -ᵥ p1) = p
 #print vadd_vsub_vadd_cancel_left /-
 @[simp]
 theorem vadd_vsub_vadd_cancel_left (v : G) (p1 p2 : P) : v +ᵥ p1 -ᵥ (v +ᵥ p2) = p1 -ᵥ p2 := by
-  rw [vsub_vadd_eq_vsub_sub, vadd_vsub_assoc, add_sub_cancel']
+  rw [vsub_vadd_eq_vsub_sub, vadd_vsub_assoc, add_sub_cancel_left]
 #align vadd_vsub_vadd_cancel_left vadd_vsub_vadd_cancel_left
 -/
 

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

@@ -251,7 +251,7 @@ theorem vadd_vsub_vadd_cancel_right (v₁ v₂ : G) (p : P) : v₁ +ᵥ p -ᵥ (
 /-- If the same point subtracted from two points produces equal
 results, those points are equal. -/
 theorem vsub_left_cancel {p1 p2 p : P} (h : p1 -ᵥ p = p2 -ᵥ p) : p1 = p2 := by
-  rwa [← sub_eq_zero, vsub_sub_vsub_cancel_right, vsub_eq_zero_iff_eq] at h 
+  rwa [← sub_eq_zero, vsub_sub_vsub_cancel_right, vsub_eq_zero_iff_eq] at h
 #align vsub_left_cancel vsub_left_cancel
 -/
 
@@ -576,7 +576,7 @@ theorem injective_pointReflection_left_of_injective_bit0 {G P : Type _} [AddComm
   fun x₁ x₂ (hy : pointReflection x₁ y = pointReflection x₂ y) => by
   rwa [point_reflection_apply, point_reflection_apply, vadd_eq_vadd_iff_sub_eq_vsub,
     vsub_sub_vsub_cancel_right, ← neg_vsub_eq_vsub_rev, neg_eq_iff_add_eq_zero, ← bit0, ← bit0_zero,
-    h.eq_iff, vsub_eq_zero_iff_eq] at hy 
+    h.eq_iff, vsub_eq_zero_iff_eq] at hy
 #align equiv.injective_point_reflection_left_of_injective_bit0 Equiv.injective_pointReflection_left_of_injective_bit0
 -/
 

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

@@ -3,7 +3,7 @@ Copyright (c) 2020 Joseph Myers. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Joseph Myers, Yury Kudryashov
 -/
-import Mathbin.Data.Set.Pointwise.Smul
+import Data.Set.Pointwise.Smul
 
 #align_import algebra.add_torsor from "leanprover-community/mathlib"@"3e32bc908f617039c74c06ea9a897e30c30803c2"
 

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

@@ -2,14 +2,11 @@
 Copyright (c) 2020 Joseph Myers. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Joseph Myers, Yury Kudryashov
-
-! This file was ported from Lean 3 source module algebra.add_torsor
-! leanprover-community/mathlib commit 3e32bc908f617039c74c06ea9a897e30c30803c2
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Set.Pointwise.Smul
 
+#align_import algebra.add_torsor from "leanprover-community/mathlib"@"3e32bc908f617039c74c06ea9a897e30c30803c2"
+
 /-!
 # Torsors of additive group actions
 

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

@@ -75,19 +75,19 @@ instance addGroupIsAddTorsor (G : Type _) [AddGroup G] : AddTorsor G G
 #align add_group_is_add_torsor addGroupIsAddTorsor
 -/
 
+#print vsub_eq_sub /-
 /-- Simplify subtraction for a torsor for an `add_group G` over
 itself. -/
 @[simp]
 theorem vsub_eq_sub {G : Type _} [AddGroup G] (g1 g2 : G) : g1 -ᵥ g2 = g1 - g2 :=
   rfl
 #align vsub_eq_sub vsub_eq_sub
+-/
 
 section General
 
 variable {G : Type _} {P : Type _} [AddGroup G] [T : AddTorsor G P]
 
-include T
-
 #print vsub_vadd /-
 /-- Adding the result of subtracting from another point produces that
 point. -/
@@ -97,12 +97,14 @@ theorem vsub_vadd (p1 p2 : P) : p1 -ᵥ p2 +ᵥ p2 = p1 :=
 #align vsub_vadd vsub_vadd
 -/
 
+#print vadd_vsub /-
 /-- Adding a group element then subtracting the original point
 produces that group element. -/
 @[simp]
 theorem vadd_vsub (g : G) (p : P) : g +ᵥ p -ᵥ p = g :=
   AddTorsor.vadd_vsub' g p
 #align vadd_vsub vadd_vsub
+-/
 
 #print vadd_right_cancel /-
 /-- If the same point added to two group elements produces equal
@@ -119,12 +121,15 @@ theorem vadd_right_cancel_iff {g1 g2 : G} (p : P) : g1 +ᵥ p = g2 +ᵥ p ↔ g1
 #align vadd_right_cancel_iff vadd_right_cancel_iff
 -/
 
+#print vadd_right_injective /-
 /-- Adding a group element to the point `p` is an injective
 function. -/
 theorem vadd_right_injective (p : P) : Function.Injective ((· +ᵥ p) : G → P) := fun g1 g2 =>
   vadd_right_cancel p
 #align vadd_right_injective vadd_right_injective
+-/
 
+#print vadd_vsub_assoc /-
 /-- Adding a group element to a point, then subtracting another point,
 produces the same result as subtracting the points then adding the
 group element. -/
@@ -133,29 +138,39 @@ theorem vadd_vsub_assoc (g : G) (p1 p2 : P) : g +ᵥ p1 -ᵥ p2 = g + (p1 -ᵥ p
   apply vadd_right_cancel p2
   rw [vsub_vadd, add_vadd, vsub_vadd]
 #align vadd_vsub_assoc vadd_vsub_assoc
+-/
 
+#print vsub_self /-
 /-- Subtracting a point from itself produces 0. -/
 @[simp]
 theorem vsub_self (p : P) : p -ᵥ p = (0 : G) := by
   rw [← zero_add (p -ᵥ p), ← vadd_vsub_assoc, vadd_vsub]
 #align vsub_self vsub_self
+-/
 
+#print eq_of_vsub_eq_zero /-
 /-- If subtracting two points produces 0, they are equal. -/
 theorem eq_of_vsub_eq_zero {p1 p2 : P} (h : p1 -ᵥ p2 = (0 : G)) : p1 = p2 := by
   rw [← vsub_vadd p1 p2, h, zero_vadd]
 #align eq_of_vsub_eq_zero eq_of_vsub_eq_zero
+-/
 
+#print vsub_eq_zero_iff_eq /-
 /-- Subtracting two points produces 0 if and only if they are
 equal. -/
 @[simp]
 theorem vsub_eq_zero_iff_eq {p1 p2 : P} : p1 -ᵥ p2 = (0 : G) ↔ p1 = p2 :=
   Iff.intro eq_of_vsub_eq_zero fun h => h ▸ vsub_self _
 #align vsub_eq_zero_iff_eq vsub_eq_zero_iff_eq
+-/
 
+#print vsub_ne_zero /-
 theorem vsub_ne_zero {p q : P} : p -ᵥ q ≠ (0 : G) ↔ p ≠ q :=
   not_congr vsub_eq_zero_iff_eq
 #align vsub_ne_zero vsub_ne_zero
+-/
 
+#print vsub_add_vsub_cancel /-
 /-- Cancellation adding the results of two subtractions. -/
 @[simp]
 theorem vsub_add_vsub_cancel (p1 p2 p3 : P) : p1 -ᵥ p2 + (p2 -ᵥ p3) = p1 -ᵥ p3 :=
@@ -163,7 +178,9 @@ theorem vsub_add_vsub_cancel (p1 p2 p3 : P) : p1 -ᵥ p2 + (p2 -ᵥ p3) = p1 -
   apply vadd_right_cancel p3
   rw [add_vadd, vsub_vadd, vsub_vadd, vsub_vadd]
 #align vsub_add_vsub_cancel vsub_add_vsub_cancel
+-/
 
+#print neg_vsub_eq_vsub_rev /-
 /-- Subtracting two points in the reverse order produces the negation
 of subtracting them. -/
 @[simp]
@@ -172,23 +189,30 @@ theorem neg_vsub_eq_vsub_rev (p1 p2 : P) : -(p1 -ᵥ p2) = p2 -ᵥ p1 :=
   refine' neg_eq_of_add_eq_zero_right (vadd_right_cancel p1 _)
   rw [vsub_add_vsub_cancel, vsub_self]
 #align neg_vsub_eq_vsub_rev neg_vsub_eq_vsub_rev
+-/
 
+#print vadd_vsub_eq_sub_vsub /-
 theorem vadd_vsub_eq_sub_vsub (g : G) (p q : P) : g +ᵥ p -ᵥ q = g - (q -ᵥ p) := by
   rw [vadd_vsub_assoc, sub_eq_add_neg, neg_vsub_eq_vsub_rev]
 #align vadd_vsub_eq_sub_vsub vadd_vsub_eq_sub_vsub
+-/
 
+#print vsub_vadd_eq_vsub_sub /-
 /-- Subtracting the result of adding a group element produces the same result
 as subtracting the points and subtracting that group element. -/
 theorem vsub_vadd_eq_vsub_sub (p1 p2 : P) (g : G) : p1 -ᵥ (g +ᵥ p2) = p1 -ᵥ p2 - g := by
   rw [← add_right_inj (p2 -ᵥ p1 : G), vsub_add_vsub_cancel, ← neg_vsub_eq_vsub_rev, vadd_vsub, ←
     add_sub_assoc, ← neg_vsub_eq_vsub_rev, neg_add_self, zero_sub]
 #align vsub_vadd_eq_vsub_sub vsub_vadd_eq_vsub_sub
+-/
 
+#print vsub_sub_vsub_cancel_right /-
 /-- Cancellation subtracting the results of two subtractions. -/
 @[simp]
 theorem vsub_sub_vsub_cancel_right (p1 p2 p3 : P) : p1 -ᵥ p3 - (p2 -ᵥ p3) = p1 -ᵥ p2 := by
   rw [← vsub_vadd_eq_vsub_sub, vsub_vadd]
 #align vsub_sub_vsub_cancel_right vsub_sub_vsub_cancel_right
+-/
 
 #print eq_vadd_iff_vsub_eq /-
 /-- Convert between an equality with adding a group element to a point
@@ -199,39 +223,49 @@ theorem eq_vadd_iff_vsub_eq (p1 : P) (g : G) (p2 : P) : p1 = g +ᵥ p2 ↔ p1 -
 #align eq_vadd_iff_vsub_eq eq_vadd_iff_vsub_eq
 -/
 
+#print vadd_eq_vadd_iff_neg_add_eq_vsub /-
 theorem vadd_eq_vadd_iff_neg_add_eq_vsub {v₁ v₂ : G} {p₁ p₂ : P} :
     v₁ +ᵥ p₁ = v₂ +ᵥ p₂ ↔ -v₁ + v₂ = p₁ -ᵥ p₂ := by
   rw [eq_vadd_iff_vsub_eq, vadd_vsub_assoc, ← add_right_inj (-v₁), neg_add_cancel_left, eq_comm]
 #align vadd_eq_vadd_iff_neg_add_eq_vsub vadd_eq_vadd_iff_neg_add_eq_vsub
+-/
 
 namespace Set
 
 open scoped Pointwise
 
+#print Set.singleton_vsub_self /-
 @[simp]
 theorem singleton_vsub_self (p : P) : ({p} : Set P) -ᵥ {p} = {(0 : G)} := by
   rw [Set.singleton_vsub_singleton, vsub_self]
 #align set.singleton_vsub_self Set.singleton_vsub_self
+-/
 
 end Set
 
+#print vadd_vsub_vadd_cancel_right /-
 @[simp]
 theorem vadd_vsub_vadd_cancel_right (v₁ v₂ : G) (p : P) : v₁ +ᵥ p -ᵥ (v₂ +ᵥ p) = v₁ - v₂ := by
   rw [vsub_vadd_eq_vsub_sub, vadd_vsub_assoc, vsub_self, add_zero]
 #align vadd_vsub_vadd_cancel_right vadd_vsub_vadd_cancel_right
+-/
 
+#print vsub_left_cancel /-
 /-- If the same point subtracted from two points produces equal
 results, those points are equal. -/
 theorem vsub_left_cancel {p1 p2 p : P} (h : p1 -ᵥ p = p2 -ᵥ p) : p1 = p2 := by
   rwa [← sub_eq_zero, vsub_sub_vsub_cancel_right, vsub_eq_zero_iff_eq] at h 
 #align vsub_left_cancel vsub_left_cancel
+-/
 
+#print vsub_left_cancel_iff /-
 /-- The same point subtracted from two points produces equal results
 if and only if those points are equal. -/
 @[simp]
 theorem vsub_left_cancel_iff {p1 p2 p : P} : p1 -ᵥ p = p2 -ᵥ p ↔ p1 = p2 :=
   ⟨vsub_left_cancel, fun h => h ▸ rfl⟩
 #align vsub_left_cancel_iff vsub_left_cancel_iff
+-/
 
 #print vsub_left_injective /-
 /-- Subtracting the point `p` is an injective function. -/
@@ -240,6 +274,7 @@ theorem vsub_left_injective (p : P) : Function.Injective ((· -ᵥ p) : P → G)
 #align vsub_left_injective vsub_left_injective
 -/
 
+#print vsub_right_cancel /-
 /-- If subtracting two points from the same point produces equal
 results, those points are equal. -/
 theorem vsub_right_cancel {p1 p2 p : P} (h : p -ᵥ p1 = p -ᵥ p2) : p1 = p2 :=
@@ -247,13 +282,16 @@ theorem vsub_right_cancel {p1 p2 p : P} (h : p -ᵥ p1 = p -ᵥ p2) : p1 = p2 :=
   refine' vadd_left_cancel (p -ᵥ p2) _
   rw [vsub_vadd, ← h, vsub_vadd]
 #align vsub_right_cancel vsub_right_cancel
+-/
 
+#print vsub_right_cancel_iff /-
 /-- Subtracting two points from the same point produces equal results
 if and only if those points are equal. -/
 @[simp]
 theorem vsub_right_cancel_iff {p1 p2 p : P} : p -ᵥ p1 = p -ᵥ p2 ↔ p1 = p2 :=
   ⟨vsub_right_cancel, fun h => h ▸ rfl⟩
 #align vsub_right_cancel_iff vsub_right_cancel_iff
+-/
 
 #print vsub_right_injective /-
 /-- Subtracting a point from the point `p` is an injective
@@ -269,18 +307,20 @@ section comm
 
 variable {G : Type _} {P : Type _} [AddCommGroup G] [AddTorsor G P]
 
-include G
-
+#print vsub_sub_vsub_cancel_left /-
 /-- Cancellation subtracting the results of two subtractions. -/
 @[simp]
 theorem vsub_sub_vsub_cancel_left (p1 p2 p3 : P) : p3 -ᵥ p2 - (p3 -ᵥ p1) = p1 -ᵥ p2 := by
   rw [sub_eq_add_neg, neg_vsub_eq_vsub_rev, add_comm, vsub_add_vsub_cancel]
 #align vsub_sub_vsub_cancel_left vsub_sub_vsub_cancel_left
+-/
 
+#print vadd_vsub_vadd_cancel_left /-
 @[simp]
 theorem vadd_vsub_vadd_cancel_left (v : G) (p1 p2 : P) : v +ᵥ p1 -ᵥ (v +ᵥ p2) = p1 -ᵥ p2 := by
   rw [vsub_vadd_eq_vsub_sub, vadd_vsub_assoc, add_sub_cancel']
 #align vadd_vsub_vadd_cancel_left vadd_vsub_vadd_cancel_left
+-/
 
 #print vsub_vadd_comm /-
 theorem vsub_vadd_comm (p1 p2 p3 : P) : (p1 -ᵥ p2 : G) +ᵥ p3 = p3 -ᵥ p2 +ᵥ p1 :=
@@ -290,14 +330,18 @@ theorem vsub_vadd_comm (p1 p2 p3 : P) : (p1 -ᵥ p2 : G) +ᵥ p3 = p3 -ᵥ p2 +
 #align vsub_vadd_comm vsub_vadd_comm
 -/
 
+#print vadd_eq_vadd_iff_sub_eq_vsub /-
 theorem vadd_eq_vadd_iff_sub_eq_vsub {v₁ v₂ : G} {p₁ p₂ : P} :
     v₁ +ᵥ p₁ = v₂ +ᵥ p₂ ↔ v₂ - v₁ = p₁ -ᵥ p₂ := by
   rw [vadd_eq_vadd_iff_neg_add_eq_vsub, neg_add_eq_sub]
 #align vadd_eq_vadd_iff_sub_eq_vsub vadd_eq_vadd_iff_sub_eq_vsub
+-/
 
+#print vsub_sub_vsub_comm /-
 theorem vsub_sub_vsub_comm (p₁ p₂ p₃ p₄ : P) : p₁ -ᵥ p₂ - (p₃ -ᵥ p₄) = p₁ -ᵥ p₃ - (p₂ -ᵥ p₄) := by
   rw [← vsub_vadd_eq_vsub_sub, vsub_vadd_comm, vsub_vadd_eq_vsub_sub]
 #align vsub_sub_vsub_comm vsub_sub_vsub_comm
+-/
 
 end comm
 
@@ -316,36 +360,48 @@ instance : AddTorsor (G × G') (P × P')
   vsub_vadd' p₁ p₂ := show (p₁.1 -ᵥ p₂.1 +ᵥ p₂.1, _) = p₁ by simp
   vadd_vsub' v p := show (v.1 +ᵥ p.1 -ᵥ p.1, v.2 +ᵥ p.2 -ᵥ p.2) = v by simp
 
+#print Prod.fst_vadd /-
 @[simp]
 theorem fst_vadd (v : G × G') (p : P × P') : (v +ᵥ p).1 = v.1 +ᵥ p.1 :=
   rfl
 #align prod.fst_vadd Prod.fst_vadd
+-/
 
+#print Prod.snd_vadd /-
 @[simp]
 theorem snd_vadd (v : G × G') (p : P × P') : (v +ᵥ p).2 = v.2 +ᵥ p.2 :=
   rfl
 #align prod.snd_vadd Prod.snd_vadd
+-/
 
+#print Prod.mk_vadd_mk /-
 @[simp]
 theorem mk_vadd_mk (v : G) (v' : G') (p : P) (p' : P') : (v, v') +ᵥ (p, p') = (v +ᵥ p, v' +ᵥ p') :=
   rfl
 #align prod.mk_vadd_mk Prod.mk_vadd_mk
+-/
 
+#print Prod.fst_vsub /-
 @[simp]
 theorem fst_vsub (p₁ p₂ : P × P') : (p₁ -ᵥ p₂ : G × G').1 = p₁.1 -ᵥ p₂.1 :=
   rfl
 #align prod.fst_vsub Prod.fst_vsub
+-/
 
+#print Prod.snd_vsub /-
 @[simp]
 theorem snd_vsub (p₁ p₂ : P × P') : (p₁ -ᵥ p₂ : G × G').2 = p₁.2 -ᵥ p₂.2 :=
   rfl
 #align prod.snd_vsub Prod.snd_vsub
+-/
 
+#print Prod.mk_vsub_mk /-
 @[simp]
 theorem mk_vsub_mk (p₁ p₂ : P) (p₁' p₂' : P') :
     ((p₁, p₁') -ᵥ (p₂, p₂') : G × G') = (p₁ -ᵥ p₂, p₁' -ᵥ p₂') :=
   rfl
 #align prod.mk_vsub_mk Prod.mk_vsub_mk
+-/
 
 end Prod
 
@@ -374,8 +430,6 @@ namespace Equiv
 
 variable {G : Type _} {P : Type _} [AddGroup G] [AddTorsor G P]
 
-include G
-
 #print Equiv.vaddConst /-
 /-- `v ↦ v +ᵥ p` as an equivalence. -/
 def vaddConst (p : P) : G ≃ P where
@@ -386,15 +440,19 @@ def vaddConst (p : P) : G ≃ P where
 #align equiv.vadd_const Equiv.vaddConst
 -/
 
+#print Equiv.coe_vaddConst /-
 @[simp]
 theorem coe_vaddConst (p : P) : ⇑(vaddConst p) = fun v => v +ᵥ p :=
   rfl
 #align equiv.coe_vadd_const Equiv.coe_vaddConst
+-/
 
+#print Equiv.coe_vaddConst_symm /-
 @[simp]
 theorem coe_vaddConst_symm (p : P) : ⇑(vaddConst p).symm = fun p' => p' -ᵥ p :=
   rfl
 #align equiv.coe_vadd_const_symm Equiv.coe_vaddConst_symm
+-/
 
 #print Equiv.constVSub /-
 /-- `p' ↦ p -ᵥ p'` as an equivalence. -/
@@ -406,15 +464,19 @@ def constVSub (p : P) : P ≃ G where
 #align equiv.const_vsub Equiv.constVSub
 -/
 
+#print Equiv.coe_constVSub /-
 @[simp]
 theorem coe_constVSub (p : P) : ⇑(constVSub p) = (· -ᵥ ·) p :=
   rfl
 #align equiv.coe_const_vsub Equiv.coe_constVSub
+-/
 
+#print Equiv.coe_constVSub_symm /-
 @[simp]
 theorem coe_constVSub_symm (p : P) : ⇑(constVSub p).symm = fun v => -v +ᵥ p :=
   rfl
 #align equiv.coe_const_vsub_symm Equiv.coe_constVSub_symm
+-/
 
 variable (P)
 
@@ -437,17 +499,21 @@ theorem coe_constVAdd (v : G) : ⇑(constVAdd P v) = (· +ᵥ ·) v :=
 
 variable (G)
 
+#print Equiv.constVAdd_zero /-
 @[simp]
 theorem constVAdd_zero : constVAdd P (0 : G) = 1 :=
   ext <| zero_vadd G
 #align equiv.const_vadd_zero Equiv.constVAdd_zero
+-/
 
 variable {G}
 
+#print Equiv.constVAdd_add /-
 @[simp]
 theorem constVAdd_add (v₁ v₂ : G) : constVAdd P (v₁ + v₂) = constVAdd P v₁ * constVAdd P v₂ :=
   ext <| add_vadd v₁ v₂
 #align equiv.const_vadd_add Equiv.constVAdd_add
+-/
 
 #print Equiv.constVAddHom /-
 /-- `equiv.const_vadd` as a homomorphism from `multiplicative G` to `equiv.perm P` -/
@@ -496,6 +562,7 @@ theorem pointReflection_involutive (x : P) : Involutive (pointReflection x : P 
 #align equiv.point_reflection_involutive Equiv.pointReflection_involutive
 -/
 
+#print Equiv.pointReflection_fixed_iff_of_injective_bit0 /-
 /-- `x` is the only fixed point of `point_reflection x`. This lemma requires
 `x + x = y + y ↔ x = y`. There is no typeclass to use here, so we add it as an explicit argument. -/
 theorem pointReflection_fixed_iff_of_injective_bit0 {x y : P} (h : Injective (bit0 : G → G)) :
@@ -503,9 +570,9 @@ theorem pointReflection_fixed_iff_of_injective_bit0 {x y : P} (h : Injective (bi
   rw [point_reflection_apply, eq_comm, eq_vadd_iff_vsub_eq, ← neg_vsub_eq_vsub_rev,
     neg_eq_iff_add_eq_zero, ← bit0, ← bit0_zero, h.eq_iff, vsub_eq_zero_iff_eq, eq_comm]
 #align equiv.point_reflection_fixed_iff_of_injective_bit0 Equiv.pointReflection_fixed_iff_of_injective_bit0
+-/
 
-omit G
-
+#print Equiv.injective_pointReflection_left_of_injective_bit0 /-
 theorem injective_pointReflection_left_of_injective_bit0 {G P : Type _} [AddCommGroup G]
     [AddTorsor G P] (h : Injective (bit0 : G → G)) (y : P) :
     Injective fun x : P => pointReflection x y :=
@@ -514,12 +581,15 @@ theorem injective_pointReflection_left_of_injective_bit0 {G P : Type _} [AddComm
     vsub_sub_vsub_cancel_right, ← neg_vsub_eq_vsub_rev, neg_eq_iff_add_eq_zero, ← bit0, ← bit0_zero,
     h.eq_iff, vsub_eq_zero_iff_eq] at hy 
 #align equiv.injective_point_reflection_left_of_injective_bit0 Equiv.injective_pointReflection_left_of_injective_bit0
+-/
 
 end Equiv
 
+#print AddTorsor.subsingleton_iff /-
 theorem AddTorsor.subsingleton_iff (G P : Type _) [AddGroup G] [AddTorsor G P] :
     Subsingleton G ↔ Subsingleton P := by
   inhabit P
   exact (Equiv.vaddConst default).subsingleton_congr
 #align add_torsor.subsingleton_iff AddTorsor.subsingleton_iff
+-/
 

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

@@ -53,7 +53,7 @@ by the `+ᵥ` operation and a corresponding subtraction given by the
 `-ᵥ` operation. In the case of a vector space, it is an affine
 space. -/
 class AddTorsor (G : outParam (Type _)) (P : Type _) [outParam <| AddGroup G] extends AddAction G P,
-  VSub G P where
+    VSub G P where
   [Nonempty : Nonempty P]
   vsub_vadd' : ∀ p1 p2 : P, (p1 -ᵥ p2 : G) +ᵥ p2 = p1
   vadd_vsub' : ∀ (g : G) (p : P), g +ᵥ p -ᵥ p = g
@@ -223,7 +223,7 @@ theorem vadd_vsub_vadd_cancel_right (v₁ v₂ : G) (p : P) : v₁ +ᵥ p -ᵥ (
 /-- If the same point subtracted from two points produces equal
 results, those points are equal. -/
 theorem vsub_left_cancel {p1 p2 p : P} (h : p1 -ᵥ p = p2 -ᵥ p) : p1 = p2 := by
-  rwa [← sub_eq_zero, vsub_sub_vsub_cancel_right, vsub_eq_zero_iff_eq] at h
+  rwa [← sub_eq_zero, vsub_sub_vsub_cancel_right, vsub_eq_zero_iff_eq] at h 
 #align vsub_left_cancel vsub_left_cancel
 
 /-- The same point subtracted from two points produces equal results
@@ -512,7 +512,7 @@ theorem injective_pointReflection_left_of_injective_bit0 {G P : Type _} [AddComm
   fun x₁ x₂ (hy : pointReflection x₁ y = pointReflection x₂ y) => by
   rwa [point_reflection_apply, point_reflection_apply, vadd_eq_vadd_iff_sub_eq_vsub,
     vsub_sub_vsub_cancel_right, ← neg_vsub_eq_vsub_rev, neg_eq_iff_add_eq_zero, ← bit0, ← bit0_zero,
-    h.eq_iff, vsub_eq_zero_iff_eq] at hy
+    h.eq_iff, vsub_eq_zero_iff_eq] at hy 
 #align equiv.injective_point_reflection_left_of_injective_bit0 Equiv.injective_pointReflection_left_of_injective_bit0
 
 end Equiv

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

@@ -206,7 +206,7 @@ theorem vadd_eq_vadd_iff_neg_add_eq_vsub {v₁ v₂ : G} {p₁ p₂ : P} :
 
 namespace Set
 
-open Pointwise
+open scoped Pointwise
 
 @[simp]
 theorem singleton_vsub_self (p : P) : ({p} : Set P) -ᵥ {p} = {(0 : G)} := by

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

@@ -75,12 +75,6 @@ instance addGroupIsAddTorsor (G : Type _) [AddGroup G] : AddTorsor G G
 #align add_group_is_add_torsor addGroupIsAddTorsor
 -/
 
-/- warning: vsub_eq_sub -> vsub_eq_sub is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : AddGroup.{u1} G] (g1 : G) (g2 : G), Eq.{succ u1} G (VSub.vsub.{u1, u1} G G (AddTorsor.toHasVsub.{u1, u1} G G _inst_1 (addGroupIsAddTorsor.{u1} G _inst_1)) g1 g2) (HSub.hSub.{u1, u1, u1} G G G (instHSub.{u1} G (SubNegMonoid.toHasSub.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1))) g1 g2)
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : AddGroup.{u1} G] (g1 : G) (g2 : G), Eq.{succ u1} G (VSub.vsub.{u1, u1} G G (AddTorsor.toVSub.{u1, u1} G G _inst_1 (addGroupIsAddTorsor.{u1} G _inst_1)) g1 g2) (HSub.hSub.{u1, u1, u1} G G G (instHSub.{u1} G (SubNegMonoid.toSub.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1))) g1 g2)
-Case conversion may be inaccurate. Consider using '#align vsub_eq_sub vsub_eq_subₓ'. -/
 /-- Simplify subtraction for a torsor for an `add_group G` over
 itself. -/
 @[simp]
@@ -103,12 +97,6 @@ theorem vsub_vadd (p1 p2 : P) : p1 -ᵥ p2 +ᵥ p2 = p1 :=
 #align vsub_vadd vsub_vadd
 -/
 
-/- warning: vadd_vsub -> vadd_vsub is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [T : AddTorsor.{u1, u2} G P _inst_1] (g : G) (p : P), Eq.{succ u1} G (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 T) (VAdd.vadd.{u1, u2} G P (AddAction.toHasVadd.{u1, u2} G P (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)) (AddTorsor.toAddAction.{u1, u2} G P _inst_1 T)) g p) p) g
-but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [T : AddTorsor.{u2, u1} G P _inst_1] (g : G) (p : P), Eq.{succ u2} G (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 T) (HVAdd.hVAdd.{u2, u1, u1} G P P (instHVAdd.{u2, u1} G P (AddAction.toVAdd.{u2, u1} G P (SubNegMonoid.toAddMonoid.{u2} G (AddGroup.toSubNegMonoid.{u2} G _inst_1)) (AddTorsor.toAddAction.{u2, u1} G P _inst_1 T))) g p) p) g
-Case conversion may be inaccurate. Consider using '#align vadd_vsub vadd_vsubₓ'. -/
 /-- Adding a group element then subtracting the original point
 produces that group element. -/
 @[simp]
@@ -131,24 +119,12 @@ theorem vadd_right_cancel_iff {g1 g2 : G} (p : P) : g1 +ᵥ p = g2 +ᵥ p ↔ g1
 #align vadd_right_cancel_iff vadd_right_cancel_iff
 -/
 
-/- warning: vadd_right_injective -> vadd_right_injective is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [T : AddTorsor.{u1, u2} G P _inst_1] (p : P), Function.Injective.{succ u1, succ u2} G P (fun (_x : G) => VAdd.vadd.{u1, u2} G P (AddAction.toHasVadd.{u1, u2} G P (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)) (AddTorsor.toAddAction.{u1, u2} G P _inst_1 T)) _x p)
-but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [T : AddTorsor.{u2, u1} G P _inst_1] (p : P), Function.Injective.{succ u2, succ u1} G P (fun (_x : G) => HVAdd.hVAdd.{u2, u1, u1} G P P (instHVAdd.{u2, u1} G P (AddAction.toVAdd.{u2, u1} G P (SubNegMonoid.toAddMonoid.{u2} G (AddGroup.toSubNegMonoid.{u2} G _inst_1)) (AddTorsor.toAddAction.{u2, u1} G P _inst_1 T))) _x p)
-Case conversion may be inaccurate. Consider using '#align vadd_right_injective vadd_right_injectiveₓ'. -/
 /-- Adding a group element to the point `p` is an injective
 function. -/
 theorem vadd_right_injective (p : P) : Function.Injective ((· +ᵥ p) : G → P) := fun g1 g2 =>
   vadd_right_cancel p
 #align vadd_right_injective vadd_right_injective
 
-/- warning: vadd_vsub_assoc -> vadd_vsub_assoc is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [T : AddTorsor.{u1, u2} G P _inst_1] (g : G) (p1 : P) (p2 : P), Eq.{succ u1} G (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 T) (VAdd.vadd.{u1, u2} G P (AddAction.toHasVadd.{u1, u2} G P (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)) (AddTorsor.toAddAction.{u1, u2} G P _inst_1 T)) g p1) p2) (HAdd.hAdd.{u1, u1, u1} G G G (instHAdd.{u1} G (AddZeroClass.toHasAdd.{u1} G (AddMonoid.toAddZeroClass.{u1} G (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1))))) g (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 T) p1 p2))
-but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [T : AddTorsor.{u2, u1} G P _inst_1] (g : G) (p1 : P) (p2 : P), Eq.{succ u2} G (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 T) (HVAdd.hVAdd.{u2, u1, u1} G P P (instHVAdd.{u2, u1} G P (AddAction.toVAdd.{u2, u1} G P (SubNegMonoid.toAddMonoid.{u2} G (AddGroup.toSubNegMonoid.{u2} G _inst_1)) (AddTorsor.toAddAction.{u2, u1} G P _inst_1 T))) g p1) p2) (HAdd.hAdd.{u2, u2, u2} G G G (instHAdd.{u2} G (AddZeroClass.toAdd.{u2} G (AddMonoid.toAddZeroClass.{u2} G (SubNegMonoid.toAddMonoid.{u2} G (AddGroup.toSubNegMonoid.{u2} G _inst_1))))) g (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 T) p1 p2))
-Case conversion may be inaccurate. Consider using '#align vadd_vsub_assoc vadd_vsub_assocₓ'. -/
 /-- Adding a group element to a point, then subtracting another point,
 produces the same result as subtracting the points then adding the
 group element. -/
@@ -158,35 +134,17 @@ theorem vadd_vsub_assoc (g : G) (p1 p2 : P) : g +ᵥ p1 -ᵥ p2 = g + (p1 -ᵥ p
   rw [vsub_vadd, add_vadd, vsub_vadd]
 #align vadd_vsub_assoc vadd_vsub_assoc
 
-/- warning: vsub_self -> vsub_self is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [T : AddTorsor.{u1, u2} G P _inst_1] (p : P), Eq.{succ u1} G (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 T) p p) (OfNat.ofNat.{u1} G 0 (OfNat.mk.{u1} G 0 (Zero.zero.{u1} G (AddZeroClass.toHasZero.{u1} G (AddMonoid.toAddZeroClass.{u1} G (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)))))))
-but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [T : AddTorsor.{u2, u1} G P _inst_1] (p : P), Eq.{succ u2} G (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 T) p p) (OfNat.ofNat.{u2} G 0 (Zero.toOfNat0.{u2} G (NegZeroClass.toZero.{u2} G (SubNegZeroMonoid.toNegZeroClass.{u2} G (SubtractionMonoid.toSubNegZeroMonoid.{u2} G (AddGroup.toSubtractionMonoid.{u2} G _inst_1))))))
-Case conversion may be inaccurate. Consider using '#align vsub_self vsub_selfₓ'. -/
 /-- Subtracting a point from itself produces 0. -/
 @[simp]
 theorem vsub_self (p : P) : p -ᵥ p = (0 : G) := by
   rw [← zero_add (p -ᵥ p), ← vadd_vsub_assoc, vadd_vsub]
 #align vsub_self vsub_self
 
-/- warning: eq_of_vsub_eq_zero -> eq_of_vsub_eq_zero is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [T : AddTorsor.{u1, u2} G P _inst_1] {p1 : P} {p2 : P}, (Eq.{succ u1} G (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 T) p1 p2) (OfNat.ofNat.{u1} G 0 (OfNat.mk.{u1} G 0 (Zero.zero.{u1} G (AddZeroClass.toHasZero.{u1} G (AddMonoid.toAddZeroClass.{u1} G (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)))))))) -> (Eq.{succ u2} P p1 p2)
-but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [T : AddTorsor.{u2, u1} G P _inst_1] {p1 : P} {p2 : P}, (Eq.{succ u2} G (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 T) p1 p2) (OfNat.ofNat.{u2} G 0 (Zero.toOfNat0.{u2} G (NegZeroClass.toZero.{u2} G (SubNegZeroMonoid.toNegZeroClass.{u2} G (SubtractionMonoid.toSubNegZeroMonoid.{u2} G (AddGroup.toSubtractionMonoid.{u2} G _inst_1))))))) -> (Eq.{succ u1} P p1 p2)
-Case conversion may be inaccurate. Consider using '#align eq_of_vsub_eq_zero eq_of_vsub_eq_zeroₓ'. -/
 /-- If subtracting two points produces 0, they are equal. -/
 theorem eq_of_vsub_eq_zero {p1 p2 : P} (h : p1 -ᵥ p2 = (0 : G)) : p1 = p2 := by
   rw [← vsub_vadd p1 p2, h, zero_vadd]
 #align eq_of_vsub_eq_zero eq_of_vsub_eq_zero
 
-/- warning: vsub_eq_zero_iff_eq -> vsub_eq_zero_iff_eq is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [T : AddTorsor.{u1, u2} G P _inst_1] {p1 : P} {p2 : P}, Iff (Eq.{succ u1} G (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 T) p1 p2) (OfNat.ofNat.{u1} G 0 (OfNat.mk.{u1} G 0 (Zero.zero.{u1} G (AddZeroClass.toHasZero.{u1} G (AddMonoid.toAddZeroClass.{u1} G (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)))))))) (Eq.{succ u2} P p1 p2)
-but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [T : AddTorsor.{u2, u1} G P _inst_1] {p1 : P} {p2 : P}, Iff (Eq.{succ u2} G (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 T) p1 p2) (OfNat.ofNat.{u2} G 0 (Zero.toOfNat0.{u2} G (NegZeroClass.toZero.{u2} G (SubNegZeroMonoid.toNegZeroClass.{u2} G (SubtractionMonoid.toSubNegZeroMonoid.{u2} G (AddGroup.toSubtractionMonoid.{u2} G _inst_1))))))) (Eq.{succ u1} P p1 p2)
-Case conversion may be inaccurate. Consider using '#align vsub_eq_zero_iff_eq vsub_eq_zero_iff_eqₓ'. -/
 /-- Subtracting two points produces 0 if and only if they are
 equal. -/
 @[simp]
@@ -194,22 +152,10 @@ theorem vsub_eq_zero_iff_eq {p1 p2 : P} : p1 -ᵥ p2 = (0 : G) ↔ p1 = p2 :=
   Iff.intro eq_of_vsub_eq_zero fun h => h ▸ vsub_self _
 #align vsub_eq_zero_iff_eq vsub_eq_zero_iff_eq
 
-/- warning: vsub_ne_zero -> vsub_ne_zero is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [T : AddTorsor.{u1, u2} G P _inst_1] {p : P} {q : P}, Iff (Ne.{succ u1} G (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 T) p q) (OfNat.ofNat.{u1} G 0 (OfNat.mk.{u1} G 0 (Zero.zero.{u1} G (AddZeroClass.toHasZero.{u1} G (AddMonoid.toAddZeroClass.{u1} G (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)))))))) (Ne.{succ u2} P p q)
-but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [T : AddTorsor.{u2, u1} G P _inst_1] {p : P} {q : P}, Iff (Ne.{succ u2} G (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 T) p q) (OfNat.ofNat.{u2} G 0 (Zero.toOfNat0.{u2} G (NegZeroClass.toZero.{u2} G (SubNegZeroMonoid.toNegZeroClass.{u2} G (SubtractionMonoid.toSubNegZeroMonoid.{u2} G (AddGroup.toSubtractionMonoid.{u2} G _inst_1))))))) (Ne.{succ u1} P p q)
-Case conversion may be inaccurate. Consider using '#align vsub_ne_zero vsub_ne_zeroₓ'. -/
 theorem vsub_ne_zero {p q : P} : p -ᵥ q ≠ (0 : G) ↔ p ≠ q :=
   not_congr vsub_eq_zero_iff_eq
 #align vsub_ne_zero vsub_ne_zero
 
-/- warning: vsub_add_vsub_cancel -> vsub_add_vsub_cancel is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [T : AddTorsor.{u1, u2} G P _inst_1] (p1 : P) (p2 : P) (p3 : P), Eq.{succ u1} G (HAdd.hAdd.{u1, u1, u1} G G G (instHAdd.{u1} G (AddZeroClass.toHasAdd.{u1} G (AddMonoid.toAddZeroClass.{u1} G (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1))))) (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 T) p1 p2) (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 T) p2 p3)) (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 T) p1 p3)
-but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [T : AddTorsor.{u2, u1} G P _inst_1] (p1 : P) (p2 : P) (p3 : P), Eq.{succ u2} G (HAdd.hAdd.{u2, u2, u2} G G G (instHAdd.{u2} G (AddZeroClass.toAdd.{u2} G (AddMonoid.toAddZeroClass.{u2} G (SubNegMonoid.toAddMonoid.{u2} G (AddGroup.toSubNegMonoid.{u2} G _inst_1))))) (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 T) p1 p2) (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 T) p2 p3)) (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 T) p1 p3)
-Case conversion may be inaccurate. Consider using '#align vsub_add_vsub_cancel vsub_add_vsub_cancelₓ'. -/
 /-- Cancellation adding the results of two subtractions. -/
 @[simp]
 theorem vsub_add_vsub_cancel (p1 p2 p3 : P) : p1 -ᵥ p2 + (p2 -ᵥ p3) = p1 -ᵥ p3 :=
@@ -218,12 +164,6 @@ theorem vsub_add_vsub_cancel (p1 p2 p3 : P) : p1 -ᵥ p2 + (p2 -ᵥ p3) = p1 -
   rw [add_vadd, vsub_vadd, vsub_vadd, vsub_vadd]
 #align vsub_add_vsub_cancel vsub_add_vsub_cancel
 
-/- warning: neg_vsub_eq_vsub_rev -> neg_vsub_eq_vsub_rev is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [T : AddTorsor.{u1, u2} G P _inst_1] (p1 : P) (p2 : P), Eq.{succ u1} G (Neg.neg.{u1} G (SubNegMonoid.toHasNeg.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)) (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 T) p1 p2)) (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 T) p2 p1)
-but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [T : AddTorsor.{u2, u1} G P _inst_1] (p1 : P) (p2 : P), Eq.{succ u2} G (Neg.neg.{u2} G (NegZeroClass.toNeg.{u2} G (SubNegZeroMonoid.toNegZeroClass.{u2} G (SubtractionMonoid.toSubNegZeroMonoid.{u2} G (AddGroup.toSubtractionMonoid.{u2} G _inst_1)))) (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 T) p1 p2)) (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 T) p2 p1)
-Case conversion may be inaccurate. Consider using '#align neg_vsub_eq_vsub_rev neg_vsub_eq_vsub_revₓ'. -/
 /-- Subtracting two points in the reverse order produces the negation
 of subtracting them. -/
 @[simp]
@@ -233,22 +173,10 @@ theorem neg_vsub_eq_vsub_rev (p1 p2 : P) : -(p1 -ᵥ p2) = p2 -ᵥ p1 :=
   rw [vsub_add_vsub_cancel, vsub_self]
 #align neg_vsub_eq_vsub_rev neg_vsub_eq_vsub_rev
 
-/- warning: vadd_vsub_eq_sub_vsub -> vadd_vsub_eq_sub_vsub is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [T : AddTorsor.{u1, u2} G P _inst_1] (g : G) (p : P) (q : P), Eq.{succ u1} G (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 T) (VAdd.vadd.{u1, u2} G P (AddAction.toHasVadd.{u1, u2} G P (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)) (AddTorsor.toAddAction.{u1, u2} G P _inst_1 T)) g p) q) (HSub.hSub.{u1, u1, u1} G G G (instHSub.{u1} G (SubNegMonoid.toHasSub.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1))) g (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 T) q p))
-but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [T : AddTorsor.{u2, u1} G P _inst_1] (g : G) (p : P) (q : P), Eq.{succ u2} G (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 T) (HVAdd.hVAdd.{u2, u1, u1} G P P (instHVAdd.{u2, u1} G P (AddAction.toVAdd.{u2, u1} G P (SubNegMonoid.toAddMonoid.{u2} G (AddGroup.toSubNegMonoid.{u2} G _inst_1)) (AddTorsor.toAddAction.{u2, u1} G P _inst_1 T))) g p) q) (HSub.hSub.{u2, u2, u2} G G G (instHSub.{u2} G (SubNegMonoid.toSub.{u2} G (AddGroup.toSubNegMonoid.{u2} G _inst_1))) g (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 T) q p))
-Case conversion may be inaccurate. Consider using '#align vadd_vsub_eq_sub_vsub vadd_vsub_eq_sub_vsubₓ'. -/
 theorem vadd_vsub_eq_sub_vsub (g : G) (p q : P) : g +ᵥ p -ᵥ q = g - (q -ᵥ p) := by
   rw [vadd_vsub_assoc, sub_eq_add_neg, neg_vsub_eq_vsub_rev]
 #align vadd_vsub_eq_sub_vsub vadd_vsub_eq_sub_vsub
 
-/- warning: vsub_vadd_eq_vsub_sub -> vsub_vadd_eq_vsub_sub is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [T : AddTorsor.{u1, u2} G P _inst_1] (p1 : P) (p2 : P) (g : G), Eq.{succ u1} G (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 T) p1 (VAdd.vadd.{u1, u2} G P (AddAction.toHasVadd.{u1, u2} G P (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)) (AddTorsor.toAddAction.{u1, u2} G P _inst_1 T)) g p2)) (HSub.hSub.{u1, u1, u1} G G G (instHSub.{u1} G (SubNegMonoid.toHasSub.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1))) (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 T) p1 p2) g)
-but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [T : AddTorsor.{u2, u1} G P _inst_1] (p1 : P) (p2 : P) (g : G), Eq.{succ u2} G (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 T) p1 (HVAdd.hVAdd.{u2, u1, u1} G P P (instHVAdd.{u2, u1} G P (AddAction.toVAdd.{u2, u1} G P (SubNegMonoid.toAddMonoid.{u2} G (AddGroup.toSubNegMonoid.{u2} G _inst_1)) (AddTorsor.toAddAction.{u2, u1} G P _inst_1 T))) g p2)) (HSub.hSub.{u2, u2, u2} G G G (instHSub.{u2} G (SubNegMonoid.toSub.{u2} G (AddGroup.toSubNegMonoid.{u2} G _inst_1))) (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 T) p1 p2) g)
-Case conversion may be inaccurate. Consider using '#align vsub_vadd_eq_vsub_sub vsub_vadd_eq_vsub_subₓ'. -/
 /-- Subtracting the result of adding a group element produces the same result
 as subtracting the points and subtracting that group element. -/
 theorem vsub_vadd_eq_vsub_sub (p1 p2 : P) (g : G) : p1 -ᵥ (g +ᵥ p2) = p1 -ᵥ p2 - g := by
@@ -256,12 +184,6 @@ theorem vsub_vadd_eq_vsub_sub (p1 p2 : P) (g : G) : p1 -ᵥ (g +ᵥ p2) = p1 -
     add_sub_assoc, ← neg_vsub_eq_vsub_rev, neg_add_self, zero_sub]
 #align vsub_vadd_eq_vsub_sub vsub_vadd_eq_vsub_sub
 
-/- warning: vsub_sub_vsub_cancel_right -> vsub_sub_vsub_cancel_right is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [T : AddTorsor.{u1, u2} G P _inst_1] (p1 : P) (p2 : P) (p3 : P), Eq.{succ u1} G (HSub.hSub.{u1, u1, u1} G G G (instHSub.{u1} G (SubNegMonoid.toHasSub.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1))) (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 T) p1 p3) (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 T) p2 p3)) (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 T) p1 p2)
-but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [T : AddTorsor.{u2, u1} G P _inst_1] (p1 : P) (p2 : P) (p3 : P), Eq.{succ u2} G (HSub.hSub.{u2, u2, u2} G G G (instHSub.{u2} G (SubNegMonoid.toSub.{u2} G (AddGroup.toSubNegMonoid.{u2} G _inst_1))) (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 T) p1 p3) (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 T) p2 p3)) (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 T) p1 p2)
-Case conversion may be inaccurate. Consider using '#align vsub_sub_vsub_cancel_right vsub_sub_vsub_cancel_rightₓ'. -/
 /-- Cancellation subtracting the results of two subtractions. -/
 @[simp]
 theorem vsub_sub_vsub_cancel_right (p1 p2 p3 : P) : p1 -ᵥ p3 - (p2 -ᵥ p3) = p1 -ᵥ p2 := by
@@ -277,12 +199,6 @@ theorem eq_vadd_iff_vsub_eq (p1 : P) (g : G) (p2 : P) : p1 = g +ᵥ p2 ↔ p1 -
 #align eq_vadd_iff_vsub_eq eq_vadd_iff_vsub_eq
 -/
 
-/- warning: vadd_eq_vadd_iff_neg_add_eq_vsub -> vadd_eq_vadd_iff_neg_add_eq_vsub is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [T : AddTorsor.{u1, u2} G P _inst_1] {v₁ : G} {v₂ : G} {p₁ : P} {p₂ : P}, Iff (Eq.{succ u2} P (VAdd.vadd.{u1, u2} G P (AddAction.toHasVadd.{u1, u2} G P (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)) (AddTorsor.toAddAction.{u1, u2} G P _inst_1 T)) v₁ p₁) (VAdd.vadd.{u1, u2} G P (AddAction.toHasVadd.{u1, u2} G P (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)) (AddTorsor.toAddAction.{u1, u2} G P _inst_1 T)) v₂ p₂)) (Eq.{succ u1} G (HAdd.hAdd.{u1, u1, u1} G G G (instHAdd.{u1} G (AddZeroClass.toHasAdd.{u1} G (AddMonoid.toAddZeroClass.{u1} G (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1))))) (Neg.neg.{u1} G (SubNegMonoid.toHasNeg.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)) v₁) v₂) (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 T) p₁ p₂))
-but is expected to have type
-  forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [T : AddTorsor.{u1, u2} G P _inst_1] {v₁ : G} {v₂ : G} {p₁ : P} {p₂ : P}, Iff (Eq.{succ u2} P (HVAdd.hVAdd.{u1, u2, u2} G P P (instHVAdd.{u1, u2} G P (AddAction.toVAdd.{u1, u2} G P (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)) (AddTorsor.toAddAction.{u1, u2} G P _inst_1 T))) v₁ p₁) (HVAdd.hVAdd.{u1, u2, u2} G P P (instHVAdd.{u1, u2} G P (AddAction.toVAdd.{u1, u2} G P (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)) (AddTorsor.toAddAction.{u1, u2} G P _inst_1 T))) v₂ p₂)) (Eq.{succ u1} G (HAdd.hAdd.{u1, u1, u1} G G G (instHAdd.{u1} G (AddZeroClass.toAdd.{u1} G (AddMonoid.toAddZeroClass.{u1} G (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1))))) (Neg.neg.{u1} G (NegZeroClass.toNeg.{u1} G (SubNegZeroMonoid.toNegZeroClass.{u1} G (SubtractionMonoid.toSubNegZeroMonoid.{u1} G (AddGroup.toSubtractionMonoid.{u1} G _inst_1)))) v₁) v₂) (VSub.vsub.{u1, u2} G P (AddTorsor.toVSub.{u1, u2} G P _inst_1 T) p₁ p₂))
-Case conversion may be inaccurate. Consider using '#align vadd_eq_vadd_iff_neg_add_eq_vsub vadd_eq_vadd_iff_neg_add_eq_vsubₓ'. -/
 theorem vadd_eq_vadd_iff_neg_add_eq_vsub {v₁ v₂ : G} {p₁ p₂ : P} :
     v₁ +ᵥ p₁ = v₂ +ᵥ p₂ ↔ -v₁ + v₂ = p₁ -ᵥ p₂ := by
   rw [eq_vadd_iff_vsub_eq, vadd_vsub_assoc, ← add_right_inj (-v₁), neg_add_cancel_left, eq_comm]
@@ -292,12 +208,6 @@ namespace Set
 
 open Pointwise
 
-/- warning: set.singleton_vsub_self -> Set.singleton_vsub_self is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [T : AddTorsor.{u1, u2} G P _inst_1] (p : P), Eq.{succ u1} (Set.{u1} G) (VSub.vsub.{u1, u2} (Set.{u1} G) (Set.{u2} P) (Set.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 T)) (Singleton.singleton.{u2, u2} P (Set.{u2} P) (Set.hasSingleton.{u2} P) p) (Singleton.singleton.{u2, u2} P (Set.{u2} P) (Set.hasSingleton.{u2} P) p)) (Singleton.singleton.{u1, u1} G (Set.{u1} G) (Set.hasSingleton.{u1} G) (OfNat.ofNat.{u1} G 0 (OfNat.mk.{u1} G 0 (Zero.zero.{u1} G (AddZeroClass.toHasZero.{u1} G (AddMonoid.toAddZeroClass.{u1} G (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1))))))))
-but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [T : AddTorsor.{u2, u1} G P _inst_1] (p : P), Eq.{succ u2} (Set.{u2} G) (VSub.vsub.{u2, u1} (Set.{u2} G) (Set.{u1} P) (Set.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 T)) (Singleton.singleton.{u1, u1} P (Set.{u1} P) (Set.instSingletonSet.{u1} P) p) (Singleton.singleton.{u1, u1} P (Set.{u1} P) (Set.instSingletonSet.{u1} P) p)) (Singleton.singleton.{u2, u2} G (Set.{u2} G) (Set.instSingletonSet.{u2} G) (OfNat.ofNat.{u2} G 0 (Zero.toOfNat0.{u2} G (NegZeroClass.toZero.{u2} G (SubNegZeroMonoid.toNegZeroClass.{u2} G (SubtractionMonoid.toSubNegZeroMonoid.{u2} G (AddGroup.toSubtractionMonoid.{u2} G _inst_1)))))))
-Case conversion may be inaccurate. Consider using '#align set.singleton_vsub_self Set.singleton_vsub_selfₓ'. -/
 @[simp]
 theorem singleton_vsub_self (p : P) : ({p} : Set P) -ᵥ {p} = {(0 : G)} := by
   rw [Set.singleton_vsub_singleton, vsub_self]
@@ -305,35 +215,17 @@ theorem singleton_vsub_self (p : P) : ({p} : Set P) -ᵥ {p} = {(0 : G)} := by
 
 end Set
 
-/- warning: vadd_vsub_vadd_cancel_right -> vadd_vsub_vadd_cancel_right is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [T : AddTorsor.{u1, u2} G P _inst_1] (v₁ : G) (v₂ : G) (p : P), Eq.{succ u1} G (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 T) (VAdd.vadd.{u1, u2} G P (AddAction.toHasVadd.{u1, u2} G P (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)) (AddTorsor.toAddAction.{u1, u2} G P _inst_1 T)) v₁ p) (VAdd.vadd.{u1, u2} G P (AddAction.toHasVadd.{u1, u2} G P (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)) (AddTorsor.toAddAction.{u1, u2} G P _inst_1 T)) v₂ p)) (HSub.hSub.{u1, u1, u1} G G G (instHSub.{u1} G (SubNegMonoid.toHasSub.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1))) v₁ v₂)
-but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [T : AddTorsor.{u2, u1} G P _inst_1] (v₁ : G) (v₂ : G) (p : P), Eq.{succ u2} G (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 T) (HVAdd.hVAdd.{u2, u1, u1} G P P (instHVAdd.{u2, u1} G P (AddAction.toVAdd.{u2, u1} G P (SubNegMonoid.toAddMonoid.{u2} G (AddGroup.toSubNegMonoid.{u2} G _inst_1)) (AddTorsor.toAddAction.{u2, u1} G P _inst_1 T))) v₁ p) (HVAdd.hVAdd.{u2, u1, u1} G P P (instHVAdd.{u2, u1} G P (AddAction.toVAdd.{u2, u1} G P (SubNegMonoid.toAddMonoid.{u2} G (AddGroup.toSubNegMonoid.{u2} G _inst_1)) (AddTorsor.toAddAction.{u2, u1} G P _inst_1 T))) v₂ p)) (HSub.hSub.{u2, u2, u2} G G G (instHSub.{u2} G (SubNegMonoid.toSub.{u2} G (AddGroup.toSubNegMonoid.{u2} G _inst_1))) v₁ v₂)
-Case conversion may be inaccurate. Consider using '#align vadd_vsub_vadd_cancel_right vadd_vsub_vadd_cancel_rightₓ'. -/
 @[simp]
 theorem vadd_vsub_vadd_cancel_right (v₁ v₂ : G) (p : P) : v₁ +ᵥ p -ᵥ (v₂ +ᵥ p) = v₁ - v₂ := by
   rw [vsub_vadd_eq_vsub_sub, vadd_vsub_assoc, vsub_self, add_zero]
 #align vadd_vsub_vadd_cancel_right vadd_vsub_vadd_cancel_right
 
-/- warning: vsub_left_cancel -> vsub_left_cancel is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [T : AddTorsor.{u1, u2} G P _inst_1] {p1 : P} {p2 : P} {p : P}, (Eq.{succ u1} G (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 T) p1 p) (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 T) p2 p)) -> (Eq.{succ u2} P p1 p2)
-but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [T : AddTorsor.{u2, u1} G P _inst_1] {p1 : P} {p2 : P} {p : P}, (Eq.{succ u2} G (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 T) p1 p) (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 T) p2 p)) -> (Eq.{succ u1} P p1 p2)
-Case conversion may be inaccurate. Consider using '#align vsub_left_cancel vsub_left_cancelₓ'. -/
 /-- If the same point subtracted from two points produces equal
 results, those points are equal. -/
 theorem vsub_left_cancel {p1 p2 p : P} (h : p1 -ᵥ p = p2 -ᵥ p) : p1 = p2 := by
   rwa [← sub_eq_zero, vsub_sub_vsub_cancel_right, vsub_eq_zero_iff_eq] at h
 #align vsub_left_cancel vsub_left_cancel
 
-/- warning: vsub_left_cancel_iff -> vsub_left_cancel_iff is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [T : AddTorsor.{u1, u2} G P _inst_1] {p1 : P} {p2 : P} {p : P}, Iff (Eq.{succ u1} G (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 T) p1 p) (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 T) p2 p)) (Eq.{succ u2} P p1 p2)
-but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [T : AddTorsor.{u2, u1} G P _inst_1] {p1 : P} {p2 : P} {p : P}, Iff (Eq.{succ u2} G (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 T) p1 p) (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 T) p2 p)) (Eq.{succ u1} P p1 p2)
-Case conversion may be inaccurate. Consider using '#align vsub_left_cancel_iff vsub_left_cancel_iffₓ'. -/
 /-- The same point subtracted from two points produces equal results
 if and only if those points are equal. -/
 @[simp]
@@ -348,12 +240,6 @@ theorem vsub_left_injective (p : P) : Function.Injective ((· -ᵥ p) : P → G)
 #align vsub_left_injective vsub_left_injective
 -/
 
-/- warning: vsub_right_cancel -> vsub_right_cancel is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [T : AddTorsor.{u1, u2} G P _inst_1] {p1 : P} {p2 : P} {p : P}, (Eq.{succ u1} G (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 T) p p1) (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 T) p p2)) -> (Eq.{succ u2} P p1 p2)
-but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [T : AddTorsor.{u2, u1} G P _inst_1] {p1 : P} {p2 : P} {p : P}, (Eq.{succ u2} G (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 T) p p1) (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 T) p p2)) -> (Eq.{succ u1} P p1 p2)
-Case conversion may be inaccurate. Consider using '#align vsub_right_cancel vsub_right_cancelₓ'. -/
 /-- If subtracting two points from the same point produces equal
 results, those points are equal. -/
 theorem vsub_right_cancel {p1 p2 p : P} (h : p -ᵥ p1 = p -ᵥ p2) : p1 = p2 :=
@@ -362,12 +248,6 @@ theorem vsub_right_cancel {p1 p2 p : P} (h : p -ᵥ p1 = p -ᵥ p2) : p1 = p2 :=
   rw [vsub_vadd, ← h, vsub_vadd]
 #align vsub_right_cancel vsub_right_cancel
 
-/- warning: vsub_right_cancel_iff -> vsub_right_cancel_iff is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [T : AddTorsor.{u1, u2} G P _inst_1] {p1 : P} {p2 : P} {p : P}, Iff (Eq.{succ u1} G (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 T) p p1) (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 T) p p2)) (Eq.{succ u2} P p1 p2)
-but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [T : AddTorsor.{u2, u1} G P _inst_1] {p1 : P} {p2 : P} {p : P}, Iff (Eq.{succ u2} G (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 T) p p1) (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 T) p p2)) (Eq.{succ u1} P p1 p2)
-Case conversion may be inaccurate. Consider using '#align vsub_right_cancel_iff vsub_right_cancel_iffₓ'. -/
 /-- Subtracting two points from the same point produces equal results
 if and only if those points are equal. -/
 @[simp]
@@ -391,24 +271,12 @@ variable {G : Type _} {P : Type _} [AddCommGroup G] [AddTorsor G P]
 
 include G
 
-/- warning: vsub_sub_vsub_cancel_left -> vsub_sub_vsub_cancel_left is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddCommGroup.{u1} G] [_inst_2 : AddTorsor.{u1, u2} G P (AddCommGroup.toAddGroup.{u1} G _inst_1)] (p1 : P) (p2 : P) (p3 : P), Eq.{succ u1} G (HSub.hSub.{u1, u1, u1} G G G (instHSub.{u1} G (SubNegMonoid.toHasSub.{u1} G (AddGroup.toSubNegMonoid.{u1} G (AddCommGroup.toAddGroup.{u1} G _inst_1)))) (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P (AddCommGroup.toAddGroup.{u1} G _inst_1) _inst_2) p3 p2) (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P (AddCommGroup.toAddGroup.{u1} G _inst_1) _inst_2) p3 p1)) (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P (AddCommGroup.toAddGroup.{u1} G _inst_1) _inst_2) p1 p2)
-but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddCommGroup.{u2} G] [_inst_2 : AddTorsor.{u2, u1} G P (AddCommGroup.toAddGroup.{u2} G _inst_1)] (p1 : P) (p2 : P) (p3 : P), Eq.{succ u2} G (HSub.hSub.{u2, u2, u2} G G G (instHSub.{u2} G (SubNegMonoid.toSub.{u2} G (AddGroup.toSubNegMonoid.{u2} G (AddCommGroup.toAddGroup.{u2} G _inst_1)))) (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P (AddCommGroup.toAddGroup.{u2} G _inst_1) _inst_2) p3 p2) (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P (AddCommGroup.toAddGroup.{u2} G _inst_1) _inst_2) p3 p1)) (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P (AddCommGroup.toAddGroup.{u2} G _inst_1) _inst_2) p1 p2)
-Case conversion may be inaccurate. Consider using '#align vsub_sub_vsub_cancel_left vsub_sub_vsub_cancel_leftₓ'. -/
 /-- Cancellation subtracting the results of two subtractions. -/
 @[simp]
 theorem vsub_sub_vsub_cancel_left (p1 p2 p3 : P) : p3 -ᵥ p2 - (p3 -ᵥ p1) = p1 -ᵥ p2 := by
   rw [sub_eq_add_neg, neg_vsub_eq_vsub_rev, add_comm, vsub_add_vsub_cancel]
 #align vsub_sub_vsub_cancel_left vsub_sub_vsub_cancel_left
 
-/- warning: vadd_vsub_vadd_cancel_left -> vadd_vsub_vadd_cancel_left is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddCommGroup.{u1} G] [_inst_2 : AddTorsor.{u1, u2} G P (AddCommGroup.toAddGroup.{u1} G _inst_1)] (v : G) (p1 : P) (p2 : P), Eq.{succ u1} G (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P (AddCommGroup.toAddGroup.{u1} G _inst_1) _inst_2) (VAdd.vadd.{u1, u2} G P (AddAction.toHasVadd.{u1, u2} G P (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G (AddCommGroup.toAddGroup.{u1} G _inst_1))) (AddTorsor.toAddAction.{u1, u2} G P (AddCommGroup.toAddGroup.{u1} G _inst_1) _inst_2)) v p1) (VAdd.vadd.{u1, u2} G P (AddAction.toHasVadd.{u1, u2} G P (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G (AddCommGroup.toAddGroup.{u1} G _inst_1))) (AddTorsor.toAddAction.{u1, u2} G P (AddCommGroup.toAddGroup.{u1} G _inst_1) _inst_2)) v p2)) (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P (AddCommGroup.toAddGroup.{u1} G _inst_1) _inst_2) p1 p2)
-but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddCommGroup.{u2} G] [_inst_2 : AddTorsor.{u2, u1} G P (AddCommGroup.toAddGroup.{u2} G _inst_1)] (v : G) (p1 : P) (p2 : P), Eq.{succ u2} G (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P (AddCommGroup.toAddGroup.{u2} G _inst_1) _inst_2) (HVAdd.hVAdd.{u2, u1, u1} G P P (instHVAdd.{u2, u1} G P (AddAction.toVAdd.{u2, u1} G P (SubNegMonoid.toAddMonoid.{u2} G (AddGroup.toSubNegMonoid.{u2} G (AddCommGroup.toAddGroup.{u2} G _inst_1))) (AddTorsor.toAddAction.{u2, u1} G P (AddCommGroup.toAddGroup.{u2} G _inst_1) _inst_2))) v p1) (HVAdd.hVAdd.{u2, u1, u1} G P P (instHVAdd.{u2, u1} G P (AddAction.toVAdd.{u2, u1} G P (SubNegMonoid.toAddMonoid.{u2} G (AddGroup.toSubNegMonoid.{u2} G (AddCommGroup.toAddGroup.{u2} G _inst_1))) (AddTorsor.toAddAction.{u2, u1} G P (AddCommGroup.toAddGroup.{u2} G _inst_1) _inst_2))) v p2)) (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P (AddCommGroup.toAddGroup.{u2} G _inst_1) _inst_2) p1 p2)
-Case conversion may be inaccurate. Consider using '#align vadd_vsub_vadd_cancel_left vadd_vsub_vadd_cancel_leftₓ'. -/
 @[simp]
 theorem vadd_vsub_vadd_cancel_left (v : G) (p1 p2 : P) : v +ᵥ p1 -ᵥ (v +ᵥ p2) = p1 -ᵥ p2 := by
   rw [vsub_vadd_eq_vsub_sub, vadd_vsub_assoc, add_sub_cancel']
@@ -422,23 +290,11 @@ theorem vsub_vadd_comm (p1 p2 p3 : P) : (p1 -ᵥ p2 : G) +ᵥ p3 = p3 -ᵥ p2 +
 #align vsub_vadd_comm vsub_vadd_comm
 -/
 
-/- warning: vadd_eq_vadd_iff_sub_eq_vsub -> vadd_eq_vadd_iff_sub_eq_vsub is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddCommGroup.{u1} G] [_inst_2 : AddTorsor.{u1, u2} G P (AddCommGroup.toAddGroup.{u1} G _inst_1)] {v₁ : G} {v₂ : G} {p₁ : P} {p₂ : P}, Iff (Eq.{succ u2} P (VAdd.vadd.{u1, u2} G P (AddAction.toHasVadd.{u1, u2} G P (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G (AddCommGroup.toAddGroup.{u1} G _inst_1))) (AddTorsor.toAddAction.{u1, u2} G P (AddCommGroup.toAddGroup.{u1} G _inst_1) _inst_2)) v₁ p₁) (VAdd.vadd.{u1, u2} G P (AddAction.toHasVadd.{u1, u2} G P (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G (AddCommGroup.toAddGroup.{u1} G _inst_1))) (AddTorsor.toAddAction.{u1, u2} G P (AddCommGroup.toAddGroup.{u1} G _inst_1) _inst_2)) v₂ p₂)) (Eq.{succ u1} G (HSub.hSub.{u1, u1, u1} G G G (instHSub.{u1} G (SubNegMonoid.toHasSub.{u1} G (AddGroup.toSubNegMonoid.{u1} G (AddCommGroup.toAddGroup.{u1} G _inst_1)))) v₂ v₁) (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P (AddCommGroup.toAddGroup.{u1} G _inst_1) _inst_2) p₁ p₂))
-but is expected to have type
-  forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddCommGroup.{u1} G] [_inst_2 : AddTorsor.{u1, u2} G P (AddCommGroup.toAddGroup.{u1} G _inst_1)] {v₁ : G} {v₂ : G} {p₁ : P} {p₂ : P}, Iff (Eq.{succ u2} P (HVAdd.hVAdd.{u1, u2, u2} G P P (instHVAdd.{u1, u2} G P (AddAction.toVAdd.{u1, u2} G P (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G (AddCommGroup.toAddGroup.{u1} G _inst_1))) (AddTorsor.toAddAction.{u1, u2} G P (AddCommGroup.toAddGroup.{u1} G _inst_1) _inst_2))) v₁ p₁) (HVAdd.hVAdd.{u1, u2, u2} G P P (instHVAdd.{u1, u2} G P (AddAction.toVAdd.{u1, u2} G P (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G (AddCommGroup.toAddGroup.{u1} G _inst_1))) (AddTorsor.toAddAction.{u1, u2} G P (AddCommGroup.toAddGroup.{u1} G _inst_1) _inst_2))) v₂ p₂)) (Eq.{succ u1} G (HSub.hSub.{u1, u1, u1} G G G (instHSub.{u1} G (SubNegMonoid.toSub.{u1} G (AddGroup.toSubNegMonoid.{u1} G (AddCommGroup.toAddGroup.{u1} G _inst_1)))) v₂ v₁) (VSub.vsub.{u1, u2} G P (AddTorsor.toVSub.{u1, u2} G P (AddCommGroup.toAddGroup.{u1} G _inst_1) _inst_2) p₁ p₂))
-Case conversion may be inaccurate. Consider using '#align vadd_eq_vadd_iff_sub_eq_vsub vadd_eq_vadd_iff_sub_eq_vsubₓ'. -/
 theorem vadd_eq_vadd_iff_sub_eq_vsub {v₁ v₂ : G} {p₁ p₂ : P} :
     v₁ +ᵥ p₁ = v₂ +ᵥ p₂ ↔ v₂ - v₁ = p₁ -ᵥ p₂ := by
   rw [vadd_eq_vadd_iff_neg_add_eq_vsub, neg_add_eq_sub]
 #align vadd_eq_vadd_iff_sub_eq_vsub vadd_eq_vadd_iff_sub_eq_vsub
 
-/- warning: vsub_sub_vsub_comm -> vsub_sub_vsub_comm is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddCommGroup.{u1} G] [_inst_2 : AddTorsor.{u1, u2} G P (AddCommGroup.toAddGroup.{u1} G _inst_1)] (p₁ : P) (p₂ : P) (p₃ : P) (p₄ : P), Eq.{succ u1} G (HSub.hSub.{u1, u1, u1} G G G (instHSub.{u1} G (SubNegMonoid.toHasSub.{u1} G (AddGroup.toSubNegMonoid.{u1} G (AddCommGroup.toAddGroup.{u1} G _inst_1)))) (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P (AddCommGroup.toAddGroup.{u1} G _inst_1) _inst_2) p₁ p₂) (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P (AddCommGroup.toAddGroup.{u1} G _inst_1) _inst_2) p₃ p₄)) (HSub.hSub.{u1, u1, u1} G G G (instHSub.{u1} G (SubNegMonoid.toHasSub.{u1} G (AddGroup.toSubNegMonoid.{u1} G (AddCommGroup.toAddGroup.{u1} G _inst_1)))) (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P (AddCommGroup.toAddGroup.{u1} G _inst_1) _inst_2) p₁ p₃) (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P (AddCommGroup.toAddGroup.{u1} G _inst_1) _inst_2) p₂ p₄))
-but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddCommGroup.{u2} G] [_inst_2 : AddTorsor.{u2, u1} G P (AddCommGroup.toAddGroup.{u2} G _inst_1)] (p₁ : P) (p₂ : P) (p₃ : P) (p₄ : P), Eq.{succ u2} G (HSub.hSub.{u2, u2, u2} G G G (instHSub.{u2} G (SubNegMonoid.toSub.{u2} G (AddGroup.toSubNegMonoid.{u2} G (AddCommGroup.toAddGroup.{u2} G _inst_1)))) (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P (AddCommGroup.toAddGroup.{u2} G _inst_1) _inst_2) p₁ p₂) (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P (AddCommGroup.toAddGroup.{u2} G _inst_1) _inst_2) p₃ p₄)) (HSub.hSub.{u2, u2, u2} G G G (instHSub.{u2} G (SubNegMonoid.toSub.{u2} G (AddGroup.toSubNegMonoid.{u2} G (AddCommGroup.toAddGroup.{u2} G _inst_1)))) (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P (AddCommGroup.toAddGroup.{u2} G _inst_1) _inst_2) p₁ p₃) (VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P (AddCommGroup.toAddGroup.{u2} G _inst_1) _inst_2) p₂ p₄))
-Case conversion may be inaccurate. Consider using '#align vsub_sub_vsub_comm vsub_sub_vsub_commₓ'. -/
 theorem vsub_sub_vsub_comm (p₁ p₂ p₃ p₄ : P) : p₁ -ᵥ p₂ - (p₃ -ᵥ p₄) = p₁ -ᵥ p₃ - (p₂ -ᵥ p₄) := by
   rw [← vsub_vadd_eq_vsub_sub, vsub_vadd_comm, vsub_vadd_eq_vsub_sub]
 #align vsub_sub_vsub_comm vsub_sub_vsub_comm
@@ -460,67 +316,31 @@ instance : AddTorsor (G × G') (P × P')
   vsub_vadd' p₁ p₂ := show (p₁.1 -ᵥ p₂.1 +ᵥ p₂.1, _) = p₁ by simp
   vadd_vsub' v p := show (v.1 +ᵥ p.1 -ᵥ p.1, v.2 +ᵥ p.2 -ᵥ p.2) = v by simp
 
-/- warning: prod.fst_vadd -> Prod.fst_vadd is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {P : Type.{u2}} {G' : Type.{u3}} {P' : Type.{u4}} [_inst_1 : AddGroup.{u1} G] [_inst_2 : AddGroup.{u3} G'] [_inst_3 : AddTorsor.{u1, u2} G P _inst_1] [_inst_4 : AddTorsor.{u3, u4} G' P' _inst_2] (v : Prod.{u1, u3} G G') (p : Prod.{u2, u4} P P'), Eq.{succ u2} P (Prod.fst.{u2, u4} P P' (VAdd.vadd.{max u1 u3, max u2 u4} (Prod.{u1, u3} G G') (Prod.{u2, u4} P P') (AddAction.toHasVadd.{max u1 u3, max u2 u4} (Prod.{u1, u3} G G') (Prod.{u2, u4} P P') (SubNegMonoid.toAddMonoid.{max u1 u3} (Prod.{u1, u3} G G') (AddGroup.toSubNegMonoid.{max u1 u3} (Prod.{u1, u3} G G') (Prod.addGroup.{u1, u3} G G' _inst_1 _inst_2))) (AddTorsor.toAddAction.{max u1 u3, max u2 u4} (Prod.{u1, u3} G G') (Prod.{u2, u4} P P') (Prod.addGroup.{u1, u3} G G' _inst_1 _inst_2) (Prod.addTorsor.{u1, u2, u3, u4} G P G' P' _inst_1 _inst_2 _inst_3 _inst_4))) v p)) (VAdd.vadd.{u1, u2} G P (AddAction.toHasVadd.{u1, u2} G P (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)) (AddTorsor.toAddAction.{u1, u2} G P _inst_1 _inst_3)) (Prod.fst.{u1, u3} G G' v) (Prod.fst.{u2, u4} P P' p))
-but is expected to have type
-  forall {G : Type.{u3}} {P : Type.{u2}} {G' : Type.{u1}} {P' : Type.{u4}} [_inst_1 : AddGroup.{u4} P'] [_inst_2 : AddGroup.{u3} G] [_inst_3 : AddTorsor.{u4, u2} P' P _inst_1] [_inst_4 : AddTorsor.{u3, u1} G G' _inst_2] (v : Prod.{u4, u3} P' G) (p : Prod.{u2, u1} P G'), Eq.{succ u2} P (Prod.fst.{u2, u1} P G' (HVAdd.hVAdd.{max u4 u3, max u2 u1, max u2 u1} (Prod.{u4, u3} P' G) (Prod.{u2, u1} P G') (Prod.{u2, u1} P G') (instHVAdd.{max u4 u3, max u2 u1} (Prod.{u4, u3} P' G) (Prod.{u2, u1} P G') (AddAction.toVAdd.{max u4 u3, max u2 u1} (Prod.{u4, u3} P' G) (Prod.{u2, u1} P G') (Prod.instAddMonoidSum.{u4, u3} P' G (SubNegMonoid.toAddMonoid.{u4} P' (AddGroup.toSubNegMonoid.{u4} P' _inst_1)) (SubNegMonoid.toAddMonoid.{u3} G (AddGroup.toSubNegMonoid.{u3} G _inst_2))) (AddTorsor.toAddAction.{max u4 u3, max u2 u1} (Prod.{u4, u3} P' G) (Prod.{u2, u1} P G') (Prod.instAddGroupSum.{u4, u3} P' G _inst_1 _inst_2) (Prod.instAddTorsorProdProdInstAddGroupSum.{u3, u2, u1, u4} G P G' P' _inst_1 _inst_2 _inst_3 _inst_4)))) v p)) (HVAdd.hVAdd.{u4, u2, u2} P' P P (instHVAdd.{u4, u2} P' P (AddAction.toVAdd.{u4, u2} P' P (SubNegMonoid.toAddMonoid.{u4} P' (AddGroup.toSubNegMonoid.{u4} P' _inst_1)) (AddTorsor.toAddAction.{u4, u2} P' P _inst_1 _inst_3))) (Prod.fst.{u4, u3} P' G v) (Prod.fst.{u2, u1} P G' p))
-Case conversion may be inaccurate. Consider using '#align prod.fst_vadd Prod.fst_vaddₓ'. -/
 @[simp]
 theorem fst_vadd (v : G × G') (p : P × P') : (v +ᵥ p).1 = v.1 +ᵥ p.1 :=
   rfl
 #align prod.fst_vadd Prod.fst_vadd
 
-/- warning: prod.snd_vadd -> Prod.snd_vadd is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {P : Type.{u2}} {G' : Type.{u3}} {P' : Type.{u4}} [_inst_1 : AddGroup.{u1} G] [_inst_2 : AddGroup.{u3} G'] [_inst_3 : AddTorsor.{u1, u2} G P _inst_1] [_inst_4 : AddTorsor.{u3, u4} G' P' _inst_2] (v : Prod.{u1, u3} G G') (p : Prod.{u2, u4} P P'), Eq.{succ u4} P' (Prod.snd.{u2, u4} P P' (VAdd.vadd.{max u1 u3, max u2 u4} (Prod.{u1, u3} G G') (Prod.{u2, u4} P P') (AddAction.toHasVadd.{max u1 u3, max u2 u4} (Prod.{u1, u3} G G') (Prod.{u2, u4} P P') (SubNegMonoid.toAddMonoid.{max u1 u3} (Prod.{u1, u3} G G') (AddGroup.toSubNegMonoid.{max u1 u3} (Prod.{u1, u3} G G') (Prod.addGroup.{u1, u3} G G' _inst_1 _inst_2))) (AddTorsor.toAddAction.{max u1 u3, max u2 u4} (Prod.{u1, u3} G G') (Prod.{u2, u4} P P') (Prod.addGroup.{u1, u3} G G' _inst_1 _inst_2) (Prod.addTorsor.{u1, u2, u3, u4} G P G' P' _inst_1 _inst_2 _inst_3 _inst_4))) v p)) (VAdd.vadd.{u3, u4} G' P' (AddAction.toHasVadd.{u3, u4} G' P' (SubNegMonoid.toAddMonoid.{u3} G' (AddGroup.toSubNegMonoid.{u3} G' _inst_2)) (AddTorsor.toAddAction.{u3, u4} G' P' _inst_2 _inst_4)) (Prod.snd.{u1, u3} G G' v) (Prod.snd.{u2, u4} P P' p))
-but is expected to have type
-  forall {G : Type.{u3}} {P : Type.{u2}} {G' : Type.{u1}} {P' : Type.{u4}} [_inst_1 : AddGroup.{u4} P'] [_inst_2 : AddGroup.{u3} G] [_inst_3 : AddTorsor.{u4, u2} P' P _inst_1] [_inst_4 : AddTorsor.{u3, u1} G G' _inst_2] (v : Prod.{u4, u3} P' G) (p : Prod.{u2, u1} P G'), Eq.{succ u1} G' (Prod.snd.{u2, u1} P G' (HVAdd.hVAdd.{max u4 u3, max u2 u1, max u2 u1} (Prod.{u4, u3} P' G) (Prod.{u2, u1} P G') (Prod.{u2, u1} P G') (instHVAdd.{max u4 u3, max u2 u1} (Prod.{u4, u3} P' G) (Prod.{u2, u1} P G') (AddAction.toVAdd.{max u4 u3, max u2 u1} (Prod.{u4, u3} P' G) (Prod.{u2, u1} P G') (Prod.instAddMonoidSum.{u4, u3} P' G (SubNegMonoid.toAddMonoid.{u4} P' (AddGroup.toSubNegMonoid.{u4} P' _inst_1)) (SubNegMonoid.toAddMonoid.{u3} G (AddGroup.toSubNegMonoid.{u3} G _inst_2))) (AddTorsor.toAddAction.{max u4 u3, max u2 u1} (Prod.{u4, u3} P' G) (Prod.{u2, u1} P G') (Prod.instAddGroupSum.{u4, u3} P' G _inst_1 _inst_2) (Prod.instAddTorsorProdProdInstAddGroupSum.{u3, u2, u1, u4} G P G' P' _inst_1 _inst_2 _inst_3 _inst_4)))) v p)) (HVAdd.hVAdd.{u3, u1, u1} G G' G' (instHVAdd.{u3, u1} G G' (AddAction.toVAdd.{u3, u1} G G' (SubNegMonoid.toAddMonoid.{u3} G (AddGroup.toSubNegMonoid.{u3} G _inst_2)) (AddTorsor.toAddAction.{u3, u1} G G' _inst_2 _inst_4))) (Prod.snd.{u4, u3} P' G v) (Prod.snd.{u2, u1} P G' p))
-Case conversion may be inaccurate. Consider using '#align prod.snd_vadd Prod.snd_vaddₓ'. -/
 @[simp]
 theorem snd_vadd (v : G × G') (p : P × P') : (v +ᵥ p).2 = v.2 +ᵥ p.2 :=
   rfl
 #align prod.snd_vadd Prod.snd_vadd
 
-/- warning: prod.mk_vadd_mk -> Prod.mk_vadd_mk is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {P : Type.{u2}} {G' : Type.{u3}} {P' : Type.{u4}} [_inst_1 : AddGroup.{u1} G] [_inst_2 : AddGroup.{u3} G'] [_inst_3 : AddTorsor.{u1, u2} G P _inst_1] [_inst_4 : AddTorsor.{u3, u4} G' P' _inst_2] (v : G) (v' : G') (p : P) (p' : P'), Eq.{succ (max u2 u4)} (Prod.{u2, u4} P P') (VAdd.vadd.{max u1 u3, max u2 u4} (Prod.{u1, u3} G G') (Prod.{u2, u4} P P') (AddAction.toHasVadd.{max u1 u3, max u2 u4} (Prod.{u1, u3} G G') (Prod.{u2, u4} P P') (SubNegMonoid.toAddMonoid.{max u1 u3} (Prod.{u1, u3} G G') (AddGroup.toSubNegMonoid.{max u1 u3} (Prod.{u1, u3} G G') (Prod.addGroup.{u1, u3} G G' _inst_1 _inst_2))) (AddTorsor.toAddAction.{max u1 u3, max u2 u4} (Prod.{u1, u3} G G') (Prod.{u2, u4} P P') (Prod.addGroup.{u1, u3} G G' _inst_1 _inst_2) (Prod.addTorsor.{u1, u2, u3, u4} G P G' P' _inst_1 _inst_2 _inst_3 _inst_4))) (Prod.mk.{u1, u3} G G' v v') (Prod.mk.{u2, u4} P P' p p')) (Prod.mk.{u2, u4} P P' (VAdd.vadd.{u1, u2} G P (AddAction.toHasVadd.{u1, u2} G P (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)) (AddTorsor.toAddAction.{u1, u2} G P _inst_1 _inst_3)) v p) (VAdd.vadd.{u3, u4} G' P' (AddAction.toHasVadd.{u3, u4} G' P' (SubNegMonoid.toAddMonoid.{u3} G' (AddGroup.toSubNegMonoid.{u3} G' _inst_2)) (AddTorsor.toAddAction.{u3, u4} G' P' _inst_2 _inst_4)) v' p'))
-but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u4}} {G' : Type.{u3}} {P' : Type.{u1}} [_inst_1 : AddGroup.{u1} P'] [_inst_2 : AddGroup.{u2} G] [_inst_3 : AddTorsor.{u1, u4} P' P _inst_1] [_inst_4 : AddTorsor.{u2, u3} G G' _inst_2] (v : P') (v' : G) (p : P) (p' : G'), Eq.{max (succ u4) (succ u3)} (Prod.{u4, u3} P G') (HVAdd.hVAdd.{max u2 u1, max u3 u4, max u4 u3} (Prod.{u1, u2} P' G) (Prod.{u4, u3} P G') (Prod.{u4, u3} P G') (instHVAdd.{max u1 u2, max u4 u3} (Prod.{u1, u2} P' G) (Prod.{u4, u3} P G') (AddAction.toVAdd.{max u1 u2, max u4 u3} (Prod.{u1, u2} P' G) (Prod.{u4, u3} P G') (Prod.instAddMonoidSum.{u1, u2} P' G (SubNegMonoid.toAddMonoid.{u1} P' (AddGroup.toSubNegMonoid.{u1} P' _inst_1)) (SubNegMonoid.toAddMonoid.{u2} G (AddGroup.toSubNegMonoid.{u2} G _inst_2))) (AddTorsor.toAddAction.{max u1 u2, max u4 u3} (Prod.{u1, u2} P' G) (Prod.{u4, u3} P G') (Prod.instAddGroupSum.{u1, u2} P' G _inst_1 _inst_2) (Prod.instAddTorsorProdProdInstAddGroupSum.{u2, u4, u3, u1} G P G' P' _inst_1 _inst_2 _inst_3 _inst_4)))) (Prod.mk.{u1, u2} P' G v v') (Prod.mk.{u4, u3} P G' p p')) (Prod.mk.{u4, u3} P G' (HVAdd.hVAdd.{u1, u4, u4} P' P P (instHVAdd.{u1, u4} P' P (AddAction.toVAdd.{u1, u4} P' P (SubNegMonoid.toAddMonoid.{u1} P' (AddGroup.toSubNegMonoid.{u1} P' _inst_1)) (AddTorsor.toAddAction.{u1, u4} P' P _inst_1 _inst_3))) v p) (HVAdd.hVAdd.{u2, u3, u3} G G' G' (instHVAdd.{u2, u3} G G' (AddAction.toVAdd.{u2, u3} G G' (SubNegMonoid.toAddMonoid.{u2} G (AddGroup.toSubNegMonoid.{u2} G _inst_2)) (AddTorsor.toAddAction.{u2, u3} G G' _inst_2 _inst_4))) v' p'))
-Case conversion may be inaccurate. Consider using '#align prod.mk_vadd_mk Prod.mk_vadd_mkₓ'. -/
 @[simp]
 theorem mk_vadd_mk (v : G) (v' : G') (p : P) (p' : P') : (v, v') +ᵥ (p, p') = (v +ᵥ p, v' +ᵥ p') :=
   rfl
 #align prod.mk_vadd_mk Prod.mk_vadd_mk
 
-/- warning: prod.fst_vsub -> Prod.fst_vsub is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {P : Type.{u2}} {G' : Type.{u3}} {P' : Type.{u4}} [_inst_1 : AddGroup.{u1} G] [_inst_2 : AddGroup.{u3} G'] [_inst_3 : AddTorsor.{u1, u2} G P _inst_1] [_inst_4 : AddTorsor.{u3, u4} G' P' _inst_2] (p₁ : Prod.{u2, u4} P P') (p₂ : Prod.{u2, u4} P P'), Eq.{succ u1} G (Prod.fst.{u1, u3} G G' (VSub.vsub.{max u1 u3, max u2 u4} (Prod.{u1, u3} G G') (Prod.{u2, u4} P P') (AddTorsor.toHasVsub.{max u1 u3, max u2 u4} (Prod.{u1, u3} G G') (Prod.{u2, u4} P P') (Prod.addGroup.{u1, u3} G G' _inst_1 _inst_2) (Prod.addTorsor.{u1, u2, u3, u4} G P G' P' _inst_1 _inst_2 _inst_3 _inst_4)) p₁ p₂)) (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 _inst_3) (Prod.fst.{u2, u4} P P' p₁) (Prod.fst.{u2, u4} P P' p₂))
-but is expected to have type
-  forall {G : Type.{u1}} {P : Type.{u4}} {G' : Type.{u3}} {P' : Type.{u2}} [_inst_1 : AddGroup.{u2} P'] [_inst_2 : AddGroup.{u1} G] [_inst_3 : AddTorsor.{u2, u4} P' P _inst_1] [_inst_4 : AddTorsor.{u1, u3} G G' _inst_2] (p₁ : Prod.{u4, u3} P G') (p₂ : Prod.{u4, u3} P G'), Eq.{succ u2} P' (Prod.fst.{u2, u1} P' G (VSub.vsub.{max u2 u1, max u4 u3} (Prod.{u2, u1} P' G) (Prod.{u4, u3} P G') (AddTorsor.toVSub.{max u2 u1, max u4 u3} (Prod.{u2, u1} P' G) (Prod.{u4, u3} P G') (Prod.instAddGroupSum.{u2, u1} P' G _inst_1 _inst_2) (Prod.instAddTorsorProdProdInstAddGroupSum.{u1, u4, u3, u2} G P G' P' _inst_1 _inst_2 _inst_3 _inst_4)) p₁ p₂)) (VSub.vsub.{u2, u4} P' P (AddTorsor.toVSub.{u2, u4} P' P _inst_1 _inst_3) (Prod.fst.{u4, u3} P G' p₁) (Prod.fst.{u4, u3} P G' p₂))
-Case conversion may be inaccurate. Consider using '#align prod.fst_vsub Prod.fst_vsubₓ'. -/
 @[simp]
 theorem fst_vsub (p₁ p₂ : P × P') : (p₁ -ᵥ p₂ : G × G').1 = p₁.1 -ᵥ p₂.1 :=
   rfl
 #align prod.fst_vsub Prod.fst_vsub
 
-/- warning: prod.snd_vsub -> Prod.snd_vsub is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {P : Type.{u2}} {G' : Type.{u3}} {P' : Type.{u4}} [_inst_1 : AddGroup.{u1} G] [_inst_2 : AddGroup.{u3} G'] [_inst_3 : AddTorsor.{u1, u2} G P _inst_1] [_inst_4 : AddTorsor.{u3, u4} G' P' _inst_2] (p₁ : Prod.{u2, u4} P P') (p₂ : Prod.{u2, u4} P P'), Eq.{succ u3} G' (Prod.snd.{u1, u3} G G' (VSub.vsub.{max u1 u3, max u2 u4} (Prod.{u1, u3} G G') (Prod.{u2, u4} P P') (AddTorsor.toHasVsub.{max u1 u3, max u2 u4} (Prod.{u1, u3} G G') (Prod.{u2, u4} P P') (Prod.addGroup.{u1, u3} G G' _inst_1 _inst_2) (Prod.addTorsor.{u1, u2, u3, u4} G P G' P' _inst_1 _inst_2 _inst_3 _inst_4)) p₁ p₂)) (VSub.vsub.{u3, u4} G' P' (AddTorsor.toHasVsub.{u3, u4} G' P' _inst_2 _inst_4) (Prod.snd.{u2, u4} P P' p₁) (Prod.snd.{u2, u4} P P' p₂))
-but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u4}} {G' : Type.{u3}} {P' : Type.{u1}} [_inst_1 : AddGroup.{u1} P'] [_inst_2 : AddGroup.{u2} G] [_inst_3 : AddTorsor.{u1, u4} P' P _inst_1] [_inst_4 : AddTorsor.{u2, u3} G G' _inst_2] (p₁ : Prod.{u4, u3} P G') (p₂ : Prod.{u4, u3} P G'), Eq.{succ u2} G (Prod.snd.{u1, u2} P' G (VSub.vsub.{max u1 u2, max u4 u3} (Prod.{u1, u2} P' G) (Prod.{u4, u3} P G') (AddTorsor.toVSub.{max u1 u2, max u4 u3} (Prod.{u1, u2} P' G) (Prod.{u4, u3} P G') (Prod.instAddGroupSum.{u1, u2} P' G _inst_1 _inst_2) (Prod.instAddTorsorProdProdInstAddGroupSum.{u2, u4, u3, u1} G P G' P' _inst_1 _inst_2 _inst_3 _inst_4)) p₁ p₂)) (VSub.vsub.{u2, u3} G G' (AddTorsor.toVSub.{u2, u3} G G' _inst_2 _inst_4) (Prod.snd.{u4, u3} P G' p₁) (Prod.snd.{u4, u3} P G' p₂))
-Case conversion may be inaccurate. Consider using '#align prod.snd_vsub Prod.snd_vsubₓ'. -/
 @[simp]
 theorem snd_vsub (p₁ p₂ : P × P') : (p₁ -ᵥ p₂ : G × G').2 = p₁.2 -ᵥ p₂.2 :=
   rfl
 #align prod.snd_vsub Prod.snd_vsub
 
-/- warning: prod.mk_vsub_mk -> Prod.mk_vsub_mk is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {P : Type.{u2}} {G' : Type.{u3}} {P' : Type.{u4}} [_inst_1 : AddGroup.{u1} G] [_inst_2 : AddGroup.{u3} G'] [_inst_3 : AddTorsor.{u1, u2} G P _inst_1] [_inst_4 : AddTorsor.{u3, u4} G' P' _inst_2] (p₁ : P) (p₂ : P) (p₁' : P') (p₂' : P'), Eq.{max (succ u1) (succ u3)} (Prod.{u1, u3} G G') (VSub.vsub.{max u1 u3, max u2 u4} (Prod.{u1, u3} G G') (Prod.{u2, u4} P P') (AddTorsor.toHasVsub.{max u1 u3, max u2 u4} (Prod.{u1, u3} G G') (Prod.{u2, u4} P P') (Prod.addGroup.{u1, u3} G G' _inst_1 _inst_2) (Prod.addTorsor.{u1, u2, u3, u4} G P G' P' _inst_1 _inst_2 _inst_3 _inst_4)) (Prod.mk.{u2, u4} P P' p₁ p₁') (Prod.mk.{u2, u4} P P' p₂ p₂')) (Prod.mk.{u1, u3} G G' (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 _inst_3) p₁ p₂) (VSub.vsub.{u3, u4} G' P' (AddTorsor.toHasVsub.{u3, u4} G' P' _inst_2 _inst_4) p₁' p₂'))
-but is expected to have type
-  forall {G : Type.{u3}} {P : Type.{u1}} {G' : Type.{u2}} {P' : Type.{u4}} [_inst_1 : AddGroup.{u4} P'] [_inst_2 : AddGroup.{u3} G] [_inst_3 : AddTorsor.{u4, u1} P' P _inst_1] [_inst_4 : AddTorsor.{u3, u2} G G' _inst_2] (p₁ : P) (p₂ : P) (p₁' : G') (p₂' : G'), Eq.{max (succ u4) (succ u3)} (Prod.{u4, u3} P' G) (VSub.vsub.{max u4 u3, max u2 u1} (Prod.{u4, u3} P' G) (Prod.{u1, u2} P G') (AddTorsor.toVSub.{max u4 u3, max u1 u2} (Prod.{u4, u3} P' G) (Prod.{u1, u2} P G') (Prod.instAddGroupSum.{u4, u3} P' G _inst_1 _inst_2) (Prod.instAddTorsorProdProdInstAddGroupSum.{u3, u1, u2, u4} G P G' P' _inst_1 _inst_2 _inst_3 _inst_4)) (Prod.mk.{u1, u2} P G' p₁ p₁') (Prod.mk.{u1, u2} P G' p₂ p₂')) (Prod.mk.{u4, u3} P' G (VSub.vsub.{u4, u1} P' P (AddTorsor.toVSub.{u4, u1} P' P _inst_1 _inst_3) p₁ p₂) (VSub.vsub.{u3, u2} G G' (AddTorsor.toVSub.{u3, u2} G G' _inst_2 _inst_4) p₁' p₂'))
-Case conversion may be inaccurate. Consider using '#align prod.mk_vsub_mk Prod.mk_vsub_mkₓ'. -/
 @[simp]
 theorem mk_vsub_mk (p₁ p₂ : P) (p₁' p₂' : P') :
     ((p₁, p₁') -ᵥ (p₂, p₂') : G × G') = (p₁ -ᵥ p₂, p₁' -ᵥ p₂') :=
@@ -566,23 +386,11 @@ def vaddConst (p : P) : G ≃ P where
 #align equiv.vadd_const Equiv.vaddConst
 -/
 
-/- warning: equiv.coe_vadd_const -> Equiv.coe_vaddConst is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [_inst_2 : AddTorsor.{u1, u2} G P _inst_1] (p : P), Eq.{max (succ u1) (succ u2)} (G -> P) (coeFn.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1), max (succ u1) (succ u2)} (Equiv.{succ u1, succ u2} G P) (fun (_x : Equiv.{succ u1, succ u2} G P) => G -> P) (Equiv.hasCoeToFun.{succ u1, succ u2} G P) (Equiv.vaddConst.{u1, u2} G P _inst_1 _inst_2 p)) (fun (v : G) => VAdd.vadd.{u1, u2} G P (AddAction.toHasVadd.{u1, u2} G P (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)) (AddTorsor.toAddAction.{u1, u2} G P _inst_1 _inst_2)) v p)
-but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [_inst_2 : AddTorsor.{u2, u1} G P _inst_1] (p : P), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : G), (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : G) => P) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} G P) G (fun (_x : G) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : G) => P) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} G P) (Equiv.vaddConst.{u2, u1} G P _inst_1 _inst_2 p)) (fun (v : G) => HVAdd.hVAdd.{u2, u1, u1} G P ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : G) => P) v) (instHVAdd.{u2, u1} G P (AddAction.toVAdd.{u2, u1} G P (SubNegMonoid.toAddMonoid.{u2} G (AddGroup.toSubNegMonoid.{u2} G _inst_1)) (AddTorsor.toAddAction.{u2, u1} G P _inst_1 _inst_2))) v p)
-Case conversion may be inaccurate. Consider using '#align equiv.coe_vadd_const Equiv.coe_vaddConstₓ'. -/
 @[simp]
 theorem coe_vaddConst (p : P) : ⇑(vaddConst p) = fun v => v +ᵥ p :=
   rfl
 #align equiv.coe_vadd_const Equiv.coe_vaddConst
 
-/- warning: equiv.coe_vadd_const_symm -> Equiv.coe_vaddConst_symm is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [_inst_2 : AddTorsor.{u1, u2} G P _inst_1] (p : P), Eq.{max (succ u2) (succ u1)} (P -> G) (coeFn.{max 1 (max (succ u2) (succ u1)) (succ u1) (succ u2), max (succ u2) (succ u1)} (Equiv.{succ u2, succ u1} P G) (fun (_x : Equiv.{succ u2, succ u1} P G) => P -> G) (Equiv.hasCoeToFun.{succ u2, succ u1} P G) (Equiv.symm.{succ u1, succ u2} G P (Equiv.vaddConst.{u1, u2} G P _inst_1 _inst_2 p))) (fun (p' : P) => VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 _inst_2) p' p)
-but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [_inst_2 : AddTorsor.{u2, u1} G P _inst_1] (p : P), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : P), (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : P) => G) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (Equiv.{succ u1, succ u2} P G) P (fun (_x : P) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : P) => G) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u2} P G) (Equiv.symm.{succ u2, succ u1} G P (Equiv.vaddConst.{u2, u1} G P _inst_1 _inst_2 p))) (fun (p' : P) => VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 _inst_2) p' p)
-Case conversion may be inaccurate. Consider using '#align equiv.coe_vadd_const_symm Equiv.coe_vaddConst_symmₓ'. -/
 @[simp]
 theorem coe_vaddConst_symm (p : P) : ⇑(vaddConst p).symm = fun p' => p' -ᵥ p :=
   rfl
@@ -598,23 +406,11 @@ def constVSub (p : P) : P ≃ G where
 #align equiv.const_vsub Equiv.constVSub
 -/
 
-/- warning: equiv.coe_const_vsub -> Equiv.coe_constVSub is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [_inst_2 : AddTorsor.{u1, u2} G P _inst_1] (p : P), Eq.{max (succ u2) (succ u1)} (P -> G) (coeFn.{max 1 (max (succ u2) (succ u1)) (succ u1) (succ u2), max (succ u2) (succ u1)} (Equiv.{succ u2, succ u1} P G) (fun (_x : Equiv.{succ u2, succ u1} P G) => P -> G) (Equiv.hasCoeToFun.{succ u2, succ u1} P G) (Equiv.constVSub.{u1, u2} G P _inst_1 _inst_2 p)) (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 _inst_2) p)
-but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [_inst_2 : AddTorsor.{u2, u1} G P _inst_1] (p : P), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : P), (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : P) => G) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (Equiv.{succ u1, succ u2} P G) P (fun (_x : P) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : P) => G) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u2} P G) (Equiv.constVSub.{u2, u1} G P _inst_1 _inst_2 p)) ((fun (x._@.Mathlib.Algebra.AddTorsor._hyg.3028 : P) (x._@.Mathlib.Algebra.AddTorsor._hyg.3030 : P) => VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 _inst_2) x._@.Mathlib.Algebra.AddTorsor._hyg.3028 x._@.Mathlib.Algebra.AddTorsor._hyg.3030) p)
-Case conversion may be inaccurate. Consider using '#align equiv.coe_const_vsub Equiv.coe_constVSubₓ'. -/
 @[simp]
 theorem coe_constVSub (p : P) : ⇑(constVSub p) = (· -ᵥ ·) p :=
   rfl
 #align equiv.coe_const_vsub Equiv.coe_constVSub
 
-/- warning: equiv.coe_const_vsub_symm -> Equiv.coe_constVSub_symm is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [_inst_2 : AddTorsor.{u1, u2} G P _inst_1] (p : P), Eq.{max (succ u1) (succ u2)} (G -> P) (coeFn.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1), max (succ u1) (succ u2)} (Equiv.{succ u1, succ u2} G P) (fun (_x : Equiv.{succ u1, succ u2} G P) => G -> P) (Equiv.hasCoeToFun.{succ u1, succ u2} G P) (Equiv.symm.{succ u2, succ u1} P G (Equiv.constVSub.{u1, u2} G P _inst_1 _inst_2 p))) (fun (v : G) => VAdd.vadd.{u1, u2} G P (AddAction.toHasVadd.{u1, u2} G P (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)) (AddTorsor.toAddAction.{u1, u2} G P _inst_1 _inst_2)) (Neg.neg.{u1} G (SubNegMonoid.toHasNeg.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)) v) p)
-but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [_inst_2 : AddTorsor.{u2, u1} G P _inst_1] (p : P), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : G), (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : G) => P) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} G P) G (fun (_x : G) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : G) => P) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} G P) (Equiv.symm.{succ u1, succ u2} P G (Equiv.constVSub.{u2, u1} G P _inst_1 _inst_2 p))) (fun (v : G) => HVAdd.hVAdd.{u2, u1, u1} G P P (instHVAdd.{u2, u1} G P (AddAction.toVAdd.{u2, u1} G P (SubNegMonoid.toAddMonoid.{u2} G (AddGroup.toSubNegMonoid.{u2} G _inst_1)) (AddTorsor.toAddAction.{u2, u1} G P _inst_1 _inst_2))) (Neg.neg.{u2} G (NegZeroClass.toNeg.{u2} G (SubNegZeroMonoid.toNegZeroClass.{u2} G (SubtractionMonoid.toSubNegZeroMonoid.{u2} G (AddGroup.toSubtractionMonoid.{u2} G _inst_1)))) v) p)
-Case conversion may be inaccurate. Consider using '#align equiv.coe_const_vsub_symm Equiv.coe_constVSub_symmₓ'. -/
 @[simp]
 theorem coe_constVSub_symm (p : P) : ⇑(constVSub p).symm = fun v => -v +ᵥ p :=
   rfl
@@ -641,12 +437,6 @@ theorem coe_constVAdd (v : G) : ⇑(constVAdd P v) = (· +ᵥ ·) v :=
 
 variable (G)
 
-/- warning: equiv.const_vadd_zero -> Equiv.constVAdd_zero is a dubious translation:
-lean 3 declaration is
-  forall (G : Type.{u1}) (P : Type.{u2}) [_inst_1 : AddGroup.{u1} G] [_inst_2 : AddTorsor.{u1, u2} G P _inst_1], Eq.{succ u2} (Equiv.Perm.{succ u2} P) (Equiv.constVAdd.{u1, u2} G P _inst_1 _inst_2 (OfNat.ofNat.{u1} G 0 (OfNat.mk.{u1} G 0 (Zero.zero.{u1} G (AddZeroClass.toHasZero.{u1} G (AddMonoid.toAddZeroClass.{u1} G (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)))))))) (OfNat.ofNat.{u2} (Equiv.Perm.{succ u2} P) 1 (OfNat.mk.{u2} (Equiv.Perm.{succ u2} P) 1 (One.one.{u2} (Equiv.Perm.{succ u2} P) (MulOneClass.toHasOne.{u2} (Equiv.Perm.{succ u2} P) (Monoid.toMulOneClass.{u2} (Equiv.Perm.{succ u2} P) (DivInvMonoid.toMonoid.{u2} (Equiv.Perm.{succ u2} P) (Group.toDivInvMonoid.{u2} (Equiv.Perm.{succ u2} P) (Equiv.Perm.permGroup.{u2} P))))))))
-but is expected to have type
-  forall (G : Type.{u1}) (P : Type.{u2}) [_inst_1 : AddGroup.{u1} G] [_inst_2 : AddTorsor.{u1, u2} G P _inst_1], Eq.{succ u2} (Equiv.Perm.{succ u2} P) (Equiv.constVAdd.{u1, u2} G P _inst_1 _inst_2 (OfNat.ofNat.{u1} G 0 (Zero.toOfNat0.{u1} G (NegZeroClass.toZero.{u1} G (SubNegZeroMonoid.toNegZeroClass.{u1} G (SubtractionMonoid.toSubNegZeroMonoid.{u1} G (AddGroup.toSubtractionMonoid.{u1} G _inst_1))))))) (OfNat.ofNat.{u2} (Equiv.Perm.{succ u2} P) 1 (One.toOfNat1.{u2} (Equiv.Perm.{succ u2} P) (InvOneClass.toOne.{u2} (Equiv.Perm.{succ u2} P) (DivInvOneMonoid.toInvOneClass.{u2} (Equiv.Perm.{succ u2} P) (DivisionMonoid.toDivInvOneMonoid.{u2} (Equiv.Perm.{succ u2} P) (Group.toDivisionMonoid.{u2} (Equiv.Perm.{succ u2} P) (Equiv.Perm.permGroup.{u2} P)))))))
-Case conversion may be inaccurate. Consider using '#align equiv.const_vadd_zero Equiv.constVAdd_zeroₓ'. -/
 @[simp]
 theorem constVAdd_zero : constVAdd P (0 : G) = 1 :=
   ext <| zero_vadd G
@@ -654,12 +444,6 @@ theorem constVAdd_zero : constVAdd P (0 : G) = 1 :=
 
 variable {G}
 
-/- warning: equiv.const_vadd_add -> Equiv.constVAdd_add is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} (P : Type.{u2}) [_inst_1 : AddGroup.{u1} G] [_inst_2 : AddTorsor.{u1, u2} G P _inst_1] (v₁ : G) (v₂ : G), Eq.{succ u2} (Equiv.Perm.{succ u2} P) (Equiv.constVAdd.{u1, u2} G P _inst_1 _inst_2 (HAdd.hAdd.{u1, u1, u1} G G G (instHAdd.{u1} G (AddZeroClass.toHasAdd.{u1} G (AddMonoid.toAddZeroClass.{u1} G (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1))))) v₁ v₂)) (HMul.hMul.{u2, u2, u2} (Equiv.Perm.{succ u2} P) (Equiv.Perm.{succ u2} P) (Equiv.Perm.{succ u2} P) (instHMul.{u2} (Equiv.Perm.{succ u2} P) (MulOneClass.toHasMul.{u2} (Equiv.Perm.{succ u2} P) (Monoid.toMulOneClass.{u2} (Equiv.Perm.{succ u2} P) (DivInvMonoid.toMonoid.{u2} (Equiv.Perm.{succ u2} P) (Group.toDivInvMonoid.{u2} (Equiv.Perm.{succ u2} P) (Equiv.Perm.permGroup.{u2} P)))))) (Equiv.constVAdd.{u1, u2} G P _inst_1 _inst_2 v₁) (Equiv.constVAdd.{u1, u2} G P _inst_1 _inst_2 v₂))
-but is expected to have type
-  forall {G : Type.{u1}} (P : Type.{u2}) [_inst_1 : AddGroup.{u1} G] [_inst_2 : AddTorsor.{u1, u2} G P _inst_1] (v₁ : G) (v₂ : G), Eq.{succ u2} (Equiv.Perm.{succ u2} P) (Equiv.constVAdd.{u1, u2} G P _inst_1 _inst_2 (HAdd.hAdd.{u1, u1, u1} G G G (instHAdd.{u1} G (AddZeroClass.toAdd.{u1} G (AddMonoid.toAddZeroClass.{u1} G (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1))))) v₁ v₂)) (HMul.hMul.{u2, u2, u2} (Equiv.Perm.{succ u2} P) (Equiv.Perm.{succ u2} P) (Equiv.Perm.{succ u2} P) (instHMul.{u2} (Equiv.Perm.{succ u2} P) (MulOneClass.toMul.{u2} (Equiv.Perm.{succ u2} P) (Monoid.toMulOneClass.{u2} (Equiv.Perm.{succ u2} P) (DivInvMonoid.toMonoid.{u2} (Equiv.Perm.{succ u2} P) (Group.toDivInvMonoid.{u2} (Equiv.Perm.{succ u2} P) (Equiv.Perm.permGroup.{u2} P)))))) (Equiv.constVAdd.{u1, u2} G P _inst_1 _inst_2 v₁) (Equiv.constVAdd.{u1, u2} G P _inst_1 _inst_2 v₂))
-Case conversion may be inaccurate. Consider using '#align equiv.const_vadd_add Equiv.constVAdd_addₓ'. -/
 @[simp]
 theorem constVAdd_add (v₁ v₂ : G) : constVAdd P (v₁ + v₂) = constVAdd P v₁ * constVAdd P v₂ :=
   ext <| add_vadd v₁ v₂
@@ -712,12 +496,6 @@ theorem pointReflection_involutive (x : P) : Involutive (pointReflection x : P 
 #align equiv.point_reflection_involutive Equiv.pointReflection_involutive
 -/
 
-/- warning: equiv.point_reflection_fixed_iff_of_injective_bit0 -> Equiv.pointReflection_fixed_iff_of_injective_bit0 is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [_inst_2 : AddTorsor.{u1, u2} G P _inst_1] {x : P} {y : P}, (Function.Injective.{succ u1, succ u1} G G (bit0.{u1} G (AddZeroClass.toHasAdd.{u1} G (AddMonoid.toAddZeroClass.{u1} G (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)))))) -> (Iff (Eq.{succ u2} P (coeFn.{succ u2, succ u2} (Equiv.Perm.{succ u2} P) (fun (_x : Equiv.{succ u2, succ u2} P P) => P -> P) (Equiv.hasCoeToFun.{succ u2, succ u2} P P) (Equiv.pointReflection.{u1, u2} G P _inst_1 _inst_2 x) y) y) (Eq.{succ u2} P y x))
-but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [_inst_2 : AddTorsor.{u2, u1} G P _inst_1] {x : P} {y : P}, (Function.Injective.{succ u2, succ u2} G G (bit0.{u2} G (AddZeroClass.toAdd.{u2} G (AddMonoid.toAddZeroClass.{u2} G (SubNegMonoid.toAddMonoid.{u2} G (AddGroup.toSubNegMonoid.{u2} G _inst_1)))))) -> (Iff (Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : P) => P) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} P) P (fun (_x : P) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : P) => P) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} P P) (Equiv.pointReflection.{u2, u1} G P _inst_1 _inst_2 x) y) y) (Eq.{succ u1} P y x))
-Case conversion may be inaccurate. Consider using '#align equiv.point_reflection_fixed_iff_of_injective_bit0 Equiv.pointReflection_fixed_iff_of_injective_bit0ₓ'. -/
 /-- `x` is the only fixed point of `point_reflection x`. This lemma requires
 `x + x = y + y ↔ x = y`. There is no typeclass to use here, so we add it as an explicit argument. -/
 theorem pointReflection_fixed_iff_of_injective_bit0 {x y : P} (h : Injective (bit0 : G → G)) :
@@ -728,12 +506,6 @@ theorem pointReflection_fixed_iff_of_injective_bit0 {x y : P} (h : Injective (bi
 
 omit G
 
-/- warning: equiv.injective_point_reflection_left_of_injective_bit0 -> Equiv.injective_pointReflection_left_of_injective_bit0 is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {P : Type.{u2}} [_inst_3 : AddCommGroup.{u1} G] [_inst_4 : AddTorsor.{u1, u2} G P (AddCommGroup.toAddGroup.{u1} G _inst_3)], (Function.Injective.{succ u1, succ u1} G G (bit0.{u1} G (AddZeroClass.toHasAdd.{u1} G (AddMonoid.toAddZeroClass.{u1} G (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G (AddCommGroup.toAddGroup.{u1} G _inst_3))))))) -> (forall (y : P), Function.Injective.{succ u2, succ u2} P P (fun (x : P) => coeFn.{succ u2, succ u2} (Equiv.Perm.{succ u2} P) (fun (_x : Equiv.{succ u2, succ u2} P P) => P -> P) (Equiv.hasCoeToFun.{succ u2, succ u2} P P) (Equiv.pointReflection.{u1, u2} G P (AddCommGroup.toAddGroup.{u1} G _inst_3) _inst_4 x) y))
-but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_3 : AddCommGroup.{u2} G] [_inst_4 : AddTorsor.{u2, u1} G P (AddCommGroup.toAddGroup.{u2} G _inst_3)], (Function.Injective.{succ u2, succ u2} G G (bit0.{u2} G (AddZeroClass.toAdd.{u2} G (AddMonoid.toAddZeroClass.{u2} G (SubNegMonoid.toAddMonoid.{u2} G (AddGroup.toSubNegMonoid.{u2} G (AddCommGroup.toAddGroup.{u2} G _inst_3))))))) -> (forall (y : P), Function.Injective.{succ u1, succ u1} P ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : P) => P) y) (fun (x : P) => FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} P) P (fun (_x : P) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : P) => P) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} P P) (Equiv.pointReflection.{u2, u1} G P (AddCommGroup.toAddGroup.{u2} G _inst_3) _inst_4 x) y))
-Case conversion may be inaccurate. Consider using '#align equiv.injective_point_reflection_left_of_injective_bit0 Equiv.injective_pointReflection_left_of_injective_bit0ₓ'. -/
 theorem injective_pointReflection_left_of_injective_bit0 {G P : Type _} [AddCommGroup G]
     [AddTorsor G P] (h : Injective (bit0 : G → G)) (y : P) :
     Injective fun x : P => pointReflection x y :=
@@ -745,12 +517,6 @@ theorem injective_pointReflection_left_of_injective_bit0 {G P : Type _} [AddComm
 
 end Equiv
 
-/- warning: add_torsor.subsingleton_iff -> AddTorsor.subsingleton_iff is a dubious translation:
-lean 3 declaration is
-  forall (G : Type.{u1}) (P : Type.{u2}) [_inst_1 : AddGroup.{u1} G] [_inst_2 : AddTorsor.{u1, u2} G P _inst_1], Iff (Subsingleton.{succ u1} G) (Subsingleton.{succ u2} P)
-but is expected to have type
-  forall (G : Type.{u2}) (P : Type.{u1}) [_inst_1 : AddGroup.{u2} G] [_inst_2 : AddTorsor.{u2, u1} G P _inst_1], Iff (Subsingleton.{succ u2} G) (Subsingleton.{succ u1} P)
-Case conversion may be inaccurate. Consider using '#align add_torsor.subsingleton_iff AddTorsor.subsingleton_iffₓ'. -/
 theorem AddTorsor.subsingleton_iff (G P : Type _) [AddGroup G] [AddTorsor G P] :
     Subsingleton G ↔ Subsingleton P := by
   inhabit P

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

@@ -570,7 +570,7 @@ def vaddConst (p : P) : G ≃ P where
 lean 3 declaration is
   forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [_inst_2 : AddTorsor.{u1, u2} G P _inst_1] (p : P), Eq.{max (succ u1) (succ u2)} (G -> P) (coeFn.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1), max (succ u1) (succ u2)} (Equiv.{succ u1, succ u2} G P) (fun (_x : Equiv.{succ u1, succ u2} G P) => G -> P) (Equiv.hasCoeToFun.{succ u1, succ u2} G P) (Equiv.vaddConst.{u1, u2} G P _inst_1 _inst_2 p)) (fun (v : G) => VAdd.vadd.{u1, u2} G P (AddAction.toHasVadd.{u1, u2} G P (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)) (AddTorsor.toAddAction.{u1, u2} G P _inst_1 _inst_2)) v p)
 but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [_inst_2 : AddTorsor.{u2, u1} G P _inst_1] (p : P), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : G), (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : G) => P) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} G P) G (fun (_x : G) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : G) => P) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} G P) (Equiv.vaddConst.{u2, u1} G P _inst_1 _inst_2 p)) (fun (v : G) => HVAdd.hVAdd.{u2, u1, u1} G P ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : G) => P) v) (instHVAdd.{u2, u1} G P (AddAction.toVAdd.{u2, u1} G P (SubNegMonoid.toAddMonoid.{u2} G (AddGroup.toSubNegMonoid.{u2} G _inst_1)) (AddTorsor.toAddAction.{u2, u1} G P _inst_1 _inst_2))) v p)
+  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [_inst_2 : AddTorsor.{u2, u1} G P _inst_1] (p : P), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : G), (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : G) => P) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} G P) G (fun (_x : G) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : G) => P) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} G P) (Equiv.vaddConst.{u2, u1} G P _inst_1 _inst_2 p)) (fun (v : G) => HVAdd.hVAdd.{u2, u1, u1} G P ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : G) => P) v) (instHVAdd.{u2, u1} G P (AddAction.toVAdd.{u2, u1} G P (SubNegMonoid.toAddMonoid.{u2} G (AddGroup.toSubNegMonoid.{u2} G _inst_1)) (AddTorsor.toAddAction.{u2, u1} G P _inst_1 _inst_2))) v p)
 Case conversion may be inaccurate. Consider using '#align equiv.coe_vadd_const Equiv.coe_vaddConstₓ'. -/
 @[simp]
 theorem coe_vaddConst (p : P) : ⇑(vaddConst p) = fun v => v +ᵥ p :=
@@ -581,7 +581,7 @@ theorem coe_vaddConst (p : P) : ⇑(vaddConst p) = fun v => v +ᵥ p :=
 lean 3 declaration is
   forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [_inst_2 : AddTorsor.{u1, u2} G P _inst_1] (p : P), Eq.{max (succ u2) (succ u1)} (P -> G) (coeFn.{max 1 (max (succ u2) (succ u1)) (succ u1) (succ u2), max (succ u2) (succ u1)} (Equiv.{succ u2, succ u1} P G) (fun (_x : Equiv.{succ u2, succ u1} P G) => P -> G) (Equiv.hasCoeToFun.{succ u2, succ u1} P G) (Equiv.symm.{succ u1, succ u2} G P (Equiv.vaddConst.{u1, u2} G P _inst_1 _inst_2 p))) (fun (p' : P) => VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 _inst_2) p' p)
 but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [_inst_2 : AddTorsor.{u2, u1} G P _inst_1] (p : P), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : P), (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : P) => G) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (Equiv.{succ u1, succ u2} P G) P (fun (_x : P) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : P) => G) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u2} P G) (Equiv.symm.{succ u2, succ u1} G P (Equiv.vaddConst.{u2, u1} G P _inst_1 _inst_2 p))) (fun (p' : P) => VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 _inst_2) p' p)
+  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [_inst_2 : AddTorsor.{u2, u1} G P _inst_1] (p : P), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : P), (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : P) => G) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (Equiv.{succ u1, succ u2} P G) P (fun (_x : P) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : P) => G) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u2} P G) (Equiv.symm.{succ u2, succ u1} G P (Equiv.vaddConst.{u2, u1} G P _inst_1 _inst_2 p))) (fun (p' : P) => VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 _inst_2) p' p)
 Case conversion may be inaccurate. Consider using '#align equiv.coe_vadd_const_symm Equiv.coe_vaddConst_symmₓ'. -/
 @[simp]
 theorem coe_vaddConst_symm (p : P) : ⇑(vaddConst p).symm = fun p' => p' -ᵥ p :=
@@ -602,7 +602,7 @@ def constVSub (p : P) : P ≃ G where
 lean 3 declaration is
   forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [_inst_2 : AddTorsor.{u1, u2} G P _inst_1] (p : P), Eq.{max (succ u2) (succ u1)} (P -> G) (coeFn.{max 1 (max (succ u2) (succ u1)) (succ u1) (succ u2), max (succ u2) (succ u1)} (Equiv.{succ u2, succ u1} P G) (fun (_x : Equiv.{succ u2, succ u1} P G) => P -> G) (Equiv.hasCoeToFun.{succ u2, succ u1} P G) (Equiv.constVSub.{u1, u2} G P _inst_1 _inst_2 p)) (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 _inst_2) p)
 but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [_inst_2 : AddTorsor.{u2, u1} G P _inst_1] (p : P), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : P), (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : P) => G) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (Equiv.{succ u1, succ u2} P G) P (fun (_x : P) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : P) => G) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u2} P G) (Equiv.constVSub.{u2, u1} G P _inst_1 _inst_2 p)) ((fun (x._@.Mathlib.Algebra.AddTorsor._hyg.3028 : P) (x._@.Mathlib.Algebra.AddTorsor._hyg.3030 : P) => VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 _inst_2) x._@.Mathlib.Algebra.AddTorsor._hyg.3028 x._@.Mathlib.Algebra.AddTorsor._hyg.3030) p)
+  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [_inst_2 : AddTorsor.{u2, u1} G P _inst_1] (p : P), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : P), (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : P) => G) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (Equiv.{succ u1, succ u2} P G) P (fun (_x : P) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : P) => G) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u2} P G) (Equiv.constVSub.{u2, u1} G P _inst_1 _inst_2 p)) ((fun (x._@.Mathlib.Algebra.AddTorsor._hyg.3028 : P) (x._@.Mathlib.Algebra.AddTorsor._hyg.3030 : P) => VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 _inst_2) x._@.Mathlib.Algebra.AddTorsor._hyg.3028 x._@.Mathlib.Algebra.AddTorsor._hyg.3030) p)
 Case conversion may be inaccurate. Consider using '#align equiv.coe_const_vsub Equiv.coe_constVSubₓ'. -/
 @[simp]
 theorem coe_constVSub (p : P) : ⇑(constVSub p) = (· -ᵥ ·) p :=
@@ -613,7 +613,7 @@ theorem coe_constVSub (p : P) : ⇑(constVSub p) = (· -ᵥ ·) p :=
 lean 3 declaration is
   forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [_inst_2 : AddTorsor.{u1, u2} G P _inst_1] (p : P), Eq.{max (succ u1) (succ u2)} (G -> P) (coeFn.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1), max (succ u1) (succ u2)} (Equiv.{succ u1, succ u2} G P) (fun (_x : Equiv.{succ u1, succ u2} G P) => G -> P) (Equiv.hasCoeToFun.{succ u1, succ u2} G P) (Equiv.symm.{succ u2, succ u1} P G (Equiv.constVSub.{u1, u2} G P _inst_1 _inst_2 p))) (fun (v : G) => VAdd.vadd.{u1, u2} G P (AddAction.toHasVadd.{u1, u2} G P (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)) (AddTorsor.toAddAction.{u1, u2} G P _inst_1 _inst_2)) (Neg.neg.{u1} G (SubNegMonoid.toHasNeg.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)) v) p)
 but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [_inst_2 : AddTorsor.{u2, u1} G P _inst_1] (p : P), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : G), (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : G) => P) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} G P) G (fun (_x : G) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : G) => P) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} G P) (Equiv.symm.{succ u1, succ u2} P G (Equiv.constVSub.{u2, u1} G P _inst_1 _inst_2 p))) (fun (v : G) => HVAdd.hVAdd.{u2, u1, u1} G P P (instHVAdd.{u2, u1} G P (AddAction.toVAdd.{u2, u1} G P (SubNegMonoid.toAddMonoid.{u2} G (AddGroup.toSubNegMonoid.{u2} G _inst_1)) (AddTorsor.toAddAction.{u2, u1} G P _inst_1 _inst_2))) (Neg.neg.{u2} G (NegZeroClass.toNeg.{u2} G (SubNegZeroMonoid.toNegZeroClass.{u2} G (SubtractionMonoid.toSubNegZeroMonoid.{u2} G (AddGroup.toSubtractionMonoid.{u2} G _inst_1)))) v) p)
+  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [_inst_2 : AddTorsor.{u2, u1} G P _inst_1] (p : P), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : G), (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : G) => P) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} G P) G (fun (_x : G) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : G) => P) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} G P) (Equiv.symm.{succ u1, succ u2} P G (Equiv.constVSub.{u2, u1} G P _inst_1 _inst_2 p))) (fun (v : G) => HVAdd.hVAdd.{u2, u1, u1} G P P (instHVAdd.{u2, u1} G P (AddAction.toVAdd.{u2, u1} G P (SubNegMonoid.toAddMonoid.{u2} G (AddGroup.toSubNegMonoid.{u2} G _inst_1)) (AddTorsor.toAddAction.{u2, u1} G P _inst_1 _inst_2))) (Neg.neg.{u2} G (NegZeroClass.toNeg.{u2} G (SubNegZeroMonoid.toNegZeroClass.{u2} G (SubtractionMonoid.toSubNegZeroMonoid.{u2} G (AddGroup.toSubtractionMonoid.{u2} G _inst_1)))) v) p)
 Case conversion may be inaccurate. Consider using '#align equiv.coe_const_vsub_symm Equiv.coe_constVSub_symmₓ'. -/
 @[simp]
 theorem coe_constVSub_symm (p : P) : ⇑(constVSub p).symm = fun v => -v +ᵥ p :=
@@ -716,7 +716,7 @@ theorem pointReflection_involutive (x : P) : Involutive (pointReflection x : P 
 lean 3 declaration is
   forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [_inst_2 : AddTorsor.{u1, u2} G P _inst_1] {x : P} {y : P}, (Function.Injective.{succ u1, succ u1} G G (bit0.{u1} G (AddZeroClass.toHasAdd.{u1} G (AddMonoid.toAddZeroClass.{u1} G (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)))))) -> (Iff (Eq.{succ u2} P (coeFn.{succ u2, succ u2} (Equiv.Perm.{succ u2} P) (fun (_x : Equiv.{succ u2, succ u2} P P) => P -> P) (Equiv.hasCoeToFun.{succ u2, succ u2} P P) (Equiv.pointReflection.{u1, u2} G P _inst_1 _inst_2 x) y) y) (Eq.{succ u2} P y x))
 but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [_inst_2 : AddTorsor.{u2, u1} G P _inst_1] {x : P} {y : P}, (Function.Injective.{succ u2, succ u2} G G (bit0.{u2} G (AddZeroClass.toAdd.{u2} G (AddMonoid.toAddZeroClass.{u2} G (SubNegMonoid.toAddMonoid.{u2} G (AddGroup.toSubNegMonoid.{u2} G _inst_1)))))) -> (Iff (Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : P) => P) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} P) P (fun (_x : P) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : P) => P) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} P P) (Equiv.pointReflection.{u2, u1} G P _inst_1 _inst_2 x) y) y) (Eq.{succ u1} P y x))
+  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [_inst_2 : AddTorsor.{u2, u1} G P _inst_1] {x : P} {y : P}, (Function.Injective.{succ u2, succ u2} G G (bit0.{u2} G (AddZeroClass.toAdd.{u2} G (AddMonoid.toAddZeroClass.{u2} G (SubNegMonoid.toAddMonoid.{u2} G (AddGroup.toSubNegMonoid.{u2} G _inst_1)))))) -> (Iff (Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : P) => P) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} P) P (fun (_x : P) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : P) => P) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} P P) (Equiv.pointReflection.{u2, u1} G P _inst_1 _inst_2 x) y) y) (Eq.{succ u1} P y x))
 Case conversion may be inaccurate. Consider using '#align equiv.point_reflection_fixed_iff_of_injective_bit0 Equiv.pointReflection_fixed_iff_of_injective_bit0ₓ'. -/
 /-- `x` is the only fixed point of `point_reflection x`. This lemma requires
 `x + x = y + y ↔ x = y`. There is no typeclass to use here, so we add it as an explicit argument. -/
@@ -732,7 +732,7 @@ omit G
 lean 3 declaration is
   forall {G : Type.{u1}} {P : Type.{u2}} [_inst_3 : AddCommGroup.{u1} G] [_inst_4 : AddTorsor.{u1, u2} G P (AddCommGroup.toAddGroup.{u1} G _inst_3)], (Function.Injective.{succ u1, succ u1} G G (bit0.{u1} G (AddZeroClass.toHasAdd.{u1} G (AddMonoid.toAddZeroClass.{u1} G (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G (AddCommGroup.toAddGroup.{u1} G _inst_3))))))) -> (forall (y : P), Function.Injective.{succ u2, succ u2} P P (fun (x : P) => coeFn.{succ u2, succ u2} (Equiv.Perm.{succ u2} P) (fun (_x : Equiv.{succ u2, succ u2} P P) => P -> P) (Equiv.hasCoeToFun.{succ u2, succ u2} P P) (Equiv.pointReflection.{u1, u2} G P (AddCommGroup.toAddGroup.{u1} G _inst_3) _inst_4 x) y))
 but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_3 : AddCommGroup.{u2} G] [_inst_4 : AddTorsor.{u2, u1} G P (AddCommGroup.toAddGroup.{u2} G _inst_3)], (Function.Injective.{succ u2, succ u2} G G (bit0.{u2} G (AddZeroClass.toAdd.{u2} G (AddMonoid.toAddZeroClass.{u2} G (SubNegMonoid.toAddMonoid.{u2} G (AddGroup.toSubNegMonoid.{u2} G (AddCommGroup.toAddGroup.{u2} G _inst_3))))))) -> (forall (y : P), Function.Injective.{succ u1, succ u1} P ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : P) => P) y) (fun (x : P) => FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} P) P (fun (_x : P) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : P) => P) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} P P) (Equiv.pointReflection.{u2, u1} G P (AddCommGroup.toAddGroup.{u2} G _inst_3) _inst_4 x) y))
+  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_3 : AddCommGroup.{u2} G] [_inst_4 : AddTorsor.{u2, u1} G P (AddCommGroup.toAddGroup.{u2} G _inst_3)], (Function.Injective.{succ u2, succ u2} G G (bit0.{u2} G (AddZeroClass.toAdd.{u2} G (AddMonoid.toAddZeroClass.{u2} G (SubNegMonoid.toAddMonoid.{u2} G (AddGroup.toSubNegMonoid.{u2} G (AddCommGroup.toAddGroup.{u2} G _inst_3))))))) -> (forall (y : P), Function.Injective.{succ u1, succ u1} P ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : P) => P) y) (fun (x : P) => FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} P) P (fun (_x : P) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : P) => P) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} P P) (Equiv.pointReflection.{u2, u1} G P (AddCommGroup.toAddGroup.{u2} G _inst_3) _inst_4 x) y))
 Case conversion may be inaccurate. Consider using '#align equiv.injective_point_reflection_left_of_injective_bit0 Equiv.injective_pointReflection_left_of_injective_bit0ₓ'. -/
 theorem injective_pointReflection_left_of_injective_bit0 {G P : Type _} [AddCommGroup G]
     [AddTorsor G P] (h : Injective (bit0 : G → G)) (y : P) :

mathlib commit https://github.com/leanprover-community/mathlib/commit/09079525fd01b3dda35e96adaa08d2f943e1648c

@@ -60,7 +60,7 @@ class AddTorsor (G : outParam (Type _)) (P : Type _) [outParam <| AddGroup G] ex
 #align add_torsor AddTorsor
 -/
 
-attribute [instance, nolint dangerous_instance] AddTorsor.nonempty
+attribute [instance 100, nolint dangerous_instance] AddTorsor.nonempty
 
 attribute [nolint dangerous_instance] AddTorsor.toHasVsub
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/347636a7a80595d55bedf6e6fbd996a3c39da69a

@@ -464,7 +464,7 @@ instance : AddTorsor (G × G') (P × P')
 lean 3 declaration is
   forall {G : Type.{u1}} {P : Type.{u2}} {G' : Type.{u3}} {P' : Type.{u4}} [_inst_1 : AddGroup.{u1} G] [_inst_2 : AddGroup.{u3} G'] [_inst_3 : AddTorsor.{u1, u2} G P _inst_1] [_inst_4 : AddTorsor.{u3, u4} G' P' _inst_2] (v : Prod.{u1, u3} G G') (p : Prod.{u2, u4} P P'), Eq.{succ u2} P (Prod.fst.{u2, u4} P P' (VAdd.vadd.{max u1 u3, max u2 u4} (Prod.{u1, u3} G G') (Prod.{u2, u4} P P') (AddAction.toHasVadd.{max u1 u3, max u2 u4} (Prod.{u1, u3} G G') (Prod.{u2, u4} P P') (SubNegMonoid.toAddMonoid.{max u1 u3} (Prod.{u1, u3} G G') (AddGroup.toSubNegMonoid.{max u1 u3} (Prod.{u1, u3} G G') (Prod.addGroup.{u1, u3} G G' _inst_1 _inst_2))) (AddTorsor.toAddAction.{max u1 u3, max u2 u4} (Prod.{u1, u3} G G') (Prod.{u2, u4} P P') (Prod.addGroup.{u1, u3} G G' _inst_1 _inst_2) (Prod.addTorsor.{u1, u2, u3, u4} G P G' P' _inst_1 _inst_2 _inst_3 _inst_4))) v p)) (VAdd.vadd.{u1, u2} G P (AddAction.toHasVadd.{u1, u2} G P (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)) (AddTorsor.toAddAction.{u1, u2} G P _inst_1 _inst_3)) (Prod.fst.{u1, u3} G G' v) (Prod.fst.{u2, u4} P P' p))
 but is expected to have type
-  forall {G : Type.{u4}} {P : Type.{u2}} {G' : Type.{u3}} {P' : Type.{u1}} [_inst_1 : AddGroup.{u4} G] [_inst_2 : AddGroup.{u3} G'] [_inst_3 : AddTorsor.{u4, u2} G P _inst_1] [_inst_4 : AddTorsor.{u3, u1} G' P' _inst_2] (v : Prod.{u4, u3} G G') (p : Prod.{u2, u1} P P'), Eq.{succ u2} P (Prod.fst.{u2, u1} P P' (HVAdd.hVAdd.{max u4 u3, max u2 u1, max u2 u1} (Prod.{u4, u3} G G') (Prod.{u2, u1} P P') (Prod.{u2, u1} P P') (instHVAdd.{max u4 u3, max u2 u1} (Prod.{u4, u3} G G') (Prod.{u2, u1} P P') (AddAction.toVAdd.{max u4 u3, max u2 u1} (Prod.{u4, u3} G G') (Prod.{u2, u1} P P') (Prod.instAddMonoidSum.{u4, u3} G G' (SubNegMonoid.toAddMonoid.{u4} G (AddGroup.toSubNegMonoid.{u4} G _inst_1)) (SubNegMonoid.toAddMonoid.{u3} G' (AddGroup.toSubNegMonoid.{u3} G' _inst_2))) (AddTorsor.toAddAction.{max u4 u3, max u2 u1} (Prod.{u4, u3} G G') (Prod.{u2, u1} P P') (Prod.instAddGroupSum.{u4, u3} G G' _inst_1 _inst_2) (Prod.instAddTorsorProdProdInstAddGroupSum.{u4, u2, u3, u1} G P G' P' _inst_1 _inst_2 _inst_3 _inst_4)))) v p)) (HVAdd.hVAdd.{u4, u2, u2} G P P (instHVAdd.{u4, u2} G P (AddAction.toVAdd.{u4, u2} G P (SubNegMonoid.toAddMonoid.{u4} G (AddGroup.toSubNegMonoid.{u4} G _inst_1)) (AddTorsor.toAddAction.{u4, u2} G P _inst_1 _inst_3))) (Prod.fst.{u4, u3} G G' v) (Prod.fst.{u2, u1} P P' p))
+  forall {G : Type.{u3}} {P : Type.{u2}} {G' : Type.{u1}} {P' : Type.{u4}} [_inst_1 : AddGroup.{u4} P'] [_inst_2 : AddGroup.{u3} G] [_inst_3 : AddTorsor.{u4, u2} P' P _inst_1] [_inst_4 : AddTorsor.{u3, u1} G G' _inst_2] (v : Prod.{u4, u3} P' G) (p : Prod.{u2, u1} P G'), Eq.{succ u2} P (Prod.fst.{u2, u1} P G' (HVAdd.hVAdd.{max u4 u3, max u2 u1, max u2 u1} (Prod.{u4, u3} P' G) (Prod.{u2, u1} P G') (Prod.{u2, u1} P G') (instHVAdd.{max u4 u3, max u2 u1} (Prod.{u4, u3} P' G) (Prod.{u2, u1} P G') (AddAction.toVAdd.{max u4 u3, max u2 u1} (Prod.{u4, u3} P' G) (Prod.{u2, u1} P G') (Prod.instAddMonoidSum.{u4, u3} P' G (SubNegMonoid.toAddMonoid.{u4} P' (AddGroup.toSubNegMonoid.{u4} P' _inst_1)) (SubNegMonoid.toAddMonoid.{u3} G (AddGroup.toSubNegMonoid.{u3} G _inst_2))) (AddTorsor.toAddAction.{max u4 u3, max u2 u1} (Prod.{u4, u3} P' G) (Prod.{u2, u1} P G') (Prod.instAddGroupSum.{u4, u3} P' G _inst_1 _inst_2) (Prod.instAddTorsorProdProdInstAddGroupSum.{u3, u2, u1, u4} G P G' P' _inst_1 _inst_2 _inst_3 _inst_4)))) v p)) (HVAdd.hVAdd.{u4, u2, u2} P' P P (instHVAdd.{u4, u2} P' P (AddAction.toVAdd.{u4, u2} P' P (SubNegMonoid.toAddMonoid.{u4} P' (AddGroup.toSubNegMonoid.{u4} P' _inst_1)) (AddTorsor.toAddAction.{u4, u2} P' P _inst_1 _inst_3))) (Prod.fst.{u4, u3} P' G v) (Prod.fst.{u2, u1} P G' p))
 Case conversion may be inaccurate. Consider using '#align prod.fst_vadd Prod.fst_vaddₓ'. -/
 @[simp]
 theorem fst_vadd (v : G × G') (p : P × P') : (v +ᵥ p).1 = v.1 +ᵥ p.1 :=
@@ -475,7 +475,7 @@ theorem fst_vadd (v : G × G') (p : P × P') : (v +ᵥ p).1 = v.1 +ᵥ p.1 :=
 lean 3 declaration is
   forall {G : Type.{u1}} {P : Type.{u2}} {G' : Type.{u3}} {P' : Type.{u4}} [_inst_1 : AddGroup.{u1} G] [_inst_2 : AddGroup.{u3} G'] [_inst_3 : AddTorsor.{u1, u2} G P _inst_1] [_inst_4 : AddTorsor.{u3, u4} G' P' _inst_2] (v : Prod.{u1, u3} G G') (p : Prod.{u2, u4} P P'), Eq.{succ u4} P' (Prod.snd.{u2, u4} P P' (VAdd.vadd.{max u1 u3, max u2 u4} (Prod.{u1, u3} G G') (Prod.{u2, u4} P P') (AddAction.toHasVadd.{max u1 u3, max u2 u4} (Prod.{u1, u3} G G') (Prod.{u2, u4} P P') (SubNegMonoid.toAddMonoid.{max u1 u3} (Prod.{u1, u3} G G') (AddGroup.toSubNegMonoid.{max u1 u3} (Prod.{u1, u3} G G') (Prod.addGroup.{u1, u3} G G' _inst_1 _inst_2))) (AddTorsor.toAddAction.{max u1 u3, max u2 u4} (Prod.{u1, u3} G G') (Prod.{u2, u4} P P') (Prod.addGroup.{u1, u3} G G' _inst_1 _inst_2) (Prod.addTorsor.{u1, u2, u3, u4} G P G' P' _inst_1 _inst_2 _inst_3 _inst_4))) v p)) (VAdd.vadd.{u3, u4} G' P' (AddAction.toHasVadd.{u3, u4} G' P' (SubNegMonoid.toAddMonoid.{u3} G' (AddGroup.toSubNegMonoid.{u3} G' _inst_2)) (AddTorsor.toAddAction.{u3, u4} G' P' _inst_2 _inst_4)) (Prod.snd.{u1, u3} G G' v) (Prod.snd.{u2, u4} P P' p))
 but is expected to have type
-  forall {G : Type.{u4}} {P : Type.{u2}} {G' : Type.{u3}} {P' : Type.{u1}} [_inst_1 : AddGroup.{u4} G] [_inst_2 : AddGroup.{u3} G'] [_inst_3 : AddTorsor.{u4, u2} G P _inst_1] [_inst_4 : AddTorsor.{u3, u1} G' P' _inst_2] (v : Prod.{u4, u3} G G') (p : Prod.{u2, u1} P P'), Eq.{succ u1} P' (Prod.snd.{u2, u1} P P' (HVAdd.hVAdd.{max u4 u3, max u2 u1, max u2 u1} (Prod.{u4, u3} G G') (Prod.{u2, u1} P P') (Prod.{u2, u1} P P') (instHVAdd.{max u4 u3, max u2 u1} (Prod.{u4, u3} G G') (Prod.{u2, u1} P P') (AddAction.toVAdd.{max u4 u3, max u2 u1} (Prod.{u4, u3} G G') (Prod.{u2, u1} P P') (Prod.instAddMonoidSum.{u4, u3} G G' (SubNegMonoid.toAddMonoid.{u4} G (AddGroup.toSubNegMonoid.{u4} G _inst_1)) (SubNegMonoid.toAddMonoid.{u3} G' (AddGroup.toSubNegMonoid.{u3} G' _inst_2))) (AddTorsor.toAddAction.{max u4 u3, max u2 u1} (Prod.{u4, u3} G G') (Prod.{u2, u1} P P') (Prod.instAddGroupSum.{u4, u3} G G' _inst_1 _inst_2) (Prod.instAddTorsorProdProdInstAddGroupSum.{u4, u2, u3, u1} G P G' P' _inst_1 _inst_2 _inst_3 _inst_4)))) v p)) (HVAdd.hVAdd.{u3, u1, u1} G' P' P' (instHVAdd.{u3, u1} G' P' (AddAction.toVAdd.{u3, u1} G' P' (SubNegMonoid.toAddMonoid.{u3} G' (AddGroup.toSubNegMonoid.{u3} G' _inst_2)) (AddTorsor.toAddAction.{u3, u1} G' P' _inst_2 _inst_4))) (Prod.snd.{u4, u3} G G' v) (Prod.snd.{u2, u1} P P' p))
+  forall {G : Type.{u3}} {P : Type.{u2}} {G' : Type.{u1}} {P' : Type.{u4}} [_inst_1 : AddGroup.{u4} P'] [_inst_2 : AddGroup.{u3} G] [_inst_3 : AddTorsor.{u4, u2} P' P _inst_1] [_inst_4 : AddTorsor.{u3, u1} G G' _inst_2] (v : Prod.{u4, u3} P' G) (p : Prod.{u2, u1} P G'), Eq.{succ u1} G' (Prod.snd.{u2, u1} P G' (HVAdd.hVAdd.{max u4 u3, max u2 u1, max u2 u1} (Prod.{u4, u3} P' G) (Prod.{u2, u1} P G') (Prod.{u2, u1} P G') (instHVAdd.{max u4 u3, max u2 u1} (Prod.{u4, u3} P' G) (Prod.{u2, u1} P G') (AddAction.toVAdd.{max u4 u3, max u2 u1} (Prod.{u4, u3} P' G) (Prod.{u2, u1} P G') (Prod.instAddMonoidSum.{u4, u3} P' G (SubNegMonoid.toAddMonoid.{u4} P' (AddGroup.toSubNegMonoid.{u4} P' _inst_1)) (SubNegMonoid.toAddMonoid.{u3} G (AddGroup.toSubNegMonoid.{u3} G _inst_2))) (AddTorsor.toAddAction.{max u4 u3, max u2 u1} (Prod.{u4, u3} P' G) (Prod.{u2, u1} P G') (Prod.instAddGroupSum.{u4, u3} P' G _inst_1 _inst_2) (Prod.instAddTorsorProdProdInstAddGroupSum.{u3, u2, u1, u4} G P G' P' _inst_1 _inst_2 _inst_3 _inst_4)))) v p)) (HVAdd.hVAdd.{u3, u1, u1} G G' G' (instHVAdd.{u3, u1} G G' (AddAction.toVAdd.{u3, u1} G G' (SubNegMonoid.toAddMonoid.{u3} G (AddGroup.toSubNegMonoid.{u3} G _inst_2)) (AddTorsor.toAddAction.{u3, u1} G G' _inst_2 _inst_4))) (Prod.snd.{u4, u3} P' G v) (Prod.snd.{u2, u1} P G' p))
 Case conversion may be inaccurate. Consider using '#align prod.snd_vadd Prod.snd_vaddₓ'. -/
 @[simp]
 theorem snd_vadd (v : G × G') (p : P × P') : (v +ᵥ p).2 = v.2 +ᵥ p.2 :=
@@ -486,7 +486,7 @@ theorem snd_vadd (v : G × G') (p : P × P') : (v +ᵥ p).2 = v.2 +ᵥ p.2 :=
 lean 3 declaration is
   forall {G : Type.{u1}} {P : Type.{u2}} {G' : Type.{u3}} {P' : Type.{u4}} [_inst_1 : AddGroup.{u1} G] [_inst_2 : AddGroup.{u3} G'] [_inst_3 : AddTorsor.{u1, u2} G P _inst_1] [_inst_4 : AddTorsor.{u3, u4} G' P' _inst_2] (v : G) (v' : G') (p : P) (p' : P'), Eq.{succ (max u2 u4)} (Prod.{u2, u4} P P') (VAdd.vadd.{max u1 u3, max u2 u4} (Prod.{u1, u3} G G') (Prod.{u2, u4} P P') (AddAction.toHasVadd.{max u1 u3, max u2 u4} (Prod.{u1, u3} G G') (Prod.{u2, u4} P P') (SubNegMonoid.toAddMonoid.{max u1 u3} (Prod.{u1, u3} G G') (AddGroup.toSubNegMonoid.{max u1 u3} (Prod.{u1, u3} G G') (Prod.addGroup.{u1, u3} G G' _inst_1 _inst_2))) (AddTorsor.toAddAction.{max u1 u3, max u2 u4} (Prod.{u1, u3} G G') (Prod.{u2, u4} P P') (Prod.addGroup.{u1, u3} G G' _inst_1 _inst_2) (Prod.addTorsor.{u1, u2, u3, u4} G P G' P' _inst_1 _inst_2 _inst_3 _inst_4))) (Prod.mk.{u1, u3} G G' v v') (Prod.mk.{u2, u4} P P' p p')) (Prod.mk.{u2, u4} P P' (VAdd.vadd.{u1, u2} G P (AddAction.toHasVadd.{u1, u2} G P (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)) (AddTorsor.toAddAction.{u1, u2} G P _inst_1 _inst_3)) v p) (VAdd.vadd.{u3, u4} G' P' (AddAction.toHasVadd.{u3, u4} G' P' (SubNegMonoid.toAddMonoid.{u3} G' (AddGroup.toSubNegMonoid.{u3} G' _inst_2)) (AddTorsor.toAddAction.{u3, u4} G' P' _inst_2 _inst_4)) v' p'))
 but is expected to have type
-  forall {G : Type.{u1}} {P : Type.{u4}} {G' : Type.{u2}} {P' : Type.{u3}} [_inst_1 : AddGroup.{u1} G] [_inst_2 : AddGroup.{u2} G'] [_inst_3 : AddTorsor.{u1, u4} G P _inst_1] [_inst_4 : AddTorsor.{u2, u3} G' P' _inst_2] (v : G) (v' : G') (p : P) (p' : P'), Eq.{max (succ u4) (succ u3)} (Prod.{u4, u3} P P') (HVAdd.hVAdd.{max u2 u1, max u3 u4, max u4 u3} (Prod.{u1, u2} G G') (Prod.{u4, u3} P P') (Prod.{u4, u3} P P') (instHVAdd.{max u1 u2, max u4 u3} (Prod.{u1, u2} G G') (Prod.{u4, u3} P P') (AddAction.toVAdd.{max u1 u2, max u4 u3} (Prod.{u1, u2} G G') (Prod.{u4, u3} P P') (Prod.instAddMonoidSum.{u1, u2} G G' (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)) (SubNegMonoid.toAddMonoid.{u2} G' (AddGroup.toSubNegMonoid.{u2} G' _inst_2))) (AddTorsor.toAddAction.{max u1 u2, max u4 u3} (Prod.{u1, u2} G G') (Prod.{u4, u3} P P') (Prod.instAddGroupSum.{u1, u2} G G' _inst_1 _inst_2) (Prod.instAddTorsorProdProdInstAddGroupSum.{u1, u4, u2, u3} G P G' P' _inst_1 _inst_2 _inst_3 _inst_4)))) (Prod.mk.{u1, u2} G G' v v') (Prod.mk.{u4, u3} P P' p p')) (Prod.mk.{u4, u3} P P' (HVAdd.hVAdd.{u1, u4, u4} G P P (instHVAdd.{u1, u4} G P (AddAction.toVAdd.{u1, u4} G P (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)) (AddTorsor.toAddAction.{u1, u4} G P _inst_1 _inst_3))) v p) (HVAdd.hVAdd.{u2, u3, u3} G' P' P' (instHVAdd.{u2, u3} G' P' (AddAction.toVAdd.{u2, u3} G' P' (SubNegMonoid.toAddMonoid.{u2} G' (AddGroup.toSubNegMonoid.{u2} G' _inst_2)) (AddTorsor.toAddAction.{u2, u3} G' P' _inst_2 _inst_4))) v' p'))
+  forall {G : Type.{u2}} {P : Type.{u4}} {G' : Type.{u3}} {P' : Type.{u1}} [_inst_1 : AddGroup.{u1} P'] [_inst_2 : AddGroup.{u2} G] [_inst_3 : AddTorsor.{u1, u4} P' P _inst_1] [_inst_4 : AddTorsor.{u2, u3} G G' _inst_2] (v : P') (v' : G) (p : P) (p' : G'), Eq.{max (succ u4) (succ u3)} (Prod.{u4, u3} P G') (HVAdd.hVAdd.{max u2 u1, max u3 u4, max u4 u3} (Prod.{u1, u2} P' G) (Prod.{u4, u3} P G') (Prod.{u4, u3} P G') (instHVAdd.{max u1 u2, max u4 u3} (Prod.{u1, u2} P' G) (Prod.{u4, u3} P G') (AddAction.toVAdd.{max u1 u2, max u4 u3} (Prod.{u1, u2} P' G) (Prod.{u4, u3} P G') (Prod.instAddMonoidSum.{u1, u2} P' G (SubNegMonoid.toAddMonoid.{u1} P' (AddGroup.toSubNegMonoid.{u1} P' _inst_1)) (SubNegMonoid.toAddMonoid.{u2} G (AddGroup.toSubNegMonoid.{u2} G _inst_2))) (AddTorsor.toAddAction.{max u1 u2, max u4 u3} (Prod.{u1, u2} P' G) (Prod.{u4, u3} P G') (Prod.instAddGroupSum.{u1, u2} P' G _inst_1 _inst_2) (Prod.instAddTorsorProdProdInstAddGroupSum.{u2, u4, u3, u1} G P G' P' _inst_1 _inst_2 _inst_3 _inst_4)))) (Prod.mk.{u1, u2} P' G v v') (Prod.mk.{u4, u3} P G' p p')) (Prod.mk.{u4, u3} P G' (HVAdd.hVAdd.{u1, u4, u4} P' P P (instHVAdd.{u1, u4} P' P (AddAction.toVAdd.{u1, u4} P' P (SubNegMonoid.toAddMonoid.{u1} P' (AddGroup.toSubNegMonoid.{u1} P' _inst_1)) (AddTorsor.toAddAction.{u1, u4} P' P _inst_1 _inst_3))) v p) (HVAdd.hVAdd.{u2, u3, u3} G G' G' (instHVAdd.{u2, u3} G G' (AddAction.toVAdd.{u2, u3} G G' (SubNegMonoid.toAddMonoid.{u2} G (AddGroup.toSubNegMonoid.{u2} G _inst_2)) (AddTorsor.toAddAction.{u2, u3} G G' _inst_2 _inst_4))) v' p'))
 Case conversion may be inaccurate. Consider using '#align prod.mk_vadd_mk Prod.mk_vadd_mkₓ'. -/
 @[simp]
 theorem mk_vadd_mk (v : G) (v' : G') (p : P) (p' : P') : (v, v') +ᵥ (p, p') = (v +ᵥ p, v' +ᵥ p') :=
@@ -497,7 +497,7 @@ theorem mk_vadd_mk (v : G) (v' : G') (p : P) (p' : P') : (v, v') +ᵥ (p, p') =
 lean 3 declaration is
   forall {G : Type.{u1}} {P : Type.{u2}} {G' : Type.{u3}} {P' : Type.{u4}} [_inst_1 : AddGroup.{u1} G] [_inst_2 : AddGroup.{u3} G'] [_inst_3 : AddTorsor.{u1, u2} G P _inst_1] [_inst_4 : AddTorsor.{u3, u4} G' P' _inst_2] (p₁ : Prod.{u2, u4} P P') (p₂ : Prod.{u2, u4} P P'), Eq.{succ u1} G (Prod.fst.{u1, u3} G G' (VSub.vsub.{max u1 u3, max u2 u4} (Prod.{u1, u3} G G') (Prod.{u2, u4} P P') (AddTorsor.toHasVsub.{max u1 u3, max u2 u4} (Prod.{u1, u3} G G') (Prod.{u2, u4} P P') (Prod.addGroup.{u1, u3} G G' _inst_1 _inst_2) (Prod.addTorsor.{u1, u2, u3, u4} G P G' P' _inst_1 _inst_2 _inst_3 _inst_4)) p₁ p₂)) (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 _inst_3) (Prod.fst.{u2, u4} P P' p₁) (Prod.fst.{u2, u4} P P' p₂))
 but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u4}} {G' : Type.{u1}} {P' : Type.{u3}} [_inst_1 : AddGroup.{u2} G] [_inst_2 : AddGroup.{u1} G'] [_inst_3 : AddTorsor.{u2, u4} G P _inst_1] [_inst_4 : AddTorsor.{u1, u3} G' P' _inst_2] (p₁ : Prod.{u4, u3} P P') (p₂ : Prod.{u4, u3} P P'), Eq.{succ u2} G (Prod.fst.{u2, u1} G G' (VSub.vsub.{max u2 u1, max u4 u3} (Prod.{u2, u1} G G') (Prod.{u4, u3} P P') (AddTorsor.toVSub.{max u2 u1, max u4 u3} (Prod.{u2, u1} G G') (Prod.{u4, u3} P P') (Prod.instAddGroupSum.{u2, u1} G G' _inst_1 _inst_2) (Prod.instAddTorsorProdProdInstAddGroupSum.{u2, u4, u1, u3} G P G' P' _inst_1 _inst_2 _inst_3 _inst_4)) p₁ p₂)) (VSub.vsub.{u2, u4} G P (AddTorsor.toVSub.{u2, u4} G P _inst_1 _inst_3) (Prod.fst.{u4, u3} P P' p₁) (Prod.fst.{u4, u3} P P' p₂))
+  forall {G : Type.{u1}} {P : Type.{u4}} {G' : Type.{u3}} {P' : Type.{u2}} [_inst_1 : AddGroup.{u2} P'] [_inst_2 : AddGroup.{u1} G] [_inst_3 : AddTorsor.{u2, u4} P' P _inst_1] [_inst_4 : AddTorsor.{u1, u3} G G' _inst_2] (p₁ : Prod.{u4, u3} P G') (p₂ : Prod.{u4, u3} P G'), Eq.{succ u2} P' (Prod.fst.{u2, u1} P' G (VSub.vsub.{max u2 u1, max u4 u3} (Prod.{u2, u1} P' G) (Prod.{u4, u3} P G') (AddTorsor.toVSub.{max u2 u1, max u4 u3} (Prod.{u2, u1} P' G) (Prod.{u4, u3} P G') (Prod.instAddGroupSum.{u2, u1} P' G _inst_1 _inst_2) (Prod.instAddTorsorProdProdInstAddGroupSum.{u1, u4, u3, u2} G P G' P' _inst_1 _inst_2 _inst_3 _inst_4)) p₁ p₂)) (VSub.vsub.{u2, u4} P' P (AddTorsor.toVSub.{u2, u4} P' P _inst_1 _inst_3) (Prod.fst.{u4, u3} P G' p₁) (Prod.fst.{u4, u3} P G' p₂))
 Case conversion may be inaccurate. Consider using '#align prod.fst_vsub Prod.fst_vsubₓ'. -/
 @[simp]
 theorem fst_vsub (p₁ p₂ : P × P') : (p₁ -ᵥ p₂ : G × G').1 = p₁.1 -ᵥ p₂.1 :=
@@ -508,7 +508,7 @@ theorem fst_vsub (p₁ p₂ : P × P') : (p₁ -ᵥ p₂ : G × G').1 = p₁.1 -
 lean 3 declaration is
   forall {G : Type.{u1}} {P : Type.{u2}} {G' : Type.{u3}} {P' : Type.{u4}} [_inst_1 : AddGroup.{u1} G] [_inst_2 : AddGroup.{u3} G'] [_inst_3 : AddTorsor.{u1, u2} G P _inst_1] [_inst_4 : AddTorsor.{u3, u4} G' P' _inst_2] (p₁ : Prod.{u2, u4} P P') (p₂ : Prod.{u2, u4} P P'), Eq.{succ u3} G' (Prod.snd.{u1, u3} G G' (VSub.vsub.{max u1 u3, max u2 u4} (Prod.{u1, u3} G G') (Prod.{u2, u4} P P') (AddTorsor.toHasVsub.{max u1 u3, max u2 u4} (Prod.{u1, u3} G G') (Prod.{u2, u4} P P') (Prod.addGroup.{u1, u3} G G' _inst_1 _inst_2) (Prod.addTorsor.{u1, u2, u3, u4} G P G' P' _inst_1 _inst_2 _inst_3 _inst_4)) p₁ p₂)) (VSub.vsub.{u3, u4} G' P' (AddTorsor.toHasVsub.{u3, u4} G' P' _inst_2 _inst_4) (Prod.snd.{u2, u4} P P' p₁) (Prod.snd.{u2, u4} P P' p₂))
 but is expected to have type
-  forall {G : Type.{u1}} {P : Type.{u4}} {G' : Type.{u2}} {P' : Type.{u3}} [_inst_1 : AddGroup.{u1} G] [_inst_2 : AddGroup.{u2} G'] [_inst_3 : AddTorsor.{u1, u4} G P _inst_1] [_inst_4 : AddTorsor.{u2, u3} G' P' _inst_2] (p₁ : Prod.{u4, u3} P P') (p₂ : Prod.{u4, u3} P P'), Eq.{succ u2} G' (Prod.snd.{u1, u2} G G' (VSub.vsub.{max u1 u2, max u4 u3} (Prod.{u1, u2} G G') (Prod.{u4, u3} P P') (AddTorsor.toVSub.{max u1 u2, max u4 u3} (Prod.{u1, u2} G G') (Prod.{u4, u3} P P') (Prod.instAddGroupSum.{u1, u2} G G' _inst_1 _inst_2) (Prod.instAddTorsorProdProdInstAddGroupSum.{u1, u4, u2, u3} G P G' P' _inst_1 _inst_2 _inst_3 _inst_4)) p₁ p₂)) (VSub.vsub.{u2, u3} G' P' (AddTorsor.toVSub.{u2, u3} G' P' _inst_2 _inst_4) (Prod.snd.{u4, u3} P P' p₁) (Prod.snd.{u4, u3} P P' p₂))
+  forall {G : Type.{u2}} {P : Type.{u4}} {G' : Type.{u3}} {P' : Type.{u1}} [_inst_1 : AddGroup.{u1} P'] [_inst_2 : AddGroup.{u2} G] [_inst_3 : AddTorsor.{u1, u4} P' P _inst_1] [_inst_4 : AddTorsor.{u2, u3} G G' _inst_2] (p₁ : Prod.{u4, u3} P G') (p₂ : Prod.{u4, u3} P G'), Eq.{succ u2} G (Prod.snd.{u1, u2} P' G (VSub.vsub.{max u1 u2, max u4 u3} (Prod.{u1, u2} P' G) (Prod.{u4, u3} P G') (AddTorsor.toVSub.{max u1 u2, max u4 u3} (Prod.{u1, u2} P' G) (Prod.{u4, u3} P G') (Prod.instAddGroupSum.{u1, u2} P' G _inst_1 _inst_2) (Prod.instAddTorsorProdProdInstAddGroupSum.{u2, u4, u3, u1} G P G' P' _inst_1 _inst_2 _inst_3 _inst_4)) p₁ p₂)) (VSub.vsub.{u2, u3} G G' (AddTorsor.toVSub.{u2, u3} G G' _inst_2 _inst_4) (Prod.snd.{u4, u3} P G' p₁) (Prod.snd.{u4, u3} P G' p₂))
 Case conversion may be inaccurate. Consider using '#align prod.snd_vsub Prod.snd_vsubₓ'. -/
 @[simp]
 theorem snd_vsub (p₁ p₂ : P × P') : (p₁ -ᵥ p₂ : G × G').2 = p₁.2 -ᵥ p₂.2 :=
@@ -519,7 +519,7 @@ theorem snd_vsub (p₁ p₂ : P × P') : (p₁ -ᵥ p₂ : G × G').2 = p₁.2 -
 lean 3 declaration is
   forall {G : Type.{u1}} {P : Type.{u2}} {G' : Type.{u3}} {P' : Type.{u4}} [_inst_1 : AddGroup.{u1} G] [_inst_2 : AddGroup.{u3} G'] [_inst_3 : AddTorsor.{u1, u2} G P _inst_1] [_inst_4 : AddTorsor.{u3, u4} G' P' _inst_2] (p₁ : P) (p₂ : P) (p₁' : P') (p₂' : P'), Eq.{max (succ u1) (succ u3)} (Prod.{u1, u3} G G') (VSub.vsub.{max u1 u3, max u2 u4} (Prod.{u1, u3} G G') (Prod.{u2, u4} P P') (AddTorsor.toHasVsub.{max u1 u3, max u2 u4} (Prod.{u1, u3} G G') (Prod.{u2, u4} P P') (Prod.addGroup.{u1, u3} G G' _inst_1 _inst_2) (Prod.addTorsor.{u1, u2, u3, u4} G P G' P' _inst_1 _inst_2 _inst_3 _inst_4)) (Prod.mk.{u2, u4} P P' p₁ p₁') (Prod.mk.{u2, u4} P P' p₂ p₂')) (Prod.mk.{u1, u3} G G' (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 _inst_3) p₁ p₂) (VSub.vsub.{u3, u4} G' P' (AddTorsor.toHasVsub.{u3, u4} G' P' _inst_2 _inst_4) p₁' p₂'))
 but is expected to have type
-  forall {G : Type.{u4}} {P : Type.{u1}} {G' : Type.{u3}} {P' : Type.{u2}} [_inst_1 : AddGroup.{u4} G] [_inst_2 : AddGroup.{u3} G'] [_inst_3 : AddTorsor.{u4, u1} G P _inst_1] [_inst_4 : AddTorsor.{u3, u2} G' P' _inst_2] (p₁ : P) (p₂ : P) (p₁' : P') (p₂' : P'), Eq.{max (succ u4) (succ u3)} (Prod.{u4, u3} G G') (VSub.vsub.{max u4 u3, max u2 u1} (Prod.{u4, u3} G G') (Prod.{u1, u2} P P') (AddTorsor.toVSub.{max u4 u3, max u1 u2} (Prod.{u4, u3} G G') (Prod.{u1, u2} P P') (Prod.instAddGroupSum.{u4, u3} G G' _inst_1 _inst_2) (Prod.instAddTorsorProdProdInstAddGroupSum.{u4, u1, u3, u2} G P G' P' _inst_1 _inst_2 _inst_3 _inst_4)) (Prod.mk.{u1, u2} P P' p₁ p₁') (Prod.mk.{u1, u2} P P' p₂ p₂')) (Prod.mk.{u4, u3} G G' (VSub.vsub.{u4, u1} G P (AddTorsor.toVSub.{u4, u1} G P _inst_1 _inst_3) p₁ p₂) (VSub.vsub.{u3, u2} G' P' (AddTorsor.toVSub.{u3, u2} G' P' _inst_2 _inst_4) p₁' p₂'))
+  forall {G : Type.{u3}} {P : Type.{u1}} {G' : Type.{u2}} {P' : Type.{u4}} [_inst_1 : AddGroup.{u4} P'] [_inst_2 : AddGroup.{u3} G] [_inst_3 : AddTorsor.{u4, u1} P' P _inst_1] [_inst_4 : AddTorsor.{u3, u2} G G' _inst_2] (p₁ : P) (p₂ : P) (p₁' : G') (p₂' : G'), Eq.{max (succ u4) (succ u3)} (Prod.{u4, u3} P' G) (VSub.vsub.{max u4 u3, max u2 u1} (Prod.{u4, u3} P' G) (Prod.{u1, u2} P G') (AddTorsor.toVSub.{max u4 u3, max u1 u2} (Prod.{u4, u3} P' G) (Prod.{u1, u2} P G') (Prod.instAddGroupSum.{u4, u3} P' G _inst_1 _inst_2) (Prod.instAddTorsorProdProdInstAddGroupSum.{u3, u1, u2, u4} G P G' P' _inst_1 _inst_2 _inst_3 _inst_4)) (Prod.mk.{u1, u2} P G' p₁ p₁') (Prod.mk.{u1, u2} P G' p₂ p₂')) (Prod.mk.{u4, u3} P' G (VSub.vsub.{u4, u1} P' P (AddTorsor.toVSub.{u4, u1} P' P _inst_1 _inst_3) p₁ p₂) (VSub.vsub.{u3, u2} G G' (AddTorsor.toVSub.{u3, u2} G G' _inst_2 _inst_4) p₁' p₂'))
 Case conversion may be inaccurate. Consider using '#align prod.mk_vsub_mk Prod.mk_vsub_mkₓ'. -/
 @[simp]
 theorem mk_vsub_mk (p₁ p₂ : P) (p₁' p₂' : P') :
@@ -602,7 +602,7 @@ def constVSub (p : P) : P ≃ G where
 lean 3 declaration is
   forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [_inst_2 : AddTorsor.{u1, u2} G P _inst_1] (p : P), Eq.{max (succ u2) (succ u1)} (P -> G) (coeFn.{max 1 (max (succ u2) (succ u1)) (succ u1) (succ u2), max (succ u2) (succ u1)} (Equiv.{succ u2, succ u1} P G) (fun (_x : Equiv.{succ u2, succ u1} P G) => P -> G) (Equiv.hasCoeToFun.{succ u2, succ u1} P G) (Equiv.constVSub.{u1, u2} G P _inst_1 _inst_2 p)) (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 _inst_2) p)
 but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [_inst_2 : AddTorsor.{u2, u1} G P _inst_1] (p : P), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : P), (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : P) => G) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (Equiv.{succ u1, succ u2} P G) P (fun (_x : P) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : P) => G) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u2} P G) (Equiv.constVSub.{u2, u1} G P _inst_1 _inst_2 p)) ((fun (x._@.Mathlib.Algebra.AddTorsor._hyg.2809 : P) (x._@.Mathlib.Algebra.AddTorsor._hyg.2811 : P) => VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 _inst_2) x._@.Mathlib.Algebra.AddTorsor._hyg.2809 x._@.Mathlib.Algebra.AddTorsor._hyg.2811) p)
+  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [_inst_2 : AddTorsor.{u2, u1} G P _inst_1] (p : P), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : P), (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : P) => G) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (Equiv.{succ u1, succ u2} P G) P (fun (_x : P) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : P) => G) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u2} P G) (Equiv.constVSub.{u2, u1} G P _inst_1 _inst_2 p)) ((fun (x._@.Mathlib.Algebra.AddTorsor._hyg.3028 : P) (x._@.Mathlib.Algebra.AddTorsor._hyg.3030 : P) => VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 _inst_2) x._@.Mathlib.Algebra.AddTorsor._hyg.3028 x._@.Mathlib.Algebra.AddTorsor._hyg.3030) p)
 Case conversion may be inaccurate. Consider using '#align equiv.coe_const_vsub Equiv.coe_constVSubₓ'. -/
 @[simp]
 theorem coe_constVSub (p : P) : ⇑(constVSub p) = (· -ᵥ ·) p :=

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

@@ -570,7 +570,7 @@ def vaddConst (p : P) : G ≃ P where
 lean 3 declaration is
   forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [_inst_2 : AddTorsor.{u1, u2} G P _inst_1] (p : P), Eq.{max (succ u1) (succ u2)} (G -> P) (coeFn.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1), max (succ u1) (succ u2)} (Equiv.{succ u1, succ u2} G P) (fun (_x : Equiv.{succ u1, succ u2} G P) => G -> P) (Equiv.hasCoeToFun.{succ u1, succ u2} G P) (Equiv.vaddConst.{u1, u2} G P _inst_1 _inst_2 p)) (fun (v : G) => VAdd.vadd.{u1, u2} G P (AddAction.toHasVadd.{u1, u2} G P (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)) (AddTorsor.toAddAction.{u1, u2} G P _inst_1 _inst_2)) v p)
 but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [_inst_2 : AddTorsor.{u2, u1} G P _inst_1] (p : P), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : G), (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : G) => P) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} G P) G (fun (_x : G) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : G) => P) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} G P) (Equiv.vaddConst.{u2, u1} G P _inst_1 _inst_2 p)) (fun (v : G) => HVAdd.hVAdd.{u2, u1, u1} G P ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : G) => P) v) (instHVAdd.{u2, u1} G P (AddAction.toVAdd.{u2, u1} G P (SubNegMonoid.toAddMonoid.{u2} G (AddGroup.toSubNegMonoid.{u2} G _inst_1)) (AddTorsor.toAddAction.{u2, u1} G P _inst_1 _inst_2))) v p)
+  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [_inst_2 : AddTorsor.{u2, u1} G P _inst_1] (p : P), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : G), (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : G) => P) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} G P) G (fun (_x : G) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : G) => P) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} G P) (Equiv.vaddConst.{u2, u1} G P _inst_1 _inst_2 p)) (fun (v : G) => HVAdd.hVAdd.{u2, u1, u1} G P ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : G) => P) v) (instHVAdd.{u2, u1} G P (AddAction.toVAdd.{u2, u1} G P (SubNegMonoid.toAddMonoid.{u2} G (AddGroup.toSubNegMonoid.{u2} G _inst_1)) (AddTorsor.toAddAction.{u2, u1} G P _inst_1 _inst_2))) v p)
 Case conversion may be inaccurate. Consider using '#align equiv.coe_vadd_const Equiv.coe_vaddConstₓ'. -/
 @[simp]
 theorem coe_vaddConst (p : P) : ⇑(vaddConst p) = fun v => v +ᵥ p :=
@@ -581,7 +581,7 @@ theorem coe_vaddConst (p : P) : ⇑(vaddConst p) = fun v => v +ᵥ p :=
 lean 3 declaration is
   forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [_inst_2 : AddTorsor.{u1, u2} G P _inst_1] (p : P), Eq.{max (succ u2) (succ u1)} (P -> G) (coeFn.{max 1 (max (succ u2) (succ u1)) (succ u1) (succ u2), max (succ u2) (succ u1)} (Equiv.{succ u2, succ u1} P G) (fun (_x : Equiv.{succ u2, succ u1} P G) => P -> G) (Equiv.hasCoeToFun.{succ u2, succ u1} P G) (Equiv.symm.{succ u1, succ u2} G P (Equiv.vaddConst.{u1, u2} G P _inst_1 _inst_2 p))) (fun (p' : P) => VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 _inst_2) p' p)
 but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [_inst_2 : AddTorsor.{u2, u1} G P _inst_1] (p : P), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : P), (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : P) => G) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (Equiv.{succ u1, succ u2} P G) P (fun (_x : P) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : P) => G) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u2} P G) (Equiv.symm.{succ u2, succ u1} G P (Equiv.vaddConst.{u2, u1} G P _inst_1 _inst_2 p))) (fun (p' : P) => VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 _inst_2) p' p)
+  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [_inst_2 : AddTorsor.{u2, u1} G P _inst_1] (p : P), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : P), (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : P) => G) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (Equiv.{succ u1, succ u2} P G) P (fun (_x : P) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : P) => G) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u2} P G) (Equiv.symm.{succ u2, succ u1} G P (Equiv.vaddConst.{u2, u1} G P _inst_1 _inst_2 p))) (fun (p' : P) => VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 _inst_2) p' p)
 Case conversion may be inaccurate. Consider using '#align equiv.coe_vadd_const_symm Equiv.coe_vaddConst_symmₓ'. -/
 @[simp]
 theorem coe_vaddConst_symm (p : P) : ⇑(vaddConst p).symm = fun p' => p' -ᵥ p :=
@@ -602,7 +602,7 @@ def constVSub (p : P) : P ≃ G where
 lean 3 declaration is
   forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [_inst_2 : AddTorsor.{u1, u2} G P _inst_1] (p : P), Eq.{max (succ u2) (succ u1)} (P -> G) (coeFn.{max 1 (max (succ u2) (succ u1)) (succ u1) (succ u2), max (succ u2) (succ u1)} (Equiv.{succ u2, succ u1} P G) (fun (_x : Equiv.{succ u2, succ u1} P G) => P -> G) (Equiv.hasCoeToFun.{succ u2, succ u1} P G) (Equiv.constVSub.{u1, u2} G P _inst_1 _inst_2 p)) (VSub.vsub.{u1, u2} G P (AddTorsor.toHasVsub.{u1, u2} G P _inst_1 _inst_2) p)
 but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [_inst_2 : AddTorsor.{u2, u1} G P _inst_1] (p : P), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : P), (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : P) => G) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (Equiv.{succ u1, succ u2} P G) P (fun (_x : P) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : P) => G) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u2} P G) (Equiv.constVSub.{u2, u1} G P _inst_1 _inst_2 p)) ((fun (x._@.Mathlib.Algebra.AddTorsor._hyg.2806 : P) (x._@.Mathlib.Algebra.AddTorsor._hyg.2808 : P) => VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 _inst_2) x._@.Mathlib.Algebra.AddTorsor._hyg.2806 x._@.Mathlib.Algebra.AddTorsor._hyg.2808) p)
+  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [_inst_2 : AddTorsor.{u2, u1} G P _inst_1] (p : P), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : P), (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : P) => G) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (Equiv.{succ u1, succ u2} P G) P (fun (_x : P) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : P) => G) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u2} P G) (Equiv.constVSub.{u2, u1} G P _inst_1 _inst_2 p)) ((fun (x._@.Mathlib.Algebra.AddTorsor._hyg.2809 : P) (x._@.Mathlib.Algebra.AddTorsor._hyg.2811 : P) => VSub.vsub.{u2, u1} G P (AddTorsor.toVSub.{u2, u1} G P _inst_1 _inst_2) x._@.Mathlib.Algebra.AddTorsor._hyg.2809 x._@.Mathlib.Algebra.AddTorsor._hyg.2811) p)
 Case conversion may be inaccurate. Consider using '#align equiv.coe_const_vsub Equiv.coe_constVSubₓ'. -/
 @[simp]
 theorem coe_constVSub (p : P) : ⇑(constVSub p) = (· -ᵥ ·) p :=
@@ -613,7 +613,7 @@ theorem coe_constVSub (p : P) : ⇑(constVSub p) = (· -ᵥ ·) p :=
 lean 3 declaration is
   forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [_inst_2 : AddTorsor.{u1, u2} G P _inst_1] (p : P), Eq.{max (succ u1) (succ u2)} (G -> P) (coeFn.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1), max (succ u1) (succ u2)} (Equiv.{succ u1, succ u2} G P) (fun (_x : Equiv.{succ u1, succ u2} G P) => G -> P) (Equiv.hasCoeToFun.{succ u1, succ u2} G P) (Equiv.symm.{succ u2, succ u1} P G (Equiv.constVSub.{u1, u2} G P _inst_1 _inst_2 p))) (fun (v : G) => VAdd.vadd.{u1, u2} G P (AddAction.toHasVadd.{u1, u2} G P (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)) (AddTorsor.toAddAction.{u1, u2} G P _inst_1 _inst_2)) (Neg.neg.{u1} G (SubNegMonoid.toHasNeg.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)) v) p)
 but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [_inst_2 : AddTorsor.{u2, u1} G P _inst_1] (p : P), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : G), (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : G) => P) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} G P) G (fun (_x : G) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : G) => P) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} G P) (Equiv.symm.{succ u1, succ u2} P G (Equiv.constVSub.{u2, u1} G P _inst_1 _inst_2 p))) (fun (v : G) => HVAdd.hVAdd.{u2, u1, u1} G P P (instHVAdd.{u2, u1} G P (AddAction.toVAdd.{u2, u1} G P (SubNegMonoid.toAddMonoid.{u2} G (AddGroup.toSubNegMonoid.{u2} G _inst_1)) (AddTorsor.toAddAction.{u2, u1} G P _inst_1 _inst_2))) (Neg.neg.{u2} G (NegZeroClass.toNeg.{u2} G (SubNegZeroMonoid.toNegZeroClass.{u2} G (SubtractionMonoid.toSubNegZeroMonoid.{u2} G (AddGroup.toSubtractionMonoid.{u2} G _inst_1)))) v) p)
+  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [_inst_2 : AddTorsor.{u2, u1} G P _inst_1] (p : P), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : G), (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : G) => P) ᾰ) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} G P) G (fun (_x : G) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : G) => P) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} G P) (Equiv.symm.{succ u1, succ u2} P G (Equiv.constVSub.{u2, u1} G P _inst_1 _inst_2 p))) (fun (v : G) => HVAdd.hVAdd.{u2, u1, u1} G P P (instHVAdd.{u2, u1} G P (AddAction.toVAdd.{u2, u1} G P (SubNegMonoid.toAddMonoid.{u2} G (AddGroup.toSubNegMonoid.{u2} G _inst_1)) (AddTorsor.toAddAction.{u2, u1} G P _inst_1 _inst_2))) (Neg.neg.{u2} G (NegZeroClass.toNeg.{u2} G (SubNegZeroMonoid.toNegZeroClass.{u2} G (SubtractionMonoid.toSubNegZeroMonoid.{u2} G (AddGroup.toSubtractionMonoid.{u2} G _inst_1)))) v) p)
 Case conversion may be inaccurate. Consider using '#align equiv.coe_const_vsub_symm Equiv.coe_constVSub_symmₓ'. -/
 @[simp]
 theorem coe_constVSub_symm (p : P) : ⇑(constVSub p).symm = fun v => -v +ᵥ p :=
@@ -716,7 +716,7 @@ theorem pointReflection_involutive (x : P) : Involutive (pointReflection x : P 
 lean 3 declaration is
   forall {G : Type.{u1}} {P : Type.{u2}} [_inst_1 : AddGroup.{u1} G] [_inst_2 : AddTorsor.{u1, u2} G P _inst_1] {x : P} {y : P}, (Function.Injective.{succ u1, succ u1} G G (bit0.{u1} G (AddZeroClass.toHasAdd.{u1} G (AddMonoid.toAddZeroClass.{u1} G (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G _inst_1)))))) -> (Iff (Eq.{succ u2} P (coeFn.{succ u2, succ u2} (Equiv.Perm.{succ u2} P) (fun (_x : Equiv.{succ u2, succ u2} P P) => P -> P) (Equiv.hasCoeToFun.{succ u2, succ u2} P P) (Equiv.pointReflection.{u1, u2} G P _inst_1 _inst_2 x) y) y) (Eq.{succ u2} P y x))
 but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [_inst_2 : AddTorsor.{u2, u1} G P _inst_1] {x : P} {y : P}, (Function.Injective.{succ u2, succ u2} G G (bit0.{u2} G (AddZeroClass.toAdd.{u2} G (AddMonoid.toAddZeroClass.{u2} G (SubNegMonoid.toAddMonoid.{u2} G (AddGroup.toSubNegMonoid.{u2} G _inst_1)))))) -> (Iff (Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : P) => P) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} P) P (fun (_x : P) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : P) => P) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} P P) (Equiv.pointReflection.{u2, u1} G P _inst_1 _inst_2 x) y) y) (Eq.{succ u1} P y x))
+  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_1 : AddGroup.{u2} G] [_inst_2 : AddTorsor.{u2, u1} G P _inst_1] {x : P} {y : P}, (Function.Injective.{succ u2, succ u2} G G (bit0.{u2} G (AddZeroClass.toAdd.{u2} G (AddMonoid.toAddZeroClass.{u2} G (SubNegMonoid.toAddMonoid.{u2} G (AddGroup.toSubNegMonoid.{u2} G _inst_1)))))) -> (Iff (Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : P) => P) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} P) P (fun (_x : P) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : P) => P) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} P P) (Equiv.pointReflection.{u2, u1} G P _inst_1 _inst_2 x) y) y) (Eq.{succ u1} P y x))
 Case conversion may be inaccurate. Consider using '#align equiv.point_reflection_fixed_iff_of_injective_bit0 Equiv.pointReflection_fixed_iff_of_injective_bit0ₓ'. -/
 /-- `x` is the only fixed point of `point_reflection x`. This lemma requires
 `x + x = y + y ↔ x = y`. There is no typeclass to use here, so we add it as an explicit argument. -/
@@ -732,7 +732,7 @@ omit G
 lean 3 declaration is
   forall {G : Type.{u1}} {P : Type.{u2}} [_inst_3 : AddCommGroup.{u1} G] [_inst_4 : AddTorsor.{u1, u2} G P (AddCommGroup.toAddGroup.{u1} G _inst_3)], (Function.Injective.{succ u1, succ u1} G G (bit0.{u1} G (AddZeroClass.toHasAdd.{u1} G (AddMonoid.toAddZeroClass.{u1} G (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G (AddCommGroup.toAddGroup.{u1} G _inst_3))))))) -> (forall (y : P), Function.Injective.{succ u2, succ u2} P P (fun (x : P) => coeFn.{succ u2, succ u2} (Equiv.Perm.{succ u2} P) (fun (_x : Equiv.{succ u2, succ u2} P P) => P -> P) (Equiv.hasCoeToFun.{succ u2, succ u2} P P) (Equiv.pointReflection.{u1, u2} G P (AddCommGroup.toAddGroup.{u1} G _inst_3) _inst_4 x) y))
 but is expected to have type
-  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_3 : AddCommGroup.{u2} G] [_inst_4 : AddTorsor.{u2, u1} G P (AddCommGroup.toAddGroup.{u2} G _inst_3)], (Function.Injective.{succ u2, succ u2} G G (bit0.{u2} G (AddZeroClass.toAdd.{u2} G (AddMonoid.toAddZeroClass.{u2} G (SubNegMonoid.toAddMonoid.{u2} G (AddGroup.toSubNegMonoid.{u2} G (AddCommGroup.toAddGroup.{u2} G _inst_3))))))) -> (forall (y : P), Function.Injective.{succ u1, succ u1} P ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : P) => P) y) (fun (x : P) => FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} P) P (fun (_x : P) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : P) => P) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} P P) (Equiv.pointReflection.{u2, u1} G P (AddCommGroup.toAddGroup.{u2} G _inst_3) _inst_4 x) y))
+  forall {G : Type.{u2}} {P : Type.{u1}} [_inst_3 : AddCommGroup.{u2} G] [_inst_4 : AddTorsor.{u2, u1} G P (AddCommGroup.toAddGroup.{u2} G _inst_3)], (Function.Injective.{succ u2, succ u2} G G (bit0.{u2} G (AddZeroClass.toAdd.{u2} G (AddMonoid.toAddZeroClass.{u2} G (SubNegMonoid.toAddMonoid.{u2} G (AddGroup.toSubNegMonoid.{u2} G (AddCommGroup.toAddGroup.{u2} G _inst_3))))))) -> (forall (y : P), Function.Injective.{succ u1, succ u1} P ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : P) => P) y) (fun (x : P) => FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} P) P (fun (_x : P) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : P) => P) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} P P) (Equiv.pointReflection.{u2, u1} G P (AddCommGroup.toAddGroup.{u2} G _inst_3) _inst_4 x) y))
 Case conversion may be inaccurate. Consider using '#align equiv.injective_point_reflection_left_of_injective_bit0 Equiv.injective_pointReflection_left_of_injective_bit0ₓ'. -/
 theorem injective_pointReflection_left_of_injective_bit0 {G P : Type _} [AddCommGroup G]
     [AddTorsor G P] (h : Injective (bit0 : G → G)) (y : P) :

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

Reference the newly created issues #12094 and #12096, as well as the pre-existing #5171. Change all references to #10927 to #5171. Some of these changes were not labelled as "porting note"; change this for good measure.

@@ -53,13 +53,15 @@ class AddTorsor (G : outParam (Type*)) (P : Type*) [outParam <| AddGroup G] exte
   vadd_vsub' : ∀ (g : G) (p : P), g +ᵥ p -ᵥ p = g
 #align add_torsor AddTorsor
 
-attribute [instance 100] AddTorsor.nonempty -- Porting note: removers `nolint instance_priority`
+ -- Porting note(#12096): removed `nolint instance_priority`; lint not ported yet
+attribute [instance 100] AddTorsor.nonempty
 
--- Porting note: removed
+-- Porting note(#12094): removed nolint; dangerous_instance linter not ported yet
 --attribute [nolint dangerous_instance] AddTorsor.toVSub
 
 /-- An `AddGroup G` is a torsor for itself. -/
---@[nolint instance_priority] Porting note: linter does not exist
+-- Porting note(#12096): linter not ported yet
+--@[nolint instance_priority]
 instance addGroupIsAddTorsor (G : Type*) [AddGroup G] : AddTorsor G G
     where
   vsub := Sub.sub

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

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

| Statement | New name | Old name | |

@@ -64,7 +64,7 @@ instance addGroupIsAddTorsor (G : Type*) [AddGroup G] : AddTorsor G G
     where
   vsub := Sub.sub
   vsub_vadd' := sub_add_cancel
-  vadd_vsub' := add_sub_cancel
+  vadd_vsub' := add_sub_cancel_right
 #align add_group_is_add_torsor addGroupIsAddTorsor
 
 /-- Simplify subtraction for a torsor for an `AddGroup G` over
@@ -253,7 +253,7 @@ theorem vsub_sub_vsub_cancel_left (p₁ p₂ p₃ : P) : p₃ -ᵥ p₂ - (p₃
 
 @[simp]
 theorem vadd_vsub_vadd_cancel_left (v : G) (p₁ p₂ : P) : v +ᵥ p₁ -ᵥ (v +ᵥ p₂) = p₁ -ᵥ p₂ := by
-  rw [vsub_vadd_eq_vsub_sub, vadd_vsub_assoc, add_sub_cancel']
+  rw [vsub_vadd_eq_vsub_sub, vadd_vsub_assoc, add_sub_cancel_left]
 #align vadd_vsub_vadd_cancel_left vadd_vsub_vadd_cancel_left
 
 theorem vsub_vadd_comm (p₁ p₂ p₃ : P) : (p₁ -ᵥ p₂ : G) +ᵥ p₃ = p₃ -ᵥ p₂ +ᵥ p₁ := by

... or reduce its scope (the full removal is not as obvious).

@@ -39,9 +39,6 @@ multiplicative group actions).
 
 -/
 
-set_option autoImplicit true
-
-
 /-- An `AddTorsor G P` gives a structure to the nonempty type `P`,
 acted on by an `AddGroup G` with a transitive and free action given
 by the `+ᵥ` operation and a corresponding subtraction given by the
@@ -277,7 +274,7 @@ end comm
 
 namespace Prod
 
-variable {G : Type*} [AddGroup G] [AddGroup G'] [AddTorsor G P] [AddTorsor G' P']
+variable {G G' P P' : Type*} [AddGroup G] [AddGroup G'] [AddTorsor G P] [AddTorsor G' P']
 
 instance instAddTorsor : AddTorsor (G × G') (P × P') where
   vadd v p := (v.1 +ᵥ p.1, v.2 +ᵥ p.2)

Homogenises porting notes via capitalisation and addition of whitespace.

It makes the following changes:

• converts "--porting note" into "-- Porting note";
• converts "porting note" into "Porting note".

@@ -56,9 +56,9 @@ class AddTorsor (G : outParam (Type*)) (P : Type*) [outParam <| AddGroup G] exte
   vadd_vsub' : ∀ (g : G) (p : P), g +ᵥ p -ᵥ p = g
 #align add_torsor AddTorsor
 
-attribute [instance 100] AddTorsor.nonempty -- porting note: removers `nolint instance_priority`
+attribute [instance 100] AddTorsor.nonempty -- Porting note: removers `nolint instance_priority`
 
---Porting note: removed
+-- Porting note: removed
 --attribute [nolint dangerous_instance] AddTorsor.toVSub
 
 /-- An `AddGroup G` is a torsor for itself. -/

Classify by adding issue number (#10618) to porting notes claiming anything semantically equivalent to simp can prove this or simp can simplify this.

@@ -191,7 +191,7 @@ namespace Set
 
 open Pointwise
 
--- Porting note: simp can prove this
+-- porting note (#10618): simp can prove this
 --@[simp]
 theorem singleton_vsub_self (p : P) : ({p} : Set P) -ᵥ {p} = {(0 : G)} := by
   rw [Set.singleton_vsub_singleton, vsub_self]

@@ -248,9 +248,6 @@ section comm
 
 variable {G : Type*} {P : Type*} [AddCommGroup G] [AddTorsor G P]
 
--- Porting note: Removed:
--- include G
-
 /-- Cancellation subtracting the results of two subtractions. -/
 @[simp]
 theorem vsub_sub_vsub_cancel_left (p₁ p₂ p₃ : P) : p₃ -ᵥ p₂ - (p₃ -ᵥ p₁) = p₁ -ᵥ p₂ := by
@@ -356,9 +353,6 @@ namespace Equiv
 
 variable {G : Type*} {P : Type*} [AddGroup G] [AddTorsor G P]
 
--- Porting note: Removed:
--- include G
-
 /-- `v ↦ v +ᵥ p` as an equivalence. -/
 def vaddConst (p : P) : G ≃ P where
   toFun v := v +ᵥ p
@@ -481,9 +475,6 @@ theorem pointReflection_fixed_iff_of_injective_bit0 {x y : P} (h : Injective (bi
     neg_eq_iff_add_eq_zero, ← bit0, ← bit0_zero, h.eq_iff, vsub_eq_zero_iff_eq, eq_comm]
 #align equiv.point_reflection_fixed_iff_of_injective_bit0 Equiv.pointReflection_fixed_iff_of_injective_bit0
 
--- Porting note: Removed:
--- omit G
-
 -- Porting note: need this to calm down CI
 theorem injective_pointReflection_left_of_injective_bit0 {G P : Type*} [AddCommGroup G]
     [AddTorsor G P] (h : Injective (bit0 : G → G)) (y : P) :

@@ -287,7 +287,7 @@ instance instAddTorsor : AddTorsor (G × G') (P × P') where
   zero_vadd _ := Prod.ext (zero_vadd _ _) (zero_vadd _ _)
   add_vadd _ _ _ := Prod.ext (add_vadd _ _ _) (add_vadd _ _ _)
   vsub p₁ p₂ := (p₁.1 -ᵥ p₂.1, p₁.2 -ᵥ p₂.2)
-  nonempty := Prod.Nonempty
+  nonempty := Prod.instNonempty
   vsub_vadd' _ _ := Prod.ext (vsub_vadd _ _) (vsub_vadd _ _)
   vadd_vsub' _ _ := Prod.ext (vadd_vsub _ _) (vadd_vsub _ _)
 

Use variable names p₁, p₂ etc instead of p1, p2 etc.

@@ -51,7 +51,7 @@ class AddTorsor (G : outParam (Type*)) (P : Type*) [outParam <| AddGroup G] exte
   VSub G P where
   [nonempty : Nonempty P]
   /-- Torsor subtraction and addition with the same element cancels out. -/
-  vsub_vadd' : ∀ p1 p2 : P, (p1 -ᵥ p2 : G) +ᵥ p2 = p1
+  vsub_vadd' : ∀ p₁ p₂ : P, (p₁ -ᵥ p₂ : G) +ᵥ p₂ = p₁
   /-- Torsor addition and subtraction with the same element cancels out. -/
   vadd_vsub' : ∀ (g : G) (p : P), g +ᵥ p -ᵥ p = g
 #align add_torsor AddTorsor
@@ -73,7 +73,7 @@ instance addGroupIsAddTorsor (G : Type*) [AddGroup G] : AddTorsor G G
 /-- Simplify subtraction for a torsor for an `AddGroup G` over
 itself. -/
 @[simp]
-theorem vsub_eq_sub {G : Type*} [AddGroup G] (g1 g2 : G) : g1 -ᵥ g2 = g1 - g2 :=
+theorem vsub_eq_sub {G : Type*} [AddGroup G] (g₁ g₂ : G) : g₁ -ᵥ g₂ = g₁ - g₂ :=
   rfl
 #align vsub_eq_sub vsub_eq_sub
 
@@ -84,8 +84,8 @@ variable {G : Type*} {P : Type*} [AddGroup G] [T : AddTorsor G P]
 /-- Adding the result of subtracting from another point produces that
 point. -/
 @[simp]
-theorem vsub_vadd (p1 p2 : P) : p1 -ᵥ p2 +ᵥ p2 = p1 :=
-  AddTorsor.vsub_vadd' p1 p2
+theorem vsub_vadd (p₁ p₂ : P) : p₁ -ᵥ p₂ +ᵥ p₂ = p₁ :=
+  AddTorsor.vsub_vadd' p₁ p₂
 #align vsub_vadd vsub_vadd
 
 /-- Adding a group element then subtracting the original point
@@ -97,13 +97,13 @@ theorem vadd_vsub (g : G) (p : P) : g +ᵥ p -ᵥ p = g :=
 
 /-- If the same point added to two group elements produces equal
 results, those group elements are equal. -/
-theorem vadd_right_cancel {g1 g2 : G} (p : P) (h : g1 +ᵥ p = g2 +ᵥ p) : g1 = g2 := by
+theorem vadd_right_cancel {g₁ g₂ : G} (p : P) (h : g₁ +ᵥ p = g₂ +ᵥ p) : g₁ = g₂ := by
 -- Porting note: vadd_vsub g₁ → vadd_vsub g₁ p
-  rw [← vadd_vsub g1 p, h, vadd_vsub]
+  rw [← vadd_vsub g₁ p, h, vadd_vsub]
 #align vadd_right_cancel vadd_right_cancel
 
 @[simp]
-theorem vadd_right_cancel_iff {g1 g2 : G} (p : P) : g1 +ᵥ p = g2 +ᵥ p ↔ g1 = g2 :=
+theorem vadd_right_cancel_iff {g₁ g₂ : G} (p : P) : g₁ +ᵥ p = g₂ +ᵥ p ↔ g₁ = g₂ :=
   ⟨vadd_right_cancel p, fun h => h ▸ rfl⟩
 #align vadd_right_cancel_iff vadd_right_cancel_iff
 
@@ -116,8 +116,8 @@ theorem vadd_right_injective (p : P) : Function.Injective ((· +ᵥ p) : G → P
 /-- Adding a group element to a point, then subtracting another point,
 produces the same result as subtracting the points then adding the
 group element. -/
-theorem vadd_vsub_assoc (g : G) (p1 p2 : P) : g +ᵥ p1 -ᵥ p2 = g + (p1 -ᵥ p2) := by
-  apply vadd_right_cancel p2
+theorem vadd_vsub_assoc (g : G) (p₁ p₂ : P) : g +ᵥ p₁ -ᵥ p₂ = g + (p₁ -ᵥ p₂) := by
+  apply vadd_right_cancel p₂
   rw [vsub_vadd, add_vadd, vsub_vadd]
 #align vadd_vsub_assoc vadd_vsub_assoc
 
@@ -128,14 +128,14 @@ theorem vsub_self (p : P) : p -ᵥ p = (0 : G) := by
 #align vsub_self vsub_self
 
 /-- If subtracting two points produces 0, they are equal. -/
-theorem eq_of_vsub_eq_zero {p1 p2 : P} (h : p1 -ᵥ p2 = (0 : G)) : p1 = p2 := by
-  rw [← vsub_vadd p1 p2, h, zero_vadd]
+theorem eq_of_vsub_eq_zero {p₁ p₂ : P} (h : p₁ -ᵥ p₂ = (0 : G)) : p₁ = p₂ := by
+  rw [← vsub_vadd p₁ p₂, h, zero_vadd]
 #align eq_of_vsub_eq_zero eq_of_vsub_eq_zero
 
 /-- Subtracting two points produces 0 if and only if they are
 equal. -/
 @[simp]
-theorem vsub_eq_zero_iff_eq {p1 p2 : P} : p1 -ᵥ p2 = (0 : G) ↔ p1 = p2 :=
+theorem vsub_eq_zero_iff_eq {p₁ p₂ : P} : p₁ -ᵥ p₂ = (0 : G) ↔ p₁ = p₂ :=
   Iff.intro eq_of_vsub_eq_zero fun h => h ▸ vsub_self _
 #align vsub_eq_zero_iff_eq vsub_eq_zero_iff_eq
 
@@ -145,16 +145,16 @@ theorem vsub_ne_zero {p q : P} : p -ᵥ q ≠ (0 : G) ↔ p ≠ q :=
 
 /-- Cancellation adding the results of two subtractions. -/
 @[simp]
-theorem vsub_add_vsub_cancel (p1 p2 p3 : P) : p1 -ᵥ p2 + (p2 -ᵥ p3) = p1 -ᵥ p3 := by
-  apply vadd_right_cancel p3
+theorem vsub_add_vsub_cancel (p₁ p₂ p₃ : P) : p₁ -ᵥ p₂ + (p₂ -ᵥ p₃) = p₁ -ᵥ p₃ := by
+  apply vadd_right_cancel p₃
   rw [add_vadd, vsub_vadd, vsub_vadd, vsub_vadd]
 #align vsub_add_vsub_cancel vsub_add_vsub_cancel
 
 /-- Subtracting two points in the reverse order produces the negation
 of subtracting them. -/
 @[simp]
-theorem neg_vsub_eq_vsub_rev (p1 p2 : P) : -(p1 -ᵥ p2) = p2 -ᵥ p1 := by
-  refine' neg_eq_of_add_eq_zero_right (vadd_right_cancel p1 _)
+theorem neg_vsub_eq_vsub_rev (p₁ p₂ : P) : -(p₁ -ᵥ p₂) = p₂ -ᵥ p₁ := by
+  refine' neg_eq_of_add_eq_zero_right (vadd_right_cancel p₁ _)
   rw [vsub_add_vsub_cancel, vsub_self]
 #align neg_vsub_eq_vsub_rev neg_vsub_eq_vsub_rev
 
@@ -164,21 +164,21 @@ theorem vadd_vsub_eq_sub_vsub (g : G) (p q : P) : g +ᵥ p -ᵥ q = g - (q -ᵥ
 
 /-- Subtracting the result of adding a group element produces the same result
 as subtracting the points and subtracting that group element. -/
-theorem vsub_vadd_eq_vsub_sub (p1 p2 : P) (g : G) : p1 -ᵥ (g +ᵥ p2) = p1 -ᵥ p2 - g := by
-  rw [← add_right_inj (p2 -ᵥ p1 : G), vsub_add_vsub_cancel, ← neg_vsub_eq_vsub_rev, vadd_vsub, ←
+theorem vsub_vadd_eq_vsub_sub (p₁ p₂ : P) (g : G) : p₁ -ᵥ (g +ᵥ p₂) = p₁ -ᵥ p₂ - g := by
+  rw [← add_right_inj (p₂ -ᵥ p₁ : G), vsub_add_vsub_cancel, ← neg_vsub_eq_vsub_rev, vadd_vsub, ←
     add_sub_assoc, ← neg_vsub_eq_vsub_rev, neg_add_self, zero_sub]
 #align vsub_vadd_eq_vsub_sub vsub_vadd_eq_vsub_sub
 
 /-- Cancellation subtracting the results of two subtractions. -/
 @[simp]
-theorem vsub_sub_vsub_cancel_right (p1 p2 p3 : P) : p1 -ᵥ p3 - (p2 -ᵥ p3) = p1 -ᵥ p2 := by
+theorem vsub_sub_vsub_cancel_right (p₁ p₂ p₃ : P) : p₁ -ᵥ p₃ - (p₂ -ᵥ p₃) = p₁ -ᵥ p₂ := by
   rw [← vsub_vadd_eq_vsub_sub, vsub_vadd]
 #align vsub_sub_vsub_cancel_right vsub_sub_vsub_cancel_right
 
 /-- Convert between an equality with adding a group element to a point
 and an equality of a subtraction of two points with a group
 element. -/
-theorem eq_vadd_iff_vsub_eq (p1 : P) (g : G) (p2 : P) : p1 = g +ᵥ p2 ↔ p1 -ᵥ p2 = g :=
+theorem eq_vadd_iff_vsub_eq (p₁ : P) (g : G) (p₂ : P) : p₁ = g +ᵥ p₂ ↔ p₁ -ᵥ p₂ = g :=
   ⟨fun h => h.symm ▸ vadd_vsub _ _, fun h => h ▸ (vsub_vadd _ _).symm⟩
 #align eq_vadd_iff_vsub_eq eq_vadd_iff_vsub_eq
 
@@ -206,14 +206,14 @@ theorem vadd_vsub_vadd_cancel_right (v₁ v₂ : G) (p : P) : v₁ +ᵥ p -ᵥ (
 
 /-- If the same point subtracted from two points produces equal
 results, those points are equal. -/
-theorem vsub_left_cancel {p1 p2 p : P} (h : p1 -ᵥ p = p2 -ᵥ p) : p1 = p2 := by
+theorem vsub_left_cancel {p₁ p₂ p : P} (h : p₁ -ᵥ p = p₂ -ᵥ p) : p₁ = p₂ := by
   rwa [← sub_eq_zero, vsub_sub_vsub_cancel_right, vsub_eq_zero_iff_eq] at h
 #align vsub_left_cancel vsub_left_cancel
 
 /-- The same point subtracted from two points produces equal results
 if and only if those points are equal. -/
 @[simp]
-theorem vsub_left_cancel_iff {p1 p2 p : P} : p1 -ᵥ p = p2 -ᵥ p ↔ p1 = p2 :=
+theorem vsub_left_cancel_iff {p₁ p₂ p : P} : p₁ -ᵥ p = p₂ -ᵥ p ↔ p₁ = p₂ :=
   ⟨vsub_left_cancel, fun h => h ▸ rfl⟩
 #align vsub_left_cancel_iff vsub_left_cancel_iff
 
@@ -224,15 +224,15 @@ theorem vsub_left_injective (p : P) : Function.Injective ((· -ᵥ p) : P → G)
 
 /-- If subtracting two points from the same point produces equal
 results, those points are equal. -/
-theorem vsub_right_cancel {p1 p2 p : P} (h : p -ᵥ p1 = p -ᵥ p2) : p1 = p2 := by
-  refine' vadd_left_cancel (p -ᵥ p2) _
+theorem vsub_right_cancel {p₁ p₂ p : P} (h : p -ᵥ p₁ = p -ᵥ p₂) : p₁ = p₂ := by
+  refine' vadd_left_cancel (p -ᵥ p₂) _
   rw [vsub_vadd, ← h, vsub_vadd]
 #align vsub_right_cancel vsub_right_cancel
 
 /-- Subtracting two points from the same point produces equal results
 if and only if those points are equal. -/
 @[simp]
-theorem vsub_right_cancel_iff {p1 p2 p : P} : p -ᵥ p1 = p -ᵥ p2 ↔ p1 = p2 :=
+theorem vsub_right_cancel_iff {p₁ p₂ p : P} : p -ᵥ p₁ = p -ᵥ p₂ ↔ p₁ = p₂ :=
   ⟨vsub_right_cancel, fun h => h ▸ rfl⟩
 #align vsub_right_cancel_iff vsub_right_cancel_iff
 
@@ -253,16 +253,16 @@ variable {G : Type*} {P : Type*} [AddCommGroup G] [AddTorsor G P]
 
 /-- Cancellation subtracting the results of two subtractions. -/
 @[simp]
-theorem vsub_sub_vsub_cancel_left (p1 p2 p3 : P) : p3 -ᵥ p2 - (p3 -ᵥ p1) = p1 -ᵥ p2 := by
+theorem vsub_sub_vsub_cancel_left (p₁ p₂ p₃ : P) : p₃ -ᵥ p₂ - (p₃ -ᵥ p₁) = p₁ -ᵥ p₂ := by
   rw [sub_eq_add_neg, neg_vsub_eq_vsub_rev, add_comm, vsub_add_vsub_cancel]
 #align vsub_sub_vsub_cancel_left vsub_sub_vsub_cancel_left
 
 @[simp]
-theorem vadd_vsub_vadd_cancel_left (v : G) (p1 p2 : P) : v +ᵥ p1 -ᵥ (v +ᵥ p2) = p1 -ᵥ p2 := by
+theorem vadd_vsub_vadd_cancel_left (v : G) (p₁ p₂ : P) : v +ᵥ p₁ -ᵥ (v +ᵥ p₂) = p₁ -ᵥ p₂ := by
   rw [vsub_vadd_eq_vsub_sub, vadd_vsub_assoc, add_sub_cancel']
 #align vadd_vsub_vadd_cancel_left vadd_vsub_vadd_cancel_left
 
-theorem vsub_vadd_comm (p1 p2 p3 : P) : (p1 -ᵥ p2 : G) +ᵥ p3 = p3 -ᵥ p2 +ᵥ p1 := by
+theorem vsub_vadd_comm (p₁ p₂ p₃ : P) : (p₁ -ᵥ p₂ : G) +ᵥ p₃ = p₃ -ᵥ p₂ +ᵥ p₁ := by
   rw [← @vsub_eq_zero_iff_eq G, vadd_vsub_assoc, vsub_vadd_eq_vsub_sub]
   simp
 #align vsub_vadd_comm vsub_vadd_comm

I used the regex \(\(· (.) ·\) (.)\), replacing with ($2 $1 ·).

@@ -379,15 +379,13 @@ theorem coe_vaddConst_symm (p : P) : ⇑(vaddConst p).symm = fun p' => p' -ᵥ p
 
 /-- `p' ↦ p -ᵥ p'` as an equivalence. -/
 def constVSub (p : P) : P ≃ G where
-  toFun := (· -ᵥ ·) p
-  invFun v := -v +ᵥ p
+  toFun := (p -ᵥ ·)
+  invFun := (-· +ᵥ p)
   left_inv p' := by simp
   right_inv v := by simp [vsub_vadd_eq_vsub_sub]
 #align equiv.const_vsub Equiv.constVSub
 
-@[simp]
-theorem coe_constVSub (p : P) : ⇑(constVSub p) = (· -ᵥ ·) p :=
-  rfl
+@[simp] lemma coe_constVSub (p : P) : ⇑(constVSub p) = (p -ᵥ ·) := rfl
 #align equiv.coe_const_vsub Equiv.coe_constVSub
 
 @[simp]
@@ -399,15 +397,13 @@ variable (P)
 
 /-- The permutation given by `p ↦ v +ᵥ p`. -/
 def constVAdd (v : G) : Equiv.Perm P where
-  toFun := (· +ᵥ ·) v
-  invFun := (· +ᵥ ·) (-v)
+  toFun := (v +ᵥ ·)
+  invFun := (-v +ᵥ ·)
   left_inv p := by simp [vadd_vadd]
   right_inv p := by simp [vadd_vadd]
 #align equiv.const_vadd Equiv.constVAdd
 
-@[simp]
-theorem coe_constVAdd (v : G) : ⇑(constVAdd P v) = (· +ᵥ ·) v :=
-  rfl
+@[simp] lemma coe_constVAdd (v : G) : ⇑(constVAdd P v) = (v +ᵥ ·) := rfl
 #align equiv.coe_const_vadd Equiv.coe_constVAdd
 
 variable (G)

Only Prop-values fields should be capitalized, not P-valued fields where P is Prop-valued.

Rather than fixing Nonempty := in constructors, I just deleted the line as the instance can almost always be found automatically.

@@ -49,14 +49,14 @@ by the `+ᵥ` operation and a corresponding subtraction given by the
 space. -/
 class AddTorsor (G : outParam (Type*)) (P : Type*) [outParam <| AddGroup G] extends AddAction G P,
   VSub G P where
-  [Nonempty : Nonempty P]
+  [nonempty : Nonempty P]
   /-- Torsor subtraction and addition with the same element cancels out. -/
   vsub_vadd' : ∀ p1 p2 : P, (p1 -ᵥ p2 : G) +ᵥ p2 = p1
   /-- Torsor addition and subtraction with the same element cancels out. -/
   vadd_vsub' : ∀ (g : G) (p : P), g +ᵥ p -ᵥ p = g
 #align add_torsor AddTorsor
 
-attribute [instance 100] AddTorsor.Nonempty -- porting note: removers `nolint instance_priority`
+attribute [instance 100] AddTorsor.nonempty -- porting note: removers `nolint instance_priority`
 
 --Porting note: removed
 --attribute [nolint dangerous_instance] AddTorsor.toVSub
@@ -287,7 +287,7 @@ instance instAddTorsor : AddTorsor (G × G') (P × P') where
   zero_vadd _ := Prod.ext (zero_vadd _ _) (zero_vadd _ _)
   add_vadd _ _ _ := Prod.ext (add_vadd _ _ _) (add_vadd _ _ _)
   vsub p₁ p₂ := (p₁.1 -ᵥ p₂.1, p₁.2 -ᵥ p₂.2)
-  Nonempty := Prod.Nonempty
+  nonempty := Prod.Nonempty
   vsub_vadd' _ _ := Prod.ext (vsub_vadd _ _) (vsub_vadd _ _)
   vadd_vsub' _ _ := Prod.ext (vadd_vsub _ _) (vadd_vsub _ _)
 
@@ -342,12 +342,11 @@ variable {I : Type u} {fg : I → Type v} [∀ i, AddGroup (fg i)] {fp : I → T
 open AddAction AddTorsor
 
 /-- A product of `AddTorsor`s is an `AddTorsor`. -/
-instance instAddTorsor [T : ∀ i, AddTorsor (fg i) (fp i)] : AddTorsor (∀ i, fg i) (∀ i, fp i) where
+instance instAddTorsor [∀ i, AddTorsor (fg i) (fp i)] : AddTorsor (∀ i, fg i) (∀ i, fp i) where
   vadd g p i := g i +ᵥ p i
   zero_vadd p := funext fun i => zero_vadd (fg i) (p i)
   add_vadd g₁ g₂ p := funext fun i => add_vadd (g₁ i) (g₂ i) (p i)
   vsub p₁ p₂ i := p₁ i -ᵥ p₂ i
-  Nonempty := ⟨fun i => Classical.choice (T i).Nonempty⟩
   vsub_vadd' p₁ p₂ := funext fun i => vsub_vadd (p₁ i) (p₂ i)
   vadd_vsub' g p := funext fun i => vadd_vsub (g i) (p i)
 

Autoimplicits are highly controversial and also defeat the performance-improving work in #6474.

The intent of this PR is to make autoImplicit opt-in on a per-file basis, by disabling it in the lakefile and enabling it again with set_option autoImplicit true in the few files that rely on it.

That also keeps this PR small, as opposed to attempting to "fix" files to not need it any more.

I claim that many of the uses of autoImplicit in these files are accidental; situations such as:

• Assuming variables are in scope, but pasting the lemma in the wrong section
• Pasting in a lemma from a scratch file without checking to see if the variable names are consistent with the rest of the file
• Making a copy-paste error between lemmas and forgetting to add an explicit arguments.

Having set_option autoImplicit false as the default prevents these types of mistake being made in the 90% of files where autoImplicits are not used at all, and causes them to be caught by CI during review.

I think there were various points during the port where we encouraged porters to delete the universes u v lines; I think having autoparams for universe variables only would cover a lot of the cases we actually use them, while avoiding any real shortcomings.

A Zulip poll (after combining overlapping votes accordingly) was in favor of this change with 5:5:18 as the no:dontcare:yes vote ratio.

While this PR was being reviewed, a handful of files gained some more likely-accidental autoImplicits. In these places, set_option autoImplicit true has been placed locally within a section, rather than at the top of the file.

@@ -39,6 +39,8 @@ multiplicative group actions).
 
 -/
 
+set_option autoImplicit true
+
 
 /-- An `AddTorsor G P` gives a structure to the nonempty type `P`,
 acted on by an `AddGroup G` with a transitive and free action given

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

This has nice performance benefits.

@@ -45,7 +45,7 @@ acted on by an `AddGroup G` with a transitive and free action given
 by the `+ᵥ` operation and a corresponding subtraction given by the
 `-ᵥ` operation. In the case of a vector space, it is an affine
 space. -/
-class AddTorsor (G : outParam (Type _)) (P : Type _) [outParam <| AddGroup G] extends AddAction G P,
+class AddTorsor (G : outParam (Type*)) (P : Type*) [outParam <| AddGroup G] extends AddAction G P,
   VSub G P where
   [Nonempty : Nonempty P]
   /-- Torsor subtraction and addition with the same element cancels out. -/
@@ -61,7 +61,7 @@ attribute [instance 100] AddTorsor.Nonempty -- porting note: removers `nolint in
 
 /-- An `AddGroup G` is a torsor for itself. -/
 --@[nolint instance_priority] Porting note: linter does not exist
-instance addGroupIsAddTorsor (G : Type _) [AddGroup G] : AddTorsor G G
+instance addGroupIsAddTorsor (G : Type*) [AddGroup G] : AddTorsor G G
     where
   vsub := Sub.sub
   vsub_vadd' := sub_add_cancel
@@ -71,13 +71,13 @@ instance addGroupIsAddTorsor (G : Type _) [AddGroup G] : AddTorsor G G
 /-- Simplify subtraction for a torsor for an `AddGroup G` over
 itself. -/
 @[simp]
-theorem vsub_eq_sub {G : Type _} [AddGroup G] (g1 g2 : G) : g1 -ᵥ g2 = g1 - g2 :=
+theorem vsub_eq_sub {G : Type*} [AddGroup G] (g1 g2 : G) : g1 -ᵥ g2 = g1 - g2 :=
   rfl
 #align vsub_eq_sub vsub_eq_sub
 
 section General
 
-variable {G : Type _} {P : Type _} [AddGroup G] [T : AddTorsor G P]
+variable {G : Type*} {P : Type*} [AddGroup G] [T : AddTorsor G P]
 
 /-- Adding the result of subtracting from another point produces that
 point. -/
@@ -244,7 +244,7 @@ end General
 
 section comm
 
-variable {G : Type _} {P : Type _} [AddCommGroup G] [AddTorsor G P]
+variable {G : Type*} {P : Type*} [AddCommGroup G] [AddTorsor G P]
 
 -- Porting note: Removed:
 -- include G
@@ -278,7 +278,7 @@ end comm
 
 namespace Prod
 
-variable {G : Type _} [AddGroup G] [AddGroup G'] [AddTorsor G P] [AddTorsor G' P']
+variable {G : Type*} [AddGroup G] [AddGroup G'] [AddTorsor G P] [AddTorsor G' P']
 
 instance instAddTorsor : AddTorsor (G × G') (P × P') where
   vadd v p := (v.1 +ᵥ p.1, v.2 +ᵥ p.2)
@@ -353,7 +353,7 @@ end Pi
 
 namespace Equiv
 
-variable {G : Type _} {P : Type _} [AddGroup G] [AddTorsor G P]
+variable {G : Type*} {P : Type*} [AddGroup G] [AddTorsor G P]
 
 -- Porting note: Removed:
 -- include G
@@ -488,7 +488,7 @@ theorem pointReflection_fixed_iff_of_injective_bit0 {x y : P} (h : Injective (bi
 -- omit G
 
 -- Porting note: need this to calm down CI
-theorem injective_pointReflection_left_of_injective_bit0 {G P : Type _} [AddCommGroup G]
+theorem injective_pointReflection_left_of_injective_bit0 {G P : Type*} [AddCommGroup G]
     [AddTorsor G P] (h : Injective (bit0 : G → G)) (y : P) :
     Injective fun x : P => pointReflection x y :=
   fun x₁ x₂ (hy : pointReflection x₁ y = pointReflection x₂ y) => by
@@ -499,7 +499,7 @@ theorem injective_pointReflection_left_of_injective_bit0 {G P : Type _} [AddComm
 
 end Equiv
 
-theorem AddTorsor.subsingleton_iff (G P : Type _) [AddGroup G] [AddTorsor G P] :
+theorem AddTorsor.subsingleton_iff (G P : Type*) [AddGroup G] [AddTorsor G P] :
     Subsingleton G ↔ Subsingleton P := by
   inhabit P
   exact (Equiv.vaddConst default).subsingleton_congr

Per https://github.com/leanprover/lean4/issues/2343, we are going to need to change the automatic generation of instance names, as they become too long.

This PR ensures that everywhere in Mathlib that refers to an instance by name, that name is given explicitly, rather than being automatically generated.

There are four exceptions, which are now commented, with links to https://github.com/leanprover/lean4/issues/2343.

This was implemented by running Mathlib against a modified Lean that appended _ᾰ to all automatically generated names, and fixing everything.

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

@@ -340,7 +340,7 @@ variable {I : Type u} {fg : I → Type v} [∀ i, AddGroup (fg i)] {fp : I → T
 open AddAction AddTorsor
 
 /-- A product of `AddTorsor`s is an `AddTorsor`. -/
-instance [T : ∀ i, AddTorsor (fg i) (fp i)] : AddTorsor (∀ i, fg i) (∀ i, fp i) where
+instance instAddTorsor [T : ∀ i, AddTorsor (fg i) (fp i)] : AddTorsor (∀ i, fg i) (∀ i, fp i) where
   vadd g p i := g i +ᵥ p i
   zero_vadd p := funext fun i => zero_vadd (fg i) (p i)
   add_vadd g₁ g₂ p := funext fun i => add_vadd (g₁ i) (g₂ i) (p i)

@@ -280,7 +280,7 @@ namespace Prod
 
 variable {G : Type _} [AddGroup G] [AddGroup G'] [AddTorsor G P] [AddTorsor G' P']
 
-instance : AddTorsor (G × G') (P × P') where
+instance instAddTorsor : AddTorsor (G × G') (P × P') where
   vadd v p := (v.1 +ᵥ p.1, v.2 +ᵥ p.2)
   zero_vadd _ := Prod.ext (zero_vadd _ _) (zero_vadd _ _)
   add_vadd _ _ _ := Prod.ext (add_vadd _ _ _) (add_vadd _ _ _)

• depends on: #5966

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

@@ -2,14 +2,11 @@
 Copyright (c) 2020 Joseph Myers. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Joseph Myers, Yury Kudryashov
-
-! This file was ported from Lean 3 source module algebra.add_torsor
-! leanprover-community/mathlib commit 9003f28797c0664a49e4179487267c494477d853
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.Set.Pointwise.SMul
 
+#align_import algebra.add_torsor from "leanprover-community/mathlib"@"9003f28797c0664a49e4179487267c494477d853"
+
 /-!
 # Torsors of additive group actions
 

@@ -448,6 +448,22 @@ theorem pointReflection_apply (x y : P) : pointReflection x y = x -ᵥ y +ᵥ x
   rfl
 #align equiv.point_reflection_apply Equiv.pointReflection_apply
 
+@[simp]
+theorem pointReflection_vsub_left (x y : P) : pointReflection x y -ᵥ x = x -ᵥ y :=
+  vadd_vsub ..
+
+@[simp]
+theorem left_vsub_pointReflection (x y : P) : x -ᵥ pointReflection x y = y -ᵥ x :=
+  neg_injective <| by simp
+
+@[simp]
+theorem pointReflection_vsub_right (x y : P) : pointReflection x y -ᵥ y = 2 • (x -ᵥ y) := by
+  simp [pointReflection, two_nsmul, vadd_vsub_assoc]
+
+@[simp]
+theorem right_vsub_pointReflection (x y : P) : y -ᵥ pointReflection x y = 2 • (y -ᵥ x) :=
+  neg_injective <| by simp [← neg_nsmul]
+
 @[simp]
 theorem pointReflection_symm (x : P) : (pointReflection x).symm = pointReflection x :=
   ext <| by simp [pointReflection]

This PR puts, with one exception, every single remaining by that lies all by itself on its own line to the previous line, thus matching the current behaviour of start-port.sh. The exception is when the by begins the second or later argument to a tuple or anonymous constructor; see https://github.com/leanprover-community/mathlib4/pull/3825#discussion_r1186702599.

Essentially this is s/\n *by$/ by/g, but with manual editing to satisfy the linter's max-100-char-line requirement. The Python style linter is also modified to catch these "isolated bys".

@@ -117,8 +117,7 @@ theorem vadd_right_injective (p : P) : Function.Injective ((· +ᵥ p) : G → P
 /-- Adding a group element to a point, then subtracting another point,
 produces the same result as subtracting the points then adding the
 group element. -/
-theorem vadd_vsub_assoc (g : G) (p1 p2 : P) : g +ᵥ p1 -ᵥ p2 = g + (p1 -ᵥ p2) :=
-  by
+theorem vadd_vsub_assoc (g : G) (p1 p2 : P) : g +ᵥ p1 -ᵥ p2 = g + (p1 -ᵥ p2) := by
   apply vadd_right_cancel p2
   rw [vsub_vadd, add_vadd, vsub_vadd]
 #align vadd_vsub_assoc vadd_vsub_assoc
@@ -147,8 +146,7 @@ theorem vsub_ne_zero {p q : P} : p -ᵥ q ≠ (0 : G) ↔ p ≠ q :=
 
 /-- Cancellation adding the results of two subtractions. -/
 @[simp]
-theorem vsub_add_vsub_cancel (p1 p2 p3 : P) : p1 -ᵥ p2 + (p2 -ᵥ p3) = p1 -ᵥ p3 :=
-  by
+theorem vsub_add_vsub_cancel (p1 p2 p3 : P) : p1 -ᵥ p2 + (p2 -ᵥ p3) = p1 -ᵥ p3 := by
   apply vadd_right_cancel p3
   rw [add_vadd, vsub_vadd, vsub_vadd, vsub_vadd]
 #align vsub_add_vsub_cancel vsub_add_vsub_cancel
@@ -156,8 +154,7 @@ theorem vsub_add_vsub_cancel (p1 p2 p3 : P) : p1 -ᵥ p2 + (p2 -ᵥ p3) = p1 -
 /-- Subtracting two points in the reverse order produces the negation
 of subtracting them. -/
 @[simp]
-theorem neg_vsub_eq_vsub_rev (p1 p2 : P) : -(p1 -ᵥ p2) = p2 -ᵥ p1 :=
-  by
+theorem neg_vsub_eq_vsub_rev (p1 p2 : P) : -(p1 -ᵥ p2) = p2 -ᵥ p1 := by
   refine' neg_eq_of_add_eq_zero_right (vadd_right_cancel p1 _)
   rw [vsub_add_vsub_cancel, vsub_self]
 #align neg_vsub_eq_vsub_rev neg_vsub_eq_vsub_rev
@@ -228,8 +225,7 @@ theorem vsub_left_injective (p : P) : Function.Injective ((· -ᵥ p) : P → G)
 
 /-- If subtracting two points from the same point produces equal
 results, those points are equal. -/
-theorem vsub_right_cancel {p1 p2 p : P} (h : p -ᵥ p1 = p -ᵥ p2) : p1 = p2 :=
-  by
+theorem vsub_right_cancel {p1 p2 p : P} (h : p -ᵥ p1 = p -ᵥ p2) : p1 = p2 := by
   refine' vadd_left_cancel (p -ᵥ p2) _
   rw [vsub_vadd, ← h, vsub_vadd]
 #align vsub_right_cancel vsub_right_cancel

This PR fixes two things:

• Most align statements for definitions and theorems and instances that are separated by two newlines from the relevant declaration (s/\n\n#align/\n#align). This is often seen in the mathport output after ending calc blocks.
• All remaining more-than-one-line #align statements. (This was needed for a script I wrote for #3630.)

@@ -473,9 +473,7 @@ theorem pointReflection_fixed_iff_of_injective_bit0 {x y : P} (h : Injective (bi
     pointReflection x y = y ↔ y = x := by
   rw [pointReflection_apply, eq_comm, eq_vadd_iff_vsub_eq, ← neg_vsub_eq_vsub_rev,
     neg_eq_iff_add_eq_zero, ← bit0, ← bit0_zero, h.eq_iff, vsub_eq_zero_iff_eq, eq_comm]
-#align
-  equiv.point_reflection_fixed_iff_of_injective_bit0
-  Equiv.pointReflection_fixed_iff_of_injective_bit0
+#align equiv.point_reflection_fixed_iff_of_injective_bit0 Equiv.pointReflection_fixed_iff_of_injective_bit0
 
 -- Porting note: Removed:
 -- omit G
@@ -488,9 +486,7 @@ theorem injective_pointReflection_left_of_injective_bit0 {G P : Type _} [AddComm
   rwa [pointReflection_apply, pointReflection_apply, vadd_eq_vadd_iff_sub_eq_vsub,
     vsub_sub_vsub_cancel_right, ← neg_vsub_eq_vsub_rev, neg_eq_iff_add_eq_zero, ← bit0, ← bit0_zero,
     h.eq_iff, vsub_eq_zero_iff_eq] at hy
-#align
-  equiv.injective_point_reflection_left_of_injective_bit0
-  Equiv.injective_pointReflection_left_of_injective_bit0
+#align equiv.injective_point_reflection_left_of_injective_bit0 Equiv.injective_pointReflection_left_of_injective_bit0
 
 end Equiv
 

See discussion at https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/mathport.20drops.20priorities.20in.20.60attribute.20.5Binstance.5D.60. mathport has been dropping the priorities on instances when using the attribute command.

This PR adds back all the priorities, except for local attribute, and instances involving coercions, which I didn't want to mess with.

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

@@ -57,7 +57,7 @@ class AddTorsor (G : outParam (Type _)) (P : Type _) [outParam <| AddGroup G] ex
   vadd_vsub' : ∀ (g : G) (p : P), g +ᵥ p -ᵥ p = g
 #align add_torsor AddTorsor
 
-attribute [instance] AddTorsor.Nonempty -- porting note: removers `nolint instance_priority`
+attribute [instance 100] AddTorsor.Nonempty -- porting note: removers `nolint instance_priority`
 
 --Porting note: removed
 --attribute [nolint dangerous_instance] AddTorsor.toVSub

@@ -285,12 +285,9 @@ end comm
 
 namespace Prod
 
-variable {G : Type _} {P : Type _} {G' : Type _} {P' : Type _} [AddGroup G] [AddGroup G']
-  [AddTorsor G P] [AddTorsor G' P']
+variable {G : Type _} [AddGroup G] [AddGroup G'] [AddTorsor G P] [AddTorsor G' P']
 
--- Porting note: the `{_ : ...}` instance terms make this instance not dangerous
-instance {G : Type _} {P : Type _} {G' : Type _} {P' : Type _} {_ : AddGroup G} {_ : AddGroup G'}
-    [AddTorsor G P] [AddTorsor G' P'] : AddTorsor (G × G') (P × P') where
+instance : AddTorsor (G × G') (P × P') where
   vadd v p := (v.1 +ᵥ p.1, v.2 +ᵥ p.2)
   zero_vadd _ := Prod.ext (zero_vadd _ _) (zero_vadd _ _)
   add_vadd _ _ _ := Prod.ext (add_vadd _ _ _) (add_vadd _ _ _)

Co-authored-by: qawbecrdtey <qawbecrdtey@kaist.ac.kr> Co-authored-by: Lukas Miaskiwskyi <lukas.mias@gmail.com>