logic.equiv.defs | Mathlib porting status

(last sync)

refactor(*): move all mk_simp_attribute commands to 1 file (#19223)

Diff

@@ -120,10 +120,10 @@ initialize_simps_projections equiv (to_fun → apply, inv_fun → symm_apply)
 @[trans] protected def trans (e₁ : α ≃ β) (e₂ : β ≃ γ) : α ≃ γ :=
 ⟨e₂ ∘ e₁, e₁.symm ∘ e₂.symm, e₂.left_inv.comp e₁.left_inv, e₂.right_inv.comp e₁.right_inv⟩
 
-@[simp]
+@[simp, transport_simps, mfld_simps]
 lemma to_fun_as_coe (e : α ≃ β) : e.to_fun = e := rfl
 
-@[simp]
+@[simp, mfld_simps]
 lemma inv_fun_as_coe (e : α ≃ β) : e.inv_fun = e.symm := rfl
 
 protected theorem injective (e : α ≃ β) : injective e := equiv_like.injective e
@@ -189,10 +189,11 @@ theorem refl_apply (x : α) : equiv.refl α x = x := rfl
 
 theorem trans_apply (f : α ≃ β) (g : β ≃ γ) (a : α) : (f.trans g) a = g (f a) := rfl
 
-@[simp] theorem apply_symm_apply  (e : α ≃ β) (x : β) : e (e.symm x) = x :=
+@[simp, equiv_rw_simp] theorem apply_symm_apply  (e : α ≃ β) (x : β) : e (e.symm x) = x :=
 e.right_inv x
 
-@[simp] theorem symm_apply_apply (e : α ≃ β) (x : α) : e.symm (e x) = x :=
+@[simp, equiv_rw_simp, transport_simps]
+theorem symm_apply_apply (e : α ≃ β) (x : α) : e.symm (e x) = x :=
 e.left_inv x
 
 @[simp] theorem symm_comp_self (e : α ≃ β) : e.symm ∘ e = id := funext e.symm_apply_apply
@@ -208,6 +209,7 @@ e.left_inv x
 
 theorem apply_eq_iff_eq (f : α ≃ β) {x y : α} : f x = f y ↔ x = y := equiv_like.apply_eq_iff_eq f
 
+@[transport_simps]
 theorem apply_eq_iff_eq_symm_apply {α β : Sort*} (f : α ≃ β) {x : α} {y : β} :
   f x = y ↔ x = f.symm y :=
 begin
@@ -234,7 +236,7 @@ lemma symm_apply_eq {α β} (e : α ≃ β) {x y} : e.symm x = y ↔ x = e y :=
 lemma eq_symm_apply {α β} (e : α ≃ β) {x y} : y = e.symm x ↔ e y = x :=
 (eq_comm.trans e.symm_apply_eq).trans eq_comm
 
-@[simp] theorem symm_symm (e : α ≃ β) : e.symm.symm = e := by { cases e, refl }
+@[simp, equiv_rw_simp] theorem symm_symm (e : α ≃ β) : e.symm.symm = e := by { cases e, refl }
 
 @[simp] theorem trans_refl (e : α ≃ β) : e.trans (equiv.refl β) = e := by { cases e, refl }
 
@@ -411,7 +413,7 @@ A version of `equiv.arrow_congr` in `Type`, rather than `Sort`.
 The `equiv_rw` tactic is not able to use the default `Sort` level `equiv.arrow_congr`,
 because Lean's universe rules will not unify `?l_1` with `imax (1 ?m_1)`.
 -/
-@[congr, simps apply]
+@[congr, simps apply { attrs := [`simp, `transport_simps] }]
 def arrow_congr' {α₁ β₁ α₂ β₂ : Type*} (hα : α₁ ≃ α₂) (hβ : β₁ ≃ β₂) : (α₁ → β₁) ≃ (α₂ → β₂) :=
 equiv.arrow_congr hα hβ
 
@@ -638,7 +640,8 @@ def sigma_congr {α₁ α₂} {β₁ : α₁ → Sort*} {β₂ : α₂ → Sort*
 (sigma_congr_right F).trans (sigma_congr_left f)
 
 /-- `sigma` type with a constant fiber is equivalent to the product. -/
-@[simps apply symm_apply] def sigma_equiv_prod (α β : Type*) : (Σ_:α, β) ≃ α × β :=
+@[simps apply symm_apply { attrs := [`simp, `mfld_simps] }]
+def sigma_equiv_prod (α β : Type*) : (Σ_:α, β) ≃ α × β :=
 ⟨λ a, ⟨a.1, a.2⟩, λ a, ⟨a.1, a.2⟩, λ ⟨a, b⟩, rfl, λ ⟨a, b⟩, rfl⟩
 
 /-- If each fiber of a `sigma` type is equivalent to a fixed type, then the sigma type

(first ported)

Changes in mathlib3port

mathlib3

mathlib3port

bump to nightly-2024-01-19-06

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

33b57512

Diff

@@ -108,38 +108,38 @@ theorem coe_fn_mk (f : α → β) (g l r) : (Equiv.mk f g l r : α → β) = f :
 #print Equiv.coe_fn_injective /-
 /-- The map `coe_fn : (r ≃ s) → (r → s)` is injective. -/
 theorem coe_fn_injective : @Function.Injective (α ≃ β) (α → β) coeFn :=
-  FunLike.coe_injective
+  DFunLike.coe_injective
 #align equiv.coe_fn_injective Equiv.coe_fn_injective
 -/
 
 #print Equiv.coe_inj /-
 protected theorem coe_inj {e₁ e₂ : α ≃ β} : (e₁ : α → β) = e₂ ↔ e₁ = e₂ :=
-  FunLike.coe_fn_eq
+  DFunLike.coe_fn_eq
 #align equiv.coe_inj Equiv.coe_inj
 -/
 
 #print Equiv.ext /-
 @[ext]
 theorem ext {f g : Equiv α β} (H : ∀ x, f x = g x) : f = g :=
-  FunLike.ext f g H
+  DFunLike.ext f g H
 #align equiv.ext Equiv.ext
 -/
 
 #print Equiv.congr_arg /-
 protected theorem congr_arg {f : Equiv α β} {x x' : α} : x = x' → f x = f x' :=
-  FunLike.congr_arg f
+  DFunLike.congr_arg f
 #align equiv.congr_arg Equiv.congr_arg
 -/
 
 #print Equiv.congr_fun /-
 protected theorem congr_fun {f g : Equiv α β} (h : f = g) (x : α) : f x = g x :=
-  FunLike.congr_fun h x
+  DFunLike.congr_fun h x
 #align equiv.congr_fun Equiv.congr_fun
 -/
 
 #print Equiv.ext_iff /-
 theorem ext_iff {f g : Equiv α β} : f = g ↔ ∀ x, f x = g x :=
-  FunLike.ext_iff
+  DFunLike.ext_iff
 #align equiv.ext_iff Equiv.ext_iff
 -/
 
@@ -259,7 +259,7 @@ theorem subsingleton_congr (e : α ≃ β) : Subsingleton α ↔ Subsingleton β
 
 #print Equiv.equiv_subsingleton_cod /-
 instance equiv_subsingleton_cod [Subsingleton β] : Subsingleton (α ≃ β) :=
-  FunLike.subsingleton_cod
+  DFunLike.subsingleton_cod
 #align equiv.equiv_subsingleton_cod Equiv.equiv_subsingleton_cod
 -/

bump to nightly-2023-11-15-06

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

38c8ceef

Diff

@@ -924,7 +924,6 @@ def arrowPUnitEquivPUnit (α : Sort _) : (α → PUnit.{v}) ≃ PUnit.{w} :=
 #align equiv.arrow_punit_equiv_punit Equiv.arrowPUnitEquivPUnit
 -/
 
-#print Equiv.piSubsingleton /-
 /-- If `α` is `subsingleton` and `a : α`, then the type of dependent functions `Π (i : α), β
 i` is equivalent to `β i`. -/
 @[simps]
@@ -935,7 +934,6 @@ def piSubsingleton {α} (β : α → Sort _) [Subsingleton α] (a : α) : (∀ a
   left_inv f := funext fun b => by rw [Subsingleton.elim b a]; rfl
   right_inv b := rfl
 #align equiv.Pi_subsingleton Equiv.piSubsingleton
--/
 
 #print Equiv.funUnique /-
 /-- If `α` has a unique term, then the type of function `α → β` is equivalent to `β`. -/

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,8 +3,8 @@ Copyright (c) 2015 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Leonardo de Moura, Mario Carneiro
 -/
-import Mathbin.Data.FunLike.Equiv
-import Mathbin.Logic.Unique
+import Data.FunLike.Equiv
+import Logic.Unique
 
 #align_import logic.equiv.defs from "leanprover-community/mathlib"@"48fb5b5280e7c81672afc9524185ae994553ebf4"

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2015 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Leonardo de Moura, Mario Carneiro
-
-! This file was ported from Lean 3 source module logic.equiv.defs
-! leanprover-community/mathlib commit 48fb5b5280e7c81672afc9524185ae994553ebf4
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.FunLike.Equiv
 import Mathbin.Logic.Unique
 
+#align_import logic.equiv.defs from "leanprover-community/mathlib"@"48fb5b5280e7c81672afc9524185ae994553ebf4"
+
 /-!
 # Equivalence between types

bump to nightly-2023-07-04-01

mathlib commit https://github.com/leanprover-community/mathlib/commit/728ef9dbb281241906f25cbeb30f90d83e0bb451

05318d71

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Leonardo de Moura, Mario Carneiro
 
 ! This file was ported from Lean 3 source module logic.equiv.defs
-! leanprover-community/mathlib commit 448144f7ae193a8990cb7473c9e9a01990f64ac7
+! leanprover-community/mathlib commit 48fb5b5280e7c81672afc9524185ae994553ebf4
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -211,14 +211,14 @@ protected def trans (e₁ : α ≃ β) (e₂ : β ≃ γ) : α ≃ γ :=
 -/
 
 #print Equiv.toFun_as_coe /-
-@[simp]
+@[simp, transport_simps, mfld_simps]
 theorem toFun_as_coe (e : α ≃ β) : e.toFun = e :=
   rfl
 #align equiv.to_fun_as_coe Equiv.toFun_as_coe
 -/
 
 #print Equiv.invFun_as_coe /-
-@[simp]
+@[simp, mfld_simps]
 theorem invFun_as_coe (e : α ≃ β) : e.invFun = e.symm :=
   rfl
 #align equiv.inv_fun_as_coe Equiv.invFun_as_coe
@@ -366,14 +366,14 @@ theorem trans_apply (f : α ≃ β) (g : β ≃ γ) (a : α) : (f.trans g) a = g
 -/
 
 #print Equiv.apply_symm_apply /-
-@[simp]
+@[simp, equiv_rw_simp]
 theorem apply_symm_apply (e : α ≃ β) (x : β) : e (e.symm x) = x :=
   e.right_inv x
 #align equiv.apply_symm_apply Equiv.apply_symm_apply
 -/
 
 #print Equiv.symm_apply_apply /-
-@[simp]
+@[simp, equiv_rw_simp, transport_simps]
 theorem symm_apply_apply (e : α ≃ β) (x : α) : e.symm (e x) = x :=
   e.left_inv x
 #align equiv.symm_apply_apply Equiv.symm_apply_apply
@@ -416,6 +416,7 @@ theorem apply_eq_iff_eq (f : α ≃ β) {x y : α} : f x = f y ↔ x = y :=
 -/
 
 #print Equiv.apply_eq_iff_eq_symm_apply /-
+@[transport_simps]
 theorem apply_eq_iff_eq_symm_apply {α β : Sort _} (f : α ≃ β) {x : α} {y : β} :
     f x = y ↔ x = f.symm y := by
   conv_lhs => rw [← apply_symm_apply f y]
@@ -471,7 +472,7 @@ theorem eq_symm_apply {α β} (e : α ≃ β) {x y} : y = e.symm x ↔ e y = x :
 -/
 
 #print Equiv.symm_symm /-
-@[simp]
+@[simp, equiv_rw_simp]
 theorem symm_symm (e : α ≃ β) : e.symm.symm = e := by cases e; rfl
 #align equiv.symm_symm Equiv.symm_symm
 -/
@@ -809,7 +810,7 @@ theorem arrowCongr_symm {α₁ β₁ α₂ β₂ : Sort _} (e₁ : α₁ ≃ α
 The `equiv_rw` tactic is not able to use the default `Sort` level `equiv.arrow_congr`,
 because Lean's universe rules will not unify `?l_1` with `imax (1 ?m_1)`.
 -/
-@[congr, simps apply]
+@[congr, simps (config := { attrs := [`simp, `transport_simps] }) apply]
 def arrowCongr' {α₁ β₁ α₂ β₂ : Type _} (hα : α₁ ≃ α₂) (hβ : β₁ ≃ β₂) : (α₁ → β₁) ≃ (α₂ → β₂) :=
   Equiv.arrowCongr hα hβ
 #align equiv.arrow_congr' Equiv.arrowCongr'
@@ -1179,7 +1180,7 @@ def sigmaCongr {α₁ α₂} {β₁ : α₁ → Sort _} {β₂ : α₂ → Sort
 
 #print Equiv.sigmaEquivProd /-
 /-- `sigma` type with a constant fiber is equivalent to the product. -/
-@[simps apply symm_apply]
+@[simps (config := { attrs := [`simp, `mfld_simps] }) apply symm_apply]
 def sigmaEquivProd (α β : Type _) : (Σ _ : α, β) ≃ α × β :=
   ⟨fun a => ⟨a.1, a.2⟩, fun a => ⟨a.1, a.2⟩, fun ⟨a, b⟩ => rfl, fun ⟨a, b⟩ => rfl⟩
 #align equiv.sigma_equiv_prod Equiv.sigmaEquivProd

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -62,6 +62,7 @@ universe u v w z
 
 variable {α : Sort u} {β : Sort v} {γ : Sort w}
 
+#print Equiv /-
 /-- `α ≃ β` is the type of functions from `α → β` with a two-sided inverse. -/
 structure Equiv (α : Sort _) (β : Sort _) where
   toFun : α → β
@@ -69,8 +70,8 @@ structure Equiv (α : Sort _) (β : Sort _) where
   left_inv : LeftInverse inv_fun to_fun
   right_inv : RightInverse inv_fun to_fun
 #align equiv Equiv
+-/
 
--- mathport name: «expr ≃ »
 infixl:25 " ≃ " => Equiv
 
 instance {F} [EquivLike F α β] : CoeTC F (α ≃ β) :=
@@ -133,13 +134,17 @@ protected theorem congr_arg {f : Equiv α β} {x x' : α} : x = x' → f x = f x
 #align equiv.congr_arg Equiv.congr_arg
 -/
 
+#print Equiv.congr_fun /-
 protected theorem congr_fun {f g : Equiv α β} (h : f = g) (x : α) : f x = g x :=
   FunLike.congr_fun h x
 #align equiv.congr_fun Equiv.congr_fun
+-/
 
+#print Equiv.ext_iff /-
 theorem ext_iff {f g : Equiv α β} : f = g ↔ ∀ x, f x = g x :=
   FunLike.ext_iff
 #align equiv.ext_iff Equiv.ext_iff
+-/
 
 #print Equiv.Perm.ext /-
 @[ext]
@@ -255,13 +260,17 @@ theorem subsingleton_congr (e : α ≃ β) : Subsingleton α ↔ Subsingleton β
 #align equiv.subsingleton_congr Equiv.subsingleton_congr
 -/
 
+#print Equiv.equiv_subsingleton_cod /-
 instance equiv_subsingleton_cod [Subsingleton β] : Subsingleton (α ≃ β) :=
   FunLike.subsingleton_cod
 #align equiv.equiv_subsingleton_cod Equiv.equiv_subsingleton_cod
+-/
 
+#print Equiv.equiv_subsingleton_dom /-
 instance equiv_subsingleton_dom [Subsingleton α] : Subsingleton (α ≃ β) :=
   EquivLike.subsingleton_dom
 #align equiv.equiv_subsingleton_dom Equiv.equiv_subsingleton_dom
+-/
 
 #print Equiv.permUnique /-
 instance permUnique [Subsingleton α] : Unique (Perm α) :=
@@ -406,11 +415,13 @@ theorem apply_eq_iff_eq (f : α ≃ β) {x y : α} : f x = f y ↔ x = y :=
 #align equiv.apply_eq_iff_eq Equiv.apply_eq_iff_eq
 -/
 
+#print Equiv.apply_eq_iff_eq_symm_apply /-
 theorem apply_eq_iff_eq_symm_apply {α β : Sort _} (f : α ≃ β) {x : α} {y : β} :
     f x = y ↔ x = f.symm y := by
   conv_lhs => rw [← apply_symm_apply f y]
   rw [apply_eq_iff_eq]
 #align equiv.apply_eq_iff_eq_symm_apply Equiv.apply_eq_iff_eq_symm_apply
+-/
 
 #print Equiv.cast_apply /-
 @[simp]
@@ -447,21 +458,29 @@ theorem cast_eq_iff_heq {α β} (h : α = β) {a : α} {b : β} : Equiv.cast h a
 #align equiv.cast_eq_iff_heq Equiv.cast_eq_iff_heq
 -/
 
+#print Equiv.symm_apply_eq /-
 theorem symm_apply_eq {α β} (e : α ≃ β) {x y} : e.symm x = y ↔ x = e y :=
   ⟨fun H => by simp [H.symm], fun H => by simp [H]⟩
 #align equiv.symm_apply_eq Equiv.symm_apply_eq
+-/
 
+#print Equiv.eq_symm_apply /-
 theorem eq_symm_apply {α β} (e : α ≃ β) {x y} : y = e.symm x ↔ e y = x :=
   (eq_comm.trans e.symm_apply_eq).trans eq_comm
 #align equiv.eq_symm_apply Equiv.eq_symm_apply
+-/
 
+#print Equiv.symm_symm /-
 @[simp]
 theorem symm_symm (e : α ≃ β) : e.symm.symm = e := by cases e; rfl
 #align equiv.symm_symm Equiv.symm_symm
+-/
 
+#print Equiv.trans_refl /-
 @[simp]
 theorem trans_refl (e : α ≃ β) : e.trans (Equiv.refl β) = e := by cases e; rfl
 #align equiv.trans_refl Equiv.trans_refl
+-/
 
 #print Equiv.refl_symm /-
 @[simp]
@@ -470,9 +489,11 @@ theorem refl_symm : (Equiv.refl α).symm = Equiv.refl α :=
 #align equiv.refl_symm Equiv.refl_symm
 -/
 
+#print Equiv.refl_trans /-
 @[simp]
 theorem refl_trans (e : α ≃ β) : (Equiv.refl α).trans e = e := by cases e; rfl
 #align equiv.refl_trans Equiv.refl_trans
+-/
 
 #print Equiv.symm_trans_self /-
 @[simp]
@@ -488,10 +509,12 @@ theorem self_trans_symm (e : α ≃ β) : e.trans e.symm = Equiv.refl α :=
 #align equiv.self_trans_symm Equiv.self_trans_symm
 -/
 
+#print Equiv.trans_assoc /-
 theorem trans_assoc {δ} (ab : α ≃ β) (bc : β ≃ γ) (cd : γ ≃ δ) :
     (ab.trans bc).trans cd = ab.trans (bc.trans cd) :=
   Equiv.ext fun a => rfl
 #align equiv.trans_assoc Equiv.trans_assoc
+-/
 
 #print Equiv.leftInverse_symm /-
 theorem leftInverse_symm (f : Equiv α β) : LeftInverse f.symm f :=
@@ -541,46 +564,60 @@ theorem comp_bijective (f : α → β) (e : β ≃ γ) : Bijective (e ∘ f) ↔
 #align equiv.comp_bijective Equiv.comp_bijective
 -/
 
+#print Equiv.equivCongr /-
 /-- If `α` is equivalent to `β` and `γ` is equivalent to `δ`, then the type of equivalences `α ≃ γ`
 is equivalent to the type of equivalences `β ≃ δ`. -/
 def equivCongr {δ} (ab : α ≃ β) (cd : γ ≃ δ) : α ≃ γ ≃ (β ≃ δ) :=
   ⟨fun ac => (ab.symm.trans ac).trans cd, fun bd => ab.trans <| bd.trans <| cd.symm, fun ac => by
     ext x; simp, fun ac => by ext x; simp⟩
 #align equiv.equiv_congr Equiv.equivCongr
+-/
 
+#print Equiv.equivCongr_refl /-
 @[simp]
 theorem equivCongr_refl {α β} : (Equiv.refl α).equivCongr (Equiv.refl β) = Equiv.refl (α ≃ β) := by
   ext; rfl
 #align equiv.equiv_congr_refl Equiv.equivCongr_refl
+-/
 
+#print Equiv.equivCongr_symm /-
 @[simp]
 theorem equivCongr_symm {δ} (ab : α ≃ β) (cd : γ ≃ δ) :
     (ab.equivCongr cd).symm = ab.symm.equivCongr cd.symm := by ext; rfl
 #align equiv.equiv_congr_symm Equiv.equivCongr_symm
+-/
 
+#print Equiv.equivCongr_trans /-
 @[simp]
 theorem equivCongr_trans {δ ε ζ} (ab : α ≃ β) (de : δ ≃ ε) (bc : β ≃ γ) (ef : ε ≃ ζ) :
     (ab.equivCongr de).trans (bc.equivCongr ef) = (ab.trans bc).equivCongr (de.trans ef) := by ext;
   rfl
 #align equiv.equiv_congr_trans Equiv.equivCongr_trans
+-/
 
+#print Equiv.equivCongr_refl_left /-
 @[simp]
 theorem equivCongr_refl_left {α β γ} (bg : β ≃ γ) (e : α ≃ β) :
     (Equiv.refl α).equivCongr bg e = e.trans bg :=
   rfl
 #align equiv.equiv_congr_refl_left Equiv.equivCongr_refl_left
+-/
 
+#print Equiv.equivCongr_refl_right /-
 @[simp]
 theorem equivCongr_refl_right {α β} (ab e : α ≃ β) :
     ab.equivCongr (Equiv.refl β) e = ab.symm.trans e :=
   rfl
 #align equiv.equiv_congr_refl_right Equiv.equivCongr_refl_right
+-/
 
+#print Equiv.equivCongr_apply_apply /-
 @[simp]
 theorem equivCongr_apply_apply {δ} (ab : α ≃ β) (cd : γ ≃ δ) (e : α ≃ γ) (x) :
     ab.equivCongr cd e x = cd (e (ab.symm x)) :=
   rfl
 #align equiv.equiv_congr_apply_apply Equiv.equivCongr_apply_apply
+-/
 
 section PermCongr
 
@@ -593,9 +630,11 @@ def permCongr : Perm α' ≃ Perm β' :=
 #align equiv.perm_congr Equiv.permCongr
 -/
 
+#print Equiv.permCongr_def /-
 theorem permCongr_def (p : Equiv.Perm α') : e.permCongr p = (e.symm.trans p).trans e :=
   rfl
 #align equiv.perm_congr_def Equiv.permCongr_def
+-/
 
 #print Equiv.permCongr_refl /-
 @[simp]
@@ -603,15 +642,19 @@ theorem permCongr_refl : e.permCongr (Equiv.refl _) = Equiv.refl _ := by simp [p
 #align equiv.perm_congr_refl Equiv.permCongr_refl
 -/
 
+#print Equiv.permCongr_symm /-
 @[simp]
 theorem permCongr_symm : e.permCongr.symm = e.symm.permCongr :=
   rfl
 #align equiv.perm_congr_symm Equiv.permCongr_symm
+-/
 
+#print Equiv.permCongr_apply /-
 @[simp]
 theorem permCongr_apply (p : Equiv.Perm α') (x) : e.permCongr p x = e (p (e.symm x)) :=
   rfl
 #align equiv.perm_congr_apply Equiv.permCongr_apply
+-/
 
 #print Equiv.permCongr_symm_apply /-
 theorem permCongr_symm_apply (p : Equiv.Perm β') (x) : e.permCongr.symm p x = e.symm (p (e x)) :=
@@ -619,9 +662,11 @@ theorem permCongr_symm_apply (p : Equiv.Perm β') (x) : e.permCongr.symm p x = e
 #align equiv.perm_congr_symm_apply Equiv.permCongr_symm_apply
 -/
 
+#print Equiv.permCongr_trans /-
 theorem permCongr_trans (p p' : Equiv.Perm α') :
     (e.permCongr p).trans (e.permCongr p') = e.permCongr (p.trans p') := by ext; simp
 #align equiv.perm_congr_trans Equiv.permCongr_trans
+-/
 
 end PermCongr
 
@@ -646,10 +691,12 @@ def equivPEmpty (α : Sort v) [IsEmpty α] : α ≃ PEmpty.{u} :=
 #align equiv.equiv_pempty Equiv.equivPEmpty
 -/
 
+#print Equiv.equivEmptyEquiv /-
 /-- `α` is equivalent to an empty type iff `α` is empty. -/
 def equivEmptyEquiv (α : Sort u) : α ≃ Empty ≃ IsEmpty α :=
   ⟨fun e => Function.isEmpty e, @equivEmpty α, fun e => ext fun x => (e x).elim, fun p => rfl⟩
 #align equiv.equiv_empty_equiv Equiv.equivEmptyEquiv
+-/
 
 #print Equiv.propEquivPEmpty /-
 /-- The `Sort` of proofs of a false proposition is equivalent to `pempty`. -/
@@ -669,15 +716,19 @@ def equivOfUnique (α β : Sort _) [Unique α] [Unique β] : α ≃ β
 #align equiv.equiv_of_unique Equiv.equivOfUnique
 -/
 
+#print Equiv.equivPUnit /-
 /-- If `α` has a unique element, then it is equivalent to any `punit`. -/
 def equivPUnit (α : Sort _) [Unique α] : α ≃ PUnit.{v} :=
   equivOfUnique α _
 #align equiv.equiv_punit Equiv.equivPUnit
+-/
 
+#print Equiv.propEquivPUnit /-
 /-- The `Sort` of proofs of a true proposition is equivalent to `punit`. -/
 def propEquivPUnit {p : Prop} (h : p) : p ≃ PUnit :=
   @equivPUnit p <| uniqueProp h
 #align equiv.prop_equiv_punit Equiv.propEquivPUnit
+-/
 
 #print Equiv.ulift /-
 /-- `ulift α` is equivalent to `α`. -/
@@ -719,30 +770,38 @@ def arrowCongr {α₁ β₁ α₂ β₂ : Sort _} (e₁ : α₁ ≃ α₂) (e₂
 #align equiv.arrow_congr Equiv.arrowCongr
 -/
 
+#print Equiv.arrowCongr_comp /-
 theorem arrowCongr_comp {α₁ β₁ γ₁ α₂ β₂ γ₂ : Sort _} (ea : α₁ ≃ α₂) (eb : β₁ ≃ β₂) (ec : γ₁ ≃ γ₂)
     (f : α₁ → β₁) (g : β₁ → γ₁) :
     arrowCongr ea ec (g ∘ f) = arrowCongr eb ec g ∘ arrowCongr ea eb f := by ext;
   simp only [comp, arrow_congr_apply, eb.symm_apply_apply]
 #align equiv.arrow_congr_comp Equiv.arrowCongr_comp
+-/
 
+#print Equiv.arrowCongr_refl /-
 @[simp]
 theorem arrowCongr_refl {α β : Sort _} :
     arrowCongr (Equiv.refl α) (Equiv.refl β) = Equiv.refl (α → β) :=
   rfl
 #align equiv.arrow_congr_refl Equiv.arrowCongr_refl
+-/
 
+#print Equiv.arrowCongr_trans /-
 @[simp]
 theorem arrowCongr_trans {α₁ β₁ α₂ β₂ α₃ β₃ : Sort _} (e₁ : α₁ ≃ α₂) (e₁' : β₁ ≃ β₂) (e₂ : α₂ ≃ α₃)
     (e₂' : β₂ ≃ β₃) :
     arrowCongr (e₁.trans e₂) (e₁'.trans e₂') = (arrowCongr e₁ e₁').trans (arrowCongr e₂ e₂') :=
   rfl
 #align equiv.arrow_congr_trans Equiv.arrowCongr_trans
+-/
 
+#print Equiv.arrowCongr_symm /-
 @[simp]
 theorem arrowCongr_symm {α₁ β₁ α₂ β₂ : Sort _} (e₁ : α₁ ≃ α₂) (e₂ : β₁ ≃ β₂) :
     (arrowCongr e₁ e₂).symm = arrowCongr e₁.symm e₂.symm :=
   rfl
 #align equiv.arrow_congr_symm Equiv.arrowCongr_symm
+-/
 
 #print Equiv.arrowCongr' /-
 /-- A version of `equiv.arrow_congr` in `Type`, rather than `Sort`.
@@ -756,24 +815,30 @@ def arrowCongr' {α₁ β₁ α₂ β₂ : Type _} (hα : α₁ ≃ α₂) (hβ
 #align equiv.arrow_congr' Equiv.arrowCongr'
 -/
 
+#print Equiv.arrowCongr'_refl /-
 @[simp]
 theorem arrowCongr'_refl {α β : Type _} :
     arrowCongr' (Equiv.refl α) (Equiv.refl β) = Equiv.refl (α → β) :=
   rfl
 #align equiv.arrow_congr'_refl Equiv.arrowCongr'_refl
+-/
 
+#print Equiv.arrowCongr'_trans /-
 @[simp]
 theorem arrowCongr'_trans {α₁ β₁ α₂ β₂ α₃ β₃ : Type _} (e₁ : α₁ ≃ α₂) (e₁' : β₁ ≃ β₂) (e₂ : α₂ ≃ α₃)
     (e₂' : β₂ ≃ β₃) :
     arrowCongr' (e₁.trans e₂) (e₁'.trans e₂') = (arrowCongr' e₁ e₁').trans (arrowCongr' e₂ e₂') :=
   rfl
 #align equiv.arrow_congr'_trans Equiv.arrowCongr'_trans
+-/
 
+#print Equiv.arrowCongr'_symm /-
 @[simp]
 theorem arrowCongr'_symm {α₁ β₁ α₂ β₂ : Type _} (e₁ : α₁ ≃ α₂) (e₂ : β₁ ≃ β₂) :
     (arrowCongr' e₁ e₂).symm = arrowCongr' e₁.symm e₂.symm :=
   rfl
 #align equiv.arrow_congr'_symm Equiv.arrowCongr'_symm
+-/
 
 #print Equiv.conj /-
 /-- Conjugate a map `f : α → α` by an equivalence `α ≃ β`. -/
@@ -790,15 +855,19 @@ theorem conj_refl : conj (Equiv.refl α) = Equiv.refl (α → α) :=
 #align equiv.conj_refl Equiv.conj_refl
 -/
 
+#print Equiv.conj_symm /-
 @[simp]
 theorem conj_symm (e : α ≃ β) : e.conj.symm = e.symm.conj :=
   rfl
 #align equiv.conj_symm Equiv.conj_symm
+-/
 
+#print Equiv.conj_trans /-
 @[simp]
 theorem conj_trans (e₁ : α ≃ β) (e₂ : β ≃ γ) : (e₁.trans e₂).conj = e₁.conj.trans e₂.conj :=
   rfl
 #align equiv.conj_trans Equiv.conj_trans
+-/
 
 #print Equiv.conj_comp /-
 -- This should not be a simp lemma as long as `(∘)` is reducible:
@@ -809,21 +878,29 @@ theorem conj_comp (e : α ≃ β) (f₁ f₂ : α → α) : e.conj (f₁ ∘ f
 #align equiv.conj_comp Equiv.conj_comp
 -/
 
+#print Equiv.eq_comp_symm /-
 theorem eq_comp_symm {α β γ} (e : α ≃ β) (f : β → γ) (g : α → γ) : f = g ∘ e.symm ↔ f ∘ e = g :=
   (e.arrowCongr (Equiv.refl γ)).symm_apply_eq.symm
 #align equiv.eq_comp_symm Equiv.eq_comp_symm
+-/
 
+#print Equiv.comp_symm_eq /-
 theorem comp_symm_eq {α β γ} (e : α ≃ β) (f : β → γ) (g : α → γ) : g ∘ e.symm = f ↔ g = f ∘ e :=
   (e.arrowCongr (Equiv.refl γ)).eq_symm_apply.symm
 #align equiv.comp_symm_eq Equiv.comp_symm_eq
+-/
 
+#print Equiv.eq_symm_comp /-
 theorem eq_symm_comp {α β γ} (e : α ≃ β) (f : γ → α) (g : γ → β) : f = e.symm ∘ g ↔ e ∘ f = g :=
   ((Equiv.refl γ).arrowCongr e).eq_symm_apply
 #align equiv.eq_symm_comp Equiv.eq_symm_comp
+-/
 
+#print Equiv.symm_comp_eq /-
 theorem symm_comp_eq {α β γ} (e : α ≃ β) (f : γ → α) (g : γ → β) : e.symm ∘ g = f ↔ g = e ∘ f :=
   ((Equiv.refl γ).arrowCongr e).symm_apply_eq
 #align equiv.symm_comp_eq Equiv.symm_comp_eq
+-/
 
 #print Equiv.punitEquivPUnit /-
 /-- `punit` sorts in any two universes are equivalent. -/
@@ -944,22 +1021,28 @@ def psigmaCongrRight {α} {β₁ β₂ : α → Sort _} (F : ∀ a, β₁ a ≃
 #align equiv.psigma_congr_right Equiv.psigmaCongrRight
 -/
 
+#print Equiv.psigmaCongrRight_trans /-
 @[simp]
 theorem psigmaCongrRight_trans {α} {β₁ β₂ β₃ : α → Sort _} (F : ∀ a, β₁ a ≃ β₂ a)
     (G : ∀ a, β₂ a ≃ β₃ a) :
     (psigmaCongrRight F).trans (psigmaCongrRight G) = psigmaCongrRight fun a => (F a).trans (G a) :=
   by ext1 x; cases x; rfl
 #align equiv.psigma_congr_right_trans Equiv.psigmaCongrRight_trans
+-/
 
+#print Equiv.psigmaCongrRight_symm /-
 @[simp]
 theorem psigmaCongrRight_symm {α} {β₁ β₂ : α → Sort _} (F : ∀ a, β₁ a ≃ β₂ a) :
     (psigmaCongrRight F).symm = psigmaCongrRight fun a => (F a).symm := by ext1 x; cases x; rfl
 #align equiv.psigma_congr_right_symm Equiv.psigmaCongrRight_symm
+-/
 
+#print Equiv.psigmaCongrRight_refl /-
 @[simp]
 theorem psigmaCongrRight_refl {α} {β : α → Sort _} :
     (psigmaCongrRight fun a => Equiv.refl (β a)) = Equiv.refl (Σ' a, β a) := by ext1 x; cases x; rfl
 #align equiv.psigma_congr_right_refl Equiv.psigmaCongrRight_refl
+-/
 
 #print Equiv.sigmaCongrRight /-
 /-- A family of equivalences `Π a, β₁ a ≃ β₂ a` generates an equivalence between `Σ a, β₁ a` and
@@ -972,22 +1055,28 @@ def sigmaCongrRight {α} {β₁ β₂ : α → Type _} (F : ∀ a, β₁ a ≃ 
 #align equiv.sigma_congr_right Equiv.sigmaCongrRight
 -/
 
+#print Equiv.sigmaCongrRight_trans /-
 @[simp]
 theorem sigmaCongrRight_trans {α} {β₁ β₂ β₃ : α → Type _} (F : ∀ a, β₁ a ≃ β₂ a)
     (G : ∀ a, β₂ a ≃ β₃ a) :
     (sigmaCongrRight F).trans (sigmaCongrRight G) = sigmaCongrRight fun a => (F a).trans (G a) := by
   ext1 x; cases x; rfl
 #align equiv.sigma_congr_right_trans Equiv.sigmaCongrRight_trans
+-/
 
+#print Equiv.sigmaCongrRight_symm /-
 @[simp]
 theorem sigmaCongrRight_symm {α} {β₁ β₂ : α → Type _} (F : ∀ a, β₁ a ≃ β₂ a) :
     (sigmaCongrRight F).symm = sigmaCongrRight fun a => (F a).symm := by ext1 x; cases x; rfl
 #align equiv.sigma_congr_right_symm Equiv.sigmaCongrRight_symm
+-/
 
+#print Equiv.sigmaCongrRight_refl /-
 @[simp]
 theorem sigmaCongrRight_refl {α} {β : α → Type _} :
     (sigmaCongrRight fun a => Equiv.refl (β a)) = Equiv.refl (Σ a, β a) := by ext1 x; cases x; rfl
 #align equiv.sigma_congr_right_refl Equiv.sigmaCongrRight_refl
+-/
 
 #print Equiv.psigmaEquivSubtype /-
 /-- A `psigma` with `Prop` fibers is equivalent to the subtype.  -/
@@ -1028,26 +1117,33 @@ def sigmaCongrRight {α} {β : α → Sort _} (F : ∀ a, Perm (β a)) : Perm (
 #align equiv.perm.sigma_congr_right Equiv.Perm.sigmaCongrRight
 -/
 
+#print Equiv.Perm.sigmaCongrRight_trans /-
 @[simp]
 theorem sigmaCongrRight_trans {α} {β : α → Sort _} (F : ∀ a, Perm (β a)) (G : ∀ a, Perm (β a)) :
     (sigmaCongrRight F).trans (sigmaCongrRight G) = sigmaCongrRight fun a => (F a).trans (G a) :=
   Equiv.sigmaCongrRight_trans F G
 #align equiv.perm.sigma_congr_right_trans Equiv.Perm.sigmaCongrRight_trans
+-/
 
+#print Equiv.Perm.sigmaCongrRight_symm /-
 @[simp]
 theorem sigmaCongrRight_symm {α} {β : α → Sort _} (F : ∀ a, Perm (β a)) :
     (sigmaCongrRight F).symm = sigmaCongrRight fun a => (F a).symm :=
   Equiv.sigmaCongrRight_symm F
 #align equiv.perm.sigma_congr_right_symm Equiv.Perm.sigmaCongrRight_symm
+-/
 
+#print Equiv.Perm.sigmaCongrRight_refl /-
 @[simp]
 theorem sigmaCongrRight_refl {α} {β : α → Sort _} :
     (sigmaCongrRight fun a => Equiv.refl (β a)) = Equiv.refl (Σ a, β a) :=
   Equiv.sigmaCongrRight_refl
 #align equiv.perm.sigma_congr_right_refl Equiv.Perm.sigmaCongrRight_refl
+-/
 
 end Perm
 
+#print Equiv.sigmaCongrLeft /-
 /-- An equivalence `f : α₁ ≃ α₂` generates an equivalence between `Σ a, β (f a)` and `Σ a, β a`. -/
 @[simps apply]
 def sigmaCongrLeft {α₁ α₂} {β : α₂ → Sort _} (e : α₁ ≃ α₂) : (Σ a : α₁, β (e a)) ≃ Σ a : α₂, β a :=
@@ -1062,6 +1158,7 @@ def sigmaCongrLeft {α₁ α₂} {β : α₂ → Sort _} (e : α₁ ≃ α₂) :
       _ with
     | _, rfl => rfl⟩
 #align equiv.sigma_congr_left Equiv.sigmaCongrLeft
+-/
 
 #print Equiv.sigmaCongrLeft' /-
 /-- Transporting a sigma type through an equivalence of the base -/
@@ -1164,6 +1261,7 @@ universe ua1 ua2 ub1 ub2 ug1 ug2
 variable {α₁ : Sort ua1} {α₂ : Sort ua2} {β₁ : Sort ub1} {β₂ : Sort ub2} {γ₁ : Sort ug1}
   {γ₂ : Sort ug2}
 
+#print Equiv.forall₂_congr /-
 protected theorem forall₂_congr {p : α₁ → β₁ → Prop} {q : α₂ → β₂ → Prop} (eα : α₁ ≃ α₂)
     (eβ : β₁ ≃ β₂) (h : ∀ {x y}, p x y ↔ q (eα x) (eβ y)) : (∀ x y, p x y) ↔ ∀ x y, q x y :=
   by
@@ -1173,13 +1271,17 @@ protected theorem forall₂_congr {p : α₁ → β₁ → Prop} {q : α₂ →
   intros
   apply h
 #align equiv.forall₂_congr Equiv.forall₂_congr
+-/
 
+#print Equiv.forall₂_congr' /-
 protected theorem forall₂_congr' {p : α₁ → β₁ → Prop} {q : α₂ → β₂ → Prop} (eα : α₁ ≃ α₂)
     (eβ : β₁ ≃ β₂) (h : ∀ {x y}, p (eα.symm x) (eβ.symm y) ↔ q x y) :
     (∀ x y, p x y) ↔ ∀ x y, q x y :=
   (Equiv.forall₂_congr eα.symm eβ.symm fun x y => h.symm).symm
 #align equiv.forall₂_congr' Equiv.forall₂_congr'
+-/
 
+#print Equiv.forall₃_congr /-
 protected theorem forall₃_congr {p : α₁ → β₁ → γ₁ → Prop} {q : α₂ → β₂ → γ₂ → Prop} (eα : α₁ ≃ α₂)
     (eβ : β₁ ≃ β₂) (eγ : γ₁ ≃ γ₂) (h : ∀ {x y z}, p x y z ↔ q (eα x) (eβ y) (eγ z)) :
     (∀ x y z, p x y z) ↔ ∀ x y z, q x y z :=
@@ -1190,12 +1292,15 @@ protected theorem forall₃_congr {p : α₁ → β₁ → γ₁ → Prop} {q :
   intros
   apply h
 #align equiv.forall₃_congr Equiv.forall₃_congr
+-/
 
+#print Equiv.forall₃_congr' /-
 protected theorem forall₃_congr' {p : α₁ → β₁ → γ₁ → Prop} {q : α₂ → β₂ → γ₂ → Prop} (eα : α₁ ≃ α₂)
     (eβ : β₁ ≃ β₂) (eγ : γ₁ ≃ γ₂) (h : ∀ {x y z}, p (eα.symm x) (eβ.symm y) (eγ.symm z) ↔ q x y z) :
     (∀ x y z, p x y z) ↔ ∀ x y z, q x y z :=
   (Equiv.forall₃_congr eα.symm eβ.symm eγ.symm fun x y z => h.symm).symm
 #align equiv.forall₃_congr' Equiv.forall₃_congr'
+-/
 
 #print Equiv.forall_congr_left' /-
 protected theorem forall_congr_left' {p : α → Prop} (f : α ≃ β) : (∀ x, p x) ↔ ∀ y, p (f.symm y) :=
@@ -1209,10 +1314,12 @@ protected theorem forall_congr_left {p : β → Prop} (f : α ≃ β) : (∀ x,
 #align equiv.forall_congr_left Equiv.forall_congr_left
 -/
 
+#print Equiv.exists_congr_left /-
 protected theorem exists_congr_left {α β} (f : α ≃ β) {p : α → Prop} :
     (∃ a, p a) ↔ ∃ b, p (f.symm b) :=
   ⟨fun ⟨a, h⟩ => ⟨f a, by simpa using h⟩, fun ⟨b, h⟩ => ⟨_, h⟩⟩
 #align equiv.exists_congr_left Equiv.exists_congr_left
+-/
 
 end Equiv

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -919,7 +919,7 @@ section
 #print Equiv.psigmaEquivSigma /-
 /-- A `psigma`-type is equivalent to the corresponding `sigma`-type. -/
 @[simps apply symm_apply]
-def psigmaEquivSigma {α} (β : α → Type _) : (Σ'i, β i) ≃ Σi, β i :=
+def psigmaEquivSigma {α} (β : α → Type _) : (Σ' i, β i) ≃ Σ i, β i :=
   ⟨fun a => ⟨a.1, a.2⟩, fun a => ⟨a.1, a.2⟩, fun ⟨a, b⟩ => rfl, fun ⟨a, b⟩ => rfl⟩
 #align equiv.psigma_equiv_sigma Equiv.psigmaEquivSigma
 -/
@@ -927,7 +927,7 @@ def psigmaEquivSigma {α} (β : α → Type _) : (Σ'i, β i) ≃ Σi, β i :=
 #print Equiv.psigmaEquivSigmaPLift /-
 /-- A `psigma`-type is equivalent to the corresponding `sigma`-type. -/
 @[simps apply symm_apply]
-def psigmaEquivSigmaPLift {α} (β : α → Sort _) : (Σ'i, β i) ≃ Σi : PLift α, PLift (β i.down) :=
+def psigmaEquivSigmaPLift {α} (β : α → Sort _) : (Σ' i, β i) ≃ Σ i : PLift α, PLift (β i.down) :=
   ⟨fun a => ⟨PLift.up a.1, PLift.up a.2⟩, fun a => ⟨a.1.down, a.2.down⟩, fun ⟨a, b⟩ => rfl,
     fun ⟨⟨a⟩, ⟨b⟩⟩ => rfl⟩
 #align equiv.psigma_equiv_sigma_plift Equiv.psigmaEquivSigmaPLift
@@ -937,7 +937,7 @@ def psigmaEquivSigmaPLift {α} (β : α → Sort _) : (Σ'i, β i) ≃ Σi : PLi
 /-- A family of equivalences `Π a, β₁ a ≃ β₂ a` generates an equivalence between `Σ' a, β₁ a` and
 `Σ' a, β₂ a`. -/
 @[simps apply]
-def psigmaCongrRight {α} {β₁ β₂ : α → Sort _} (F : ∀ a, β₁ a ≃ β₂ a) : (Σ'a, β₁ a) ≃ Σ'a, β₂ a :=
+def psigmaCongrRight {α} {β₁ β₂ : α → Sort _} (F : ∀ a, β₁ a ≃ β₂ a) : (Σ' a, β₁ a) ≃ Σ' a, β₂ a :=
   ⟨fun a => ⟨a.1, F a.1 a.2⟩, fun a => ⟨a.1, (F a.1).symm a.2⟩, fun ⟨a, b⟩ =>
     congr_arg (PSigma.mk a) <| symm_apply_apply (F a) b, fun ⟨a, b⟩ =>
     congr_arg (PSigma.mk a) <| apply_symm_apply (F a) b⟩
@@ -958,14 +958,14 @@ theorem psigmaCongrRight_symm {α} {β₁ β₂ : α → Sort _} (F : ∀ a, β
 
 @[simp]
 theorem psigmaCongrRight_refl {α} {β : α → Sort _} :
-    (psigmaCongrRight fun a => Equiv.refl (β a)) = Equiv.refl (Σ'a, β a) := by ext1 x; cases x; rfl
+    (psigmaCongrRight fun a => Equiv.refl (β a)) = Equiv.refl (Σ' a, β a) := by ext1 x; cases x; rfl
 #align equiv.psigma_congr_right_refl Equiv.psigmaCongrRight_refl
 
 #print Equiv.sigmaCongrRight /-
 /-- A family of equivalences `Π a, β₁ a ≃ β₂ a` generates an equivalence between `Σ a, β₁ a` and
 `Σ a, β₂ a`. -/
 @[simps apply]
-def sigmaCongrRight {α} {β₁ β₂ : α → Type _} (F : ∀ a, β₁ a ≃ β₂ a) : (Σa, β₁ a) ≃ Σa, β₂ a :=
+def sigmaCongrRight {α} {β₁ β₂ : α → Type _} (F : ∀ a, β₁ a ≃ β₂ a) : (Σ a, β₁ a) ≃ Σ a, β₂ a :=
   ⟨fun a => ⟨a.1, F a.1 a.2⟩, fun a => ⟨a.1, (F a.1).symm a.2⟩, fun ⟨a, b⟩ =>
     congr_arg (Sigma.mk a) <| symm_apply_apply (F a) b, fun ⟨a, b⟩ =>
     congr_arg (Sigma.mk a) <| apply_symm_apply (F a) b⟩
@@ -986,12 +986,12 @@ theorem sigmaCongrRight_symm {α} {β₁ β₂ : α → Type _} (F : ∀ a, β
 
 @[simp]
 theorem sigmaCongrRight_refl {α} {β : α → Type _} :
-    (sigmaCongrRight fun a => Equiv.refl (β a)) = Equiv.refl (Σa, β a) := by ext1 x; cases x; rfl
+    (sigmaCongrRight fun a => Equiv.refl (β a)) = Equiv.refl (Σ a, β a) := by ext1 x; cases x; rfl
 #align equiv.sigma_congr_right_refl Equiv.sigmaCongrRight_refl
 
 #print Equiv.psigmaEquivSubtype /-
 /-- A `psigma` with `Prop` fibers is equivalent to the subtype.  -/
-def psigmaEquivSubtype {α : Type v} (P : α → Prop) : (Σ'i, P i) ≃ Subtype P
+def psigmaEquivSubtype {α : Type v} (P : α → Prop) : (Σ' i, P i) ≃ Subtype P
     where
   toFun x := ⟨x.1, x.2⟩
   invFun x := ⟨x.1, x.2⟩
@@ -1002,7 +1002,7 @@ def psigmaEquivSubtype {α : Type v} (P : α → Prop) : (Σ'i, P i) ≃ Subtype
 
 #print Equiv.sigmaPLiftEquivSubtype /-
 /-- A `sigma` with `plift` fibers is equivalent to the subtype. -/
-def sigmaPLiftEquivSubtype {α : Type v} (P : α → Prop) : (Σi, PLift (P i)) ≃ Subtype P :=
+def sigmaPLiftEquivSubtype {α : Type v} (P : α → Prop) : (Σ i, PLift (P i)) ≃ Subtype P :=
   ((psigmaEquivSigma _).symm.trans (psigmaCongrRight fun a => Equiv.plift)).trans
     (psigmaEquivSubtype P)
 #align equiv.sigma_plift_equiv_subtype Equiv.sigmaPLiftEquivSubtype
@@ -1013,7 +1013,7 @@ def sigmaPLiftEquivSubtype {α : Type v} (P : α → Prop) : (Σi, PLift (P i))
 Variant of `sigma_plift_equiv_subtype`.
 -/
 def sigmaULiftPLiftEquivSubtype {α : Type v} (P : α → Prop) :
-    (Σi, ULift (PLift (P i))) ≃ Subtype P :=
+    (Σ i, ULift (PLift (P i))) ≃ Subtype P :=
   (sigmaCongrRight fun a => Equiv.ulift).trans (sigmaPLiftEquivSubtype P)
 #align equiv.sigma_ulift_plift_equiv_subtype Equiv.sigmaULiftPLiftEquivSubtype
 -/
@@ -1023,7 +1023,7 @@ namespace Perm
 #print Equiv.Perm.sigmaCongrRight /-
 /-- A family of permutations `Π a, perm (β a)` generates a permuation `perm (Σ a, β₁ a)`. -/
 @[reducible]
-def sigmaCongrRight {α} {β : α → Sort _} (F : ∀ a, Perm (β a)) : Perm (Σa, β a) :=
+def sigmaCongrRight {α} {β : α → Sort _} (F : ∀ a, Perm (β a)) : Perm (Σ a, β a) :=
   Equiv.sigmaCongrRight F
 #align equiv.perm.sigma_congr_right Equiv.Perm.sigmaCongrRight
 -/
@@ -1042,7 +1042,7 @@ theorem sigmaCongrRight_symm {α} {β : α → Sort _} (F : ∀ a, Perm (β a))
 
 @[simp]
 theorem sigmaCongrRight_refl {α} {β : α → Sort _} :
-    (sigmaCongrRight fun a => Equiv.refl (β a)) = Equiv.refl (Σa, β a) :=
+    (sigmaCongrRight fun a => Equiv.refl (β a)) = Equiv.refl (Σ a, β a) :=
   Equiv.sigmaCongrRight_refl
 #align equiv.perm.sigma_congr_right_refl Equiv.Perm.sigmaCongrRight_refl
 
@@ -1050,7 +1050,7 @@ end Perm
 
 /-- An equivalence `f : α₁ ≃ α₂` generates an equivalence between `Σ a, β (f a)` and `Σ a, β a`. -/
 @[simps apply]
-def sigmaCongrLeft {α₁ α₂} {β : α₂ → Sort _} (e : α₁ ≃ α₂) : (Σa : α₁, β (e a)) ≃ Σa : α₂, β a :=
+def sigmaCongrLeft {α₁ α₂} {β : α₂ → Sort _} (e : α₁ ≃ α₂) : (Σ a : α₁, β (e a)) ≃ Σ a : α₂, β a :=
   ⟨fun a => ⟨e a.1, a.2⟩, fun a => ⟨e.symm a.1, @Eq.ndrec β a.2 (e.right_inv a.1).symm⟩,
     fun ⟨a, b⟩ =>
     match (motive :=
@@ -1066,7 +1066,7 @@ def sigmaCongrLeft {α₁ α₂} {β : α₂ → Sort _} (e : α₁ ≃ α₂) :
 #print Equiv.sigmaCongrLeft' /-
 /-- Transporting a sigma type through an equivalence of the base -/
 def sigmaCongrLeft' {α₁ α₂} {β : α₁ → Sort _} (f : α₁ ≃ α₂) :
-    (Σa : α₁, β a) ≃ Σa : α₂, β (f.symm a) :=
+    (Σ a : α₁, β a) ≃ Σ a : α₂, β (f.symm a) :=
   (sigmaCongrLeft f.symm).symm
 #align equiv.sigma_congr_left' Equiv.sigmaCongrLeft'
 -/
@@ -1083,7 +1083,7 @@ def sigmaCongr {α₁ α₂} {β₁ : α₁ → Sort _} {β₂ : α₂ → Sort
 #print Equiv.sigmaEquivProd /-
 /-- `sigma` type with a constant fiber is equivalent to the product. -/
 @[simps apply symm_apply]
-def sigmaEquivProd (α β : Type _) : (Σ_ : α, β) ≃ α × β :=
+def sigmaEquivProd (α β : Type _) : (Σ _ : α, β) ≃ α × β :=
   ⟨fun a => ⟨a.1, a.2⟩, fun a => ⟨a.1, a.2⟩, fun ⟨a, b⟩ => rfl, fun ⟨a, b⟩ => rfl⟩
 #align equiv.sigma_equiv_prod Equiv.sigmaEquivProd
 -/
@@ -1099,7 +1099,7 @@ def sigmaEquivProdOfEquiv {α β} {β₁ : α → Sort _} (F : ∀ a, β₁ a 
 #print Equiv.sigmaAssoc /-
 /-- Dependent product of types is associative up to an equivalence. -/
 def sigmaAssoc {α : Type _} {β : α → Type _} (γ : ∀ a : α, β a → Type _) :
-    (Σab : Σa : α, β a, γ ab.1 ab.2) ≃ Σa : α, Σb : β a, γ a b
+    (Σ ab : Σ a : α, β a, γ ab.1 ab.2) ≃ Σ a : α, Σ b : β a, γ a b
     where
   toFun x := ⟨x.1.1, ⟨x.1.2, x.2⟩⟩
   invFun x := ⟨⟨x.1, x.2.1⟩, x.2.2⟩

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -62,12 +62,6 @@ universe u v w z
 
 variable {α : Sort u} {β : Sort v} {γ : Sort w}
 
-/- warning: equiv -> Equiv is a dubious translation:
-lean 3 declaration is
-  Sort.{u1} -> Sort.{u2} -> Sort.{max 1 (imax u1 u2) (imax u2 u1)}
-but is expected to have type
-  Sort.{u1} -> Sort.{u2} -> Sort.{max (max 1 u1) u2}
-Case conversion may be inaccurate. Consider using '#align equiv Equivₓ'. -/
 /-- `α ≃ β` is the type of functions from `α → β` with a two-sided inverse. -/
 structure Equiv (α : Sort _) (β : Sort _) where
   toFun : α → β
@@ -139,22 +133,10 @@ protected theorem congr_arg {f : Equiv α β} {x x' : α} : x = x' → f x = f x
 #align equiv.congr_arg Equiv.congr_arg
 -/
 
-/- warning: equiv.congr_fun -> Equiv.congr_fun is a dubious translation:
-lean 3 declaration is
-  forall {α : Sort.{u1}} {β : Sort.{u2}} {f : Equiv.{u1, u2} α β} {g : Equiv.{u1, u2} α β}, (Eq.{max 1 (imax u1 u2) (imax u2 u1)} (Equiv.{u1, u2} α β) f g) -> (forall (x : α), Eq.{u2} β (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α β) (fun (_x : Equiv.{u1, u2} α β) => α -> β) (Equiv.hasCoeToFun.{u1, u2} α β) f x) (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α β) (fun (_x : Equiv.{u1, u2} α β) => α -> β) (Equiv.hasCoeToFun.{u1, u2} α β) g x))
-but is expected to have type
-  forall {α : Sort.{u1}} {β : Sort.{u2}} {f : Equiv.{u1, u2} α β} {g : Equiv.{u1, u2} α β}, (Eq.{max (max 1 u1) u2} (Equiv.{u1, u2} α β) f g) -> (forall (x : α), Eq.{u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => β) x) (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => β) _x) (Equiv.instFunLikeEquiv.{u1, u2} α β) f x) (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => β) _x) (Equiv.instFunLikeEquiv.{u1, u2} α β) g x))
-Case conversion may be inaccurate. Consider using '#align equiv.congr_fun Equiv.congr_funₓ'. -/
 protected theorem congr_fun {f g : Equiv α β} (h : f = g) (x : α) : f x = g x :=
   FunLike.congr_fun h x
 #align equiv.congr_fun Equiv.congr_fun
 
-/- warning: equiv.ext_iff -> Equiv.ext_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Sort.{u1}} {β : Sort.{u2}} {f : Equiv.{u1, u2} α β} {g : Equiv.{u1, u2} α β}, Iff (Eq.{max 1 (imax u1 u2) (imax u2 u1)} (Equiv.{u1, u2} α β) f g) (forall (x : α), Eq.{u2} β (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α β) (fun (_x : Equiv.{u1, u2} α β) => α -> β) (Equiv.hasCoeToFun.{u1, u2} α β) f x) (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α β) (fun (_x : Equiv.{u1, u2} α β) => α -> β) (Equiv.hasCoeToFun.{u1, u2} α β) g x))
-but is expected to have type
-  forall {α : Sort.{u1}} {β : Sort.{u2}} {f : Equiv.{u1, u2} α β} {g : Equiv.{u1, u2} α β}, Iff (Eq.{max (max 1 u1) u2} (Equiv.{u1, u2} α β) f g) (forall (x : α), Eq.{u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => β) x) (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => β) _x) (Equiv.instFunLikeEquiv.{u1, u2} α β) f x) (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => β) _x) (Equiv.instFunLikeEquiv.{u1, u2} α β) g x))
-Case conversion may be inaccurate. Consider using '#align equiv.ext_iff Equiv.ext_iffₓ'. -/
 theorem ext_iff {f g : Equiv α β} : f = g ↔ ∀ x, f x = g x :=
   FunLike.ext_iff
 #align equiv.ext_iff Equiv.ext_iff
@@ -273,22 +255,10 @@ theorem subsingleton_congr (e : α ≃ β) : Subsingleton α ↔ Subsingleton β
 #align equiv.subsingleton_congr Equiv.subsingleton_congr
 -/
 
-/- warning: equiv.equiv_subsingleton_cod -> Equiv.equiv_subsingleton_cod is a dubious translation:
-lean 3 declaration is
-  forall {α : Sort.{u1}} {β : Sort.{u2}} [_inst_1 : Subsingleton.{u2} β], Subsingleton.{max 1 (imax u1 u2) (imax u2 u1)} (Equiv.{u1, u2} α β)
-but is expected to have type
-  forall {α : Sort.{u1}} {β : Sort.{u2}} [_inst_1 : Subsingleton.{u2} β], Subsingleton.{max (max 1 u2) u1} (Equiv.{u1, u2} α β)
-Case conversion may be inaccurate. Consider using '#align equiv.equiv_subsingleton_cod Equiv.equiv_subsingleton_codₓ'. -/
 instance equiv_subsingleton_cod [Subsingleton β] : Subsingleton (α ≃ β) :=
   FunLike.subsingleton_cod
 #align equiv.equiv_subsingleton_cod Equiv.equiv_subsingleton_cod
 
-/- warning: equiv.equiv_subsingleton_dom -> Equiv.equiv_subsingleton_dom is a dubious translation:
-lean 3 declaration is
-  forall {α : Sort.{u1}} {β : Sort.{u2}} [_inst_1 : Subsingleton.{u1} α], Subsingleton.{max 1 (imax u1 u2) (imax u2 u1)} (Equiv.{u1, u2} α β)
-but is expected to have type
-  forall {α : Sort.{u1}} {β : Sort.{u2}} [_inst_1 : Subsingleton.{u1} α], Subsingleton.{max (max 1 u2) u1} (Equiv.{u1, u2} α β)
-Case conversion may be inaccurate. Consider using '#align equiv.equiv_subsingleton_dom Equiv.equiv_subsingleton_domₓ'. -/
 instance equiv_subsingleton_dom [Subsingleton α] : Subsingleton (α ≃ β) :=
   EquivLike.subsingleton_dom
 #align equiv.equiv_subsingleton_dom Equiv.equiv_subsingleton_dom
@@ -436,12 +406,6 @@ theorem apply_eq_iff_eq (f : α ≃ β) {x y : α} : f x = f y ↔ x = y :=
 #align equiv.apply_eq_iff_eq Equiv.apply_eq_iff_eq
 -/
 
-/- warning: equiv.apply_eq_iff_eq_symm_apply -> Equiv.apply_eq_iff_eq_symm_apply is a dubious translation:
-lean 3 declaration is
-  forall {α : Sort.{u1}} {β : Sort.{u2}} (f : Equiv.{u1, u2} α β) {x : α} {y : β}, Iff (Eq.{u2} β (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α β) (fun (_x : Equiv.{u1, u2} α β) => α -> β) (Equiv.hasCoeToFun.{u1, u2} α β) f x) y) (Eq.{u1} α x (coeFn.{max 1 (imax u2 u1) (imax u1 u2), imax u2 u1} (Equiv.{u2, u1} β α) (fun (_x : Equiv.{u2, u1} β α) => β -> α) (Equiv.hasCoeToFun.{u2, u1} β α) (Equiv.symm.{u1, u2} α β f) y))
-but is expected to have type
-  forall {α : Sort.{u1}} {β : Sort.{u2}} {f : α} {x : (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => β) f} (y : Equiv.{u1, u2} α β), Iff (Eq.{u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => β) f) (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => β) _x) (Equiv.instFunLikeEquiv.{u1, u2} α β) y f) x) (Eq.{u1} α f (FunLike.coe.{max (max 1 u1) u2, u2, u1} (Equiv.{u2, u1} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => α) _x) (Equiv.instFunLikeEquiv.{u2, u1} β α) (Equiv.symm.{u1, u2} α β y) x))
-Case conversion may be inaccurate. Consider using '#align equiv.apply_eq_iff_eq_symm_apply Equiv.apply_eq_iff_eq_symm_applyₓ'. -/
 theorem apply_eq_iff_eq_symm_apply {α β : Sort _} (f : α ≃ β) {x : α} {y : β} :
     f x = y ↔ x = f.symm y := by
   conv_lhs => rw [← apply_symm_apply f y]
@@ -483,42 +447,18 @@ theorem cast_eq_iff_heq {α β} (h : α = β) {a : α} {b : β} : Equiv.cast h a
 #align equiv.cast_eq_iff_heq Equiv.cast_eq_iff_heq
 -/
 
-/- warning: equiv.symm_apply_eq -> Equiv.symm_apply_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Sort.{u1}} {β : Sort.{u2}} (e : Equiv.{u1, u2} α β) {x : β} {y : α}, Iff (Eq.{u1} α (coeFn.{max 1 (imax u2 u1) (imax u1 u2), imax u2 u1} (Equiv.{u2, u1} β α) (fun (_x : Equiv.{u2, u1} β α) => β -> α) (Equiv.hasCoeToFun.{u2, u1} β α) (Equiv.symm.{u1, u2} α β e) x) y) (Eq.{u2} β x (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α β) (fun (_x : Equiv.{u1, u2} α β) => α -> β) (Equiv.hasCoeToFun.{u1, u2} α β) e y))
-but is expected to have type
-  forall {α : Sort.{u2}} {β : Sort.{u1}} (e : Equiv.{u2, u1} α β) {x : β} {y : (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => α) x}, Iff (Eq.{u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => α) x) (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => α) _x) (Equiv.instFunLikeEquiv.{u1, u2} β α) (Equiv.symm.{u2, u1} α β e) x) y) (Eq.{u1} β x (FunLike.coe.{max (max 1 u1) u2, u2, u1} (Equiv.{u2, u1} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => β) _x) (Equiv.instFunLikeEquiv.{u2, u1} α β) e y))
-Case conversion may be inaccurate. Consider using '#align equiv.symm_apply_eq Equiv.symm_apply_eqₓ'. -/
 theorem symm_apply_eq {α β} (e : α ≃ β) {x y} : e.symm x = y ↔ x = e y :=
   ⟨fun H => by simp [H.symm], fun H => by simp [H]⟩
 #align equiv.symm_apply_eq Equiv.symm_apply_eq
 
-/- warning: equiv.eq_symm_apply -> Equiv.eq_symm_apply is a dubious translation:
-lean 3 declaration is
-  forall {α : Sort.{u1}} {β : Sort.{u2}} (e : Equiv.{u1, u2} α β) {x : β} {y : α}, Iff (Eq.{u1} α y (coeFn.{max 1 (imax u2 u1) (imax u1 u2), imax u2 u1} (Equiv.{u2, u1} β α) (fun (_x : Equiv.{u2, u1} β α) => β -> α) (Equiv.hasCoeToFun.{u2, u1} β α) (Equiv.symm.{u1, u2} α β e) x)) (Eq.{u2} β (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α β) (fun (_x : Equiv.{u1, u2} α β) => α -> β) (Equiv.hasCoeToFun.{u1, u2} α β) e y) x)
-but is expected to have type
-  forall {α : Sort.{u2}} {β : Sort.{u1}} (e : Equiv.{u2, u1} α β) {x : β} {y : (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => α) x}, Iff (Eq.{u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => α) x) y (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => α) _x) (Equiv.instFunLikeEquiv.{u1, u2} β α) (Equiv.symm.{u2, u1} α β e) x)) (Eq.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => β) y) (FunLike.coe.{max (max 1 u1) u2, u2, u1} (Equiv.{u2, u1} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => β) _x) (Equiv.instFunLikeEquiv.{u2, u1} α β) e y) x)
-Case conversion may be inaccurate. Consider using '#align equiv.eq_symm_apply Equiv.eq_symm_applyₓ'. -/
 theorem eq_symm_apply {α β} (e : α ≃ β) {x y} : y = e.symm x ↔ e y = x :=
   (eq_comm.trans e.symm_apply_eq).trans eq_comm
 #align equiv.eq_symm_apply Equiv.eq_symm_apply
 
-/- warning: equiv.symm_symm -> Equiv.symm_symm is a dubious translation:
-lean 3 declaration is
-  forall {α : Sort.{u1}} {β : Sort.{u2}} (e : Equiv.{u1, u2} α β), Eq.{max 1 (imax u1 u2) (imax u2 u1)} (Equiv.{u1, u2} α β) (Equiv.symm.{u2, u1} β α (Equiv.symm.{u1, u2} α β e)) e
-but is expected to have type
-  forall {α : Sort.{u1}} {β : Sort.{u2}} (e : Equiv.{u1, u2} α β), Eq.{max (max 1 u1) u2} (Equiv.{u1, u2} α β) (Equiv.symm.{u2, u1} β α (Equiv.symm.{u1, u2} α β e)) e
-Case conversion may be inaccurate. Consider using '#align equiv.symm_symm Equiv.symm_symmₓ'. -/
 @[simp]
 theorem symm_symm (e : α ≃ β) : e.symm.symm = e := by cases e; rfl
 #align equiv.symm_symm Equiv.symm_symm
 
-/- warning: equiv.trans_refl -> Equiv.trans_refl is a dubious translation:
-lean 3 declaration is
-  forall {α : Sort.{u1}} {β : Sort.{u2}} (e : Equiv.{u1, u2} α β), Eq.{max 1 (imax u1 u2) (imax u2 u1)} (Equiv.{u1, u2} α β) (Equiv.trans.{u1, u2, u2} α β β e (Equiv.refl.{u2} β)) e
-but is expected to have type
-  forall {α : Sort.{u1}} {β : Sort.{u2}} (e : Equiv.{u1, u2} α β), Eq.{max (max 1 u1) u2} (Equiv.{u1, u2} α β) (Equiv.trans.{u1, u2, u2} α β β e (Equiv.refl.{u2} β)) e
-Case conversion may be inaccurate. Consider using '#align equiv.trans_refl Equiv.trans_reflₓ'. -/
 @[simp]
 theorem trans_refl (e : α ≃ β) : e.trans (Equiv.refl β) = e := by cases e; rfl
 #align equiv.trans_refl Equiv.trans_refl
@@ -530,12 +470,6 @@ theorem refl_symm : (Equiv.refl α).symm = Equiv.refl α :=
 #align equiv.refl_symm Equiv.refl_symm
 -/
 
-/- warning: equiv.refl_trans -> Equiv.refl_trans is a dubious translation:
-lean 3 declaration is
-  forall {α : Sort.{u1}} {β : Sort.{u2}} (e : Equiv.{u1, u2} α β), Eq.{max 1 (imax u1 u2) (imax u2 u1)} (Equiv.{u1, u2} α β) (Equiv.trans.{u1, u1, u2} α α β (Equiv.refl.{u1} α) e) e
-but is expected to have type
-  forall {α : Sort.{u1}} {β : Sort.{u2}} (e : Equiv.{u1, u2} α β), Eq.{max (max 1 u1) u2} (Equiv.{u1, u2} α β) (Equiv.trans.{u1, u1, u2} α α β (Equiv.refl.{u1} α) e) e
-Case conversion may be inaccurate. Consider using '#align equiv.refl_trans Equiv.refl_transₓ'. -/
 @[simp]
 theorem refl_trans (e : α ≃ β) : (Equiv.refl α).trans e = e := by cases e; rfl
 #align equiv.refl_trans Equiv.refl_trans
@@ -554,12 +488,6 @@ theorem self_trans_symm (e : α ≃ β) : e.trans e.symm = Equiv.refl α :=
 #align equiv.self_trans_symm Equiv.self_trans_symm
 -/
 
-/- warning: equiv.trans_assoc -> Equiv.trans_assoc is a dubious translation:
-lean 3 declaration is
-  forall {α : Sort.{u1}} {β : Sort.{u2}} {γ : Sort.{u3}} {δ : Sort.{u4}} (ab : Equiv.{u1, u2} α β) (bc : Equiv.{u2, u3} β γ) (cd : Equiv.{u3, u4} γ δ), Eq.{max 1 (imax u1 u4) (imax u4 u1)} (Equiv.{u1, u4} α δ) (Equiv.trans.{u1, u3, u4} α γ δ (Equiv.trans.{u1, u2, u3} α β γ ab bc) cd) (Equiv.trans.{u1, u2, u4} α β δ ab (Equiv.trans.{u2, u3, u4} β γ δ bc cd))
-but is expected to have type
-  forall {α : Sort.{u2}} {β : Sort.{u3}} {γ : Sort.{u4}} {δ : Sort.{u1}} (ab : Equiv.{u2, u3} α β) (bc : Equiv.{u3, u4} β γ) (cd : Equiv.{u4, u1} γ δ), Eq.{max (max 1 u2) u1} (Equiv.{u2, u1} α δ) (Equiv.trans.{u2, u4, u1} α γ δ (Equiv.trans.{u2, u3, u4} α β γ ab bc) cd) (Equiv.trans.{u2, u3, u1} α β δ ab (Equiv.trans.{u3, u4, u1} β γ δ bc cd))
-Case conversion may be inaccurate. Consider using '#align equiv.trans_assoc Equiv.trans_assocₓ'. -/
 theorem trans_assoc {δ} (ab : α ≃ β) (bc : β ≃ γ) (cd : γ ≃ δ) :
     (ab.trans bc).trans cd = ab.trans (bc.trans cd) :=
   Equiv.ext fun a => rfl
@@ -613,12 +541,6 @@ theorem comp_bijective (f : α → β) (e : β ≃ γ) : Bijective (e ∘ f) ↔
 #align equiv.comp_bijective Equiv.comp_bijective
 -/
 
-/- warning: equiv.equiv_congr -> Equiv.equivCongr is a dubious translation:
-lean 3 declaration is
-  forall {α : Sort.{u1}} {β : Sort.{u2}} {γ : Sort.{u3}} {δ : Sort.{u4}}, (Equiv.{u1, u2} α β) -> (Equiv.{u3, u4} γ δ) -> (Equiv.{max 1 (imax u1 u3) (imax u3 u1), max 1 (imax u2 u4) (imax u4 u2)} (Equiv.{u1, u3} α γ) (Equiv.{u2, u4} β δ))
-but is expected to have type
-  forall {α : Sort.{u1}} {β : Sort.{u2}} {γ : Sort.{u3}} {δ : Sort.{u4}}, (Equiv.{u1, u2} α β) -> (Equiv.{u3, u4} γ δ) -> (Equiv.{max (max 1 u3) u1, max (max 1 u4) u2} (Equiv.{u1, u3} α γ) (Equiv.{u2, u4} β δ))
-Case conversion may be inaccurate. Consider using '#align equiv.equiv_congr Equiv.equivCongrₓ'. -/
 /-- If `α` is equivalent to `β` and `γ` is equivalent to `δ`, then the type of equivalences `α ≃ γ`
 is equivalent to the type of equivalences `β ≃ δ`. -/
 def equivCongr {δ} (ab : α ≃ β) (cd : γ ≃ δ) : α ≃ γ ≃ (β ≃ δ) :=
@@ -626,70 +548,34 @@ def equivCongr {δ} (ab : α ≃ β) (cd : γ ≃ δ) : α ≃ γ ≃ (β ≃ δ
     ext x; simp, fun ac => by ext x; simp⟩
 #align equiv.equiv_congr Equiv.equivCongr
 
-/- warning: equiv.equiv_congr_refl -> Equiv.equivCongr_refl is a dubious translation:
-lean 3 declaration is
-  forall {α : Sort.{u1}} {β : Sort.{u2}}, Eq.{max 1 (imax u1 u2) (imax u2 u1)} (Equiv.{max 1 (imax u1 u2) (imax u2 u1), max 1 (imax u1 u2) (imax u2 u1)} (Equiv.{u1, u2} α β) (Equiv.{u1, u2} α β)) (Equiv.equivCongr.{u1, u1, u2, u2} α α β β (Equiv.refl.{u1} α) (Equiv.refl.{u2} β)) (Equiv.refl.{max 1 (imax u1 u2) (imax u2 u1)} (Equiv.{u1, u2} α β))
-but is expected to have type
-  forall {α : Sort.{u2}} {β : Sort.{u1}}, Eq.{max (max 1 u2) u1} (Equiv.{max (max 1 u1) u2, max (max 1 u1) u2} (Equiv.{u2, u1} α β) (Equiv.{u2, u1} α β)) (Equiv.equivCongr.{u2, u2, u1, u1} α α β β (Equiv.refl.{u2} α) (Equiv.refl.{u1} β)) (Equiv.refl.{max (max 1 u1) u2} (Equiv.{u2, u1} α β))
-Case conversion may be inaccurate. Consider using '#align equiv.equiv_congr_refl Equiv.equivCongr_reflₓ'. -/
 @[simp]
 theorem equivCongr_refl {α β} : (Equiv.refl α).equivCongr (Equiv.refl β) = Equiv.refl (α ≃ β) := by
   ext; rfl
 #align equiv.equiv_congr_refl Equiv.equivCongr_refl
 
-/- warning: equiv.equiv_congr_symm -> Equiv.equivCongr_symm is a dubious translation:
-lean 3 declaration is
-  forall {α : Sort.{u1}} {β : Sort.{u2}} {γ : Sort.{u3}} {δ : Sort.{u4}} (ab : Equiv.{u1, u2} α β) (cd : Equiv.{u3, u4} γ δ), Eq.{max 1 (max (max 1 (imax u2 u4) (imax u4 u2)) 1 (imax u1 u3) (imax u3 u1)) (max 1 (imax u1 u3) (imax u3 u1)) 1 (imax u2 u4) (imax u4 u2)} (Equiv.{max 1 (imax u2 u4) (imax u4 u2), max 1 (imax u1 u3) (imax u3 u1)} (Equiv.{u2, u4} β δ) (Equiv.{u1, u3} α γ)) (Equiv.symm.{max 1 (imax u1 u3) (imax u3 u1), max 1 (imax u2 u4) (imax u4 u2)} (Equiv.{u1, u3} α γ) (Equiv.{u2, u4} β δ) (Equiv.equivCongr.{u1, u2, u3, u4} α β γ δ ab cd)) (Equiv.equivCongr.{u2, u1, u4, u3} β α δ γ (Equiv.symm.{u1, u2} α β ab) (Equiv.symm.{u3, u4} γ δ cd))
-but is expected to have type
-  forall {α : Sort.{u2}} {β : Sort.{u3}} {γ : Sort.{u4}} {δ : Sort.{u1}} (ab : Equiv.{u2, u3} α β) (cd : Equiv.{u4, u1} γ δ), Eq.{max (max (max (max 1 u2) u3) u4) u1} (Equiv.{max (max 1 u3) u1, max (max 1 u2) u4} (Equiv.{u3, u1} β δ) (Equiv.{u2, u4} α γ)) (Equiv.symm.{max (max 1 u2) u4, max (max 1 u3) u1} (Equiv.{u2, u4} α γ) (Equiv.{u3, u1} β δ) (Equiv.equivCongr.{u2, u3, u4, u1} α β γ δ ab cd)) (Equiv.equivCongr.{u3, u2, u1, u4} β α δ γ (Equiv.symm.{u2, u3} α β ab) (Equiv.symm.{u4, u1} γ δ cd))
-Case conversion may be inaccurate. Consider using '#align equiv.equiv_congr_symm Equiv.equivCongr_symmₓ'. -/
 @[simp]
 theorem equivCongr_symm {δ} (ab : α ≃ β) (cd : γ ≃ δ) :
     (ab.equivCongr cd).symm = ab.symm.equivCongr cd.symm := by ext; rfl
 #align equiv.equiv_congr_symm Equiv.equivCongr_symm
 
-/- warning: equiv.equiv_congr_trans -> Equiv.equivCongr_trans is a dubious translation:
-lean 3 declaration is
-  forall {α : Sort.{u1}} {β : Sort.{u2}} {γ : Sort.{u3}} {δ : Sort.{u4}} {ε : Sort.{u5}} {ζ : Sort.{u6}} (ab : Equiv.{u1, u2} α β) (de : Equiv.{u4, u5} δ ε) (bc : Equiv.{u2, u3} β γ) (ef : Equiv.{u5, u6} ε ζ), Eq.{max 1 (max (max 1 (imax u1 u4) (imax u4 u1)) 1 (imax u3 u6) (imax u6 u3)) (max 1 (imax u3 u6) (imax u6 u3)) 1 (imax u1 u4) (imax u4 u1)} (Equiv.{max 1 (imax u1 u4) (imax u4 u1), max 1 (imax u3 u6) (imax u6 u3)} (Equiv.{u1, u4} α δ) (Equiv.{u3, u6} γ ζ)) (Equiv.trans.{max 1 (imax u1 u4) (imax u4 u1), max 1 (imax u2 u5) (imax u5 u2), max 1 (imax u3 u6) (imax u6 u3)} (Equiv.{u1, u4} α δ) (Equiv.{u2, u5} β ε) (Equiv.{u3, u6} γ ζ) (Equiv.equivCongr.{u1, u2, u4, u5} α β δ ε ab de) (Equiv.equivCongr.{u2, u3, u5, u6} β γ ε ζ bc ef)) (Equiv.equivCongr.{u1, u3, u4, u6} α γ δ ζ (Equiv.trans.{u1, u2, u3} α β γ ab bc) (Equiv.trans.{u4, u5, u6} δ ε ζ de ef))
-but is expected to have type
-  forall {α : Sort.{u4}} {β : Sort.{u5}} {γ : Sort.{u6}} {δ : Sort.{u3}} {ε : Sort.{u2}} {ζ : Sort.{u1}} (ab : Equiv.{u4, u5} α β) (de : Equiv.{u3, u2} δ ε) (bc : Equiv.{u5, u6} β γ) (ef : Equiv.{u2, u1} ε ζ), Eq.{max (max (max (max 1 u4) u6) u3) u1} (Equiv.{max (max 1 u4) u3, max (max 1 u6) u1} (Equiv.{u4, u3} α δ) (Equiv.{u6, u1} γ ζ)) (Equiv.trans.{max (max 1 u4) u3, max (max 1 u5) u2, max (max 1 u6) u1} (Equiv.{u4, u3} α δ) (Equiv.{u5, u2} β ε) (Equiv.{u6, u1} γ ζ) (Equiv.equivCongr.{u4, u5, u3, u2} α β δ ε ab de) (Equiv.equivCongr.{u5, u6, u2, u1} β γ ε ζ bc ef)) (Equiv.equivCongr.{u4, u6, u3, u1} α γ δ ζ (Equiv.trans.{u4, u5, u6} α β γ ab bc) (Equiv.trans.{u3, u2, u1} δ ε ζ de ef))
-Case conversion may be inaccurate. Consider using '#align equiv.equiv_congr_trans Equiv.equivCongr_transₓ'. -/
 @[simp]
 theorem equivCongr_trans {δ ε ζ} (ab : α ≃ β) (de : δ ≃ ε) (bc : β ≃ γ) (ef : ε ≃ ζ) :
     (ab.equivCongr de).trans (bc.equivCongr ef) = (ab.trans bc).equivCongr (de.trans ef) := by ext;
   rfl
 #align equiv.equiv_congr_trans Equiv.equivCongr_trans
 
-/- warning: equiv.equiv_congr_refl_left -> Equiv.equivCongr_refl_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Sort.{u1}} {β : Sort.{u2}} {γ : Sort.{u3}} (bg : Equiv.{u2, u3} β γ) (e : Equiv.{u1, u2} α β), Eq.{max 1 (imax u1 u3) (imax u3 u1)} (Equiv.{u1, u3} α γ) (coeFn.{max 1 (max (max 1 (imax u1 u2) (imax u2 u1)) 1 (imax u1 u3) (imax u3 u1)) (max 1 (imax u1 u3) (imax u3 u1)) 1 (imax u1 u2) (imax u2 u1), max (max 1 (imax u1 u2) (imax u2 u1)) 1 (imax u1 u3) (imax u3 u1)} (Equiv.{max 1 (imax u1 u2) (imax u2 u1), max 1 (imax u1 u3) (imax u3 u1)} (Equiv.{u1, u2} α β) (Equiv.{u1, u3} α γ)) (fun (_x : Equiv.{max 1 (imax u1 u2) (imax u2 u1), max 1 (imax u1 u3) (imax u3 u1)} (Equiv.{u1, u2} α β) (Equiv.{u1, u3} α γ)) => (Equiv.{u1, u2} α β) -> (Equiv.{u1, u3} α γ)) (Equiv.hasCoeToFun.{max 1 (imax u1 u2) (imax u2 u1), max 1 (imax u1 u3) (imax u3 u1)} (Equiv.{u1, u2} α β) (Equiv.{u1, u3} α γ)) (Equiv.equivCongr.{u1, u1, u2, u3} α α β γ (Equiv.refl.{u1} α) bg) e) (Equiv.trans.{u1, u2, u3} α β γ e bg)
-but is expected to have type
-  forall {α : Sort.{u3}} {β : Sort.{u2}} {γ : Sort.{u1}} (bg : Equiv.{u2, u1} β γ) (e : Equiv.{u3, u2} α β), Eq.{max (max 1 u1) u3} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Equiv.{u3, u2} α β) => Equiv.{u3, u1} α γ) e) (FunLike.coe.{max (max (max 1 u1) u2) u3, max (max 1 u2) u3, max (max 1 u1) u3} (Equiv.{max (max 1 u2) u3, max (max 1 u1) u3} (Equiv.{u3, u2} α β) (Equiv.{u3, u1} α γ)) (Equiv.{u3, u2} α β) (fun (_x : Equiv.{u3, u2} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Equiv.{u3, u2} α β) => Equiv.{u3, u1} α γ) _x) (Equiv.instFunLikeEquiv.{max (max 1 u2) u3, max (max 1 u1) u3} (Equiv.{u3, u2} α β) (Equiv.{u3, u1} α γ)) (Equiv.equivCongr.{u3, u3, u2, u1} α α β γ (Equiv.refl.{u3} α) bg) e) (Equiv.trans.{u3, u2, u1} α β γ e bg)
-Case conversion may be inaccurate. Consider using '#align equiv.equiv_congr_refl_left Equiv.equivCongr_refl_leftₓ'. -/
 @[simp]
 theorem equivCongr_refl_left {α β γ} (bg : β ≃ γ) (e : α ≃ β) :
     (Equiv.refl α).equivCongr bg e = e.trans bg :=
   rfl
 #align equiv.equiv_congr_refl_left Equiv.equivCongr_refl_left
 
-/- warning: equiv.equiv_congr_refl_right -> Equiv.equivCongr_refl_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Sort.{u1}} {β : Sort.{u2}} (ab : Equiv.{u1, u2} α β) (e : Equiv.{u1, u2} α β), Eq.{max 1 u2} (Equiv.{u2, u2} β β) (coeFn.{max 1 (max (max 1 (imax u1 u2) (imax u2 u1)) 1 u2) (max 1 u2) 1 (imax u1 u2) (imax u2 u1), max (max 1 (imax u1 u2) (imax u2 u1)) 1 u2} (Equiv.{max 1 (imax u1 u2) (imax u2 u1), max 1 u2} (Equiv.{u1, u2} α β) (Equiv.{u2, u2} β β)) (fun (_x : Equiv.{max 1 (imax u1 u2) (imax u2 u1), max 1 u2} (Equiv.{u1, u2} α β) (Equiv.{u2, u2} β β)) => (Equiv.{u1, u2} α β) -> (Equiv.{u2, u2} β β)) (Equiv.hasCoeToFun.{max 1 (imax u1 u2) (imax u2 u1), max 1 u2} (Equiv.{u1, u2} α β) (Equiv.{u2, u2} β β)) (Equiv.equivCongr.{u1, u2, u2, u2} α β β β ab (Equiv.refl.{u2} β)) e) (Equiv.trans.{u2, u1, u2} β α β (Equiv.symm.{u1, u2} α β ab) e)
-but is expected to have type
-  forall {α : Sort.{u2}} {β : Sort.{u1}} (ab : Equiv.{u2, u1} α β) (e : Equiv.{u2, u1} α β), Eq.{max 1 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Equiv.{u2, u1} α β) => Equiv.{u1, u1} β β) e) (FunLike.coe.{max (max 1 u1) u2, max (max 1 u1) u2, max 1 u1} (Equiv.{max (max 1 u1) u2, max 1 u1} (Equiv.{u2, u1} α β) (Equiv.{u1, u1} β β)) (Equiv.{u2, u1} α β) (fun (_x : Equiv.{u2, u1} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Equiv.{u2, u1} α β) => Equiv.{u1, u1} β β) _x) (Equiv.instFunLikeEquiv.{max (max 1 u1) u2, max 1 u1} (Equiv.{u2, u1} α β) (Equiv.{u1, u1} β β)) (Equiv.equivCongr.{u2, u1, u1, u1} α β β β ab (Equiv.refl.{u1} β)) e) (Equiv.trans.{u1, u2, u1} β α β (Equiv.symm.{u2, u1} α β ab) e)
-Case conversion may be inaccurate. Consider using '#align equiv.equiv_congr_refl_right Equiv.equivCongr_refl_rightₓ'. -/
 @[simp]
 theorem equivCongr_refl_right {α β} (ab e : α ≃ β) :
     ab.equivCongr (Equiv.refl β) e = ab.symm.trans e :=
   rfl
 #align equiv.equiv_congr_refl_right Equiv.equivCongr_refl_right
 
-/- warning: equiv.equiv_congr_apply_apply -> Equiv.equivCongr_apply_apply is a dubious translation:
-lean 3 declaration is
-  forall {α : Sort.{u1}} {β : Sort.{u2}} {γ : Sort.{u3}} {δ : Sort.{u4}} (ab : Equiv.{u1, u2} α β) (cd : Equiv.{u3, u4} γ δ) (e : Equiv.{u1, u3} α γ) (x : β), Eq.{u4} δ (coeFn.{max 1 (imax u2 u4) (imax u4 u2), imax u2 u4} (Equiv.{u2, u4} β δ) (fun (_x : Equiv.{u2, u4} β δ) => β -> δ) (Equiv.hasCoeToFun.{u2, u4} β δ) (coeFn.{max 1 (max (max 1 (imax u1 u3) (imax u3 u1)) 1 (imax u2 u4) (imax u4 u2)) (max 1 (imax u2 u4) (imax u4 u2)) 1 (imax u1 u3) (imax u3 u1), max (max 1 (imax u1 u3) (imax u3 u1)) 1 (imax u2 u4) (imax u4 u2)} (Equiv.{max 1 (imax u1 u3) (imax u3 u1), max 1 (imax u2 u4) (imax u4 u2)} (Equiv.{u1, u3} α γ) (Equiv.{u2, u4} β δ)) (fun (_x : Equiv.{max 1 (imax u1 u3) (imax u3 u1), max 1 (imax u2 u4) (imax u4 u2)} (Equiv.{u1, u3} α γ) (Equiv.{u2, u4} β δ)) => (Equiv.{u1, u3} α γ) -> (Equiv.{u2, u4} β δ)) (Equiv.hasCoeToFun.{max 1 (imax u1 u3) (imax u3 u1), max 1 (imax u2 u4) (imax u4 u2)} (Equiv.{u1, u3} α γ) (Equiv.{u2, u4} β δ)) (Equiv.equivCongr.{u1, u2, u3, u4} α β γ δ ab cd) e) x) (coeFn.{max 1 (imax u3 u4) (imax u4 u3), imax u3 u4} (Equiv.{u3, u4} γ δ) (fun (_x : Equiv.{u3, u4} γ δ) => γ -> δ) (Equiv.hasCoeToFun.{u3, u4} γ δ) cd (coeFn.{max 1 (imax u1 u3) (imax u3 u1), imax u1 u3} (Equiv.{u1, u3} α γ) (fun (_x : Equiv.{u1, u3} α γ) => α -> γ) (Equiv.hasCoeToFun.{u1, u3} α γ) e (coeFn.{max 1 (imax u2 u1) (imax u1 u2), imax u2 u1} (Equiv.{u2, u1} β α) (fun (_x : Equiv.{u2, u1} β α) => β -> α) (Equiv.hasCoeToFun.{u2, u1} β α) (Equiv.symm.{u1, u2} α β ab) x)))
-but is expected to have type
-  forall {α : Sort.{u2}} {β : Sort.{u3}} {γ : Sort.{u4}} {δ : Sort.{u1}} (ab : Equiv.{u2, u3} α β) (cd : Equiv.{u4, u1} γ δ) (e : Equiv.{u2, u4} α γ) (x : β), Eq.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => δ) x) (FunLike.coe.{max (max 1 u3) u1, u3, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Equiv.{u2, u4} α γ) => Equiv.{u3, u1} β δ) e) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => δ) _x) (Equiv.instFunLikeEquiv.{u3, u1} β δ) (FunLike.coe.{max (max (max (max 1 u2) u3) u4) u1, max (max 1 u2) u4, max (max 1 u3) u1} (Equiv.{max (max 1 u4) u2, max (max 1 u1) u3} (Equiv.{u2, u4} α γ) (Equiv.{u3, u1} β δ)) (Equiv.{u2, u4} α γ) (fun (_x : Equiv.{u2, u4} α γ) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Equiv.{u2, u4} α γ) => Equiv.{u3, u1} β δ) _x) (Equiv.instFunLikeEquiv.{max (max 1 u2) u4, max (max 1 u3) u1} (Equiv.{u2, u4} α γ) (Equiv.{u3, u1} β δ)) (Equiv.equivCongr.{u2, u3, u4, u1} α β γ δ ab cd) e) x) (FunLike.coe.{max (max 1 u4) u1, u4, u1} (Equiv.{u4, u1} γ δ) γ (fun (_x : γ) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : γ) => δ) _x) (Equiv.instFunLikeEquiv.{u4, u1} γ δ) cd (FunLike.coe.{max (max 1 u2) u4, u2, u4} (Equiv.{u2, u4} α γ) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => γ) _x) (Equiv.instFunLikeEquiv.{u2, u4} α γ) e (FunLike.coe.{max (max 1 u2) u3, u3, u2} (Equiv.{u3, u2} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => α) _x) (Equiv.instFunLikeEquiv.{u3, u2} β α) (Equiv.symm.{u2, u3} α β ab) x)))
-Case conversion may be inaccurate. Consider using '#align equiv.equiv_congr_apply_apply Equiv.equivCongr_apply_applyₓ'. -/
 @[simp]
 theorem equivCongr_apply_apply {δ} (ab : α ≃ β) (cd : γ ≃ δ) (e : α ≃ γ) (x) :
     ab.equivCongr cd e x = cd (e (ab.symm x)) :=
@@ -707,12 +593,6 @@ def permCongr : Perm α' ≃ Perm β' :=
 #align equiv.perm_congr Equiv.permCongr
 -/
 
-/- warning: equiv.perm_congr_def -> Equiv.permCongr_def is a dubious translation:
-lean 3 declaration is
-  forall {α' : Type.{u1}} {β' : Type.{u2}} (e : Equiv.{succ u1, succ u2} α' β') (p : Equiv.Perm.{succ u1} α'), Eq.{succ u2} (Equiv.Perm.{succ u2} β') (coeFn.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1), max (succ u1) (succ u2)} (Equiv.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) (fun (_x : Equiv.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) => (Equiv.Perm.{succ u1} α') -> (Equiv.Perm.{succ u2} β')) (Equiv.hasCoeToFun.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) (Equiv.permCongr.{u1, u2} α' β' e) p) (Equiv.trans.{succ u2, succ u1, succ u2} β' α' β' (Equiv.trans.{succ u2, succ u1, succ u1} β' α' α' (Equiv.symm.{succ u1, succ u2} α' β' e) p) e)
-but is expected to have type
-  forall {α' : Type.{u2}} {β' : Type.{u1}} (e : Equiv.{succ u2, succ u1} α' β') (p : Equiv.Perm.{succ u2} α'), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') p) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.Perm.{succ u2} α') (fun (_x : Equiv.Perm.{succ u2} α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.permCongr.{u2, u1} α' β' e) p) (Equiv.trans.{succ u1, succ u2, succ u1} β' α' β' (Equiv.trans.{succ u1, succ u2, succ u2} β' α' α' (Equiv.symm.{succ u2, succ u1} α' β' e) p) e)
-Case conversion may be inaccurate. Consider using '#align equiv.perm_congr_def Equiv.permCongr_defₓ'. -/
 theorem permCongr_def (p : Equiv.Perm α') : e.permCongr p = (e.symm.trans p).trans e :=
   rfl
 #align equiv.perm_congr_def Equiv.permCongr_def
@@ -723,23 +603,11 @@ theorem permCongr_refl : e.permCongr (Equiv.refl _) = Equiv.refl _ := by simp [p
 #align equiv.perm_congr_refl Equiv.permCongr_refl
 -/
 
-/- warning: equiv.perm_congr_symm -> Equiv.permCongr_symm is a dubious translation:
-lean 3 declaration is
-  forall {α' : Type.{u1}} {β' : Type.{u2}} (e : Equiv.{succ u1, succ u2} α' β'), Eq.{max 1 (max (succ u2) (succ u1)) (succ u1) (succ u2)} (Equiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} β') (Equiv.Perm.{succ u1} α')) (Equiv.symm.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β') (Equiv.permCongr.{u1, u2} α' β' e)) (Equiv.permCongr.{u2, u1} β' α' (Equiv.symm.{succ u1, succ u2} α' β' e))
-but is expected to have type
-  forall {α' : Type.{u2}} {β' : Type.{u1}} (e : Equiv.{succ u2, succ u1} α' β'), Eq.{max (succ u2) (succ u1)} (Equiv.{succ u1, succ u2} (Equiv.Perm.{succ u1} β') (Equiv.Perm.{succ u2} α')) (Equiv.symm.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β') (Equiv.permCongr.{u2, u1} α' β' e)) (Equiv.permCongr.{u1, u2} β' α' (Equiv.symm.{succ u2, succ u1} α' β' e))
-Case conversion may be inaccurate. Consider using '#align equiv.perm_congr_symm Equiv.permCongr_symmₓ'. -/
 @[simp]
 theorem permCongr_symm : e.permCongr.symm = e.symm.permCongr :=
   rfl
 #align equiv.perm_congr_symm Equiv.permCongr_symm
 
-/- warning: equiv.perm_congr_apply -> Equiv.permCongr_apply is a dubious translation:
-lean 3 declaration is
-  forall {α' : Type.{u1}} {β' : Type.{u2}} (e : Equiv.{succ u1, succ u2} α' β') (p : Equiv.Perm.{succ u1} α') (x : β'), Eq.{succ u2} β' (coeFn.{succ u2, succ u2} (Equiv.Perm.{succ u2} β') (fun (_x : Equiv.{succ u2, succ u2} β' β') => β' -> β') (Equiv.hasCoeToFun.{succ u2, succ u2} β' β') (coeFn.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1), max (succ u1) (succ u2)} (Equiv.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) (fun (_x : Equiv.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) => (Equiv.Perm.{succ u1} α') -> (Equiv.Perm.{succ u2} β')) (Equiv.hasCoeToFun.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) (Equiv.permCongr.{u1, u2} α' β' e) p) x) (coeFn.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1), max (succ u1) (succ u2)} (Equiv.{succ u1, succ u2} α' β') (fun (_x : Equiv.{succ u1, succ u2} α' β') => α' -> β') (Equiv.hasCoeToFun.{succ u1, succ u2} α' β') e (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α') (fun (_x : Equiv.{succ u1, succ u1} α' α') => α' -> α') (Equiv.hasCoeToFun.{succ u1, succ u1} α' α') p (coeFn.{max 1 (max (succ u2) (succ u1)) (succ u1) (succ u2), max (succ u2) (succ u1)} (Equiv.{succ u2, succ u1} β' α') (fun (_x : Equiv.{succ u2, succ u1} β' α') => β' -> α') (Equiv.hasCoeToFun.{succ u2, succ u1} β' α') (Equiv.symm.{succ u1, succ u2} α' β' e) x)))
-but is expected to have type
-  forall {α' : Type.{u2}} {β' : Type.{u1}} (e : Equiv.{succ u2, succ u1} α' β') (p : Equiv.Perm.{succ u2} α') (x : β'), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β') => β') x) (FunLike.coe.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') p) β' (fun (_x : β') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β') => β') _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} β' β') (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.Perm.{succ u2} α') (fun (_x : Equiv.Perm.{succ u2} α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.permCongr.{u2, u1} α' β' e) p) x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} α' β') α' (fun (_x : α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α') => β') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} α' β') e (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.Perm.{succ u2} α') α' (fun (_x : α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α') => α') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} α' α') p (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (Equiv.{succ u1, succ u2} β' α') β' (fun (_x : β') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β') => α') _x) (Equiv.instFunLikeEquiv.{succ u1, succ u2} β' α') (Equiv.symm.{succ u2, succ u1} α' β' e) x)))
-Case conversion may be inaccurate. Consider using '#align equiv.perm_congr_apply Equiv.permCongr_applyₓ'. -/
 @[simp]
 theorem permCongr_apply (p : Equiv.Perm α') (x) : e.permCongr p x = e (p (e.symm x)) :=
   rfl
@@ -751,12 +619,6 @@ theorem permCongr_symm_apply (p : Equiv.Perm β') (x) : e.permCongr.symm p x = e
 #align equiv.perm_congr_symm_apply Equiv.permCongr_symm_apply
 -/
 
-/- warning: equiv.perm_congr_trans -> Equiv.permCongr_trans is a dubious translation:
-lean 3 declaration is
-  forall {α' : Type.{u1}} {β' : Type.{u2}} (e : Equiv.{succ u1, succ u2} α' β') (p : Equiv.Perm.{succ u1} α') (p' : Equiv.Perm.{succ u1} α'), Eq.{succ u2} (Equiv.{succ u2, succ u2} β' β') (Equiv.trans.{succ u2, succ u2, succ u2} β' β' β' (coeFn.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1), max (succ u1) (succ u2)} (Equiv.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) (fun (_x : Equiv.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) => (Equiv.Perm.{succ u1} α') -> (Equiv.Perm.{succ u2} β')) (Equiv.hasCoeToFun.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) (Equiv.permCongr.{u1, u2} α' β' e) p) (coeFn.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1), max (succ u1) (succ u2)} (Equiv.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) (fun (_x : Equiv.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) => (Equiv.Perm.{succ u1} α') -> (Equiv.Perm.{succ u2} β')) (Equiv.hasCoeToFun.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) (Equiv.permCongr.{u1, u2} α' β' e) p')) (coeFn.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1), max (succ u1) (succ u2)} (Equiv.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) (fun (_x : Equiv.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) => (Equiv.Perm.{succ u1} α') -> (Equiv.Perm.{succ u2} β')) (Equiv.hasCoeToFun.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) (Equiv.permCongr.{u1, u2} α' β' e) (Equiv.trans.{succ u1, succ u1, succ u1} α' α' α' p p'))
-but is expected to have type
-  forall {α' : Type.{u2}} {β' : Type.{u1}} (e : Equiv.{succ u2, succ u1} α' β') (p : Equiv.Perm.{succ u2} α') (p' : Equiv.Perm.{succ u2} α'), Eq.{succ u1} (Equiv.{succ u1, succ u1} β' β') (Equiv.trans.{succ u1, succ u1, succ u1} β' β' β' (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.Perm.{succ u2} α') (fun (_x : Equiv.Perm.{succ u2} α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.permCongr.{u2, u1} α' β' e) p) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.Perm.{succ u2} α') (fun (_x : Equiv.Perm.{succ u2} α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.permCongr.{u2, u1} α' β' e) p')) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.Perm.{succ u2} α') (fun (_x : Equiv.Perm.{succ u2} α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.permCongr.{u2, u1} α' β' e) (Equiv.trans.{succ u2, succ u2, succ u2} α' α' α' p p'))
-Case conversion may be inaccurate. Consider using '#align equiv.perm_congr_trans Equiv.permCongr_transₓ'. -/
 theorem permCongr_trans (p p' : Equiv.Perm α') :
     (e.permCongr p).trans (e.permCongr p') = e.permCongr (p.trans p') := by ext; simp
 #align equiv.perm_congr_trans Equiv.permCongr_trans
@@ -784,12 +646,6 @@ def equivPEmpty (α : Sort v) [IsEmpty α] : α ≃ PEmpty.{u} :=
 #align equiv.equiv_pempty Equiv.equivPEmpty
 -/
 
-/- warning: equiv.equiv_empty_equiv -> Equiv.equivEmptyEquiv is a dubious translation:
-lean 3 declaration is
-  forall (α : Sort.{u1}), Equiv.{max 1 (max u1 1) (imax 1 u1), 0} (Equiv.{u1, 1} α Empty) (IsEmpty.{u1} α)
-but is expected to have type
-  forall (α : Sort.{u1}), Equiv.{max 1 u1, 0} (Equiv.{u1, 1} α Empty) (IsEmpty.{u1} α)
-Case conversion may be inaccurate. Consider using '#align equiv.equiv_empty_equiv Equiv.equivEmptyEquivₓ'. -/
 /-- `α` is equivalent to an empty type iff `α` is empty. -/
 def equivEmptyEquiv (α : Sort u) : α ≃ Empty ≃ IsEmpty α :=
   ⟨fun e => Function.isEmpty e, @equivEmpty α, fun e => ext fun x => (e x).elim, fun p => rfl⟩
@@ -813,23 +669,11 @@ def equivOfUnique (α β : Sort _) [Unique α] [Unique β] : α ≃ β
 #align equiv.equiv_of_unique Equiv.equivOfUnique
 -/
 
-/- warning: equiv.equiv_punit -> Equiv.equivPUnit is a dubious translation:
-lean 3 declaration is
-  forall (α : Sort.{u2}) [_inst_1 : Unique.{u2} α], Equiv.{u2, u1} α PUnit.{u1}
-but is expected to have type
-  forall (α : Sort.{u1}) [_inst_1 : Unique.{u1} α], Equiv.{u1, u2} α PUnit.{u2}
-Case conversion may be inaccurate. Consider using '#align equiv.equiv_punit Equiv.equivPUnitₓ'. -/
 /-- If `α` has a unique element, then it is equivalent to any `punit`. -/
 def equivPUnit (α : Sort _) [Unique α] : α ≃ PUnit.{v} :=
   equivOfUnique α _
 #align equiv.equiv_punit Equiv.equivPUnit
 
-/- warning: equiv.prop_equiv_punit -> Equiv.propEquivPUnit is a dubious translation:
-lean 3 declaration is
-  forall {p : Prop}, p -> (Equiv.{0, u_1} p PUnit.{u_1})
-but is expected to have type
-  forall {p : Prop}, p -> (Equiv.{0, 0} p PUnit.{0})
-Case conversion may be inaccurate. Consider using '#align equiv.prop_equiv_punit Equiv.propEquivPUnitₓ'. -/
 /-- The `Sort` of proofs of a true proposition is equivalent to `punit`. -/
 def propEquivPUnit {p : Prop} (h : p) : p ≃ PUnit :=
   @equivPUnit p <| uniqueProp h
@@ -875,36 +719,18 @@ def arrowCongr {α₁ β₁ α₂ β₂ : Sort _} (e₁ : α₁ ≃ α₂) (e₂
 #align equiv.arrow_congr Equiv.arrowCongr
 -/
 
-/- warning: equiv.arrow_congr_comp -> Equiv.arrowCongr_comp is a dubious translation:
-lean 3 declaration is
-  forall {α₁ : Sort.{u1}} {β₁ : Sort.{u2}} {γ₁ : Sort.{u3}} {α₂ : Sort.{u4}} {β₂ : Sort.{u5}} {γ₂ : Sort.{u6}} (ea : Equiv.{u1, u4} α₁ α₂) (eb : Equiv.{u2, u5} β₁ β₂) (ec : Equiv.{u3, u6} γ₁ γ₂) (f : α₁ -> β₁) (g : β₁ -> γ₁), Eq.{imax u4 u6} (α₂ -> γ₂) (coeFn.{max 1 (imax (imax u1 u3) u4 u6) (imax (imax u4 u6) u1 u3), imax (imax u1 u3) u4 u6} (Equiv.{imax u1 u3, imax u4 u6} (α₁ -> γ₁) (α₂ -> γ₂)) (fun (_x : Equiv.{imax u1 u3, imax u4 u6} (α₁ -> γ₁) (α₂ -> γ₂)) => (α₁ -> γ₁) -> α₂ -> γ₂) (Equiv.hasCoeToFun.{imax u1 u3, imax u4 u6} (α₁ -> γ₁) (α₂ -> γ₂)) (Equiv.arrowCongr.{u1, u3, u4, u6} α₁ γ₁ α₂ γ₂ ea ec) (Function.comp.{u1, u2, u3} α₁ β₁ γ₁ g f)) (Function.comp.{u4, u5, u6} α₂ β₂ γ₂ (coeFn.{max 1 (imax (imax u2 u3) u5 u6) (imax (imax u5 u6) u2 u3), imax (imax u2 u3) u5 u6} (Equiv.{imax u2 u3, imax u5 u6} (β₁ -> γ₁) (β₂ -> γ₂)) (fun (_x : Equiv.{imax u2 u3, imax u5 u6} (β₁ -> γ₁) (β₂ -> γ₂)) => (β₁ -> γ₁) -> β₂ -> γ₂) (Equiv.hasCoeToFun.{imax u2 u3, imax u5 u6} (β₁ -> γ₁) (β₂ -> γ₂)) (Equiv.arrowCongr.{u2, u3, u5, u6} β₁ γ₁ β₂ γ₂ eb ec) g) (coeFn.{max 1 (imax (imax u1 u2) u4 u5) (imax (imax u4 u5) u1 u2), imax (imax u1 u2) u4 u5} (Equiv.{imax u1 u2, imax u4 u5} (α₁ -> β₁) (α₂ -> β₂)) (fun (_x : Equiv.{imax u1 u2, imax u4 u5} (α₁ -> β₁) (α₂ -> β₂)) => (α₁ -> β₁) -> α₂ -> β₂) (Equiv.hasCoeToFun.{imax u1 u2, imax u4 u5} (α₁ -> β₁) (α₂ -> β₂)) (Equiv.arrowCongr.{u1, u2, u4, u5} α₁ β₁ α₂ β₂ ea eb) f))
-but is expected to have type
-  forall {α₁ : Sort.{u6}} {β₁ : Sort.{u5}} {γ₁ : Sort.{u4}} {α₂ : Sort.{u3}} {β₂ : Sort.{u2}} {γ₂ : Sort.{u1}} (ea : Equiv.{u6, u3} α₁ α₂) (eb : Equiv.{u5, u2} β₁ β₂) (ec : Equiv.{u4, u1} γ₁ γ₂) (f : α₁ -> β₁) (g : β₁ -> γ₁), Eq.{imax u3 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α₁ -> γ₁) => α₂ -> γ₂) (Function.comp.{u6, u5, u4} α₁ β₁ γ₁ g f)) (FunLike.coe.{max (max 1 (imax u6 u4)) (imax u3 u1), imax u6 u4, imax u3 u1} (Equiv.{imax u6 u4, imax u3 u1} (α₁ -> γ₁) (α₂ -> γ₂)) (α₁ -> γ₁) (fun (_x : α₁ -> γ₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α₁ -> γ₁) => α₂ -> γ₂) _x) (Equiv.instFunLikeEquiv.{imax u6 u4, imax u3 u1} (α₁ -> γ₁) (α₂ -> γ₂)) (Equiv.arrowCongr.{u6, u4, u3, u1} α₁ γ₁ α₂ γ₂ ea ec) (Function.comp.{u6, u5, u4} α₁ β₁ γ₁ g f)) (Function.comp.{u3, u2, u1} α₂ β₂ γ₂ (FunLike.coe.{max (max 1 (imax u5 u4)) (imax u2 u1), imax u5 u4, imax u2 u1} (Equiv.{imax u5 u4, imax u2 u1} (β₁ -> γ₁) (β₂ -> γ₂)) (β₁ -> γ₁) (fun (_x : β₁ -> γ₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β₁ -> γ₁) => β₂ -> γ₂) _x) (Equiv.instFunLikeEquiv.{imax u5 u4, imax u2 u1} (β₁ -> γ₁) (β₂ -> γ₂)) (Equiv.arrowCongr.{u5, u4, u2, u1} β₁ γ₁ β₂ γ₂ eb ec) g) (FunLike.coe.{max (max 1 (imax u6 u5)) (imax u3 u2), imax u6 u5, imax u3 u2} (Equiv.{imax u6 u5, imax u3 u2} (α₁ -> β₁) (α₂ -> β₂)) (α₁ -> β₁) (fun (_x : α₁ -> β₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α₁ -> β₁) => α₂ -> β₂) _x) (Equiv.instFunLikeEquiv.{imax u6 u5, imax u3 u2} (α₁ -> β₁) (α₂ -> β₂)) (Equiv.arrowCongr.{u6, u5, u3, u2} α₁ β₁ α₂ β₂ ea eb) f))
-Case conversion may be inaccurate. Consider using '#align equiv.arrow_congr_comp Equiv.arrowCongr_compₓ'. -/
 theorem arrowCongr_comp {α₁ β₁ γ₁ α₂ β₂ γ₂ : Sort _} (ea : α₁ ≃ α₂) (eb : β₁ ≃ β₂) (ec : γ₁ ≃ γ₂)
     (f : α₁ → β₁) (g : β₁ → γ₁) :
     arrowCongr ea ec (g ∘ f) = arrowCongr eb ec g ∘ arrowCongr ea eb f := by ext;
   simp only [comp, arrow_congr_apply, eb.symm_apply_apply]
 #align equiv.arrow_congr_comp Equiv.arrowCongr_comp
 
-/- warning: equiv.arrow_congr_refl -> Equiv.arrowCongr_refl is a dubious translation:
-lean 3 declaration is
-  forall {α : Sort.{u1}} {β : Sort.{u2}}, Eq.{max 1 (imax u1 u2)} (Equiv.{imax u1 u2, imax u1 u2} (α -> β) (α -> β)) (Equiv.arrowCongr.{u1, u2, u1, u2} α β α β (Equiv.refl.{u1} α) (Equiv.refl.{u2} β)) (Equiv.refl.{imax u1 u2} (α -> β))
-but is expected to have type
-  forall {α : Sort.{u2}} {β : Sort.{u1}}, Eq.{max 1 (imax u2 u1)} (Equiv.{imax u2 u1, imax u2 u1} (α -> β) (α -> β)) (Equiv.arrowCongr.{u2, u1, u2, u1} α β α β (Equiv.refl.{u2} α) (Equiv.refl.{u1} β)) (Equiv.refl.{imax u2 u1} (α -> β))
-Case conversion may be inaccurate. Consider using '#align equiv.arrow_congr_refl Equiv.arrowCongr_reflₓ'. -/
 @[simp]
 theorem arrowCongr_refl {α β : Sort _} :
     arrowCongr (Equiv.refl α) (Equiv.refl β) = Equiv.refl (α → β) :=
   rfl
 #align equiv.arrow_congr_refl Equiv.arrowCongr_refl
 
-/- warning: equiv.arrow_congr_trans -> Equiv.arrowCongr_trans is a dubious translation:
-lean 3 declaration is
-  forall {α₁ : Sort.{u1}} {β₁ : Sort.{u2}} {α₂ : Sort.{u3}} {β₂ : Sort.{u4}} {α₃ : Sort.{u5}} {β₃ : Sort.{u6}} (e₁ : Equiv.{u1, u3} α₁ α₂) (e₁' : Equiv.{u2, u4} β₁ β₂) (e₂ : Equiv.{u3, u5} α₂ α₃) (e₂' : Equiv.{u4, u6} β₂ β₃), Eq.{max 1 (imax (imax u1 u2) u5 u6) (imax (imax u5 u6) u1 u2)} (Equiv.{imax u1 u2, imax u5 u6} (α₁ -> β₁) (α₃ -> β₃)) (Equiv.arrowCongr.{u1, u2, u5, u6} α₁ β₁ α₃ β₃ (Equiv.trans.{u1, u3, u5} α₁ α₂ α₃ e₁ e₂) (Equiv.trans.{u2, u4, u6} β₁ β₂ β₃ e₁' e₂')) (Equiv.trans.{imax u1 u2, imax u3 u4, imax u5 u6} (α₁ -> β₁) (α₂ -> β₂) (α₃ -> β₃) (Equiv.arrowCongr.{u1, u2, u3, u4} α₁ β₁ α₂ β₂ e₁ e₁') (Equiv.arrowCongr.{u3, u4, u5, u6} α₂ β₂ α₃ β₃ e₂ e₂'))
-but is expected to have type
-  forall {α₁ : Sort.{u6}} {β₁ : Sort.{u5}} {α₂ : Sort.{u4}} {β₂ : Sort.{u3}} {α₃ : Sort.{u2}} {β₃ : Sort.{u1}} (e₁ : Equiv.{u6, u5} α₁ β₁) (e₁' : Equiv.{u4, u3} α₂ β₂) (e₂ : Equiv.{u5, u2} β₁ α₃) (e₂' : Equiv.{u3, u1} β₂ β₃), Eq.{max (max 1 (imax u6 u4)) (imax u2 u1)} (Equiv.{imax u6 u4, imax u2 u1} (α₁ -> α₂) (α₃ -> β₃)) (Equiv.arrowCongr.{u6, u4, u2, u1} α₁ α₂ α₃ β₃ (Equiv.trans.{u6, u5, u2} α₁ β₁ α₃ e₁ e₂) (Equiv.trans.{u4, u3, u1} α₂ β₂ β₃ e₁' e₂')) (Equiv.trans.{imax u6 u4, imax u5 u3, imax u2 u1} (α₁ -> α₂) (β₁ -> β₂) (α₃ -> β₃) (Equiv.arrowCongr.{u6, u4, u5, u3} α₁ α₂ β₁ β₂ e₁ e₁') (Equiv.arrowCongr.{u5, u3, u2, u1} β₁ β₂ α₃ β₃ e₂ e₂'))
-Case conversion may be inaccurate. Consider using '#align equiv.arrow_congr_trans Equiv.arrowCongr_transₓ'. -/
 @[simp]
 theorem arrowCongr_trans {α₁ β₁ α₂ β₂ α₃ β₃ : Sort _} (e₁ : α₁ ≃ α₂) (e₁' : β₁ ≃ β₂) (e₂ : α₂ ≃ α₃)
     (e₂' : β₂ ≃ β₃) :
@@ -912,12 +738,6 @@ theorem arrowCongr_trans {α₁ β₁ α₂ β₂ α₃ β₃ : Sort _} (e₁ :
   rfl
 #align equiv.arrow_congr_trans Equiv.arrowCongr_trans
 
-/- warning: equiv.arrow_congr_symm -> Equiv.arrowCongr_symm is a dubious translation:
-lean 3 declaration is
-  forall {α₁ : Sort.{u1}} {β₁ : Sort.{u2}} {α₂ : Sort.{u3}} {β₂ : Sort.{u4}} (e₁ : Equiv.{u1, u3} α₁ α₂) (e₂ : Equiv.{u2, u4} β₁ β₂), Eq.{max 1 (imax (imax u3 u4) u1 u2) (imax (imax u1 u2) u3 u4)} (Equiv.{imax u3 u4, imax u1 u2} (α₂ -> β₂) (α₁ -> β₁)) (Equiv.symm.{imax u1 u2, imax u3 u4} (α₁ -> β₁) (α₂ -> β₂) (Equiv.arrowCongr.{u1, u2, u3, u4} α₁ β₁ α₂ β₂ e₁ e₂)) (Equiv.arrowCongr.{u3, u4, u1, u2} α₂ β₂ α₁ β₁ (Equiv.symm.{u1, u3} α₁ α₂ e₁) (Equiv.symm.{u2, u4} β₁ β₂ e₂))
-but is expected to have type
-  forall {α₁ : Sort.{u4}} {β₁ : Sort.{u3}} {α₂ : Sort.{u2}} {β₂ : Sort.{u1}} (e₁ : Equiv.{u4, u3} α₁ β₁) (e₂ : Equiv.{u2, u1} α₂ β₂), Eq.{max (max 1 (imax u3 u1)) (imax u4 u2)} (Equiv.{imax u3 u1, imax u4 u2} (β₁ -> β₂) (α₁ -> α₂)) (Equiv.symm.{imax u4 u2, imax u3 u1} (α₁ -> α₂) (β₁ -> β₂) (Equiv.arrowCongr.{u4, u2, u3, u1} α₁ α₂ β₁ β₂ e₁ e₂)) (Equiv.arrowCongr.{u3, u1, u4, u2} β₁ β₂ α₁ α₂ (Equiv.symm.{u4, u3} α₁ β₁ e₁) (Equiv.symm.{u2, u1} α₂ β₂ e₂))
-Case conversion may be inaccurate. Consider using '#align equiv.arrow_congr_symm Equiv.arrowCongr_symmₓ'. -/
 @[simp]
 theorem arrowCongr_symm {α₁ β₁ α₂ β₂ : Sort _} (e₁ : α₁ ≃ α₂) (e₂ : β₁ ≃ β₂) :
     (arrowCongr e₁ e₂).symm = arrowCongr e₁.symm e₂.symm :=
@@ -936,24 +756,12 @@ def arrowCongr' {α₁ β₁ α₂ β₂ : Type _} (hα : α₁ ≃ α₂) (hβ
 #align equiv.arrow_congr' Equiv.arrowCongr'
 -/
 
-/- warning: equiv.arrow_congr'_refl -> Equiv.arrowCongr'_refl is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}}, Eq.{max 1 (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (α -> β) (α -> β)) (Equiv.arrowCongr'.{u1, u2, u1, u2} α β α β (Equiv.refl.{succ u1} α) (Equiv.refl.{succ u2} β)) (Equiv.refl.{max (succ u1) (succ u2)} (α -> β))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}}, Eq.{max (succ u2) (succ u1)} (Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (α -> β) (α -> β)) (Equiv.arrowCongr'.{u2, u1, u2, u1} α β α β (Equiv.refl.{succ u2} α) (Equiv.refl.{succ u1} β)) (Equiv.refl.{max (succ u2) (succ u1)} (α -> β))
-Case conversion may be inaccurate. Consider using '#align equiv.arrow_congr'_refl Equiv.arrowCongr'_reflₓ'. -/
 @[simp]
 theorem arrowCongr'_refl {α β : Type _} :
     arrowCongr' (Equiv.refl α) (Equiv.refl β) = Equiv.refl (α → β) :=
   rfl
 #align equiv.arrow_congr'_refl Equiv.arrowCongr'_refl
 
-/- warning: equiv.arrow_congr'_trans -> Equiv.arrowCongr'_trans is a dubious translation:
-lean 3 declaration is
-  forall {α₁ : Type.{u1}} {β₁ : Type.{u2}} {α₂ : Type.{u3}} {β₂ : Type.{u4}} {α₃ : Type.{u5}} {β₃ : Type.{u6}} (e₁ : Equiv.{succ u1, succ u3} α₁ α₂) (e₁' : Equiv.{succ u2, succ u4} β₁ β₂) (e₂ : Equiv.{succ u3, succ u5} α₂ α₃) (e₂' : Equiv.{succ u4, succ u6} β₂ β₃), Eq.{max 1 (max (max (succ u1) (succ u2)) (succ u5) (succ u6)) (max (succ u5) (succ u6)) (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u5) (succ u6)} (α₁ -> β₁) (α₃ -> β₃)) (Equiv.arrowCongr'.{u1, u2, u5, u6} α₁ β₁ α₃ β₃ (Equiv.trans.{succ u1, succ u3, succ u5} α₁ α₂ α₃ e₁ e₂) (Equiv.trans.{succ u2, succ u4, succ u6} β₁ β₂ β₃ e₁' e₂')) (Equiv.trans.{max (succ u1) (succ u2), max (succ u3) (succ u4), max (succ u5) (succ u6)} (α₁ -> β₁) (α₂ -> β₂) (α₃ -> β₃) (Equiv.arrowCongr'.{u1, u2, u3, u4} α₁ β₁ α₂ β₂ e₁ e₁') (Equiv.arrowCongr'.{u3, u4, u5, u6} α₂ β₂ α₃ β₃ e₂ e₂'))
-but is expected to have type
-  forall {α₁ : Type.{u6}} {β₁ : Type.{u5}} {α₂ : Type.{u4}} {β₂ : Type.{u3}} {α₃ : Type.{u2}} {β₃ : Type.{u1}} (e₁ : Equiv.{succ u6, succ u5} α₁ β₁) (e₁' : Equiv.{succ u4, succ u3} α₂ β₂) (e₂ : Equiv.{succ u5, succ u2} β₁ α₃) (e₂' : Equiv.{succ u3, succ u1} β₂ β₃), Eq.{max (max (max (succ u1) (succ u2)) (succ u4)) (succ u6)} (Equiv.{max (succ u6) (succ u4), max (succ u2) (succ u1)} (α₁ -> α₂) (α₃ -> β₃)) (Equiv.arrowCongr'.{u6, u4, u2, u1} α₁ α₂ α₃ β₃ (Equiv.trans.{succ u6, succ u5, succ u2} α₁ β₁ α₃ e₁ e₂) (Equiv.trans.{succ u4, succ u3, succ u1} α₂ β₂ β₃ e₁' e₂')) (Equiv.trans.{max (succ u4) (succ u6), max (succ u3) (succ u5), max (succ u1) (succ u2)} (α₁ -> α₂) (β₁ -> β₂) (α₃ -> β₃) (Equiv.arrowCongr'.{u6, u4, u5, u3} α₁ α₂ β₁ β₂ e₁ e₁') (Equiv.arrowCongr'.{u5, u3, u2, u1} β₁ β₂ α₃ β₃ e₂ e₂'))
-Case conversion may be inaccurate. Consider using '#align equiv.arrow_congr'_trans Equiv.arrowCongr'_transₓ'. -/
 @[simp]
 theorem arrowCongr'_trans {α₁ β₁ α₂ β₂ α₃ β₃ : Type _} (e₁ : α₁ ≃ α₂) (e₁' : β₁ ≃ β₂) (e₂ : α₂ ≃ α₃)
     (e₂' : β₂ ≃ β₃) :
@@ -961,12 +769,6 @@ theorem arrowCongr'_trans {α₁ β₁ α₂ β₂ α₃ β₃ : Type _} (e₁ :
   rfl
 #align equiv.arrow_congr'_trans Equiv.arrowCongr'_trans
 
-/- warning: equiv.arrow_congr'_symm -> Equiv.arrowCongr'_symm is a dubious translation:
-lean 3 declaration is
-  forall {α₁ : Type.{u1}} {β₁ : Type.{u2}} {α₂ : Type.{u3}} {β₂ : Type.{u4}} (e₁ : Equiv.{succ u1, succ u3} α₁ α₂) (e₂ : Equiv.{succ u2, succ u4} β₁ β₂), Eq.{max 1 (max (max (succ u3) (succ u4)) (succ u1) (succ u2)) (max (succ u1) (succ u2)) (succ u3) (succ u4)} (Equiv.{max (succ u3) (succ u4), max (succ u1) (succ u2)} (α₂ -> β₂) (α₁ -> β₁)) (Equiv.symm.{max (succ u1) (succ u2), max (succ u3) (succ u4)} (α₁ -> β₁) (α₂ -> β₂) (Equiv.arrowCongr'.{u1, u2, u3, u4} α₁ β₁ α₂ β₂ e₁ e₂)) (Equiv.arrowCongr'.{u3, u4, u1, u2} α₂ β₂ α₁ β₁ (Equiv.symm.{succ u1, succ u3} α₁ α₂ e₁) (Equiv.symm.{succ u2, succ u4} β₁ β₂ e₂))
-but is expected to have type
-  forall {α₁ : Type.{u4}} {β₁ : Type.{u3}} {α₂ : Type.{u2}} {β₂ : Type.{u1}} (e₁ : Equiv.{succ u4, succ u3} α₁ β₁) (e₂ : Equiv.{succ u2, succ u1} α₂ β₂), Eq.{max (max (max (succ u1) (succ u3)) (succ u2)) (succ u4)} (Equiv.{max (succ u1) (succ u3), max (succ u2) (succ u4)} (β₁ -> β₂) (α₁ -> α₂)) (Equiv.symm.{max (succ u2) (succ u4), max (succ u1) (succ u3)} (α₁ -> α₂) (β₁ -> β₂) (Equiv.arrowCongr'.{u4, u2, u3, u1} α₁ α₂ β₁ β₂ e₁ e₂)) (Equiv.arrowCongr'.{u3, u1, u4, u2} β₁ β₂ α₁ α₂ (Equiv.symm.{succ u4, succ u3} α₁ β₁ e₁) (Equiv.symm.{succ u2, succ u1} α₂ β₂ e₂))
-Case conversion may be inaccurate. Consider using '#align equiv.arrow_congr'_symm Equiv.arrowCongr'_symmₓ'. -/
 @[simp]
 theorem arrowCongr'_symm {α₁ β₁ α₂ β₂ : Type _} (e₁ : α₁ ≃ α₂) (e₂ : β₁ ≃ β₂) :
     (arrowCongr' e₁ e₂).symm = arrowCongr' e₁.symm e₂.symm :=
@@ -988,23 +790,11 @@ theorem conj_refl : conj (Equiv.refl α) = Equiv.refl (α → α) :=
 #align equiv.conj_refl Equiv.conj_refl
 -/
 
-/- warning: equiv.conj_symm -> Equiv.conj_symm is a dubious translation:
-lean 3 declaration is
-  forall {α : Sort.{u1}} {β : Sort.{u2}} (e : Equiv.{u1, u2} α β), Eq.{max 1 (imax u2 u1) (imax u1 u2)} (Equiv.{u2, u1} (β -> β) (α -> α)) (Equiv.symm.{u1, u2} (α -> α) (β -> β) (Equiv.conj.{u1, u2} α β e)) (Equiv.conj.{u2, u1} β α (Equiv.symm.{u1, u2} α β e))
-but is expected to have type
-  forall {α : Sort.{u1}} {β : Sort.{u2}} (e : Equiv.{u1, u2} α β), Eq.{max (max 1 u1) u2} (Equiv.{u2, u1} (β -> β) (α -> α)) (Equiv.symm.{u1, u2} (α -> α) (β -> β) (Equiv.conj.{u1, u2} α β e)) (Equiv.conj.{u2, u1} β α (Equiv.symm.{u1, u2} α β e))
-Case conversion may be inaccurate. Consider using '#align equiv.conj_symm Equiv.conj_symmₓ'. -/
 @[simp]
 theorem conj_symm (e : α ≃ β) : e.conj.symm = e.symm.conj :=
   rfl
 #align equiv.conj_symm Equiv.conj_symm
 
-/- warning: equiv.conj_trans -> Equiv.conj_trans is a dubious translation:
-lean 3 declaration is
-  forall {α : Sort.{u1}} {β : Sort.{u2}} {γ : Sort.{u3}} (e₁ : Equiv.{u1, u2} α β) (e₂ : Equiv.{u2, u3} β γ), Eq.{max 1 (imax u1 u3) (imax u3 u1)} (Equiv.{u1, u3} (α -> α) (γ -> γ)) (Equiv.conj.{u1, u3} α γ (Equiv.trans.{u1, u2, u3} α β γ e₁ e₂)) (Equiv.trans.{u1, u2, u3} (α -> α) (β -> β) (γ -> γ) (Equiv.conj.{u1, u2} α β e₁) (Equiv.conj.{u2, u3} β γ e₂))
-but is expected to have type
-  forall {α : Sort.{u1}} {β : Sort.{u2}} {γ : Sort.{u3}} (e₁ : Equiv.{u1, u2} α β) (e₂ : Equiv.{u2, u3} β γ), Eq.{max (max 1 u1) u3} (Equiv.{u1, u3} (α -> α) (γ -> γ)) (Equiv.conj.{u1, u3} α γ (Equiv.trans.{u1, u2, u3} α β γ e₁ e₂)) (Equiv.trans.{u1, u2, u3} (α -> α) (β -> β) (γ -> γ) (Equiv.conj.{u1, u2} α β e₁) (Equiv.conj.{u2, u3} β γ e₂))
-Case conversion may be inaccurate. Consider using '#align equiv.conj_trans Equiv.conj_transₓ'. -/
 @[simp]
 theorem conj_trans (e₁ : α ≃ β) (e₂ : β ≃ γ) : (e₁.trans e₂).conj = e₁.conj.trans e₂.conj :=
   rfl
@@ -1019,42 +809,18 @@ theorem conj_comp (e : α ≃ β) (f₁ f₂ : α → α) : e.conj (f₁ ∘ f
 #align equiv.conj_comp Equiv.conj_comp
 -/
 
-/- warning: equiv.eq_comp_symm -> Equiv.eq_comp_symm is a dubious translation:
-lean 3 declaration is
-  forall {α : Sort.{u1}} {β : Sort.{u2}} {γ : Sort.{u3}} (e : Equiv.{u1, u2} α β) (f : β -> γ) (g : α -> γ), Iff (Eq.{imax u2 u3} (β -> γ) f (Function.comp.{u2, u1, u3} β α γ g (coeFn.{max 1 (imax u2 u1) (imax u1 u2), imax u2 u1} (Equiv.{u2, u1} β α) (fun (_x : Equiv.{u2, u1} β α) => β -> α) (Equiv.hasCoeToFun.{u2, u1} β α) (Equiv.symm.{u1, u2} α β e)))) (Eq.{imax u1 u3} (α -> γ) (Function.comp.{u1, u2, u3} α β γ f (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α β) (fun (_x : Equiv.{u1, u2} α β) => α -> β) (Equiv.hasCoeToFun.{u1, u2} α β) e)) g)
-but is expected to have type
-  forall {α : Sort.{u3}} {β : Sort.{u2}} {γ : Sort.{u1}} (e : Equiv.{u3, u2} α β) (f : β -> γ) (g : α -> γ), Iff (Eq.{imax u2 u1} (β -> γ) f (Function.comp.{u2, u3, u1} β α γ g (FunLike.coe.{max (max 1 u2) u3, u2, u3} (Equiv.{u2, u3} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => α) _x) (Equiv.instFunLikeEquiv.{u2, u3} β α) (Equiv.symm.{u3, u2} α β e)))) (Eq.{imax u3 u1} (α -> γ) (Function.comp.{u3, u2, u1} α β γ f (FunLike.coe.{max (max 1 u2) u3, u3, u2} (Equiv.{u3, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => β) _x) (Equiv.instFunLikeEquiv.{u3, u2} α β) e)) g)
-Case conversion may be inaccurate. Consider using '#align equiv.eq_comp_symm Equiv.eq_comp_symmₓ'. -/
 theorem eq_comp_symm {α β γ} (e : α ≃ β) (f : β → γ) (g : α → γ) : f = g ∘ e.symm ↔ f ∘ e = g :=
   (e.arrowCongr (Equiv.refl γ)).symm_apply_eq.symm
 #align equiv.eq_comp_symm Equiv.eq_comp_symm
 
-/- warning: equiv.comp_symm_eq -> Equiv.comp_symm_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Sort.{u1}} {β : Sort.{u2}} {γ : Sort.{u3}} (e : Equiv.{u1, u2} α β) (f : β -> γ) (g : α -> γ), Iff (Eq.{imax u2 u3} (β -> γ) (Function.comp.{u2, u1, u3} β α γ g (coeFn.{max 1 (imax u2 u1) (imax u1 u2), imax u2 u1} (Equiv.{u2, u1} β α) (fun (_x : Equiv.{u2, u1} β α) => β -> α) (Equiv.hasCoeToFun.{u2, u1} β α) (Equiv.symm.{u1, u2} α β e))) f) (Eq.{imax u1 u3} (α -> γ) g (Function.comp.{u1, u2, u3} α β γ f (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α β) (fun (_x : Equiv.{u1, u2} α β) => α -> β) (Equiv.hasCoeToFun.{u1, u2} α β) e)))
-but is expected to have type
-  forall {α : Sort.{u3}} {β : Sort.{u2}} {γ : Sort.{u1}} (e : Equiv.{u3, u2} α β) (f : β -> γ) (g : α -> γ), Iff (Eq.{imax u2 u1} (β -> γ) (Function.comp.{u2, u3, u1} β α γ g (FunLike.coe.{max (max 1 u2) u3, u2, u3} (Equiv.{u2, u3} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => α) _x) (Equiv.instFunLikeEquiv.{u2, u3} β α) (Equiv.symm.{u3, u2} α β e))) f) (Eq.{imax u3 u1} (α -> γ) g (Function.comp.{u3, u2, u1} α β γ f (FunLike.coe.{max (max 1 u2) u3, u3, u2} (Equiv.{u3, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => β) _x) (Equiv.instFunLikeEquiv.{u3, u2} α β) e)))
-Case conversion may be inaccurate. Consider using '#align equiv.comp_symm_eq Equiv.comp_symm_eqₓ'. -/
 theorem comp_symm_eq {α β γ} (e : α ≃ β) (f : β → γ) (g : α → γ) : g ∘ e.symm = f ↔ g = f ∘ e :=
   (e.arrowCongr (Equiv.refl γ)).eq_symm_apply.symm
 #align equiv.comp_symm_eq Equiv.comp_symm_eq
 
-/- warning: equiv.eq_symm_comp -> Equiv.eq_symm_comp is a dubious translation:
-lean 3 declaration is
-  forall {α : Sort.{u1}} {β : Sort.{u2}} {γ : Sort.{u3}} (e : Equiv.{u1, u2} α β) (f : γ -> α) (g : γ -> β), Iff (Eq.{imax u3 u1} (γ -> α) f (Function.comp.{u3, u2, u1} γ β α (coeFn.{max 1 (imax u2 u1) (imax u1 u2), imax u2 u1} (Equiv.{u2, u1} β α) (fun (_x : Equiv.{u2, u1} β α) => β -> α) (Equiv.hasCoeToFun.{u2, u1} β α) (Equiv.symm.{u1, u2} α β e)) g)) (Eq.{imax u3 u2} (γ -> β) (Function.comp.{u3, u1, u2} γ α β (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α β) (fun (_x : Equiv.{u1, u2} α β) => α -> β) (Equiv.hasCoeToFun.{u1, u2} α β) e) f) g)
-but is expected to have type
-  forall {α : Sort.{u3}} {β : Sort.{u2}} {γ : Sort.{u1}} (e : Equiv.{u3, u2} α β) (f : γ -> α) (g : γ -> β), Iff (Eq.{imax u1 u3} (γ -> α) f (Function.comp.{u1, u2, u3} γ β α (FunLike.coe.{max (max 1 u2) u3, u2, u3} (Equiv.{u2, u3} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => α) _x) (Equiv.instFunLikeEquiv.{u2, u3} β α) (Equiv.symm.{u3, u2} α β e)) g)) (Eq.{imax u1 u2} (γ -> β) (Function.comp.{u1, u3, u2} γ α β (FunLike.coe.{max (max 1 u2) u3, u3, u2} (Equiv.{u3, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => β) _x) (Equiv.instFunLikeEquiv.{u3, u2} α β) e) f) g)
-Case conversion may be inaccurate. Consider using '#align equiv.eq_symm_comp Equiv.eq_symm_compₓ'. -/
 theorem eq_symm_comp {α β γ} (e : α ≃ β) (f : γ → α) (g : γ → β) : f = e.symm ∘ g ↔ e ∘ f = g :=
   ((Equiv.refl γ).arrowCongr e).eq_symm_apply
 #align equiv.eq_symm_comp Equiv.eq_symm_comp
 
-/- warning: equiv.symm_comp_eq -> Equiv.symm_comp_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Sort.{u1}} {β : Sort.{u2}} {γ : Sort.{u3}} (e : Equiv.{u1, u2} α β) (f : γ -> α) (g : γ -> β), Iff (Eq.{imax u3 u1} (γ -> α) (Function.comp.{u3, u2, u1} γ β α (coeFn.{max 1 (imax u2 u1) (imax u1 u2), imax u2 u1} (Equiv.{u2, u1} β α) (fun (_x : Equiv.{u2, u1} β α) => β -> α) (Equiv.hasCoeToFun.{u2, u1} β α) (Equiv.symm.{u1, u2} α β e)) g) f) (Eq.{imax u3 u2} (γ -> β) g (Function.comp.{u3, u1, u2} γ α β (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α β) (fun (_x : Equiv.{u1, u2} α β) => α -> β) (Equiv.hasCoeToFun.{u1, u2} α β) e) f))
-but is expected to have type
-  forall {α : Sort.{u3}} {β : Sort.{u2}} {γ : Sort.{u1}} (e : Equiv.{u3, u2} α β) (f : γ -> α) (g : γ -> β), Iff (Eq.{imax u1 u3} (γ -> α) (Function.comp.{u1, u2, u3} γ β α (FunLike.coe.{max (max 1 u2) u3, u2, u3} (Equiv.{u2, u3} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => α) _x) (Equiv.instFunLikeEquiv.{u2, u3} β α) (Equiv.symm.{u3, u2} α β e)) g) f) (Eq.{imax u1 u2} (γ -> β) g (Function.comp.{u1, u3, u2} γ α β (FunLike.coe.{max (max 1 u2) u3, u3, u2} (Equiv.{u3, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => β) _x) (Equiv.instFunLikeEquiv.{u3, u2} α β) e) f))
-Case conversion may be inaccurate. Consider using '#align equiv.symm_comp_eq Equiv.symm_comp_eqₓ'. -/
 theorem symm_comp_eq {α β γ} (e : α ≃ β) (f : γ → α) (g : γ → β) : e.symm ∘ g = f ↔ g = e ∘ f :=
   ((Equiv.refl γ).arrowCongr e).symm_apply_eq
 #align equiv.symm_comp_eq Equiv.symm_comp_eq
@@ -1178,12 +944,6 @@ def psigmaCongrRight {α} {β₁ β₂ : α → Sort _} (F : ∀ a, β₁ a ≃
 #align equiv.psigma_congr_right Equiv.psigmaCongrRight
 -/
 
-/- warning: equiv.psigma_congr_right_trans -> Equiv.psigmaCongrRight_trans is a dubious translation:
-lean 3 declaration is
-  forall {α : Sort.{u1}} {β₁ : α -> Sort.{u2}} {β₂ : α -> Sort.{u3}} {β₃ : α -> Sort.{u4}} (F : forall (a : α), Equiv.{u2, u3} (β₁ a) (β₂ a)) (G : forall (a : α), Equiv.{u3, u4} (β₂ a) (β₃ a)), Eq.{max 1 (max (max 1 u1 u2) 1 u1 u4) (max 1 u1 u4) 1 u1 u2} (Equiv.{max 1 u1 u2, max 1 u1 u4} (PSigma.{u1, u2} α (fun (a : α) => β₁ a)) (PSigma.{u1, u4} α (fun (a : α) => β₃ a))) (Equiv.trans.{max 1 u1 u2, max 1 u1 u3, max 1 u1 u4} (PSigma.{u1, u2} α (fun (a : α) => β₁ a)) (PSigma.{u1, u3} α (fun (a : α) => β₂ a)) (PSigma.{u1, u4} α (fun (a : α) => β₃ a)) (Equiv.psigmaCongrRight.{u1, u2, u3} α (fun (a : α) => β₁ a) (fun (a : α) => β₂ a) F) (Equiv.psigmaCongrRight.{u1, u3, u4} α (fun (a : α) => β₂ a) (fun (a : α) => β₃ a) G)) (Equiv.psigmaCongrRight.{u1, u2, u4} α (fun (a : α) => β₁ a) (fun (a : α) => β₃ a) (fun (a : α) => Equiv.trans.{u2, u3, u4} (β₁ a) (β₂ a) (β₃ a) (F a) (G a)))
-but is expected to have type
-  forall {α : Sort.{u4}} {β₁ : α -> Sort.{u3}} {β₂ : α -> Sort.{u2}} {β₃ : α -> Sort.{u1}} (F : forall (a : α), Equiv.{u3, u2} (β₁ a) (β₂ a)) (G : forall (a : α), Equiv.{u2, u1} (β₂ a) (β₃ a)), Eq.{max (max (max 1 u4) u3) u1} (Equiv.{max (max 1 u4) u3, max (max 1 u4) u1} (PSigma.{u4, u3} α (fun (a : α) => β₁ a)) (PSigma.{u4, u1} α (fun (a : α) => β₃ a))) (Equiv.trans.{max (max 1 u4) u3, max (max 1 u4) u2, max (max 1 u4) u1} (PSigma.{u4, u3} α (fun (a : α) => β₁ a)) (PSigma.{u4, u2} α (fun (a : α) => β₂ a)) (PSigma.{u4, u1} α (fun (a : α) => β₃ a)) (Equiv.psigmaCongrRight.{u4, u3, u2} α (fun (a : α) => β₁ a) (fun (a : α) => β₂ a) F) (Equiv.psigmaCongrRight.{u4, u2, u1} α (fun (a : α) => β₂ a) (fun (a : α) => β₃ a) G)) (Equiv.psigmaCongrRight.{u4, u3, u1} α (fun (a : α) => β₁ a) (fun (a : α) => β₃ a) (fun (a : α) => Equiv.trans.{u3, u2, u1} (β₁ a) (β₂ a) (β₃ a) (F a) (G a)))
-Case conversion may be inaccurate. Consider using '#align equiv.psigma_congr_right_trans Equiv.psigmaCongrRight_transₓ'. -/
 @[simp]
 theorem psigmaCongrRight_trans {α} {β₁ β₂ β₃ : α → Sort _} (F : ∀ a, β₁ a ≃ β₂ a)
     (G : ∀ a, β₂ a ≃ β₃ a) :
@@ -1191,23 +951,11 @@ theorem psigmaCongrRight_trans {α} {β₁ β₂ β₃ : α → Sort _} (F : ∀
   by ext1 x; cases x; rfl
 #align equiv.psigma_congr_right_trans Equiv.psigmaCongrRight_trans
 
-/- warning: equiv.psigma_congr_right_symm -> Equiv.psigmaCongrRight_symm is a dubious translation:
-lean 3 declaration is
-  forall {α : Sort.{u1}} {β₁ : α -> Sort.{u2}} {β₂ : α -> Sort.{u3}} (F : forall (a : α), Equiv.{u2, u3} (β₁ a) (β₂ a)), Eq.{max 1 (max (max 1 u1 u3) 1 u1 u2) (max 1 u1 u2) 1 u1 u3} (Equiv.{max 1 u1 u3, max 1 u1 u2} (PSigma.{u1, u3} α (fun (a : α) => β₂ a)) (PSigma.{u1, u2} α (fun (a : α) => β₁ a))) (Equiv.symm.{max 1 u1 u2, max 1 u1 u3} (PSigma.{u1, u2} α (fun (a : α) => β₁ a)) (PSigma.{u1, u3} α (fun (a : α) => β₂ a)) (Equiv.psigmaCongrRight.{u1, u2, u3} α (fun (a : α) => β₁ a) (fun (a : α) => β₂ a) F)) (Equiv.psigmaCongrRight.{u1, u3, u2} α (fun (a : α) => β₂ a) (fun (a : α) => β₁ a) (fun (a : α) => Equiv.symm.{u2, u3} (β₁ a) (β₂ a) (F a)))
-but is expected to have type
-  forall {α : Sort.{u3}} {β₁ : α -> Sort.{u2}} {β₂ : α -> Sort.{u1}} (F : forall (a : α), Equiv.{u2, u1} (β₁ a) (β₂ a)), Eq.{max (max (max 1 u3) u2) u1} (Equiv.{max (max 1 u3) u1, max (max 1 u3) u2} (PSigma.{u3, u1} α (fun (a : α) => β₂ a)) (PSigma.{u3, u2} α (fun (a : α) => β₁ a))) (Equiv.symm.{max (max 1 u3) u2, max (max 1 u3) u1} (PSigma.{u3, u2} α (fun (a : α) => β₁ a)) (PSigma.{u3, u1} α (fun (a : α) => β₂ a)) (Equiv.psigmaCongrRight.{u3, u2, u1} α (fun (a : α) => β₁ a) (fun (a : α) => β₂ a) F)) (Equiv.psigmaCongrRight.{u3, u1, u2} α (fun (a : α) => β₂ a) (fun (a : α) => β₁ a) (fun (a : α) => Equiv.symm.{u2, u1} (β₁ a) (β₂ a) (F a)))
-Case conversion may be inaccurate. Consider using '#align equiv.psigma_congr_right_symm Equiv.psigmaCongrRight_symmₓ'. -/
 @[simp]
 theorem psigmaCongrRight_symm {α} {β₁ β₂ : α → Sort _} (F : ∀ a, β₁ a ≃ β₂ a) :
     (psigmaCongrRight F).symm = psigmaCongrRight fun a => (F a).symm := by ext1 x; cases x; rfl
 #align equiv.psigma_congr_right_symm Equiv.psigmaCongrRight_symm
 
-/- warning: equiv.psigma_congr_right_refl -> Equiv.psigmaCongrRight_refl is a dubious translation:
-lean 3 declaration is
-  forall {α : Sort.{u1}} {β : α -> Sort.{u2}}, Eq.{max 1 u1 u2} (Equiv.{max 1 u1 u2, max 1 u1 u2} (PSigma.{u1, u2} α (fun (a : α) => β a)) (PSigma.{u1, u2} α (fun (a : α) => β a))) (Equiv.psigmaCongrRight.{u1, u2, u2} α (fun (a : α) => β a) (fun (a : α) => β a) (fun (a : α) => Equiv.refl.{u2} (β a))) (Equiv.refl.{max 1 u1 u2} (PSigma.{u1, u2} α (fun (a : α) => β a)))
-but is expected to have type
-  forall {α : Sort.{u2}} {β : α -> Sort.{u1}}, Eq.{max (max 1 u2) u1} (Equiv.{max (max 1 u1) u2, max (max 1 u1) u2} (PSigma.{u2, u1} α (fun (a : α) => β a)) (PSigma.{u2, u1} α (fun (a : α) => β a))) (Equiv.psigmaCongrRight.{u2, u1, u1} α (fun (a : α) => β a) (fun (a : α) => β a) (fun (a : α) => Equiv.refl.{u1} (β a))) (Equiv.refl.{max (max 1 u1) u2} (PSigma.{u2, u1} α (fun (a : α) => β a)))
-Case conversion may be inaccurate. Consider using '#align equiv.psigma_congr_right_refl Equiv.psigmaCongrRight_reflₓ'. -/
 @[simp]
 theorem psigmaCongrRight_refl {α} {β : α → Sort _} :
     (psigmaCongrRight fun a => Equiv.refl (β a)) = Equiv.refl (Σ'a, β a) := by ext1 x; cases x; rfl
@@ -1224,12 +972,6 @@ def sigmaCongrRight {α} {β₁ β₂ : α → Type _} (F : ∀ a, β₁ a ≃ 
 #align equiv.sigma_congr_right Equiv.sigmaCongrRight
 -/
 
-/- warning: equiv.sigma_congr_right_trans -> Equiv.sigmaCongrRight_trans is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β₁ : α -> Type.{u2}} {β₂ : α -> Type.{u3}} {β₃ : α -> Type.{u4}} (F : forall (a : α), Equiv.{succ u2, succ u3} (β₁ a) (β₂ a)) (G : forall (a : α), Equiv.{succ u3, succ u4} (β₂ a) (β₃ a)), Eq.{max 1 (max (max (succ u1) (succ u2)) (succ u1) (succ u4)) (max (succ u1) (succ u4)) (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u4)} (Sigma.{u1, u2} α (fun (a : α) => β₁ a)) (Sigma.{u1, u4} α (fun (a : α) => β₃ a))) (Equiv.trans.{max (succ u1) (succ u2), max (succ u1) (succ u3), max (succ u1) (succ u4)} (Sigma.{u1, u2} α (fun (a : α) => β₁ a)) (Sigma.{u1, u3} α (fun (a : α) => β₂ a)) (Sigma.{u1, u4} α (fun (a : α) => β₃ a)) (Equiv.sigmaCongrRight.{u1, u2, u3} α (fun (a : α) => β₁ a) (fun (a : α) => β₂ a) F) (Equiv.sigmaCongrRight.{u1, u3, u4} α (fun (a : α) => β₂ a) (fun (a : α) => β₃ a) G)) (Equiv.sigmaCongrRight.{u1, u2, u4} α (fun (a : α) => β₁ a) (fun (a : α) => β₃ a) (fun (a : α) => Equiv.trans.{succ u2, succ u3, succ u4} (β₁ a) (β₂ a) (β₃ a) (F a) (G a)))
-but is expected to have type
-  forall {α : Type.{u4}} {β₁ : α -> Type.{u3}} {β₂ : α -> Type.{u2}} {β₃ : α -> Type.{u1}} (F : forall (a : α), Equiv.{succ u3, succ u2} (β₁ a) (β₂ a)) (G : forall (a : α), Equiv.{succ u2, succ u1} (β₂ a) (β₃ a)), Eq.{max (max (succ u3) (succ u1)) (succ u4)} (Equiv.{max (succ u3) (succ u4), max (succ u4) (succ u1)} (Sigma.{u4, u3} α (fun (a : α) => β₁ a)) (Sigma.{u4, u1} α (fun (a : α) => β₃ a))) (Equiv.trans.{max (succ u3) (succ u4), max (succ u2) (succ u4), max (succ u4) (succ u1)} (Sigma.{u4, u3} α (fun (a : α) => β₁ a)) (Sigma.{u4, u2} α (fun (a : α) => β₂ a)) (Sigma.{u4, u1} α (fun (a : α) => β₃ a)) (Equiv.sigmaCongrRight.{u4, u3, u2} α (fun (a : α) => β₁ a) (fun (a : α) => β₂ a) F) (Equiv.sigmaCongrRight.{u4, u2, u1} α (fun (a : α) => β₂ a) (fun (a : α) => β₃ a) G)) (Equiv.sigmaCongrRight.{u4, u3, u1} α (fun (a : α) => β₁ a) (fun (a : α) => β₃ a) (fun (a : α) => Equiv.trans.{succ u3, succ u2, succ u1} (β₁ a) (β₂ a) (β₃ a) (F a) (G a)))
-Case conversion may be inaccurate. Consider using '#align equiv.sigma_congr_right_trans Equiv.sigmaCongrRight_transₓ'. -/
 @[simp]
 theorem sigmaCongrRight_trans {α} {β₁ β₂ β₃ : α → Type _} (F : ∀ a, β₁ a ≃ β₂ a)
     (G : ∀ a, β₂ a ≃ β₃ a) :
@@ -1237,23 +979,11 @@ theorem sigmaCongrRight_trans {α} {β₁ β₂ β₃ : α → Type _} (F : ∀
   ext1 x; cases x; rfl
 #align equiv.sigma_congr_right_trans Equiv.sigmaCongrRight_trans
 
-/- warning: equiv.sigma_congr_right_symm -> Equiv.sigmaCongrRight_symm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β₁ : α -> Type.{u2}} {β₂ : α -> Type.{u3}} (F : forall (a : α), Equiv.{succ u2, succ u3} (β₁ a) (β₂ a)), Eq.{max 1 (max (max (succ u1) (succ u3)) (succ u1) (succ u2)) (max (succ u1) (succ u2)) (succ u1) (succ u3)} (Equiv.{max (succ u1) (succ u3), max (succ u1) (succ u2)} (Sigma.{u1, u3} α (fun (a : α) => β₂ a)) (Sigma.{u1, u2} α (fun (a : α) => β₁ a))) (Equiv.symm.{max (succ u1) (succ u2), max (succ u1) (succ u3)} (Sigma.{u1, u2} α (fun (a : α) => β₁ a)) (Sigma.{u1, u3} α (fun (a : α) => β₂ a)) (Equiv.sigmaCongrRight.{u1, u2, u3} α (fun (a : α) => β₁ a) (fun (a : α) => β₂ a) F)) (Equiv.sigmaCongrRight.{u1, u3, u2} α (fun (a : α) => β₂ a) (fun (a : α) => β₁ a) (fun (a : α) => Equiv.symm.{succ u2, succ u3} (β₁ a) (β₂ a) (F a)))
-but is expected to have type
-  forall {α : Type.{u3}} {β₁ : α -> Type.{u2}} {β₂ : α -> Type.{u1}} (F : forall (a : α), Equiv.{succ u2, succ u1} (β₁ a) (β₂ a)), Eq.{max (max (succ u2) (succ u1)) (succ u3)} (Equiv.{max (succ u1) (succ u3), max (succ u2) (succ u3)} (Sigma.{u3, u1} α (fun (a : α) => β₂ a)) (Sigma.{u3, u2} α (fun (a : α) => β₁ a))) (Equiv.symm.{max (succ u2) (succ u3), max (succ u1) (succ u3)} (Sigma.{u3, u2} α (fun (a : α) => β₁ a)) (Sigma.{u3, u1} α (fun (a : α) => β₂ a)) (Equiv.sigmaCongrRight.{u3, u2, u1} α (fun (a : α) => β₁ a) (fun (a : α) => β₂ a) F)) (Equiv.sigmaCongrRight.{u3, u1, u2} α (fun (a : α) => β₂ a) (fun (a : α) => β₁ a) (fun (a : α) => Equiv.symm.{succ u2, succ u1} (β₁ a) (β₂ a) (F a)))
-Case conversion may be inaccurate. Consider using '#align equiv.sigma_congr_right_symm Equiv.sigmaCongrRight_symmₓ'. -/
 @[simp]
 theorem sigmaCongrRight_symm {α} {β₁ β₂ : α → Type _} (F : ∀ a, β₁ a ≃ β₂ a) :
     (sigmaCongrRight F).symm = sigmaCongrRight fun a => (F a).symm := by ext1 x; cases x; rfl
 #align equiv.sigma_congr_right_symm Equiv.sigmaCongrRight_symm
 
-/- warning: equiv.sigma_congr_right_refl -> Equiv.sigmaCongrRight_refl is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : α -> Type.{u2}}, Eq.{max 1 (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Sigma.{u1, u2} α (fun (a : α) => β a)) (Sigma.{u1, u2} α (fun (a : α) => β a))) (Equiv.sigmaCongrRight.{u1, u2, u2} α (fun (a : α) => β a) (fun (a : α) => β a) (fun (a : α) => Equiv.refl.{succ u2} (β a))) (Equiv.refl.{max (succ u1) (succ u2)} (Sigma.{u1, u2} α (fun (a : α) => β a)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : α -> Type.{u1}}, Eq.{max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Sigma.{u2, u1} α (fun (a : α) => β a)) (Sigma.{u2, u1} α (fun (a : α) => β a))) (Equiv.sigmaCongrRight.{u2, u1, u1} α (fun (a : α) => β a) (fun (a : α) => β a) (fun (a : α) => Equiv.refl.{succ u1} (β a))) (Equiv.refl.{max (succ u1) (succ u2)} (Sigma.{u2, u1} α (fun (a : α) => β a)))
-Case conversion may be inaccurate. Consider using '#align equiv.sigma_congr_right_refl Equiv.sigmaCongrRight_reflₓ'. -/
 @[simp]
 theorem sigmaCongrRight_refl {α} {β : α → Type _} :
     (sigmaCongrRight fun a => Equiv.refl (β a)) = Equiv.refl (Σa, β a) := by ext1 x; cases x; rfl
@@ -1298,36 +1028,18 @@ def sigmaCongrRight {α} {β : α → Sort _} (F : ∀ a, Perm (β a)) : Perm (
 #align equiv.perm.sigma_congr_right Equiv.Perm.sigmaCongrRight
 -/
 
-/- warning: equiv.perm.sigma_congr_right_trans -> Equiv.Perm.sigmaCongrRight_trans is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : α -> Type.{u2}} (F : forall (a : α), Equiv.Perm.{succ u2} (β a)) (G : forall (a : α), Equiv.Perm.{succ u2} (β a)), Eq.{max 1 (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Sigma.{u1, u2} α (fun (a : α) => β a)) (Sigma.{u1, u2} α (fun (a : α) => β a))) (Equiv.trans.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Sigma.{u1, u2} α (fun (a : α) => β a)) (Sigma.{u1, u2} α (fun (a : α) => β a)) (Sigma.{u1, u2} α (fun (a : α) => β a)) (Equiv.Perm.sigmaCongrRight.{u1, u2} α (fun (a : α) => β a) F) (Equiv.Perm.sigmaCongrRight.{u1, u2} α (fun (a : α) => β a) G)) (Equiv.Perm.sigmaCongrRight.{u1, u2} α (fun (a : α) => β a) (fun (a : α) => Equiv.trans.{succ u2, succ u2, succ u2} (β a) (β a) (β a) (F a) (G a)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : α -> Type.{u1}} (F : forall (a : α), Equiv.Perm.{succ u1} (β a)) (G : forall (a : α), Equiv.Perm.{succ u1} (β a)), Eq.{max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Sigma.{u2, u1} α (fun (a : α) => β a)) (Sigma.{u2, u1} α (fun (a : α) => β a))) (Equiv.trans.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Sigma.{u2, u1} α (fun (a : α) => β a)) (Sigma.{u2, u1} α (fun (a : α) => β a)) (Sigma.{u2, u1} α (fun (a : α) => β a)) (Equiv.Perm.sigmaCongrRight.{u2, u1} α (fun (a : α) => β a) F) (Equiv.Perm.sigmaCongrRight.{u2, u1} α (fun (a : α) => β a) G)) (Equiv.Perm.sigmaCongrRight.{u2, u1} α (fun (a : α) => β a) (fun (a : α) => Equiv.trans.{succ u1, succ u1, succ u1} (β a) (β a) (β a) (F a) (G a)))
-Case conversion may be inaccurate. Consider using '#align equiv.perm.sigma_congr_right_trans Equiv.Perm.sigmaCongrRight_transₓ'. -/
 @[simp]
 theorem sigmaCongrRight_trans {α} {β : α → Sort _} (F : ∀ a, Perm (β a)) (G : ∀ a, Perm (β a)) :
     (sigmaCongrRight F).trans (sigmaCongrRight G) = sigmaCongrRight fun a => (F a).trans (G a) :=
   Equiv.sigmaCongrRight_trans F G
 #align equiv.perm.sigma_congr_right_trans Equiv.Perm.sigmaCongrRight_trans
 
-/- warning: equiv.perm.sigma_congr_right_symm -> Equiv.Perm.sigmaCongrRight_symm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : α -> Type.{u2}} (F : forall (a : α), Equiv.Perm.{succ u2} (β a)), Eq.{max 1 (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Sigma.{u1, u2} α (fun (a : α) => β a)) (Sigma.{u1, u2} α (fun (a : α) => β a))) (Equiv.symm.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Sigma.{u1, u2} α (fun (a : α) => β a)) (Sigma.{u1, u2} α (fun (a : α) => β a)) (Equiv.Perm.sigmaCongrRight.{u1, u2} α (fun (a : α) => β a) F)) (Equiv.Perm.sigmaCongrRight.{u1, u2} α (fun (a : α) => β a) (fun (a : α) => Equiv.symm.{succ u2, succ u2} (β a) (β a) (F a)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : α -> Type.{u1}} (F : forall (a : α), Equiv.Perm.{succ u1} (β a)), Eq.{max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Sigma.{u2, u1} α (fun (a : α) => β a)) (Sigma.{u2, u1} α (fun (a : α) => β a))) (Equiv.symm.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (Sigma.{u2, u1} α (fun (a : α) => β a)) (Sigma.{u2, u1} α (fun (a : α) => β a)) (Equiv.Perm.sigmaCongrRight.{u2, u1} α (fun (a : α) => β a) F)) (Equiv.Perm.sigmaCongrRight.{u2, u1} α (fun (a : α) => β a) (fun (a : α) => Equiv.symm.{succ u1, succ u1} (β a) (β a) (F a)))
-Case conversion may be inaccurate. Consider using '#align equiv.perm.sigma_congr_right_symm Equiv.Perm.sigmaCongrRight_symmₓ'. -/
 @[simp]
 theorem sigmaCongrRight_symm {α} {β : α → Sort _} (F : ∀ a, Perm (β a)) :
     (sigmaCongrRight F).symm = sigmaCongrRight fun a => (F a).symm :=
   Equiv.sigmaCongrRight_symm F
 #align equiv.perm.sigma_congr_right_symm Equiv.Perm.sigmaCongrRight_symm
 
-/- warning: equiv.perm.sigma_congr_right_refl -> Equiv.Perm.sigmaCongrRight_refl is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : α -> Type.{u2}}, Eq.{max 1 (succ u1) (succ u2)} (Equiv.Perm.{max (succ u1) (succ u2)} (Sigma.{u1, u2} α (fun (a : α) => β a))) (Equiv.Perm.sigmaCongrRight.{u1, u2} α (fun (a : α) => β a) (fun (a : α) => Equiv.refl.{succ u2} (β a))) (Equiv.refl.{max (succ u1) (succ u2)} (Sigma.{u1, u2} α (fun (a : α) => β a)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : α -> Type.{u1}}, Eq.{max (succ u1) (succ u2)} (Equiv.Perm.{max (succ u1) (succ u2)} (Sigma.{u2, u1} α (fun (a : α) => β a))) (Equiv.Perm.sigmaCongrRight.{u2, u1} α (fun (a : α) => β a) (fun (a : α) => Equiv.refl.{succ u1} (β a))) (Equiv.refl.{max (succ u1) (succ u2)} (Sigma.{u2, u1} α (fun (a : α) => β a)))
-Case conversion may be inaccurate. Consider using '#align equiv.perm.sigma_congr_right_refl Equiv.Perm.sigmaCongrRight_reflₓ'. -/
 @[simp]
 theorem sigmaCongrRight_refl {α} {β : α → Sort _} :
     (sigmaCongrRight fun a => Equiv.refl (β a)) = Equiv.refl (Σa, β a) :=
@@ -1336,12 +1048,6 @@ theorem sigmaCongrRight_refl {α} {β : α → Sort _} :
 
 end Perm
 
-/- warning: equiv.sigma_congr_left -> Equiv.sigmaCongrLeft is a dubious translation:
-lean 3 declaration is
-  forall {α₁ : Type.{u1}} {α₂ : Type.{u2}} {β : α₂ -> Type.{u3}} (e : Equiv.{succ u1, succ u2} α₁ α₂), Equiv.{max (succ u1) (succ u3), max (succ u2) (succ u3)} (Sigma.{u1, u3} α₁ (fun (a : α₁) => β (coeFn.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1), max (succ u1) (succ u2)} (Equiv.{succ u1, succ u2} α₁ α₂) (fun (_x : Equiv.{succ u1, succ u2} α₁ α₂) => α₁ -> α₂) (Equiv.hasCoeToFun.{succ u1, succ u2} α₁ α₂) e a))) (Sigma.{u2, u3} α₂ (fun (a : α₂) => β a))
-but is expected to have type
-  forall {α₁ : Type.{u1}} {α₂ : Type.{u2}} {β : α₁ -> Type.{u3}} (e : Equiv.{succ u2, succ u1} α₂ α₁), Equiv.{max (succ u3) (succ u2), max (succ u3) (succ u1)} (Sigma.{u2, u3} α₂ (fun (a : α₂) => β (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} (Equiv.{succ u2, succ u1} α₂ α₁) α₂ (fun (_x : α₂) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α₂) => α₁) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} α₂ α₁) e a))) (Sigma.{u1, u3} α₁ (fun (a : α₁) => β a))
-Case conversion may be inaccurate. Consider using '#align equiv.sigma_congr_left Equiv.sigmaCongrLeftₓ'. -/
 /-- An equivalence `f : α₁ ≃ α₂` generates an equivalence between `Σ a, β (f a)` and `Σ a, β a`. -/
 @[simps apply]
 def sigmaCongrLeft {α₁ α₂} {β : α₂ → Sort _} (e : α₁ ≃ α₂) : (Σa : α₁, β (e a)) ≃ Σa : α₂, β a :=
@@ -1458,12 +1164,6 @@ universe ua1 ua2 ub1 ub2 ug1 ug2
 variable {α₁ : Sort ua1} {α₂ : Sort ua2} {β₁ : Sort ub1} {β₂ : Sort ub2} {γ₁ : Sort ug1}
   {γ₂ : Sort ug2}
 
-/- warning: equiv.forall₂_congr -> Equiv.forall₂_congr is a dubious translation:
-lean 3 declaration is
-  forall {α₁ : Sort.{u1}} {α₂ : Sort.{u2}} {β₁ : Sort.{u3}} {β₂ : Sort.{u4}} {p : α₁ -> β₁ -> Prop} {q : α₂ -> β₂ -> Prop} (eα : Equiv.{u1, u2} α₁ α₂) (eβ : Equiv.{u3, u4} β₁ β₂), (forall {x : α₁} {y : β₁}, Iff (p x y) (q (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α₁ α₂) (fun (_x : Equiv.{u1, u2} α₁ α₂) => α₁ -> α₂) (Equiv.hasCoeToFun.{u1, u2} α₁ α₂) eα x) (coeFn.{max 1 (imax u3 u4) (imax u4 u3), imax u3 u4} (Equiv.{u3, u4} β₁ β₂) (fun (_x : Equiv.{u3, u4} β₁ β₂) => β₁ -> β₂) (Equiv.hasCoeToFun.{u3, u4} β₁ β₂) eβ y))) -> (Iff (forall (x : α₁) (y : β₁), p x y) (forall (x : α₂) (y : β₂), q x y))
-but is expected to have type
-  forall {α₁ : Sort.{u4}} {α₂ : Sort.{u3}} {β₁ : Sort.{u2}} {β₂ : Sort.{u1}} {p : α₁ -> α₂ -> Prop} {q : β₁ -> β₂ -> Prop} (eα : Equiv.{u4, u2} α₁ β₁) (eβ : Equiv.{u3, u1} α₂ β₂), (forall {x : α₁} {y : α₂}, Iff (p x y) (q (FunLike.coe.{max (max 1 u4) u2, u4, u2} (Equiv.{u4, u2} α₁ β₁) α₁ (fun (_x : α₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α₁) => β₁) _x) (Equiv.instFunLikeEquiv.{u4, u2} α₁ β₁) eα x) (FunLike.coe.{max (max 1 u3) u1, u3, u1} (Equiv.{u3, u1} α₂ β₂) α₂ (fun (_x : α₂) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α₂) => β₂) _x) (Equiv.instFunLikeEquiv.{u3, u1} α₂ β₂) eβ y))) -> (Iff (forall (x : α₁) (y : α₂), p x y) (forall (x : β₁) (y : β₂), q x y))
-Case conversion may be inaccurate. Consider using '#align equiv.forall₂_congr Equiv.forall₂_congrₓ'. -/
 protected theorem forall₂_congr {p : α₁ → β₁ → Prop} {q : α₂ → β₂ → Prop} (eα : α₁ ≃ α₂)
     (eβ : β₁ ≃ β₂) (h : ∀ {x y}, p x y ↔ q (eα x) (eβ y)) : (∀ x y, p x y) ↔ ∀ x y, q x y :=
   by
@@ -1474,24 +1174,12 @@ protected theorem forall₂_congr {p : α₁ → β₁ → Prop} {q : α₂ →
   apply h
 #align equiv.forall₂_congr Equiv.forall₂_congr
 
-/- warning: equiv.forall₂_congr' -> Equiv.forall₂_congr' is a dubious translation:
-lean 3 declaration is
-  forall {α₁ : Sort.{u1}} {α₂ : Sort.{u2}} {β₁ : Sort.{u3}} {β₂ : Sort.{u4}} {p : α₁ -> β₁ -> Prop} {q : α₂ -> β₂ -> Prop} (eα : Equiv.{u1, u2} α₁ α₂) (eβ : Equiv.{u3, u4} β₁ β₂), (forall {x : α₂} {y : β₂}, Iff (p (coeFn.{max 1 (imax u2 u1) (imax u1 u2), imax u2 u1} (Equiv.{u2, u1} α₂ α₁) (fun (_x : Equiv.{u2, u1} α₂ α₁) => α₂ -> α₁) (Equiv.hasCoeToFun.{u2, u1} α₂ α₁) (Equiv.symm.{u1, u2} α₁ α₂ eα) x) (coeFn.{max 1 (imax u4 u3) (imax u3 u4), imax u4 u3} (Equiv.{u4, u3} β₂ β₁) (fun (_x : Equiv.{u4, u3} β₂ β₁) => β₂ -> β₁) (Equiv.hasCoeToFun.{u4, u3} β₂ β₁) (Equiv.symm.{u3, u4} β₁ β₂ eβ) y)) (q x y)) -> (Iff (forall (x : α₁) (y : β₁), p x y) (forall (x : α₂) (y : β₂), q x y))
-but is expected to have type
-  forall {α₁ : Sort.{u4}} {α₂ : Sort.{u3}} {β₁ : Sort.{u2}} {β₂ : Sort.{u1}} {p : α₁ -> α₂ -> Prop} {q : β₁ -> β₂ -> Prop} (eα : Equiv.{u4, u2} α₁ β₁) (eβ : Equiv.{u3, u1} α₂ β₂), (forall {x : β₁} {y : β₂}, Iff (p (FunLike.coe.{max (max 1 u4) u2, u2, u4} (Equiv.{u2, u4} β₁ α₁) β₁ (fun (_x : β₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β₁) => α₁) _x) (Equiv.instFunLikeEquiv.{u2, u4} β₁ α₁) (Equiv.symm.{u4, u2} α₁ β₁ eα) x) (FunLike.coe.{max (max 1 u3) u1, u1, u3} (Equiv.{u1, u3} β₂ α₂) β₂ (fun (_x : β₂) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β₂) => α₂) _x) (Equiv.instFunLikeEquiv.{u1, u3} β₂ α₂) (Equiv.symm.{u3, u1} α₂ β₂ eβ) y)) (q x y)) -> (Iff (forall (x : α₁) (y : α₂), p x y) (forall (x : β₁) (y : β₂), q x y))
-Case conversion may be inaccurate. Consider using '#align equiv.forall₂_congr' Equiv.forall₂_congr'ₓ'. -/
 protected theorem forall₂_congr' {p : α₁ → β₁ → Prop} {q : α₂ → β₂ → Prop} (eα : α₁ ≃ α₂)
     (eβ : β₁ ≃ β₂) (h : ∀ {x y}, p (eα.symm x) (eβ.symm y) ↔ q x y) :
     (∀ x y, p x y) ↔ ∀ x y, q x y :=
   (Equiv.forall₂_congr eα.symm eβ.symm fun x y => h.symm).symm
 #align equiv.forall₂_congr' Equiv.forall₂_congr'
 
-/- warning: equiv.forall₃_congr -> Equiv.forall₃_congr is a dubious translation:
-lean 3 declaration is
-  forall {α₁ : Sort.{u1}} {α₂ : Sort.{u2}} {β₁ : Sort.{u3}} {β₂ : Sort.{u4}} {γ₁ : Sort.{u5}} {γ₂ : Sort.{u6}} {p : α₁ -> β₁ -> γ₁ -> Prop} {q : α₂ -> β₂ -> γ₂ -> Prop} (eα : Equiv.{u1, u2} α₁ α₂) (eβ : Equiv.{u3, u4} β₁ β₂) (eγ : Equiv.{u5, u6} γ₁ γ₂), (forall {x : α₁} {y : β₁} {z : γ₁}, Iff (p x y z) (q (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α₁ α₂) (fun (_x : Equiv.{u1, u2} α₁ α₂) => α₁ -> α₂) (Equiv.hasCoeToFun.{u1, u2} α₁ α₂) eα x) (coeFn.{max 1 (imax u3 u4) (imax u4 u3), imax u3 u4} (Equiv.{u3, u4} β₁ β₂) (fun (_x : Equiv.{u3, u4} β₁ β₂) => β₁ -> β₂) (Equiv.hasCoeToFun.{u3, u4} β₁ β₂) eβ y) (coeFn.{max 1 (imax u5 u6) (imax u6 u5), imax u5 u6} (Equiv.{u5, u6} γ₁ γ₂) (fun (_x : Equiv.{u5, u6} γ₁ γ₂) => γ₁ -> γ₂) (Equiv.hasCoeToFun.{u5, u6} γ₁ γ₂) eγ z))) -> (Iff (forall (x : α₁) (y : β₁) (z : γ₁), p x y z) (forall (x : α₂) (y : β₂) (z : γ₂), q x y z))
-but is expected to have type
-  forall {α₁ : Sort.{u6}} {α₂ : Sort.{u5}} {β₁ : Sort.{u4}} {β₂ : Sort.{u3}} {γ₁ : Sort.{u2}} {γ₂ : Sort.{u1}} {p : α₁ -> α₂ -> β₁ -> Prop} {q : β₂ -> γ₁ -> γ₂ -> Prop} (eα : Equiv.{u6, u3} α₁ β₂) (eβ : Equiv.{u5, u2} α₂ γ₁) (eγ : Equiv.{u4, u1} β₁ γ₂), (forall {x : α₁} {y : α₂} {z : β₁}, Iff (p x y z) (q (FunLike.coe.{max (max 1 u6) u3, u6, u3} (Equiv.{u6, u3} α₁ β₂) α₁ (fun (_x : α₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α₁) => β₂) _x) (Equiv.instFunLikeEquiv.{u6, u3} α₁ β₂) eα x) (FunLike.coe.{max (max 1 u5) u2, u5, u2} (Equiv.{u5, u2} α₂ γ₁) α₂ (fun (_x : α₂) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α₂) => γ₁) _x) (Equiv.instFunLikeEquiv.{u5, u2} α₂ γ₁) eβ y) (FunLike.coe.{max (max 1 u4) u1, u4, u1} (Equiv.{u4, u1} β₁ γ₂) β₁ (fun (_x : β₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β₁) => γ₂) _x) (Equiv.instFunLikeEquiv.{u4, u1} β₁ γ₂) eγ z))) -> (Iff (forall (x : α₁) (y : α₂) (z : β₁), p x y z) (forall (x : β₂) (y : γ₁) (z : γ₂), q x y z))
-Case conversion may be inaccurate. Consider using '#align equiv.forall₃_congr Equiv.forall₃_congrₓ'. -/
 protected theorem forall₃_congr {p : α₁ → β₁ → γ₁ → Prop} {q : α₂ → β₂ → γ₂ → Prop} (eα : α₁ ≃ α₂)
     (eβ : β₁ ≃ β₂) (eγ : γ₁ ≃ γ₂) (h : ∀ {x y z}, p x y z ↔ q (eα x) (eβ y) (eγ z)) :
     (∀ x y z, p x y z) ↔ ∀ x y z, q x y z :=
@@ -1503,12 +1191,6 @@ protected theorem forall₃_congr {p : α₁ → β₁ → γ₁ → Prop} {q :
   apply h
 #align equiv.forall₃_congr Equiv.forall₃_congr
 
-/- warning: equiv.forall₃_congr' -> Equiv.forall₃_congr' is a dubious translation:
-lean 3 declaration is
-  forall {α₁ : Sort.{u1}} {α₂ : Sort.{u2}} {β₁ : Sort.{u3}} {β₂ : Sort.{u4}} {γ₁ : Sort.{u5}} {γ₂ : Sort.{u6}} {p : α₁ -> β₁ -> γ₁ -> Prop} {q : α₂ -> β₂ -> γ₂ -> Prop} (eα : Equiv.{u1, u2} α₁ α₂) (eβ : Equiv.{u3, u4} β₁ β₂) (eγ : Equiv.{u5, u6} γ₁ γ₂), (forall {x : α₂} {y : β₂} {z : γ₂}, Iff (p (coeFn.{max 1 (imax u2 u1) (imax u1 u2), imax u2 u1} (Equiv.{u2, u1} α₂ α₁) (fun (_x : Equiv.{u2, u1} α₂ α₁) => α₂ -> α₁) (Equiv.hasCoeToFun.{u2, u1} α₂ α₁) (Equiv.symm.{u1, u2} α₁ α₂ eα) x) (coeFn.{max 1 (imax u4 u3) (imax u3 u4), imax u4 u3} (Equiv.{u4, u3} β₂ β₁) (fun (_x : Equiv.{u4, u3} β₂ β₁) => β₂ -> β₁) (Equiv.hasCoeToFun.{u4, u3} β₂ β₁) (Equiv.symm.{u3, u4} β₁ β₂ eβ) y) (coeFn.{max 1 (imax u6 u5) (imax u5 u6), imax u6 u5} (Equiv.{u6, u5} γ₂ γ₁) (fun (_x : Equiv.{u6, u5} γ₂ γ₁) => γ₂ -> γ₁) (Equiv.hasCoeToFun.{u6, u5} γ₂ γ₁) (Equiv.symm.{u5, u6} γ₁ γ₂ eγ) z)) (q x y z)) -> (Iff (forall (x : α₁) (y : β₁) (z : γ₁), p x y z) (forall (x : α₂) (y : β₂) (z : γ₂), q x y z))
-but is expected to have type
-  forall {α₁ : Sort.{u6}} {α₂ : Sort.{u5}} {β₁ : Sort.{u4}} {β₂ : Sort.{u3}} {γ₁ : Sort.{u2}} {γ₂ : Sort.{u1}} {p : α₁ -> α₂ -> β₁ -> Prop} {q : β₂ -> γ₁ -> γ₂ -> Prop} (eα : Equiv.{u6, u3} α₁ β₂) (eβ : Equiv.{u5, u2} α₂ γ₁) (eγ : Equiv.{u4, u1} β₁ γ₂), (forall {x : β₂} {y : γ₁} {z : γ₂}, Iff (p (FunLike.coe.{max (max 1 u6) u3, u3, u6} (Equiv.{u3, u6} β₂ α₁) β₂ (fun (_x : β₂) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β₂) => α₁) _x) (Equiv.instFunLikeEquiv.{u3, u6} β₂ α₁) (Equiv.symm.{u6, u3} α₁ β₂ eα) x) (FunLike.coe.{max (max 1 u5) u2, u2, u5} (Equiv.{u2, u5} γ₁ α₂) γ₁ (fun (_x : γ₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : γ₁) => α₂) _x) (Equiv.instFunLikeEquiv.{u2, u5} γ₁ α₂) (Equiv.symm.{u5, u2} α₂ γ₁ eβ) y) (FunLike.coe.{max (max 1 u4) u1, u1, u4} (Equiv.{u1, u4} γ₂ β₁) γ₂ (fun (_x : γ₂) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : γ₂) => β₁) _x) (Equiv.instFunLikeEquiv.{u1, u4} γ₂ β₁) (Equiv.symm.{u4, u1} β₁ γ₂ eγ) z)) (q x y z)) -> (Iff (forall (x : α₁) (y : α₂) (z : β₁), p x y z) (forall (x : β₂) (y : γ₁) (z : γ₂), q x y z))
-Case conversion may be inaccurate. Consider using '#align equiv.forall₃_congr' Equiv.forall₃_congr'ₓ'. -/
 protected theorem forall₃_congr' {p : α₁ → β₁ → γ₁ → Prop} {q : α₂ → β₂ → γ₂ → Prop} (eα : α₁ ≃ α₂)
     (eβ : β₁ ≃ β₂) (eγ : γ₁ ≃ γ₂) (h : ∀ {x y z}, p (eα.symm x) (eβ.symm y) (eγ.symm z) ↔ q x y z) :
     (∀ x y z, p x y z) ↔ ∀ x y z, q x y z :=
@@ -1527,12 +1209,6 @@ protected theorem forall_congr_left {p : β → Prop} (f : α ≃ β) : (∀ x,
 #align equiv.forall_congr_left Equiv.forall_congr_left
 -/
 
-/- warning: equiv.exists_congr_left -> Equiv.exists_congr_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Sort.{u1}} {β : Sort.{u2}} (f : Equiv.{u1, u2} α β) {p : α -> Prop}, Iff (Exists.{u1} α (fun (a : α) => p a)) (Exists.{u2} β (fun (b : β) => p (coeFn.{max 1 (imax u2 u1) (imax u1 u2), imax u2 u1} (Equiv.{u2, u1} β α) (fun (_x : Equiv.{u2, u1} β α) => β -> α) (Equiv.hasCoeToFun.{u2, u1} β α) (Equiv.symm.{u1, u2} α β f) b)))
-but is expected to have type
-  forall {α : Sort.{u2}} {β : Sort.{u1}} (f : Equiv.{u2, u1} α β) {p : α -> Prop}, Iff (Exists.{u2} α (fun (a : α) => p a)) (Exists.{u1} β (fun (b : β) => p (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => α) _x) (Equiv.instFunLikeEquiv.{u1, u2} β α) (Equiv.symm.{u2, u1} α β f) b)))
-Case conversion may be inaccurate. Consider using '#align equiv.exists_congr_left Equiv.exists_congr_leftₓ'. -/
 protected theorem exists_congr_left {α β} (f : α ≃ β) {p : α → Prop} :
     (∃ a, p a) ↔ ∃ b, p (f.symm b) :=
   ⟨fun ⟨a, h⟩ => ⟨f a, by simpa using h⟩, fun ⟨b, h⟩ => ⟨_, h⟩⟩

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -101,10 +101,7 @@ instance : EquivLike (α ≃ β) α β where
   inv := invFun
   left_inv := left_inv
   right_inv := right_inv
-  coe_injective' e₁ e₂ h₁ h₂ := by
-    cases e₁
-    cases e₂
-    congr
+  coe_injective' e₁ e₂ h₁ h₂ := by cases e₁; cases e₂; congr
 
 instance : CoeFun (α ≃ β) fun _ => α → β :=
   ⟨toFun⟩
@@ -344,11 +341,7 @@ protected def unique [Unique β] (e : α ≃ β) : Unique α :=
 #print Equiv.cast /-
 /-- Equivalence between equal types. -/
 protected def cast {α β : Sort _} (h : α = β) : α ≃ β :=
-  ⟨cast h, cast h.symm, fun x => by
-    cases h
-    rfl, fun x => by
-    cases h
-    rfl⟩
+  ⟨cast h, cast h.symm, fun x => by cases h; rfl, fun x => by cases h; rfl⟩
 #align equiv.cast Equiv.cast
 -/
 
@@ -480,17 +473,13 @@ theorem cast_refl {α} (h : α = α := rfl) : Equiv.cast h = Equiv.refl α :=
 @[simp]
 theorem cast_trans {α β γ} (h : α = β) (h2 : β = γ) :
     (Equiv.cast h).trans (Equiv.cast h2) = Equiv.cast (h.trans h2) :=
-  ext fun x => by
-    substs h h2
-    rfl
+  ext fun x => by substs h h2; rfl
 #align equiv.cast_trans Equiv.cast_trans
 -/
 
 #print Equiv.cast_eq_iff_heq /-
-theorem cast_eq_iff_heq {α β} (h : α = β) {a : α} {b : β} : Equiv.cast h a = b ↔ HEq a b :=
-  by
-  subst h
-  simp
+theorem cast_eq_iff_heq {α β} (h : α = β) {a : α} {b : β} : Equiv.cast h a = b ↔ HEq a b := by
+  subst h; simp
 #align equiv.cast_eq_iff_heq Equiv.cast_eq_iff_heq
 -/
 
@@ -521,10 +510,7 @@ but is expected to have type
   forall {α : Sort.{u1}} {β : Sort.{u2}} (e : Equiv.{u1, u2} α β), Eq.{max (max 1 u1) u2} (Equiv.{u1, u2} α β) (Equiv.symm.{u2, u1} β α (Equiv.symm.{u1, u2} α β e)) e
 Case conversion may be inaccurate. Consider using '#align equiv.symm_symm Equiv.symm_symmₓ'. -/
 @[simp]
-theorem symm_symm (e : α ≃ β) : e.symm.symm = e :=
-  by
-  cases e
-  rfl
+theorem symm_symm (e : α ≃ β) : e.symm.symm = e := by cases e; rfl
 #align equiv.symm_symm Equiv.symm_symm
 
 /- warning: equiv.trans_refl -> Equiv.trans_refl is a dubious translation:
@@ -534,10 +520,7 @@ but is expected to have type
   forall {α : Sort.{u1}} {β : Sort.{u2}} (e : Equiv.{u1, u2} α β), Eq.{max (max 1 u1) u2} (Equiv.{u1, u2} α β) (Equiv.trans.{u1, u2, u2} α β β e (Equiv.refl.{u2} β)) e
 Case conversion may be inaccurate. Consider using '#align equiv.trans_refl Equiv.trans_reflₓ'. -/
 @[simp]
-theorem trans_refl (e : α ≃ β) : e.trans (Equiv.refl β) = e :=
-  by
-  cases e
-  rfl
+theorem trans_refl (e : α ≃ β) : e.trans (Equiv.refl β) = e := by cases e; rfl
 #align equiv.trans_refl Equiv.trans_refl
 
 #print Equiv.refl_symm /-
@@ -554,10 +537,7 @@ but is expected to have type
   forall {α : Sort.{u1}} {β : Sort.{u2}} (e : Equiv.{u1, u2} α β), Eq.{max (max 1 u1) u2} (Equiv.{u1, u2} α β) (Equiv.trans.{u1, u1, u2} α α β (Equiv.refl.{u1} α) e) e
 Case conversion may be inaccurate. Consider using '#align equiv.refl_trans Equiv.refl_transₓ'. -/
 @[simp]
-theorem refl_trans (e : α ≃ β) : (Equiv.refl α).trans e = e :=
-  by
-  cases e
-  rfl
+theorem refl_trans (e : α ≃ β) : (Equiv.refl α).trans e = e := by cases e; rfl
 #align equiv.refl_trans Equiv.refl_trans
 
 #print Equiv.symm_trans_self /-
@@ -642,12 +622,8 @@ Case conversion may be inaccurate. Consider using '#align equiv.equiv_congr Equi
 /-- If `α` is equivalent to `β` and `γ` is equivalent to `δ`, then the type of equivalences `α ≃ γ`
 is equivalent to the type of equivalences `β ≃ δ`. -/
 def equivCongr {δ} (ab : α ≃ β) (cd : γ ≃ δ) : α ≃ γ ≃ (β ≃ δ) :=
-  ⟨fun ac => (ab.symm.trans ac).trans cd, fun bd => ab.trans <| bd.trans <| cd.symm, fun ac =>
-    by
-    ext x
-    simp, fun ac => by
-    ext x
-    simp⟩
+  ⟨fun ac => (ab.symm.trans ac).trans cd, fun bd => ab.trans <| bd.trans <| cd.symm, fun ac => by
+    ext x; simp, fun ac => by ext x; simp⟩
 #align equiv.equiv_congr Equiv.equivCongr
 
 /- warning: equiv.equiv_congr_refl -> Equiv.equivCongr_refl is a dubious translation:
@@ -657,10 +633,8 @@ but is expected to have type
   forall {α : Sort.{u2}} {β : Sort.{u1}}, Eq.{max (max 1 u2) u1} (Equiv.{max (max 1 u1) u2, max (max 1 u1) u2} (Equiv.{u2, u1} α β) (Equiv.{u2, u1} α β)) (Equiv.equivCongr.{u2, u2, u1, u1} α α β β (Equiv.refl.{u2} α) (Equiv.refl.{u1} β)) (Equiv.refl.{max (max 1 u1) u2} (Equiv.{u2, u1} α β))
 Case conversion may be inaccurate. Consider using '#align equiv.equiv_congr_refl Equiv.equivCongr_reflₓ'. -/
 @[simp]
-theorem equivCongr_refl {α β} : (Equiv.refl α).equivCongr (Equiv.refl β) = Equiv.refl (α ≃ β) :=
-  by
-  ext
-  rfl
+theorem equivCongr_refl {α β} : (Equiv.refl α).equivCongr (Equiv.refl β) = Equiv.refl (α ≃ β) := by
+  ext; rfl
 #align equiv.equiv_congr_refl Equiv.equivCongr_refl
 
 /- warning: equiv.equiv_congr_symm -> Equiv.equivCongr_symm is a dubious translation:
@@ -671,10 +645,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align equiv.equiv_congr_symm Equiv.equivCongr_symmₓ'. -/
 @[simp]
 theorem equivCongr_symm {δ} (ab : α ≃ β) (cd : γ ≃ δ) :
-    (ab.equivCongr cd).symm = ab.symm.equivCongr cd.symm :=
-  by
-  ext
-  rfl
+    (ab.equivCongr cd).symm = ab.symm.equivCongr cd.symm := by ext; rfl
 #align equiv.equiv_congr_symm Equiv.equivCongr_symm
 
 /- warning: equiv.equiv_congr_trans -> Equiv.equivCongr_trans is a dubious translation:
@@ -685,9 +656,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align equiv.equiv_congr_trans Equiv.equivCongr_transₓ'. -/
 @[simp]
 theorem equivCongr_trans {δ ε ζ} (ab : α ≃ β) (de : δ ≃ ε) (bc : β ≃ γ) (ef : ε ≃ ζ) :
-    (ab.equivCongr de).trans (bc.equivCongr ef) = (ab.trans bc).equivCongr (de.trans ef) :=
-  by
-  ext
+    (ab.equivCongr de).trans (bc.equivCongr ef) = (ab.trans bc).equivCongr (de.trans ef) := by ext;
   rfl
 #align equiv.equiv_congr_trans Equiv.equivCongr_trans
 
@@ -789,10 +758,7 @@ but is expected to have type
   forall {α' : Type.{u2}} {β' : Type.{u1}} (e : Equiv.{succ u2, succ u1} α' β') (p : Equiv.Perm.{succ u2} α') (p' : Equiv.Perm.{succ u2} α'), Eq.{succ u1} (Equiv.{succ u1, succ u1} β' β') (Equiv.trans.{succ u1, succ u1, succ u1} β' β' β' (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.Perm.{succ u2} α') (fun (_x : Equiv.Perm.{succ u2} α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.permCongr.{u2, u1} α' β' e) p) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.Perm.{succ u2} α') (fun (_x : Equiv.Perm.{succ u2} α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.permCongr.{u2, u1} α' β' e) p')) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.Perm.{succ u2} α') (fun (_x : Equiv.Perm.{succ u2} α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.permCongr.{u2, u1} α' β' e) (Equiv.trans.{succ u2, succ u2, succ u2} α' α' α' p p'))
 Case conversion may be inaccurate. Consider using '#align equiv.perm_congr_trans Equiv.permCongr_transₓ'. -/
 theorem permCongr_trans (p p' : Equiv.Perm α') :
-    (e.permCongr p).trans (e.permCongr p') = e.permCongr (p.trans p') :=
-  by
-  ext
-  simp
+    (e.permCongr p).trans (e.permCongr p') = e.permCongr (p.trans p') := by ext; simp
 #align equiv.perm_congr_trans Equiv.permCongr_trans
 
 end PermCongr
@@ -917,9 +883,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align equiv.arrow_congr_comp Equiv.arrowCongr_compₓ'. -/
 theorem arrowCongr_comp {α₁ β₁ γ₁ α₂ β₂ γ₂ : Sort _} (ea : α₁ ≃ α₂) (eb : β₁ ≃ β₂) (ec : γ₁ ≃ γ₂)
     (f : α₁ → β₁) (g : β₁ → γ₁) :
-    arrowCongr ea ec (g ∘ f) = arrowCongr eb ec g ∘ arrowCongr ea eb f :=
-  by
-  ext
+    arrowCongr ea ec (g ∘ f) = arrowCongr eb ec g ∘ arrowCongr ea eb f := by ext;
   simp only [comp, arrow_congr_apply, eb.symm_apply_apply]
 #align equiv.arrow_congr_comp Equiv.arrowCongr_comp
 
@@ -1098,12 +1062,7 @@ theorem symm_comp_eq {α β γ} (e : α ≃ β) (f : γ → α) (g : γ → β)
 #print Equiv.punitEquivPUnit /-
 /-- `punit` sorts in any two universes are equivalent. -/
 def punitEquivPUnit : PUnit.{v} ≃ PUnit.{w} :=
-  ⟨fun _ => PUnit.unit, fun _ => PUnit.unit, fun u =>
-    by
-    cases u
-    rfl, fun u => by
-    cases u
-    rfl⟩
+  ⟨fun _ => PUnit.unit, fun _ => PUnit.unit, fun u => by cases u; rfl, fun u => by cases u; rfl⟩
 #align equiv.punit_equiv_punit Equiv.punitEquivPUnit
 -/
 
@@ -1119,13 +1078,8 @@ section
 #print Equiv.arrowPUnitEquivPUnit /-
 /-- The sort of maps to `punit.{v}` is equivalent to `punit.{w}`. -/
 def arrowPUnitEquivPUnit (α : Sort _) : (α → PUnit.{v}) ≃ PUnit.{w} :=
-  ⟨fun f => PUnit.unit, fun u f => PUnit.unit, fun f =>
-    by
-    funext x
-    cases f x
-    rfl, fun u => by
-    cases u
-    rfl⟩
+  ⟨fun f => PUnit.unit, fun u f => PUnit.unit, fun f => by funext x; cases f x; rfl, fun u => by
+    cases u; rfl⟩
 #align equiv.arrow_punit_equiv_punit Equiv.arrowPUnitEquivPUnit
 -/
 
@@ -1137,10 +1091,7 @@ def piSubsingleton {α} (β : α → Sort _) [Subsingleton α] (a : α) : (∀ a
     where
   toFun := eval a
   invFun x b := cast (congr_arg β <| Subsingleton.elim a b) x
-  left_inv f :=
-    funext fun b => by
-      rw [Subsingleton.elim b a]
-      rfl
+  left_inv f := funext fun b => by rw [Subsingleton.elim b a]; rfl
   right_inv b := rfl
 #align equiv.Pi_subsingleton Equiv.piSubsingleton
 -/
@@ -1170,10 +1121,7 @@ def trueArrowEquiv (α : Sort _) : (True → α) ≃ α :=
 #print Equiv.arrowPUnitOfIsEmpty /-
 /-- The sort of maps from a type that `is_empty` is equivalent to `punit`. -/
 def arrowPUnitOfIsEmpty (α β : Sort _) [IsEmpty α] : (α → β) ≃ PUnit.{u} :=
-  ⟨fun f => PUnit.unit, fun u => isEmptyElim, fun f => funext isEmptyElim, fun u =>
-    by
-    cases u
-    rfl⟩
+  ⟨fun f => PUnit.unit, fun u => isEmptyElim, fun f => funext isEmptyElim, fun u => by cases u; rfl⟩
 #align equiv.arrow_punit_of_is_empty Equiv.arrowPUnitOfIsEmpty
 -/
 
@@ -1240,10 +1188,7 @@ Case conversion may be inaccurate. Consider using '#align equiv.psigma_congr_rig
 theorem psigmaCongrRight_trans {α} {β₁ β₂ β₃ : α → Sort _} (F : ∀ a, β₁ a ≃ β₂ a)
     (G : ∀ a, β₂ a ≃ β₃ a) :
     (psigmaCongrRight F).trans (psigmaCongrRight G) = psigmaCongrRight fun a => (F a).trans (G a) :=
-  by
-  ext1 x
-  cases x
-  rfl
+  by ext1 x; cases x; rfl
 #align equiv.psigma_congr_right_trans Equiv.psigmaCongrRight_trans
 
 /- warning: equiv.psigma_congr_right_symm -> Equiv.psigmaCongrRight_symm is a dubious translation:
@@ -1254,11 +1199,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align equiv.psigma_congr_right_symm Equiv.psigmaCongrRight_symmₓ'. -/
 @[simp]
 theorem psigmaCongrRight_symm {α} {β₁ β₂ : α → Sort _} (F : ∀ a, β₁ a ≃ β₂ a) :
-    (psigmaCongrRight F).symm = psigmaCongrRight fun a => (F a).symm :=
-  by
-  ext1 x
-  cases x
-  rfl
+    (psigmaCongrRight F).symm = psigmaCongrRight fun a => (F a).symm := by ext1 x; cases x; rfl
 #align equiv.psigma_congr_right_symm Equiv.psigmaCongrRight_symm
 
 /- warning: equiv.psigma_congr_right_refl -> Equiv.psigmaCongrRight_refl is a dubious translation:
@@ -1269,11 +1210,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align equiv.psigma_congr_right_refl Equiv.psigmaCongrRight_reflₓ'. -/
 @[simp]
 theorem psigmaCongrRight_refl {α} {β : α → Sort _} :
-    (psigmaCongrRight fun a => Equiv.refl (β a)) = Equiv.refl (Σ'a, β a) :=
-  by
-  ext1 x
-  cases x
-  rfl
+    (psigmaCongrRight fun a => Equiv.refl (β a)) = Equiv.refl (Σ'a, β a) := by ext1 x; cases x; rfl
 #align equiv.psigma_congr_right_refl Equiv.psigmaCongrRight_refl
 
 #print Equiv.sigmaCongrRight /-
@@ -1296,11 +1233,8 @@ Case conversion may be inaccurate. Consider using '#align equiv.sigma_congr_righ
 @[simp]
 theorem sigmaCongrRight_trans {α} {β₁ β₂ β₃ : α → Type _} (F : ∀ a, β₁ a ≃ β₂ a)
     (G : ∀ a, β₂ a ≃ β₃ a) :
-    (sigmaCongrRight F).trans (sigmaCongrRight G) = sigmaCongrRight fun a => (F a).trans (G a) :=
-  by
-  ext1 x
-  cases x
-  rfl
+    (sigmaCongrRight F).trans (sigmaCongrRight G) = sigmaCongrRight fun a => (F a).trans (G a) := by
+  ext1 x; cases x; rfl
 #align equiv.sigma_congr_right_trans Equiv.sigmaCongrRight_trans
 
 /- warning: equiv.sigma_congr_right_symm -> Equiv.sigmaCongrRight_symm is a dubious translation:
@@ -1311,11 +1245,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align equiv.sigma_congr_right_symm Equiv.sigmaCongrRight_symmₓ'. -/
 @[simp]
 theorem sigmaCongrRight_symm {α} {β₁ β₂ : α → Type _} (F : ∀ a, β₁ a ≃ β₂ a) :
-    (sigmaCongrRight F).symm = sigmaCongrRight fun a => (F a).symm :=
-  by
-  ext1 x
-  cases x
-  rfl
+    (sigmaCongrRight F).symm = sigmaCongrRight fun a => (F a).symm := by ext1 x; cases x; rfl
 #align equiv.sigma_congr_right_symm Equiv.sigmaCongrRight_symm
 
 /- warning: equiv.sigma_congr_right_refl -> Equiv.sigmaCongrRight_refl is a dubious translation:
@@ -1326,11 +1256,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align equiv.sigma_congr_right_refl Equiv.sigmaCongrRight_reflₓ'. -/
 @[simp]
 theorem sigmaCongrRight_refl {α} {β : α → Type _} :
-    (sigmaCongrRight fun a => Equiv.refl (β a)) = Equiv.refl (Σa, β a) :=
-  by
-  ext1 x
-  cases x
-  rfl
+    (sigmaCongrRight fun a => Equiv.refl (β a)) = Equiv.refl (Σa, β a) := by ext1 x; cases x; rfl
 #align equiv.sigma_congr_right_refl Equiv.sigmaCongrRight_refl
 
 #print Equiv.psigmaEquivSubtype /-
@@ -1339,12 +1265,8 @@ def psigmaEquivSubtype {α : Type v} (P : α → Prop) : (Σ'i, P i) ≃ Subtype
     where
   toFun x := ⟨x.1, x.2⟩
   invFun x := ⟨x.1, x.2⟩
-  left_inv x := by
-    cases x
-    rfl
-  right_inv x := by
-    cases x
-    rfl
+  left_inv x := by cases x; rfl
+  right_inv x := by cases x; rfl
 #align equiv.psigma_equiv_subtype Equiv.psigmaEquivSubtype
 -/
 
@@ -1513,9 +1435,7 @@ protected theorem forall_congr {p : α → Prop} {q : β → Prop} (f : α ≃ 
     (h : ∀ {x}, p x ↔ q (f x)) : (∀ x, p x) ↔ ∀ y, q y :=
   by
   constructor <;> intro h₂ x
-  · rw [← f.right_inv x]
-    apply h.mp
-    apply h₂
+  · rw [← f.right_inv x]; apply h.mp; apply h₂
   apply h.mpr; apply h₂
 #align equiv.forall_congr Equiv.forall_congr
 -/
@@ -1633,14 +1553,8 @@ protected def congr {ra : α → α → Prop} {rb : β → β → Prop} (e : α
     Quot.map e.symm fun b₁ b₂ h =>
       (Eq (e.symm b₁) (e.symm b₂)).2
         ((e.apply_symm_apply b₁).symm ▸ (e.apply_symm_apply b₂).symm ▸ h)
-  left_inv := by
-    rintro ⟨a⟩
-    dsimp only [Quot.map]
-    simp only [Equiv.symm_apply_apply]
-  right_inv := by
-    rintro ⟨a⟩
-    dsimp only [Quot.map]
-    simp only [Equiv.apply_symm_apply]
+  left_inv := by rintro ⟨a⟩; dsimp only [Quot.map]; simp only [Equiv.symm_apply_apply]
+  right_inv := by rintro ⟨a⟩; dsimp only [Quot.map]; simp only [Equiv.apply_symm_apply]
 #align quot.congr Quot.congr
 -/

bump to nightly-2023-05-19-16

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

a31df521

Diff

@@ -146,7 +146,7 @@ protected theorem congr_arg {f : Equiv α β} {x x' : α} : x = x' → f x = f x
 lean 3 declaration is
   forall {α : Sort.{u1}} {β : Sort.{u2}} {f : Equiv.{u1, u2} α β} {g : Equiv.{u1, u2} α β}, (Eq.{max 1 (imax u1 u2) (imax u2 u1)} (Equiv.{u1, u2} α β) f g) -> (forall (x : α), Eq.{u2} β (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α β) (fun (_x : Equiv.{u1, u2} α β) => α -> β) (Equiv.hasCoeToFun.{u1, u2} α β) f x) (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α β) (fun (_x : Equiv.{u1, u2} α β) => α -> β) (Equiv.hasCoeToFun.{u1, u2} α β) g x))
 but is expected to have type
-  forall {α : Sort.{u1}} {β : Sort.{u2}} {f : Equiv.{u1, u2} α β} {g : Equiv.{u1, u2} α β}, (Eq.{max (max 1 u1) u2} (Equiv.{u1, u2} α β) f g) -> (forall (x : α), Eq.{u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => β) x) (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => β) _x) (Equiv.instFunLikeEquiv.{u1, u2} α β) f x) (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => β) _x) (Equiv.instFunLikeEquiv.{u1, u2} α β) g x))
+  forall {α : Sort.{u1}} {β : Sort.{u2}} {f : Equiv.{u1, u2} α β} {g : Equiv.{u1, u2} α β}, (Eq.{max (max 1 u1) u2} (Equiv.{u1, u2} α β) f g) -> (forall (x : α), Eq.{u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => β) x) (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => β) _x) (Equiv.instFunLikeEquiv.{u1, u2} α β) f x) (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => β) _x) (Equiv.instFunLikeEquiv.{u1, u2} α β) g x))
 Case conversion may be inaccurate. Consider using '#align equiv.congr_fun Equiv.congr_funₓ'. -/
 protected theorem congr_fun {f g : Equiv α β} (h : f = g) (x : α) : f x = g x :=
   FunLike.congr_fun h x
@@ -156,7 +156,7 @@ protected theorem congr_fun {f g : Equiv α β} (h : f = g) (x : α) : f x = g x
 lean 3 declaration is
   forall {α : Sort.{u1}} {β : Sort.{u2}} {f : Equiv.{u1, u2} α β} {g : Equiv.{u1, u2} α β}, Iff (Eq.{max 1 (imax u1 u2) (imax u2 u1)} (Equiv.{u1, u2} α β) f g) (forall (x : α), Eq.{u2} β (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α β) (fun (_x : Equiv.{u1, u2} α β) => α -> β) (Equiv.hasCoeToFun.{u1, u2} α β) f x) (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α β) (fun (_x : Equiv.{u1, u2} α β) => α -> β) (Equiv.hasCoeToFun.{u1, u2} α β) g x))
 but is expected to have type
-  forall {α : Sort.{u1}} {β : Sort.{u2}} {f : Equiv.{u1, u2} α β} {g : Equiv.{u1, u2} α β}, Iff (Eq.{max (max 1 u1) u2} (Equiv.{u1, u2} α β) f g) (forall (x : α), Eq.{u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => β) x) (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => β) _x) (Equiv.instFunLikeEquiv.{u1, u2} α β) f x) (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => β) _x) (Equiv.instFunLikeEquiv.{u1, u2} α β) g x))
+  forall {α : Sort.{u1}} {β : Sort.{u2}} {f : Equiv.{u1, u2} α β} {g : Equiv.{u1, u2} α β}, Iff (Eq.{max (max 1 u1) u2} (Equiv.{u1, u2} α β) f g) (forall (x : α), Eq.{u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => β) x) (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => β) _x) (Equiv.instFunLikeEquiv.{u1, u2} α β) f x) (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => β) _x) (Equiv.instFunLikeEquiv.{u1, u2} α β) g x))
 Case conversion may be inaccurate. Consider using '#align equiv.ext_iff Equiv.ext_iffₓ'. -/
 theorem ext_iff {f g : Equiv α β} : f = g ↔ ∀ x, f x = g x :=
   FunLike.ext_iff
@@ -447,7 +447,7 @@ theorem apply_eq_iff_eq (f : α ≃ β) {x y : α} : f x = f y ↔ x = y :=
 lean 3 declaration is
   forall {α : Sort.{u1}} {β : Sort.{u2}} (f : Equiv.{u1, u2} α β) {x : α} {y : β}, Iff (Eq.{u2} β (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α β) (fun (_x : Equiv.{u1, u2} α β) => α -> β) (Equiv.hasCoeToFun.{u1, u2} α β) f x) y) (Eq.{u1} α x (coeFn.{max 1 (imax u2 u1) (imax u1 u2), imax u2 u1} (Equiv.{u2, u1} β α) (fun (_x : Equiv.{u2, u1} β α) => β -> α) (Equiv.hasCoeToFun.{u2, u1} β α) (Equiv.symm.{u1, u2} α β f) y))
 but is expected to have type
-  forall {α : Sort.{u1}} {β : Sort.{u2}} {f : α} {x : (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => β) f} (y : Equiv.{u1, u2} α β), Iff (Eq.{u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => β) f) (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => β) _x) (Equiv.instFunLikeEquiv.{u1, u2} α β) y f) x) (Eq.{u1} α f (FunLike.coe.{max (max 1 u1) u2, u2, u1} (Equiv.{u2, u1} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => α) _x) (Equiv.instFunLikeEquiv.{u2, u1} β α) (Equiv.symm.{u1, u2} α β y) x))
+  forall {α : Sort.{u1}} {β : Sort.{u2}} {f : α} {x : (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => β) f} (y : Equiv.{u1, u2} α β), Iff (Eq.{u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => β) f) (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => β) _x) (Equiv.instFunLikeEquiv.{u1, u2} α β) y f) x) (Eq.{u1} α f (FunLike.coe.{max (max 1 u1) u2, u2, u1} (Equiv.{u2, u1} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => α) _x) (Equiv.instFunLikeEquiv.{u2, u1} β α) (Equiv.symm.{u1, u2} α β y) x))
 Case conversion may be inaccurate. Consider using '#align equiv.apply_eq_iff_eq_symm_apply Equiv.apply_eq_iff_eq_symm_applyₓ'. -/
 theorem apply_eq_iff_eq_symm_apply {α β : Sort _} (f : α ≃ β) {x : α} {y : β} :
     f x = y ↔ x = f.symm y := by
@@ -498,7 +498,7 @@ theorem cast_eq_iff_heq {α β} (h : α = β) {a : α} {b : β} : Equiv.cast h a
 lean 3 declaration is
   forall {α : Sort.{u1}} {β : Sort.{u2}} (e : Equiv.{u1, u2} α β) {x : β} {y : α}, Iff (Eq.{u1} α (coeFn.{max 1 (imax u2 u1) (imax u1 u2), imax u2 u1} (Equiv.{u2, u1} β α) (fun (_x : Equiv.{u2, u1} β α) => β -> α) (Equiv.hasCoeToFun.{u2, u1} β α) (Equiv.symm.{u1, u2} α β e) x) y) (Eq.{u2} β x (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α β) (fun (_x : Equiv.{u1, u2} α β) => α -> β) (Equiv.hasCoeToFun.{u1, u2} α β) e y))
 but is expected to have type
-  forall {α : Sort.{u2}} {β : Sort.{u1}} (e : Equiv.{u2, u1} α β) {x : β} {y : (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => α) x}, Iff (Eq.{u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => α) x) (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => α) _x) (Equiv.instFunLikeEquiv.{u1, u2} β α) (Equiv.symm.{u2, u1} α β e) x) y) (Eq.{u1} β x (FunLike.coe.{max (max 1 u1) u2, u2, u1} (Equiv.{u2, u1} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => β) _x) (Equiv.instFunLikeEquiv.{u2, u1} α β) e y))
+  forall {α : Sort.{u2}} {β : Sort.{u1}} (e : Equiv.{u2, u1} α β) {x : β} {y : (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => α) x}, Iff (Eq.{u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => α) x) (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => α) _x) (Equiv.instFunLikeEquiv.{u1, u2} β α) (Equiv.symm.{u2, u1} α β e) x) y) (Eq.{u1} β x (FunLike.coe.{max (max 1 u1) u2, u2, u1} (Equiv.{u2, u1} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => β) _x) (Equiv.instFunLikeEquiv.{u2, u1} α β) e y))
 Case conversion may be inaccurate. Consider using '#align equiv.symm_apply_eq Equiv.symm_apply_eqₓ'. -/
 theorem symm_apply_eq {α β} (e : α ≃ β) {x y} : e.symm x = y ↔ x = e y :=
   ⟨fun H => by simp [H.symm], fun H => by simp [H]⟩
@@ -508,7 +508,7 @@ theorem symm_apply_eq {α β} (e : α ≃ β) {x y} : e.symm x = y ↔ x = e y :
 lean 3 declaration is
   forall {α : Sort.{u1}} {β : Sort.{u2}} (e : Equiv.{u1, u2} α β) {x : β} {y : α}, Iff (Eq.{u1} α y (coeFn.{max 1 (imax u2 u1) (imax u1 u2), imax u2 u1} (Equiv.{u2, u1} β α) (fun (_x : Equiv.{u2, u1} β α) => β -> α) (Equiv.hasCoeToFun.{u2, u1} β α) (Equiv.symm.{u1, u2} α β e) x)) (Eq.{u2} β (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α β) (fun (_x : Equiv.{u1, u2} α β) => α -> β) (Equiv.hasCoeToFun.{u1, u2} α β) e y) x)
 but is expected to have type
-  forall {α : Sort.{u2}} {β : Sort.{u1}} (e : Equiv.{u2, u1} α β) {x : β} {y : (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => α) x}, Iff (Eq.{u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => α) x) y (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => α) _x) (Equiv.instFunLikeEquiv.{u1, u2} β α) (Equiv.symm.{u2, u1} α β e) x)) (Eq.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => β) y) (FunLike.coe.{max (max 1 u1) u2, u2, u1} (Equiv.{u2, u1} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => β) _x) (Equiv.instFunLikeEquiv.{u2, u1} α β) e y) x)
+  forall {α : Sort.{u2}} {β : Sort.{u1}} (e : Equiv.{u2, u1} α β) {x : β} {y : (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => α) x}, Iff (Eq.{u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => α) x) y (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => α) _x) (Equiv.instFunLikeEquiv.{u1, u2} β α) (Equiv.symm.{u2, u1} α β e) x)) (Eq.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => β) y) (FunLike.coe.{max (max 1 u1) u2, u2, u1} (Equiv.{u2, u1} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => β) _x) (Equiv.instFunLikeEquiv.{u2, u1} α β) e y) x)
 Case conversion may be inaccurate. Consider using '#align equiv.eq_symm_apply Equiv.eq_symm_applyₓ'. -/
 theorem eq_symm_apply {α β} (e : α ≃ β) {x y} : y = e.symm x ↔ e y = x :=
   (eq_comm.trans e.symm_apply_eq).trans eq_comm
@@ -695,7 +695,7 @@ theorem equivCongr_trans {δ ε ζ} (ab : α ≃ β) (de : δ ≃ ε) (bc : β 
 lean 3 declaration is
   forall {α : Sort.{u1}} {β : Sort.{u2}} {γ : Sort.{u3}} (bg : Equiv.{u2, u3} β γ) (e : Equiv.{u1, u2} α β), Eq.{max 1 (imax u1 u3) (imax u3 u1)} (Equiv.{u1, u3} α γ) (coeFn.{max 1 (max (max 1 (imax u1 u2) (imax u2 u1)) 1 (imax u1 u3) (imax u3 u1)) (max 1 (imax u1 u3) (imax u3 u1)) 1 (imax u1 u2) (imax u2 u1), max (max 1 (imax u1 u2) (imax u2 u1)) 1 (imax u1 u3) (imax u3 u1)} (Equiv.{max 1 (imax u1 u2) (imax u2 u1), max 1 (imax u1 u3) (imax u3 u1)} (Equiv.{u1, u2} α β) (Equiv.{u1, u3} α γ)) (fun (_x : Equiv.{max 1 (imax u1 u2) (imax u2 u1), max 1 (imax u1 u3) (imax u3 u1)} (Equiv.{u1, u2} α β) (Equiv.{u1, u3} α γ)) => (Equiv.{u1, u2} α β) -> (Equiv.{u1, u3} α γ)) (Equiv.hasCoeToFun.{max 1 (imax u1 u2) (imax u2 u1), max 1 (imax u1 u3) (imax u3 u1)} (Equiv.{u1, u2} α β) (Equiv.{u1, u3} α γ)) (Equiv.equivCongr.{u1, u1, u2, u3} α α β γ (Equiv.refl.{u1} α) bg) e) (Equiv.trans.{u1, u2, u3} α β γ e bg)
 but is expected to have type
-  forall {α : Sort.{u3}} {β : Sort.{u2}} {γ : Sort.{u1}} (bg : Equiv.{u2, u1} β γ) (e : Equiv.{u3, u2} α β), Eq.{max (max 1 u1) u3} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Equiv.{u3, u2} α β) => Equiv.{u3, u1} α γ) e) (FunLike.coe.{max (max (max 1 u1) u2) u3, max (max 1 u2) u3, max (max 1 u1) u3} (Equiv.{max (max 1 u2) u3, max (max 1 u1) u3} (Equiv.{u3, u2} α β) (Equiv.{u3, u1} α γ)) (Equiv.{u3, u2} α β) (fun (_x : Equiv.{u3, u2} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Equiv.{u3, u2} α β) => Equiv.{u3, u1} α γ) _x) (Equiv.instFunLikeEquiv.{max (max 1 u2) u3, max (max 1 u1) u3} (Equiv.{u3, u2} α β) (Equiv.{u3, u1} α γ)) (Equiv.equivCongr.{u3, u3, u2, u1} α α β γ (Equiv.refl.{u3} α) bg) e) (Equiv.trans.{u3, u2, u1} α β γ e bg)
+  forall {α : Sort.{u3}} {β : Sort.{u2}} {γ : Sort.{u1}} (bg : Equiv.{u2, u1} β γ) (e : Equiv.{u3, u2} α β), Eq.{max (max 1 u1) u3} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Equiv.{u3, u2} α β) => Equiv.{u3, u1} α γ) e) (FunLike.coe.{max (max (max 1 u1) u2) u3, max (max 1 u2) u3, max (max 1 u1) u3} (Equiv.{max (max 1 u2) u3, max (max 1 u1) u3} (Equiv.{u3, u2} α β) (Equiv.{u3, u1} α γ)) (Equiv.{u3, u2} α β) (fun (_x : Equiv.{u3, u2} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Equiv.{u3, u2} α β) => Equiv.{u3, u1} α γ) _x) (Equiv.instFunLikeEquiv.{max (max 1 u2) u3, max (max 1 u1) u3} (Equiv.{u3, u2} α β) (Equiv.{u3, u1} α γ)) (Equiv.equivCongr.{u3, u3, u2, u1} α α β γ (Equiv.refl.{u3} α) bg) e) (Equiv.trans.{u3, u2, u1} α β γ e bg)
 Case conversion may be inaccurate. Consider using '#align equiv.equiv_congr_refl_left Equiv.equivCongr_refl_leftₓ'. -/
 @[simp]
 theorem equivCongr_refl_left {α β γ} (bg : β ≃ γ) (e : α ≃ β) :
@@ -707,7 +707,7 @@ theorem equivCongr_refl_left {α β γ} (bg : β ≃ γ) (e : α ≃ β) :
 lean 3 declaration is
   forall {α : Sort.{u1}} {β : Sort.{u2}} (ab : Equiv.{u1, u2} α β) (e : Equiv.{u1, u2} α β), Eq.{max 1 u2} (Equiv.{u2, u2} β β) (coeFn.{max 1 (max (max 1 (imax u1 u2) (imax u2 u1)) 1 u2) (max 1 u2) 1 (imax u1 u2) (imax u2 u1), max (max 1 (imax u1 u2) (imax u2 u1)) 1 u2} (Equiv.{max 1 (imax u1 u2) (imax u2 u1), max 1 u2} (Equiv.{u1, u2} α β) (Equiv.{u2, u2} β β)) (fun (_x : Equiv.{max 1 (imax u1 u2) (imax u2 u1), max 1 u2} (Equiv.{u1, u2} α β) (Equiv.{u2, u2} β β)) => (Equiv.{u1, u2} α β) -> (Equiv.{u2, u2} β β)) (Equiv.hasCoeToFun.{max 1 (imax u1 u2) (imax u2 u1), max 1 u2} (Equiv.{u1, u2} α β) (Equiv.{u2, u2} β β)) (Equiv.equivCongr.{u1, u2, u2, u2} α β β β ab (Equiv.refl.{u2} β)) e) (Equiv.trans.{u2, u1, u2} β α β (Equiv.symm.{u1, u2} α β ab) e)
 but is expected to have type
-  forall {α : Sort.{u2}} {β : Sort.{u1}} (ab : Equiv.{u2, u1} α β) (e : Equiv.{u2, u1} α β), Eq.{max 1 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Equiv.{u2, u1} α β) => Equiv.{u1, u1} β β) e) (FunLike.coe.{max (max 1 u1) u2, max (max 1 u1) u2, max 1 u1} (Equiv.{max (max 1 u1) u2, max 1 u1} (Equiv.{u2, u1} α β) (Equiv.{u1, u1} β β)) (Equiv.{u2, u1} α β) (fun (_x : Equiv.{u2, u1} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Equiv.{u2, u1} α β) => Equiv.{u1, u1} β β) _x) (Equiv.instFunLikeEquiv.{max (max 1 u1) u2, max 1 u1} (Equiv.{u2, u1} α β) (Equiv.{u1, u1} β β)) (Equiv.equivCongr.{u2, u1, u1, u1} α β β β ab (Equiv.refl.{u1} β)) e) (Equiv.trans.{u1, u2, u1} β α β (Equiv.symm.{u2, u1} α β ab) e)
+  forall {α : Sort.{u2}} {β : Sort.{u1}} (ab : Equiv.{u2, u1} α β) (e : Equiv.{u2, u1} α β), Eq.{max 1 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Equiv.{u2, u1} α β) => Equiv.{u1, u1} β β) e) (FunLike.coe.{max (max 1 u1) u2, max (max 1 u1) u2, max 1 u1} (Equiv.{max (max 1 u1) u2, max 1 u1} (Equiv.{u2, u1} α β) (Equiv.{u1, u1} β β)) (Equiv.{u2, u1} α β) (fun (_x : Equiv.{u2, u1} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Equiv.{u2, u1} α β) => Equiv.{u1, u1} β β) _x) (Equiv.instFunLikeEquiv.{max (max 1 u1) u2, max 1 u1} (Equiv.{u2, u1} α β) (Equiv.{u1, u1} β β)) (Equiv.equivCongr.{u2, u1, u1, u1} α β β β ab (Equiv.refl.{u1} β)) e) (Equiv.trans.{u1, u2, u1} β α β (Equiv.symm.{u2, u1} α β ab) e)
 Case conversion may be inaccurate. Consider using '#align equiv.equiv_congr_refl_right Equiv.equivCongr_refl_rightₓ'. -/
 @[simp]
 theorem equivCongr_refl_right {α β} (ab e : α ≃ β) :
@@ -719,7 +719,7 @@ theorem equivCongr_refl_right {α β} (ab e : α ≃ β) :
 lean 3 declaration is
   forall {α : Sort.{u1}} {β : Sort.{u2}} {γ : Sort.{u3}} {δ : Sort.{u4}} (ab : Equiv.{u1, u2} α β) (cd : Equiv.{u3, u4} γ δ) (e : Equiv.{u1, u3} α γ) (x : β), Eq.{u4} δ (coeFn.{max 1 (imax u2 u4) (imax u4 u2), imax u2 u4} (Equiv.{u2, u4} β δ) (fun (_x : Equiv.{u2, u4} β δ) => β -> δ) (Equiv.hasCoeToFun.{u2, u4} β δ) (coeFn.{max 1 (max (max 1 (imax u1 u3) (imax u3 u1)) 1 (imax u2 u4) (imax u4 u2)) (max 1 (imax u2 u4) (imax u4 u2)) 1 (imax u1 u3) (imax u3 u1), max (max 1 (imax u1 u3) (imax u3 u1)) 1 (imax u2 u4) (imax u4 u2)} (Equiv.{max 1 (imax u1 u3) (imax u3 u1), max 1 (imax u2 u4) (imax u4 u2)} (Equiv.{u1, u3} α γ) (Equiv.{u2, u4} β δ)) (fun (_x : Equiv.{max 1 (imax u1 u3) (imax u3 u1), max 1 (imax u2 u4) (imax u4 u2)} (Equiv.{u1, u3} α γ) (Equiv.{u2, u4} β δ)) => (Equiv.{u1, u3} α γ) -> (Equiv.{u2, u4} β δ)) (Equiv.hasCoeToFun.{max 1 (imax u1 u3) (imax u3 u1), max 1 (imax u2 u4) (imax u4 u2)} (Equiv.{u1, u3} α γ) (Equiv.{u2, u4} β δ)) (Equiv.equivCongr.{u1, u2, u3, u4} α β γ δ ab cd) e) x) (coeFn.{max 1 (imax u3 u4) (imax u4 u3), imax u3 u4} (Equiv.{u3, u4} γ δ) (fun (_x : Equiv.{u3, u4} γ δ) => γ -> δ) (Equiv.hasCoeToFun.{u3, u4} γ δ) cd (coeFn.{max 1 (imax u1 u3) (imax u3 u1), imax u1 u3} (Equiv.{u1, u3} α γ) (fun (_x : Equiv.{u1, u3} α γ) => α -> γ) (Equiv.hasCoeToFun.{u1, u3} α γ) e (coeFn.{max 1 (imax u2 u1) (imax u1 u2), imax u2 u1} (Equiv.{u2, u1} β α) (fun (_x : Equiv.{u2, u1} β α) => β -> α) (Equiv.hasCoeToFun.{u2, u1} β α) (Equiv.symm.{u1, u2} α β ab) x)))
 but is expected to have type
-  forall {α : Sort.{u2}} {β : Sort.{u3}} {γ : Sort.{u4}} {δ : Sort.{u1}} (ab : Equiv.{u2, u3} α β) (cd : Equiv.{u4, u1} γ δ) (e : Equiv.{u2, u4} α γ) (x : β), Eq.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => δ) x) (FunLike.coe.{max (max 1 u3) u1, u3, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Equiv.{u2, u4} α γ) => Equiv.{u3, u1} β δ) e) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => δ) _x) (Equiv.instFunLikeEquiv.{u3, u1} β δ) (FunLike.coe.{max (max (max (max 1 u2) u3) u4) u1, max (max 1 u2) u4, max (max 1 u3) u1} (Equiv.{max (max 1 u4) u2, max (max 1 u1) u3} (Equiv.{u2, u4} α γ) (Equiv.{u3, u1} β δ)) (Equiv.{u2, u4} α γ) (fun (_x : Equiv.{u2, u4} α γ) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Equiv.{u2, u4} α γ) => Equiv.{u3, u1} β δ) _x) (Equiv.instFunLikeEquiv.{max (max 1 u2) u4, max (max 1 u3) u1} (Equiv.{u2, u4} α γ) (Equiv.{u3, u1} β δ)) (Equiv.equivCongr.{u2, u3, u4, u1} α β γ δ ab cd) e) x) (FunLike.coe.{max (max 1 u4) u1, u4, u1} (Equiv.{u4, u1} γ δ) γ (fun (_x : γ) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : γ) => δ) _x) (Equiv.instFunLikeEquiv.{u4, u1} γ δ) cd (FunLike.coe.{max (max 1 u2) u4, u2, u4} (Equiv.{u2, u4} α γ) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => γ) _x) (Equiv.instFunLikeEquiv.{u2, u4} α γ) e (FunLike.coe.{max (max 1 u2) u3, u3, u2} (Equiv.{u3, u2} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => α) _x) (Equiv.instFunLikeEquiv.{u3, u2} β α) (Equiv.symm.{u2, u3} α β ab) x)))
+  forall {α : Sort.{u2}} {β : Sort.{u3}} {γ : Sort.{u4}} {δ : Sort.{u1}} (ab : Equiv.{u2, u3} α β) (cd : Equiv.{u4, u1} γ δ) (e : Equiv.{u2, u4} α γ) (x : β), Eq.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => δ) x) (FunLike.coe.{max (max 1 u3) u1, u3, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Equiv.{u2, u4} α γ) => Equiv.{u3, u1} β δ) e) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => δ) _x) (Equiv.instFunLikeEquiv.{u3, u1} β δ) (FunLike.coe.{max (max (max (max 1 u2) u3) u4) u1, max (max 1 u2) u4, max (max 1 u3) u1} (Equiv.{max (max 1 u4) u2, max (max 1 u1) u3} (Equiv.{u2, u4} α γ) (Equiv.{u3, u1} β δ)) (Equiv.{u2, u4} α γ) (fun (_x : Equiv.{u2, u4} α γ) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Equiv.{u2, u4} α γ) => Equiv.{u3, u1} β δ) _x) (Equiv.instFunLikeEquiv.{max (max 1 u2) u4, max (max 1 u3) u1} (Equiv.{u2, u4} α γ) (Equiv.{u3, u1} β δ)) (Equiv.equivCongr.{u2, u3, u4, u1} α β γ δ ab cd) e) x) (FunLike.coe.{max (max 1 u4) u1, u4, u1} (Equiv.{u4, u1} γ δ) γ (fun (_x : γ) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : γ) => δ) _x) (Equiv.instFunLikeEquiv.{u4, u1} γ δ) cd (FunLike.coe.{max (max 1 u2) u4, u2, u4} (Equiv.{u2, u4} α γ) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => γ) _x) (Equiv.instFunLikeEquiv.{u2, u4} α γ) e (FunLike.coe.{max (max 1 u2) u3, u3, u2} (Equiv.{u3, u2} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => α) _x) (Equiv.instFunLikeEquiv.{u3, u2} β α) (Equiv.symm.{u2, u3} α β ab) x)))
 Case conversion may be inaccurate. Consider using '#align equiv.equiv_congr_apply_apply Equiv.equivCongr_apply_applyₓ'. -/
 @[simp]
 theorem equivCongr_apply_apply {δ} (ab : α ≃ β) (cd : γ ≃ δ) (e : α ≃ γ) (x) :
@@ -742,7 +742,7 @@ def permCongr : Perm α' ≃ Perm β' :=
 lean 3 declaration is
   forall {α' : Type.{u1}} {β' : Type.{u2}} (e : Equiv.{succ u1, succ u2} α' β') (p : Equiv.Perm.{succ u1} α'), Eq.{succ u2} (Equiv.Perm.{succ u2} β') (coeFn.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1), max (succ u1) (succ u2)} (Equiv.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) (fun (_x : Equiv.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) => (Equiv.Perm.{succ u1} α') -> (Equiv.Perm.{succ u2} β')) (Equiv.hasCoeToFun.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) (Equiv.permCongr.{u1, u2} α' β' e) p) (Equiv.trans.{succ u2, succ u1, succ u2} β' α' β' (Equiv.trans.{succ u2, succ u1, succ u1} β' α' α' (Equiv.symm.{succ u1, succ u2} α' β' e) p) e)
 but is expected to have type
-  forall {α' : Type.{u2}} {β' : Type.{u1}} (e : Equiv.{succ u2, succ u1} α' β') (p : Equiv.Perm.{succ u2} α'), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') p) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.Perm.{succ u2} α') (fun (_x : Equiv.Perm.{succ u2} α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.permCongr.{u2, u1} α' β' e) p) (Equiv.trans.{succ u1, succ u2, succ u1} β' α' β' (Equiv.trans.{succ u1, succ u2, succ u2} β' α' α' (Equiv.symm.{succ u2, succ u1} α' β' e) p) e)
+  forall {α' : Type.{u2}} {β' : Type.{u1}} (e : Equiv.{succ u2, succ u1} α' β') (p : Equiv.Perm.{succ u2} α'), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') p) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.Perm.{succ u2} α') (fun (_x : Equiv.Perm.{succ u2} α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.permCongr.{u2, u1} α' β' e) p) (Equiv.trans.{succ u1, succ u2, succ u1} β' α' β' (Equiv.trans.{succ u1, succ u2, succ u2} β' α' α' (Equiv.symm.{succ u2, succ u1} α' β' e) p) e)
 Case conversion may be inaccurate. Consider using '#align equiv.perm_congr_def Equiv.permCongr_defₓ'. -/
 theorem permCongr_def (p : Equiv.Perm α') : e.permCongr p = (e.symm.trans p).trans e :=
   rfl
@@ -769,7 +769,7 @@ theorem permCongr_symm : e.permCongr.symm = e.symm.permCongr :=
 lean 3 declaration is
   forall {α' : Type.{u1}} {β' : Type.{u2}} (e : Equiv.{succ u1, succ u2} α' β') (p : Equiv.Perm.{succ u1} α') (x : β'), Eq.{succ u2} β' (coeFn.{succ u2, succ u2} (Equiv.Perm.{succ u2} β') (fun (_x : Equiv.{succ u2, succ u2} β' β') => β' -> β') (Equiv.hasCoeToFun.{succ u2, succ u2} β' β') (coeFn.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1), max (succ u1) (succ u2)} (Equiv.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) (fun (_x : Equiv.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) => (Equiv.Perm.{succ u1} α') -> (Equiv.Perm.{succ u2} β')) (Equiv.hasCoeToFun.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) (Equiv.permCongr.{u1, u2} α' β' e) p) x) (coeFn.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1), max (succ u1) (succ u2)} (Equiv.{succ u1, succ u2} α' β') (fun (_x : Equiv.{succ u1, succ u2} α' β') => α' -> β') (Equiv.hasCoeToFun.{succ u1, succ u2} α' β') e (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α') (fun (_x : Equiv.{succ u1, succ u1} α' α') => α' -> α') (Equiv.hasCoeToFun.{succ u1, succ u1} α' α') p (coeFn.{max 1 (max (succ u2) (succ u1)) (succ u1) (succ u2), max (succ u2) (succ u1)} (Equiv.{succ u2, succ u1} β' α') (fun (_x : Equiv.{succ u2, succ u1} β' α') => β' -> α') (Equiv.hasCoeToFun.{succ u2, succ u1} β' α') (Equiv.symm.{succ u1, succ u2} α' β' e) x)))
 but is expected to have type
-  forall {α' : Type.{u2}} {β' : Type.{u1}} (e : Equiv.{succ u2, succ u1} α' β') (p : Equiv.Perm.{succ u2} α') (x : β'), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β') => β') x) (FunLike.coe.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') p) β' (fun (_x : β') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β') => β') _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} β' β') (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.Perm.{succ u2} α') (fun (_x : Equiv.Perm.{succ u2} α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.permCongr.{u2, u1} α' β' e) p) x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} α' β') α' (fun (_x : α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α') => β') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} α' β') e (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.Perm.{succ u2} α') α' (fun (_x : α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α') => α') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} α' α') p (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (Equiv.{succ u1, succ u2} β' α') β' (fun (_x : β') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β') => α') _x) (Equiv.instFunLikeEquiv.{succ u1, succ u2} β' α') (Equiv.symm.{succ u2, succ u1} α' β' e) x)))
+  forall {α' : Type.{u2}} {β' : Type.{u1}} (e : Equiv.{succ u2, succ u1} α' β') (p : Equiv.Perm.{succ u2} α') (x : β'), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β') => β') x) (FunLike.coe.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') p) β' (fun (_x : β') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β') => β') _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} β' β') (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.Perm.{succ u2} α') (fun (_x : Equiv.Perm.{succ u2} α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.permCongr.{u2, u1} α' β' e) p) x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} α' β') α' (fun (_x : α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α') => β') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} α' β') e (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.Perm.{succ u2} α') α' (fun (_x : α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α') => α') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} α' α') p (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (Equiv.{succ u1, succ u2} β' α') β' (fun (_x : β') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β') => α') _x) (Equiv.instFunLikeEquiv.{succ u1, succ u2} β' α') (Equiv.symm.{succ u2, succ u1} α' β' e) x)))
 Case conversion may be inaccurate. Consider using '#align equiv.perm_congr_apply Equiv.permCongr_applyₓ'. -/
 @[simp]
 theorem permCongr_apply (p : Equiv.Perm α') (x) : e.permCongr p x = e (p (e.symm x)) :=
@@ -786,7 +786,7 @@ theorem permCongr_symm_apply (p : Equiv.Perm β') (x) : e.permCongr.symm p x = e
 lean 3 declaration is
   forall {α' : Type.{u1}} {β' : Type.{u2}} (e : Equiv.{succ u1, succ u2} α' β') (p : Equiv.Perm.{succ u1} α') (p' : Equiv.Perm.{succ u1} α'), Eq.{succ u2} (Equiv.{succ u2, succ u2} β' β') (Equiv.trans.{succ u2, succ u2, succ u2} β' β' β' (coeFn.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1), max (succ u1) (succ u2)} (Equiv.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) (fun (_x : Equiv.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) => (Equiv.Perm.{succ u1} α') -> (Equiv.Perm.{succ u2} β')) (Equiv.hasCoeToFun.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) (Equiv.permCongr.{u1, u2} α' β' e) p) (coeFn.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1), max (succ u1) (succ u2)} (Equiv.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) (fun (_x : Equiv.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) => (Equiv.Perm.{succ u1} α') -> (Equiv.Perm.{succ u2} β')) (Equiv.hasCoeToFun.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) (Equiv.permCongr.{u1, u2} α' β' e) p')) (coeFn.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1), max (succ u1) (succ u2)} (Equiv.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) (fun (_x : Equiv.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) => (Equiv.Perm.{succ u1} α') -> (Equiv.Perm.{succ u2} β')) (Equiv.hasCoeToFun.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) (Equiv.permCongr.{u1, u2} α' β' e) (Equiv.trans.{succ u1, succ u1, succ u1} α' α' α' p p'))
 but is expected to have type
-  forall {α' : Type.{u2}} {β' : Type.{u1}} (e : Equiv.{succ u2, succ u1} α' β') (p : Equiv.Perm.{succ u2} α') (p' : Equiv.Perm.{succ u2} α'), Eq.{succ u1} (Equiv.{succ u1, succ u1} β' β') (Equiv.trans.{succ u1, succ u1, succ u1} β' β' β' (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.Perm.{succ u2} α') (fun (_x : Equiv.Perm.{succ u2} α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.permCongr.{u2, u1} α' β' e) p) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.Perm.{succ u2} α') (fun (_x : Equiv.Perm.{succ u2} α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.permCongr.{u2, u1} α' β' e) p')) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.Perm.{succ u2} α') (fun (_x : Equiv.Perm.{succ u2} α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.permCongr.{u2, u1} α' β' e) (Equiv.trans.{succ u2, succ u2, succ u2} α' α' α' p p'))
+  forall {α' : Type.{u2}} {β' : Type.{u1}} (e : Equiv.{succ u2, succ u1} α' β') (p : Equiv.Perm.{succ u2} α') (p' : Equiv.Perm.{succ u2} α'), Eq.{succ u1} (Equiv.{succ u1, succ u1} β' β') (Equiv.trans.{succ u1, succ u1, succ u1} β' β' β' (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.Perm.{succ u2} α') (fun (_x : Equiv.Perm.{succ u2} α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.permCongr.{u2, u1} α' β' e) p) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.Perm.{succ u2} α') (fun (_x : Equiv.Perm.{succ u2} α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.permCongr.{u2, u1} α' β' e) p')) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.Perm.{succ u2} α') (fun (_x : Equiv.Perm.{succ u2} α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.permCongr.{u2, u1} α' β' e) (Equiv.trans.{succ u2, succ u2, succ u2} α' α' α' p p'))
 Case conversion may be inaccurate. Consider using '#align equiv.perm_congr_trans Equiv.permCongr_transₓ'. -/
 theorem permCongr_trans (p p' : Equiv.Perm α') :
     (e.permCongr p).trans (e.permCongr p') = e.permCongr (p.trans p') :=
@@ -913,7 +913,7 @@ def arrowCongr {α₁ β₁ α₂ β₂ : Sort _} (e₁ : α₁ ≃ α₂) (e₂
 lean 3 declaration is
   forall {α₁ : Sort.{u1}} {β₁ : Sort.{u2}} {γ₁ : Sort.{u3}} {α₂ : Sort.{u4}} {β₂ : Sort.{u5}} {γ₂ : Sort.{u6}} (ea : Equiv.{u1, u4} α₁ α₂) (eb : Equiv.{u2, u5} β₁ β₂) (ec : Equiv.{u3, u6} γ₁ γ₂) (f : α₁ -> β₁) (g : β₁ -> γ₁), Eq.{imax u4 u6} (α₂ -> γ₂) (coeFn.{max 1 (imax (imax u1 u3) u4 u6) (imax (imax u4 u6) u1 u3), imax (imax u1 u3) u4 u6} (Equiv.{imax u1 u3, imax u4 u6} (α₁ -> γ₁) (α₂ -> γ₂)) (fun (_x : Equiv.{imax u1 u3, imax u4 u6} (α₁ -> γ₁) (α₂ -> γ₂)) => (α₁ -> γ₁) -> α₂ -> γ₂) (Equiv.hasCoeToFun.{imax u1 u3, imax u4 u6} (α₁ -> γ₁) (α₂ -> γ₂)) (Equiv.arrowCongr.{u1, u3, u4, u6} α₁ γ₁ α₂ γ₂ ea ec) (Function.comp.{u1, u2, u3} α₁ β₁ γ₁ g f)) (Function.comp.{u4, u5, u6} α₂ β₂ γ₂ (coeFn.{max 1 (imax (imax u2 u3) u5 u6) (imax (imax u5 u6) u2 u3), imax (imax u2 u3) u5 u6} (Equiv.{imax u2 u3, imax u5 u6} (β₁ -> γ₁) (β₂ -> γ₂)) (fun (_x : Equiv.{imax u2 u3, imax u5 u6} (β₁ -> γ₁) (β₂ -> γ₂)) => (β₁ -> γ₁) -> β₂ -> γ₂) (Equiv.hasCoeToFun.{imax u2 u3, imax u5 u6} (β₁ -> γ₁) (β₂ -> γ₂)) (Equiv.arrowCongr.{u2, u3, u5, u6} β₁ γ₁ β₂ γ₂ eb ec) g) (coeFn.{max 1 (imax (imax u1 u2) u4 u5) (imax (imax u4 u5) u1 u2), imax (imax u1 u2) u4 u5} (Equiv.{imax u1 u2, imax u4 u5} (α₁ -> β₁) (α₂ -> β₂)) (fun (_x : Equiv.{imax u1 u2, imax u4 u5} (α₁ -> β₁) (α₂ -> β₂)) => (α₁ -> β₁) -> α₂ -> β₂) (Equiv.hasCoeToFun.{imax u1 u2, imax u4 u5} (α₁ -> β₁) (α₂ -> β₂)) (Equiv.arrowCongr.{u1, u2, u4, u5} α₁ β₁ α₂ β₂ ea eb) f))
 but is expected to have type
-  forall {α₁ : Sort.{u6}} {β₁ : Sort.{u5}} {γ₁ : Sort.{u4}} {α₂ : Sort.{u3}} {β₂ : Sort.{u2}} {γ₂ : Sort.{u1}} (ea : Equiv.{u6, u3} α₁ α₂) (eb : Equiv.{u5, u2} β₁ β₂) (ec : Equiv.{u4, u1} γ₁ γ₂) (f : α₁ -> β₁) (g : β₁ -> γ₁), Eq.{imax u3 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α₁ -> γ₁) => α₂ -> γ₂) (Function.comp.{u6, u5, u4} α₁ β₁ γ₁ g f)) (FunLike.coe.{max (max 1 (imax u6 u4)) (imax u3 u1), imax u6 u4, imax u3 u1} (Equiv.{imax u6 u4, imax u3 u1} (α₁ -> γ₁) (α₂ -> γ₂)) (α₁ -> γ₁) (fun (_x : α₁ -> γ₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α₁ -> γ₁) => α₂ -> γ₂) _x) (Equiv.instFunLikeEquiv.{imax u6 u4, imax u3 u1} (α₁ -> γ₁) (α₂ -> γ₂)) (Equiv.arrowCongr.{u6, u4, u3, u1} α₁ γ₁ α₂ γ₂ ea ec) (Function.comp.{u6, u5, u4} α₁ β₁ γ₁ g f)) (Function.comp.{u3, u2, u1} α₂ β₂ γ₂ (FunLike.coe.{max (max 1 (imax u5 u4)) (imax u2 u1), imax u5 u4, imax u2 u1} (Equiv.{imax u5 u4, imax u2 u1} (β₁ -> γ₁) (β₂ -> γ₂)) (β₁ -> γ₁) (fun (_x : β₁ -> γ₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β₁ -> γ₁) => β₂ -> γ₂) _x) (Equiv.instFunLikeEquiv.{imax u5 u4, imax u2 u1} (β₁ -> γ₁) (β₂ -> γ₂)) (Equiv.arrowCongr.{u5, u4, u2, u1} β₁ γ₁ β₂ γ₂ eb ec) g) (FunLike.coe.{max (max 1 (imax u6 u5)) (imax u3 u2), imax u6 u5, imax u3 u2} (Equiv.{imax u6 u5, imax u3 u2} (α₁ -> β₁) (α₂ -> β₂)) (α₁ -> β₁) (fun (_x : α₁ -> β₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α₁ -> β₁) => α₂ -> β₂) _x) (Equiv.instFunLikeEquiv.{imax u6 u5, imax u3 u2} (α₁ -> β₁) (α₂ -> β₂)) (Equiv.arrowCongr.{u6, u5, u3, u2} α₁ β₁ α₂ β₂ ea eb) f))
+  forall {α₁ : Sort.{u6}} {β₁ : Sort.{u5}} {γ₁ : Sort.{u4}} {α₂ : Sort.{u3}} {β₂ : Sort.{u2}} {γ₂ : Sort.{u1}} (ea : Equiv.{u6, u3} α₁ α₂) (eb : Equiv.{u5, u2} β₁ β₂) (ec : Equiv.{u4, u1} γ₁ γ₂) (f : α₁ -> β₁) (g : β₁ -> γ₁), Eq.{imax u3 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α₁ -> γ₁) => α₂ -> γ₂) (Function.comp.{u6, u5, u4} α₁ β₁ γ₁ g f)) (FunLike.coe.{max (max 1 (imax u6 u4)) (imax u3 u1), imax u6 u4, imax u3 u1} (Equiv.{imax u6 u4, imax u3 u1} (α₁ -> γ₁) (α₂ -> γ₂)) (α₁ -> γ₁) (fun (_x : α₁ -> γ₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α₁ -> γ₁) => α₂ -> γ₂) _x) (Equiv.instFunLikeEquiv.{imax u6 u4, imax u3 u1} (α₁ -> γ₁) (α₂ -> γ₂)) (Equiv.arrowCongr.{u6, u4, u3, u1} α₁ γ₁ α₂ γ₂ ea ec) (Function.comp.{u6, u5, u4} α₁ β₁ γ₁ g f)) (Function.comp.{u3, u2, u1} α₂ β₂ γ₂ (FunLike.coe.{max (max 1 (imax u5 u4)) (imax u2 u1), imax u5 u4, imax u2 u1} (Equiv.{imax u5 u4, imax u2 u1} (β₁ -> γ₁) (β₂ -> γ₂)) (β₁ -> γ₁) (fun (_x : β₁ -> γ₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β₁ -> γ₁) => β₂ -> γ₂) _x) (Equiv.instFunLikeEquiv.{imax u5 u4, imax u2 u1} (β₁ -> γ₁) (β₂ -> γ₂)) (Equiv.arrowCongr.{u5, u4, u2, u1} β₁ γ₁ β₂ γ₂ eb ec) g) (FunLike.coe.{max (max 1 (imax u6 u5)) (imax u3 u2), imax u6 u5, imax u3 u2} (Equiv.{imax u6 u5, imax u3 u2} (α₁ -> β₁) (α₂ -> β₂)) (α₁ -> β₁) (fun (_x : α₁ -> β₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α₁ -> β₁) => α₂ -> β₂) _x) (Equiv.instFunLikeEquiv.{imax u6 u5, imax u3 u2} (α₁ -> β₁) (α₂ -> β₂)) (Equiv.arrowCongr.{u6, u5, u3, u2} α₁ β₁ α₂ β₂ ea eb) f))
 Case conversion may be inaccurate. Consider using '#align equiv.arrow_congr_comp Equiv.arrowCongr_compₓ'. -/
 theorem arrowCongr_comp {α₁ β₁ γ₁ α₂ β₂ γ₂ : Sort _} (ea : α₁ ≃ α₂) (eb : β₁ ≃ β₂) (ec : γ₁ ≃ γ₂)
     (f : α₁ → β₁) (g : β₁ → γ₁) :
@@ -1059,7 +1059,7 @@ theorem conj_comp (e : α ≃ β) (f₁ f₂ : α → α) : e.conj (f₁ ∘ f
 lean 3 declaration is
   forall {α : Sort.{u1}} {β : Sort.{u2}} {γ : Sort.{u3}} (e : Equiv.{u1, u2} α β) (f : β -> γ) (g : α -> γ), Iff (Eq.{imax u2 u3} (β -> γ) f (Function.comp.{u2, u1, u3} β α γ g (coeFn.{max 1 (imax u2 u1) (imax u1 u2), imax u2 u1} (Equiv.{u2, u1} β α) (fun (_x : Equiv.{u2, u1} β α) => β -> α) (Equiv.hasCoeToFun.{u2, u1} β α) (Equiv.symm.{u1, u2} α β e)))) (Eq.{imax u1 u3} (α -> γ) (Function.comp.{u1, u2, u3} α β γ f (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α β) (fun (_x : Equiv.{u1, u2} α β) => α -> β) (Equiv.hasCoeToFun.{u1, u2} α β) e)) g)
 but is expected to have type
-  forall {α : Sort.{u3}} {β : Sort.{u2}} {γ : Sort.{u1}} (e : Equiv.{u3, u2} α β) (f : β -> γ) (g : α -> γ), Iff (Eq.{imax u2 u1} (β -> γ) f (Function.comp.{u2, u3, u1} β α γ g (FunLike.coe.{max (max 1 u2) u3, u2, u3} (Equiv.{u2, u3} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => α) _x) (Equiv.instFunLikeEquiv.{u2, u3} β α) (Equiv.symm.{u3, u2} α β e)))) (Eq.{imax u3 u1} (α -> γ) (Function.comp.{u3, u2, u1} α β γ f (FunLike.coe.{max (max 1 u2) u3, u3, u2} (Equiv.{u3, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => β) _x) (Equiv.instFunLikeEquiv.{u3, u2} α β) e)) g)
+  forall {α : Sort.{u3}} {β : Sort.{u2}} {γ : Sort.{u1}} (e : Equiv.{u3, u2} α β) (f : β -> γ) (g : α -> γ), Iff (Eq.{imax u2 u1} (β -> γ) f (Function.comp.{u2, u3, u1} β α γ g (FunLike.coe.{max (max 1 u2) u3, u2, u3} (Equiv.{u2, u3} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => α) _x) (Equiv.instFunLikeEquiv.{u2, u3} β α) (Equiv.symm.{u3, u2} α β e)))) (Eq.{imax u3 u1} (α -> γ) (Function.comp.{u3, u2, u1} α β γ f (FunLike.coe.{max (max 1 u2) u3, u3, u2} (Equiv.{u3, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => β) _x) (Equiv.instFunLikeEquiv.{u3, u2} α β) e)) g)
 Case conversion may be inaccurate. Consider using '#align equiv.eq_comp_symm Equiv.eq_comp_symmₓ'. -/
 theorem eq_comp_symm {α β γ} (e : α ≃ β) (f : β → γ) (g : α → γ) : f = g ∘ e.symm ↔ f ∘ e = g :=
   (e.arrowCongr (Equiv.refl γ)).symm_apply_eq.symm
@@ -1069,7 +1069,7 @@ theorem eq_comp_symm {α β γ} (e : α ≃ β) (f : β → γ) (g : α → γ)
 lean 3 declaration is
   forall {α : Sort.{u1}} {β : Sort.{u2}} {γ : Sort.{u3}} (e : Equiv.{u1, u2} α β) (f : β -> γ) (g : α -> γ), Iff (Eq.{imax u2 u3} (β -> γ) (Function.comp.{u2, u1, u3} β α γ g (coeFn.{max 1 (imax u2 u1) (imax u1 u2), imax u2 u1} (Equiv.{u2, u1} β α) (fun (_x : Equiv.{u2, u1} β α) => β -> α) (Equiv.hasCoeToFun.{u2, u1} β α) (Equiv.symm.{u1, u2} α β e))) f) (Eq.{imax u1 u3} (α -> γ) g (Function.comp.{u1, u2, u3} α β γ f (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α β) (fun (_x : Equiv.{u1, u2} α β) => α -> β) (Equiv.hasCoeToFun.{u1, u2} α β) e)))
 but is expected to have type
-  forall {α : Sort.{u3}} {β : Sort.{u2}} {γ : Sort.{u1}} (e : Equiv.{u3, u2} α β) (f : β -> γ) (g : α -> γ), Iff (Eq.{imax u2 u1} (β -> γ) (Function.comp.{u2, u3, u1} β α γ g (FunLike.coe.{max (max 1 u2) u3, u2, u3} (Equiv.{u2, u3} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => α) _x) (Equiv.instFunLikeEquiv.{u2, u3} β α) (Equiv.symm.{u3, u2} α β e))) f) (Eq.{imax u3 u1} (α -> γ) g (Function.comp.{u3, u2, u1} α β γ f (FunLike.coe.{max (max 1 u2) u3, u3, u2} (Equiv.{u3, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => β) _x) (Equiv.instFunLikeEquiv.{u3, u2} α β) e)))
+  forall {α : Sort.{u3}} {β : Sort.{u2}} {γ : Sort.{u1}} (e : Equiv.{u3, u2} α β) (f : β -> γ) (g : α -> γ), Iff (Eq.{imax u2 u1} (β -> γ) (Function.comp.{u2, u3, u1} β α γ g (FunLike.coe.{max (max 1 u2) u3, u2, u3} (Equiv.{u2, u3} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => α) _x) (Equiv.instFunLikeEquiv.{u2, u3} β α) (Equiv.symm.{u3, u2} α β e))) f) (Eq.{imax u3 u1} (α -> γ) g (Function.comp.{u3, u2, u1} α β γ f (FunLike.coe.{max (max 1 u2) u3, u3, u2} (Equiv.{u3, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => β) _x) (Equiv.instFunLikeEquiv.{u3, u2} α β) e)))
 Case conversion may be inaccurate. Consider using '#align equiv.comp_symm_eq Equiv.comp_symm_eqₓ'. -/
 theorem comp_symm_eq {α β γ} (e : α ≃ β) (f : β → γ) (g : α → γ) : g ∘ e.symm = f ↔ g = f ∘ e :=
   (e.arrowCongr (Equiv.refl γ)).eq_symm_apply.symm
@@ -1079,7 +1079,7 @@ theorem comp_symm_eq {α β γ} (e : α ≃ β) (f : β → γ) (g : α → γ)
 lean 3 declaration is
   forall {α : Sort.{u1}} {β : Sort.{u2}} {γ : Sort.{u3}} (e : Equiv.{u1, u2} α β) (f : γ -> α) (g : γ -> β), Iff (Eq.{imax u3 u1} (γ -> α) f (Function.comp.{u3, u2, u1} γ β α (coeFn.{max 1 (imax u2 u1) (imax u1 u2), imax u2 u1} (Equiv.{u2, u1} β α) (fun (_x : Equiv.{u2, u1} β α) => β -> α) (Equiv.hasCoeToFun.{u2, u1} β α) (Equiv.symm.{u1, u2} α β e)) g)) (Eq.{imax u3 u2} (γ -> β) (Function.comp.{u3, u1, u2} γ α β (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α β) (fun (_x : Equiv.{u1, u2} α β) => α -> β) (Equiv.hasCoeToFun.{u1, u2} α β) e) f) g)
 but is expected to have type
-  forall {α : Sort.{u3}} {β : Sort.{u2}} {γ : Sort.{u1}} (e : Equiv.{u3, u2} α β) (f : γ -> α) (g : γ -> β), Iff (Eq.{imax u1 u3} (γ -> α) f (Function.comp.{u1, u2, u3} γ β α (FunLike.coe.{max (max 1 u2) u3, u2, u3} (Equiv.{u2, u3} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => α) _x) (Equiv.instFunLikeEquiv.{u2, u3} β α) (Equiv.symm.{u3, u2} α β e)) g)) (Eq.{imax u1 u2} (γ -> β) (Function.comp.{u1, u3, u2} γ α β (FunLike.coe.{max (max 1 u2) u3, u3, u2} (Equiv.{u3, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => β) _x) (Equiv.instFunLikeEquiv.{u3, u2} α β) e) f) g)
+  forall {α : Sort.{u3}} {β : Sort.{u2}} {γ : Sort.{u1}} (e : Equiv.{u3, u2} α β) (f : γ -> α) (g : γ -> β), Iff (Eq.{imax u1 u3} (γ -> α) f (Function.comp.{u1, u2, u3} γ β α (FunLike.coe.{max (max 1 u2) u3, u2, u3} (Equiv.{u2, u3} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => α) _x) (Equiv.instFunLikeEquiv.{u2, u3} β α) (Equiv.symm.{u3, u2} α β e)) g)) (Eq.{imax u1 u2} (γ -> β) (Function.comp.{u1, u3, u2} γ α β (FunLike.coe.{max (max 1 u2) u3, u3, u2} (Equiv.{u3, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => β) _x) (Equiv.instFunLikeEquiv.{u3, u2} α β) e) f) g)
 Case conversion may be inaccurate. Consider using '#align equiv.eq_symm_comp Equiv.eq_symm_compₓ'. -/
 theorem eq_symm_comp {α β γ} (e : α ≃ β) (f : γ → α) (g : γ → β) : f = e.symm ∘ g ↔ e ∘ f = g :=
   ((Equiv.refl γ).arrowCongr e).eq_symm_apply
@@ -1089,7 +1089,7 @@ theorem eq_symm_comp {α β γ} (e : α ≃ β) (f : γ → α) (g : γ → β)
 lean 3 declaration is
   forall {α : Sort.{u1}} {β : Sort.{u2}} {γ : Sort.{u3}} (e : Equiv.{u1, u2} α β) (f : γ -> α) (g : γ -> β), Iff (Eq.{imax u3 u1} (γ -> α) (Function.comp.{u3, u2, u1} γ β α (coeFn.{max 1 (imax u2 u1) (imax u1 u2), imax u2 u1} (Equiv.{u2, u1} β α) (fun (_x : Equiv.{u2, u1} β α) => β -> α) (Equiv.hasCoeToFun.{u2, u1} β α) (Equiv.symm.{u1, u2} α β e)) g) f) (Eq.{imax u3 u2} (γ -> β) g (Function.comp.{u3, u1, u2} γ α β (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α β) (fun (_x : Equiv.{u1, u2} α β) => α -> β) (Equiv.hasCoeToFun.{u1, u2} α β) e) f))
 but is expected to have type
-  forall {α : Sort.{u3}} {β : Sort.{u2}} {γ : Sort.{u1}} (e : Equiv.{u3, u2} α β) (f : γ -> α) (g : γ -> β), Iff (Eq.{imax u1 u3} (γ -> α) (Function.comp.{u1, u2, u3} γ β α (FunLike.coe.{max (max 1 u2) u3, u2, u3} (Equiv.{u2, u3} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => α) _x) (Equiv.instFunLikeEquiv.{u2, u3} β α) (Equiv.symm.{u3, u2} α β e)) g) f) (Eq.{imax u1 u2} (γ -> β) g (Function.comp.{u1, u3, u2} γ α β (FunLike.coe.{max (max 1 u2) u3, u3, u2} (Equiv.{u3, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => β) _x) (Equiv.instFunLikeEquiv.{u3, u2} α β) e) f))
+  forall {α : Sort.{u3}} {β : Sort.{u2}} {γ : Sort.{u1}} (e : Equiv.{u3, u2} α β) (f : γ -> α) (g : γ -> β), Iff (Eq.{imax u1 u3} (γ -> α) (Function.comp.{u1, u2, u3} γ β α (FunLike.coe.{max (max 1 u2) u3, u2, u3} (Equiv.{u2, u3} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => α) _x) (Equiv.instFunLikeEquiv.{u2, u3} β α) (Equiv.symm.{u3, u2} α β e)) g) f) (Eq.{imax u1 u2} (γ -> β) g (Function.comp.{u1, u3, u2} γ α β (FunLike.coe.{max (max 1 u2) u3, u3, u2} (Equiv.{u3, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => β) _x) (Equiv.instFunLikeEquiv.{u3, u2} α β) e) f))
 Case conversion may be inaccurate. Consider using '#align equiv.symm_comp_eq Equiv.symm_comp_eqₓ'. -/
 theorem symm_comp_eq {α β γ} (e : α ≃ β) (f : γ → α) (g : γ → β) : e.symm ∘ g = f ↔ g = e ∘ f :=
   ((Equiv.refl γ).arrowCongr e).symm_apply_eq
@@ -1418,7 +1418,7 @@ end Perm
 lean 3 declaration is
   forall {α₁ : Type.{u1}} {α₂ : Type.{u2}} {β : α₂ -> Type.{u3}} (e : Equiv.{succ u1, succ u2} α₁ α₂), Equiv.{max (succ u1) (succ u3), max (succ u2) (succ u3)} (Sigma.{u1, u3} α₁ (fun (a : α₁) => β (coeFn.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1), max (succ u1) (succ u2)} (Equiv.{succ u1, succ u2} α₁ α₂) (fun (_x : Equiv.{succ u1, succ u2} α₁ α₂) => α₁ -> α₂) (Equiv.hasCoeToFun.{succ u1, succ u2} α₁ α₂) e a))) (Sigma.{u2, u3} α₂ (fun (a : α₂) => β a))
 but is expected to have type
-  forall {α₁ : Type.{u1}} {α₂ : Type.{u2}} {β : α₁ -> Type.{u3}} (e : Equiv.{succ u2, succ u1} α₂ α₁), Equiv.{max (succ u3) (succ u2), max (succ u3) (succ u1)} (Sigma.{u2, u3} α₂ (fun (a : α₂) => β (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} (Equiv.{succ u2, succ u1} α₂ α₁) α₂ (fun (_x : α₂) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α₂) => α₁) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} α₂ α₁) e a))) (Sigma.{u1, u3} α₁ (fun (a : α₁) => β a))
+  forall {α₁ : Type.{u1}} {α₂ : Type.{u2}} {β : α₁ -> Type.{u3}} (e : Equiv.{succ u2, succ u1} α₂ α₁), Equiv.{max (succ u3) (succ u2), max (succ u3) (succ u1)} (Sigma.{u2, u3} α₂ (fun (a : α₂) => β (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} (Equiv.{succ u2, succ u1} α₂ α₁) α₂ (fun (_x : α₂) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α₂) => α₁) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} α₂ α₁) e a))) (Sigma.{u1, u3} α₁ (fun (a : α₁) => β a))
 Case conversion may be inaccurate. Consider using '#align equiv.sigma_congr_left Equiv.sigmaCongrLeftₓ'. -/
 /-- An equivalence `f : α₁ ≃ α₂` generates an equivalence between `Σ a, β (f a)` and `Σ a, β a`. -/
 @[simps apply]
@@ -1542,7 +1542,7 @@ variable {α₁ : Sort ua1} {α₂ : Sort ua2} {β₁ : Sort ub1} {β₂ : Sort
 lean 3 declaration is
   forall {α₁ : Sort.{u1}} {α₂ : Sort.{u2}} {β₁ : Sort.{u3}} {β₂ : Sort.{u4}} {p : α₁ -> β₁ -> Prop} {q : α₂ -> β₂ -> Prop} (eα : Equiv.{u1, u2} α₁ α₂) (eβ : Equiv.{u3, u4} β₁ β₂), (forall {x : α₁} {y : β₁}, Iff (p x y) (q (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α₁ α₂) (fun (_x : Equiv.{u1, u2} α₁ α₂) => α₁ -> α₂) (Equiv.hasCoeToFun.{u1, u2} α₁ α₂) eα x) (coeFn.{max 1 (imax u3 u4) (imax u4 u3), imax u3 u4} (Equiv.{u3, u4} β₁ β₂) (fun (_x : Equiv.{u3, u4} β₁ β₂) => β₁ -> β₂) (Equiv.hasCoeToFun.{u3, u4} β₁ β₂) eβ y))) -> (Iff (forall (x : α₁) (y : β₁), p x y) (forall (x : α₂) (y : β₂), q x y))
 but is expected to have type
-  forall {α₁ : Sort.{u4}} {α₂ : Sort.{u3}} {β₁ : Sort.{u2}} {β₂ : Sort.{u1}} {p : α₁ -> α₂ -> Prop} {q : β₁ -> β₂ -> Prop} (eα : Equiv.{u4, u2} α₁ β₁) (eβ : Equiv.{u3, u1} α₂ β₂), (forall {x : α₁} {y : α₂}, Iff (p x y) (q (FunLike.coe.{max (max 1 u4) u2, u4, u2} (Equiv.{u4, u2} α₁ β₁) α₁ (fun (_x : α₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α₁) => β₁) _x) (Equiv.instFunLikeEquiv.{u4, u2} α₁ β₁) eα x) (FunLike.coe.{max (max 1 u3) u1, u3, u1} (Equiv.{u3, u1} α₂ β₂) α₂ (fun (_x : α₂) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α₂) => β₂) _x) (Equiv.instFunLikeEquiv.{u3, u1} α₂ β₂) eβ y))) -> (Iff (forall (x : α₁) (y : α₂), p x y) (forall (x : β₁) (y : β₂), q x y))
+  forall {α₁ : Sort.{u4}} {α₂ : Sort.{u3}} {β₁ : Sort.{u2}} {β₂ : Sort.{u1}} {p : α₁ -> α₂ -> Prop} {q : β₁ -> β₂ -> Prop} (eα : Equiv.{u4, u2} α₁ β₁) (eβ : Equiv.{u3, u1} α₂ β₂), (forall {x : α₁} {y : α₂}, Iff (p x y) (q (FunLike.coe.{max (max 1 u4) u2, u4, u2} (Equiv.{u4, u2} α₁ β₁) α₁ (fun (_x : α₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α₁) => β₁) _x) (Equiv.instFunLikeEquiv.{u4, u2} α₁ β₁) eα x) (FunLike.coe.{max (max 1 u3) u1, u3, u1} (Equiv.{u3, u1} α₂ β₂) α₂ (fun (_x : α₂) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α₂) => β₂) _x) (Equiv.instFunLikeEquiv.{u3, u1} α₂ β₂) eβ y))) -> (Iff (forall (x : α₁) (y : α₂), p x y) (forall (x : β₁) (y : β₂), q x y))
 Case conversion may be inaccurate. Consider using '#align equiv.forall₂_congr Equiv.forall₂_congrₓ'. -/
 protected theorem forall₂_congr {p : α₁ → β₁ → Prop} {q : α₂ → β₂ → Prop} (eα : α₁ ≃ α₂)
     (eβ : β₁ ≃ β₂) (h : ∀ {x y}, p x y ↔ q (eα x) (eβ y)) : (∀ x y, p x y) ↔ ∀ x y, q x y :=
@@ -1558,7 +1558,7 @@ protected theorem forall₂_congr {p : α₁ → β₁ → Prop} {q : α₂ →
 lean 3 declaration is
   forall {α₁ : Sort.{u1}} {α₂ : Sort.{u2}} {β₁ : Sort.{u3}} {β₂ : Sort.{u4}} {p : α₁ -> β₁ -> Prop} {q : α₂ -> β₂ -> Prop} (eα : Equiv.{u1, u2} α₁ α₂) (eβ : Equiv.{u3, u4} β₁ β₂), (forall {x : α₂} {y : β₂}, Iff (p (coeFn.{max 1 (imax u2 u1) (imax u1 u2), imax u2 u1} (Equiv.{u2, u1} α₂ α₁) (fun (_x : Equiv.{u2, u1} α₂ α₁) => α₂ -> α₁) (Equiv.hasCoeToFun.{u2, u1} α₂ α₁) (Equiv.symm.{u1, u2} α₁ α₂ eα) x) (coeFn.{max 1 (imax u4 u3) (imax u3 u4), imax u4 u3} (Equiv.{u4, u3} β₂ β₁) (fun (_x : Equiv.{u4, u3} β₂ β₁) => β₂ -> β₁) (Equiv.hasCoeToFun.{u4, u3} β₂ β₁) (Equiv.symm.{u3, u4} β₁ β₂ eβ) y)) (q x y)) -> (Iff (forall (x : α₁) (y : β₁), p x y) (forall (x : α₂) (y : β₂), q x y))
 but is expected to have type
-  forall {α₁ : Sort.{u4}} {α₂ : Sort.{u3}} {β₁ : Sort.{u2}} {β₂ : Sort.{u1}} {p : α₁ -> α₂ -> Prop} {q : β₁ -> β₂ -> Prop} (eα : Equiv.{u4, u2} α₁ β₁) (eβ : Equiv.{u3, u1} α₂ β₂), (forall {x : β₁} {y : β₂}, Iff (p (FunLike.coe.{max (max 1 u4) u2, u2, u4} (Equiv.{u2, u4} β₁ α₁) β₁ (fun (_x : β₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β₁) => α₁) _x) (Equiv.instFunLikeEquiv.{u2, u4} β₁ α₁) (Equiv.symm.{u4, u2} α₁ β₁ eα) x) (FunLike.coe.{max (max 1 u3) u1, u1, u3} (Equiv.{u1, u3} β₂ α₂) β₂ (fun (_x : β₂) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β₂) => α₂) _x) (Equiv.instFunLikeEquiv.{u1, u3} β₂ α₂) (Equiv.symm.{u3, u1} α₂ β₂ eβ) y)) (q x y)) -> (Iff (forall (x : α₁) (y : α₂), p x y) (forall (x : β₁) (y : β₂), q x y))
+  forall {α₁ : Sort.{u4}} {α₂ : Sort.{u3}} {β₁ : Sort.{u2}} {β₂ : Sort.{u1}} {p : α₁ -> α₂ -> Prop} {q : β₁ -> β₂ -> Prop} (eα : Equiv.{u4, u2} α₁ β₁) (eβ : Equiv.{u3, u1} α₂ β₂), (forall {x : β₁} {y : β₂}, Iff (p (FunLike.coe.{max (max 1 u4) u2, u2, u4} (Equiv.{u2, u4} β₁ α₁) β₁ (fun (_x : β₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β₁) => α₁) _x) (Equiv.instFunLikeEquiv.{u2, u4} β₁ α₁) (Equiv.symm.{u4, u2} α₁ β₁ eα) x) (FunLike.coe.{max (max 1 u3) u1, u1, u3} (Equiv.{u1, u3} β₂ α₂) β₂ (fun (_x : β₂) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β₂) => α₂) _x) (Equiv.instFunLikeEquiv.{u1, u3} β₂ α₂) (Equiv.symm.{u3, u1} α₂ β₂ eβ) y)) (q x y)) -> (Iff (forall (x : α₁) (y : α₂), p x y) (forall (x : β₁) (y : β₂), q x y))
 Case conversion may be inaccurate. Consider using '#align equiv.forall₂_congr' Equiv.forall₂_congr'ₓ'. -/
 protected theorem forall₂_congr' {p : α₁ → β₁ → Prop} {q : α₂ → β₂ → Prop} (eα : α₁ ≃ α₂)
     (eβ : β₁ ≃ β₂) (h : ∀ {x y}, p (eα.symm x) (eβ.symm y) ↔ q x y) :
@@ -1570,7 +1570,7 @@ protected theorem forall₂_congr' {p : α₁ → β₁ → Prop} {q : α₂ →
 lean 3 declaration is
   forall {α₁ : Sort.{u1}} {α₂ : Sort.{u2}} {β₁ : Sort.{u3}} {β₂ : Sort.{u4}} {γ₁ : Sort.{u5}} {γ₂ : Sort.{u6}} {p : α₁ -> β₁ -> γ₁ -> Prop} {q : α₂ -> β₂ -> γ₂ -> Prop} (eα : Equiv.{u1, u2} α₁ α₂) (eβ : Equiv.{u3, u4} β₁ β₂) (eγ : Equiv.{u5, u6} γ₁ γ₂), (forall {x : α₁} {y : β₁} {z : γ₁}, Iff (p x y z) (q (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α₁ α₂) (fun (_x : Equiv.{u1, u2} α₁ α₂) => α₁ -> α₂) (Equiv.hasCoeToFun.{u1, u2} α₁ α₂) eα x) (coeFn.{max 1 (imax u3 u4) (imax u4 u3), imax u3 u4} (Equiv.{u3, u4} β₁ β₂) (fun (_x : Equiv.{u3, u4} β₁ β₂) => β₁ -> β₂) (Equiv.hasCoeToFun.{u3, u4} β₁ β₂) eβ y) (coeFn.{max 1 (imax u5 u6) (imax u6 u5), imax u5 u6} (Equiv.{u5, u6} γ₁ γ₂) (fun (_x : Equiv.{u5, u6} γ₁ γ₂) => γ₁ -> γ₂) (Equiv.hasCoeToFun.{u5, u6} γ₁ γ₂) eγ z))) -> (Iff (forall (x : α₁) (y : β₁) (z : γ₁), p x y z) (forall (x : α₂) (y : β₂) (z : γ₂), q x y z))
 but is expected to have type
-  forall {α₁ : Sort.{u6}} {α₂ : Sort.{u5}} {β₁ : Sort.{u4}} {β₂ : Sort.{u3}} {γ₁ : Sort.{u2}} {γ₂ : Sort.{u1}} {p : α₁ -> α₂ -> β₁ -> Prop} {q : β₂ -> γ₁ -> γ₂ -> Prop} (eα : Equiv.{u6, u3} α₁ β₂) (eβ : Equiv.{u5, u2} α₂ γ₁) (eγ : Equiv.{u4, u1} β₁ γ₂), (forall {x : α₁} {y : α₂} {z : β₁}, Iff (p x y z) (q (FunLike.coe.{max (max 1 u6) u3, u6, u3} (Equiv.{u6, u3} α₁ β₂) α₁ (fun (_x : α₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α₁) => β₂) _x) (Equiv.instFunLikeEquiv.{u6, u3} α₁ β₂) eα x) (FunLike.coe.{max (max 1 u5) u2, u5, u2} (Equiv.{u5, u2} α₂ γ₁) α₂ (fun (_x : α₂) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α₂) => γ₁) _x) (Equiv.instFunLikeEquiv.{u5, u2} α₂ γ₁) eβ y) (FunLike.coe.{max (max 1 u4) u1, u4, u1} (Equiv.{u4, u1} β₁ γ₂) β₁ (fun (_x : β₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β₁) => γ₂) _x) (Equiv.instFunLikeEquiv.{u4, u1} β₁ γ₂) eγ z))) -> (Iff (forall (x : α₁) (y : α₂) (z : β₁), p x y z) (forall (x : β₂) (y : γ₁) (z : γ₂), q x y z))
+  forall {α₁ : Sort.{u6}} {α₂ : Sort.{u5}} {β₁ : Sort.{u4}} {β₂ : Sort.{u3}} {γ₁ : Sort.{u2}} {γ₂ : Sort.{u1}} {p : α₁ -> α₂ -> β₁ -> Prop} {q : β₂ -> γ₁ -> γ₂ -> Prop} (eα : Equiv.{u6, u3} α₁ β₂) (eβ : Equiv.{u5, u2} α₂ γ₁) (eγ : Equiv.{u4, u1} β₁ γ₂), (forall {x : α₁} {y : α₂} {z : β₁}, Iff (p x y z) (q (FunLike.coe.{max (max 1 u6) u3, u6, u3} (Equiv.{u6, u3} α₁ β₂) α₁ (fun (_x : α₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α₁) => β₂) _x) (Equiv.instFunLikeEquiv.{u6, u3} α₁ β₂) eα x) (FunLike.coe.{max (max 1 u5) u2, u5, u2} (Equiv.{u5, u2} α₂ γ₁) α₂ (fun (_x : α₂) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α₂) => γ₁) _x) (Equiv.instFunLikeEquiv.{u5, u2} α₂ γ₁) eβ y) (FunLike.coe.{max (max 1 u4) u1, u4, u1} (Equiv.{u4, u1} β₁ γ₂) β₁ (fun (_x : β₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β₁) => γ₂) _x) (Equiv.instFunLikeEquiv.{u4, u1} β₁ γ₂) eγ z))) -> (Iff (forall (x : α₁) (y : α₂) (z : β₁), p x y z) (forall (x : β₂) (y : γ₁) (z : γ₂), q x y z))
 Case conversion may be inaccurate. Consider using '#align equiv.forall₃_congr Equiv.forall₃_congrₓ'. -/
 protected theorem forall₃_congr {p : α₁ → β₁ → γ₁ → Prop} {q : α₂ → β₂ → γ₂ → Prop} (eα : α₁ ≃ α₂)
     (eβ : β₁ ≃ β₂) (eγ : γ₁ ≃ γ₂) (h : ∀ {x y z}, p x y z ↔ q (eα x) (eβ y) (eγ z)) :
@@ -1587,7 +1587,7 @@ protected theorem forall₃_congr {p : α₁ → β₁ → γ₁ → Prop} {q :
 lean 3 declaration is
   forall {α₁ : Sort.{u1}} {α₂ : Sort.{u2}} {β₁ : Sort.{u3}} {β₂ : Sort.{u4}} {γ₁ : Sort.{u5}} {γ₂ : Sort.{u6}} {p : α₁ -> β₁ -> γ₁ -> Prop} {q : α₂ -> β₂ -> γ₂ -> Prop} (eα : Equiv.{u1, u2} α₁ α₂) (eβ : Equiv.{u3, u4} β₁ β₂) (eγ : Equiv.{u5, u6} γ₁ γ₂), (forall {x : α₂} {y : β₂} {z : γ₂}, Iff (p (coeFn.{max 1 (imax u2 u1) (imax u1 u2), imax u2 u1} (Equiv.{u2, u1} α₂ α₁) (fun (_x : Equiv.{u2, u1} α₂ α₁) => α₂ -> α₁) (Equiv.hasCoeToFun.{u2, u1} α₂ α₁) (Equiv.symm.{u1, u2} α₁ α₂ eα) x) (coeFn.{max 1 (imax u4 u3) (imax u3 u4), imax u4 u3} (Equiv.{u4, u3} β₂ β₁) (fun (_x : Equiv.{u4, u3} β₂ β₁) => β₂ -> β₁) (Equiv.hasCoeToFun.{u4, u3} β₂ β₁) (Equiv.symm.{u3, u4} β₁ β₂ eβ) y) (coeFn.{max 1 (imax u6 u5) (imax u5 u6), imax u6 u5} (Equiv.{u6, u5} γ₂ γ₁) (fun (_x : Equiv.{u6, u5} γ₂ γ₁) => γ₂ -> γ₁) (Equiv.hasCoeToFun.{u6, u5} γ₂ γ₁) (Equiv.symm.{u5, u6} γ₁ γ₂ eγ) z)) (q x y z)) -> (Iff (forall (x : α₁) (y : β₁) (z : γ₁), p x y z) (forall (x : α₂) (y : β₂) (z : γ₂), q x y z))
 but is expected to have type
-  forall {α₁ : Sort.{u6}} {α₂ : Sort.{u5}} {β₁ : Sort.{u4}} {β₂ : Sort.{u3}} {γ₁ : Sort.{u2}} {γ₂ : Sort.{u1}} {p : α₁ -> α₂ -> β₁ -> Prop} {q : β₂ -> γ₁ -> γ₂ -> Prop} (eα : Equiv.{u6, u3} α₁ β₂) (eβ : Equiv.{u5, u2} α₂ γ₁) (eγ : Equiv.{u4, u1} β₁ γ₂), (forall {x : β₂} {y : γ₁} {z : γ₂}, Iff (p (FunLike.coe.{max (max 1 u6) u3, u3, u6} (Equiv.{u3, u6} β₂ α₁) β₂ (fun (_x : β₂) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β₂) => α₁) _x) (Equiv.instFunLikeEquiv.{u3, u6} β₂ α₁) (Equiv.symm.{u6, u3} α₁ β₂ eα) x) (FunLike.coe.{max (max 1 u5) u2, u2, u5} (Equiv.{u2, u5} γ₁ α₂) γ₁ (fun (_x : γ₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : γ₁) => α₂) _x) (Equiv.instFunLikeEquiv.{u2, u5} γ₁ α₂) (Equiv.symm.{u5, u2} α₂ γ₁ eβ) y) (FunLike.coe.{max (max 1 u4) u1, u1, u4} (Equiv.{u1, u4} γ₂ β₁) γ₂ (fun (_x : γ₂) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : γ₂) => β₁) _x) (Equiv.instFunLikeEquiv.{u1, u4} γ₂ β₁) (Equiv.symm.{u4, u1} β₁ γ₂ eγ) z)) (q x y z)) -> (Iff (forall (x : α₁) (y : α₂) (z : β₁), p x y z) (forall (x : β₂) (y : γ₁) (z : γ₂), q x y z))
+  forall {α₁ : Sort.{u6}} {α₂ : Sort.{u5}} {β₁ : Sort.{u4}} {β₂ : Sort.{u3}} {γ₁ : Sort.{u2}} {γ₂ : Sort.{u1}} {p : α₁ -> α₂ -> β₁ -> Prop} {q : β₂ -> γ₁ -> γ₂ -> Prop} (eα : Equiv.{u6, u3} α₁ β₂) (eβ : Equiv.{u5, u2} α₂ γ₁) (eγ : Equiv.{u4, u1} β₁ γ₂), (forall {x : β₂} {y : γ₁} {z : γ₂}, Iff (p (FunLike.coe.{max (max 1 u6) u3, u3, u6} (Equiv.{u3, u6} β₂ α₁) β₂ (fun (_x : β₂) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β₂) => α₁) _x) (Equiv.instFunLikeEquiv.{u3, u6} β₂ α₁) (Equiv.symm.{u6, u3} α₁ β₂ eα) x) (FunLike.coe.{max (max 1 u5) u2, u2, u5} (Equiv.{u2, u5} γ₁ α₂) γ₁ (fun (_x : γ₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : γ₁) => α₂) _x) (Equiv.instFunLikeEquiv.{u2, u5} γ₁ α₂) (Equiv.symm.{u5, u2} α₂ γ₁ eβ) y) (FunLike.coe.{max (max 1 u4) u1, u1, u4} (Equiv.{u1, u4} γ₂ β₁) γ₂ (fun (_x : γ₂) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : γ₂) => β₁) _x) (Equiv.instFunLikeEquiv.{u1, u4} γ₂ β₁) (Equiv.symm.{u4, u1} β₁ γ₂ eγ) z)) (q x y z)) -> (Iff (forall (x : α₁) (y : α₂) (z : β₁), p x y z) (forall (x : β₂) (y : γ₁) (z : γ₂), q x y z))
 Case conversion may be inaccurate. Consider using '#align equiv.forall₃_congr' Equiv.forall₃_congr'ₓ'. -/
 protected theorem forall₃_congr' {p : α₁ → β₁ → γ₁ → Prop} {q : α₂ → β₂ → γ₂ → Prop} (eα : α₁ ≃ α₂)
     (eβ : β₁ ≃ β₂) (eγ : γ₁ ≃ γ₂) (h : ∀ {x y z}, p (eα.symm x) (eβ.symm y) (eγ.symm z) ↔ q x y z) :
@@ -1611,7 +1611,7 @@ protected theorem forall_congr_left {p : β → Prop} (f : α ≃ β) : (∀ x,
 lean 3 declaration is
   forall {α : Sort.{u1}} {β : Sort.{u2}} (f : Equiv.{u1, u2} α β) {p : α -> Prop}, Iff (Exists.{u1} α (fun (a : α) => p a)) (Exists.{u2} β (fun (b : β) => p (coeFn.{max 1 (imax u2 u1) (imax u1 u2), imax u2 u1} (Equiv.{u2, u1} β α) (fun (_x : Equiv.{u2, u1} β α) => β -> α) (Equiv.hasCoeToFun.{u2, u1} β α) (Equiv.symm.{u1, u2} α β f) b)))
 but is expected to have type
-  forall {α : Sort.{u2}} {β : Sort.{u1}} (f : Equiv.{u2, u1} α β) {p : α -> Prop}, Iff (Exists.{u2} α (fun (a : α) => p a)) (Exists.{u1} β (fun (b : β) => p (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => α) _x) (Equiv.instFunLikeEquiv.{u1, u2} β α) (Equiv.symm.{u2, u1} α β f) b)))
+  forall {α : Sort.{u2}} {β : Sort.{u1}} (f : Equiv.{u2, u1} α β) {p : α -> Prop}, Iff (Exists.{u2} α (fun (a : α) => p a)) (Exists.{u1} β (fun (b : β) => p (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => α) _x) (Equiv.instFunLikeEquiv.{u1, u2} β α) (Equiv.symm.{u2, u1} α β f) b)))
 Case conversion may be inaccurate. Consider using '#align equiv.exists_congr_left Equiv.exists_congr_leftₓ'. -/
 protected theorem exists_congr_left {α β} (f : α ≃ β) {p : α → Prop} :
     (∃ a, p a) ↔ ∃ b, p (f.symm b) :=

bump to nightly-2023-03-11-22

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

a8ee822f

Diff

@@ -146,7 +146,7 @@ protected theorem congr_arg {f : Equiv α β} {x x' : α} : x = x' → f x = f x
 lean 3 declaration is
   forall {α : Sort.{u1}} {β : Sort.{u2}} {f : Equiv.{u1, u2} α β} {g : Equiv.{u1, u2} α β}, (Eq.{max 1 (imax u1 u2) (imax u2 u1)} (Equiv.{u1, u2} α β) f g) -> (forall (x : α), Eq.{u2} β (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α β) (fun (_x : Equiv.{u1, u2} α β) => α -> β) (Equiv.hasCoeToFun.{u1, u2} α β) f x) (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α β) (fun (_x : Equiv.{u1, u2} α β) => α -> β) (Equiv.hasCoeToFun.{u1, u2} α β) g x))
 but is expected to have type
-  forall {α : Sort.{u1}} {β : Sort.{u2}} {f : Equiv.{u1, u2} α β} {g : Equiv.{u1, u2} α β}, (Eq.{max (max 1 u1) u2} (Equiv.{u1, u2} α β) f g) -> (forall (x : α), Eq.{u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α) => β) x) (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α) => β) _x) (Equiv.instFunLikeEquiv.{u1, u2} α β) f x) (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α) => β) _x) (Equiv.instFunLikeEquiv.{u1, u2} α β) g x))
+  forall {α : Sort.{u1}} {β : Sort.{u2}} {f : Equiv.{u1, u2} α β} {g : Equiv.{u1, u2} α β}, (Eq.{max (max 1 u1) u2} (Equiv.{u1, u2} α β) f g) -> (forall (x : α), Eq.{u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => β) x) (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => β) _x) (Equiv.instFunLikeEquiv.{u1, u2} α β) f x) (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => β) _x) (Equiv.instFunLikeEquiv.{u1, u2} α β) g x))
 Case conversion may be inaccurate. Consider using '#align equiv.congr_fun Equiv.congr_funₓ'. -/
 protected theorem congr_fun {f g : Equiv α β} (h : f = g) (x : α) : f x = g x :=
   FunLike.congr_fun h x
@@ -156,7 +156,7 @@ protected theorem congr_fun {f g : Equiv α β} (h : f = g) (x : α) : f x = g x
 lean 3 declaration is
   forall {α : Sort.{u1}} {β : Sort.{u2}} {f : Equiv.{u1, u2} α β} {g : Equiv.{u1, u2} α β}, Iff (Eq.{max 1 (imax u1 u2) (imax u2 u1)} (Equiv.{u1, u2} α β) f g) (forall (x : α), Eq.{u2} β (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α β) (fun (_x : Equiv.{u1, u2} α β) => α -> β) (Equiv.hasCoeToFun.{u1, u2} α β) f x) (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α β) (fun (_x : Equiv.{u1, u2} α β) => α -> β) (Equiv.hasCoeToFun.{u1, u2} α β) g x))
 but is expected to have type
-  forall {α : Sort.{u1}} {β : Sort.{u2}} {f : Equiv.{u1, u2} α β} {g : Equiv.{u1, u2} α β}, Iff (Eq.{max (max 1 u1) u2} (Equiv.{u1, u2} α β) f g) (forall (x : α), Eq.{u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α) => β) x) (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α) => β) _x) (Equiv.instFunLikeEquiv.{u1, u2} α β) f x) (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α) => β) _x) (Equiv.instFunLikeEquiv.{u1, u2} α β) g x))
+  forall {α : Sort.{u1}} {β : Sort.{u2}} {f : Equiv.{u1, u2} α β} {g : Equiv.{u1, u2} α β}, Iff (Eq.{max (max 1 u1) u2} (Equiv.{u1, u2} α β) f g) (forall (x : α), Eq.{u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => β) x) (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => β) _x) (Equiv.instFunLikeEquiv.{u1, u2} α β) f x) (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => β) _x) (Equiv.instFunLikeEquiv.{u1, u2} α β) g x))
 Case conversion may be inaccurate. Consider using '#align equiv.ext_iff Equiv.ext_iffₓ'. -/
 theorem ext_iff {f g : Equiv α β} : f = g ↔ ∀ x, f x = g x :=
   FunLike.ext_iff
@@ -447,7 +447,7 @@ theorem apply_eq_iff_eq (f : α ≃ β) {x y : α} : f x = f y ↔ x = y :=
 lean 3 declaration is
   forall {α : Sort.{u1}} {β : Sort.{u2}} (f : Equiv.{u1, u2} α β) {x : α} {y : β}, Iff (Eq.{u2} β (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α β) (fun (_x : Equiv.{u1, u2} α β) => α -> β) (Equiv.hasCoeToFun.{u1, u2} α β) f x) y) (Eq.{u1} α x (coeFn.{max 1 (imax u2 u1) (imax u1 u2), imax u2 u1} (Equiv.{u2, u1} β α) (fun (_x : Equiv.{u2, u1} β α) => β -> α) (Equiv.hasCoeToFun.{u2, u1} β α) (Equiv.symm.{u1, u2} α β f) y))
 but is expected to have type
-  forall {α : Sort.{u1}} {β : Sort.{u2}} {f : α} {x : (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α) => β) f} (y : Equiv.{u1, u2} α β), Iff (Eq.{u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α) => β) f) (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α) => β) _x) (Equiv.instFunLikeEquiv.{u1, u2} α β) y f) x) (Eq.{u1} α f (FunLike.coe.{max (max 1 u1) u2, u2, u1} (Equiv.{u2, u1} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : β) => α) _x) (Equiv.instFunLikeEquiv.{u2, u1} β α) (Equiv.symm.{u1, u2} α β y) x))
+  forall {α : Sort.{u1}} {β : Sort.{u2}} {f : α} {x : (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => β) f} (y : Equiv.{u1, u2} α β), Iff (Eq.{u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => β) f) (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => β) _x) (Equiv.instFunLikeEquiv.{u1, u2} α β) y f) x) (Eq.{u1} α f (FunLike.coe.{max (max 1 u1) u2, u2, u1} (Equiv.{u2, u1} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => α) _x) (Equiv.instFunLikeEquiv.{u2, u1} β α) (Equiv.symm.{u1, u2} α β y) x))
 Case conversion may be inaccurate. Consider using '#align equiv.apply_eq_iff_eq_symm_apply Equiv.apply_eq_iff_eq_symm_applyₓ'. -/
 theorem apply_eq_iff_eq_symm_apply {α β : Sort _} (f : α ≃ β) {x : α} {y : β} :
     f x = y ↔ x = f.symm y := by
@@ -498,7 +498,7 @@ theorem cast_eq_iff_heq {α β} (h : α = β) {a : α} {b : β} : Equiv.cast h a
 lean 3 declaration is
   forall {α : Sort.{u1}} {β : Sort.{u2}} (e : Equiv.{u1, u2} α β) {x : β} {y : α}, Iff (Eq.{u1} α (coeFn.{max 1 (imax u2 u1) (imax u1 u2), imax u2 u1} (Equiv.{u2, u1} β α) (fun (_x : Equiv.{u2, u1} β α) => β -> α) (Equiv.hasCoeToFun.{u2, u1} β α) (Equiv.symm.{u1, u2} α β e) x) y) (Eq.{u2} β x (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α β) (fun (_x : Equiv.{u1, u2} α β) => α -> β) (Equiv.hasCoeToFun.{u1, u2} α β) e y))
 but is expected to have type
-  forall {α : Sort.{u2}} {β : Sort.{u1}} (e : Equiv.{u2, u1} α β) {x : β} {y : (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : β) => α) x}, Iff (Eq.{u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : β) => α) x) (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : β) => α) _x) (Equiv.instFunLikeEquiv.{u1, u2} β α) (Equiv.symm.{u2, u1} α β e) x) y) (Eq.{u1} β x (FunLike.coe.{max (max 1 u1) u2, u2, u1} (Equiv.{u2, u1} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α) => β) _x) (Equiv.instFunLikeEquiv.{u2, u1} α β) e y))
+  forall {α : Sort.{u2}} {β : Sort.{u1}} (e : Equiv.{u2, u1} α β) {x : β} {y : (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => α) x}, Iff (Eq.{u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => α) x) (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => α) _x) (Equiv.instFunLikeEquiv.{u1, u2} β α) (Equiv.symm.{u2, u1} α β e) x) y) (Eq.{u1} β x (FunLike.coe.{max (max 1 u1) u2, u2, u1} (Equiv.{u2, u1} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => β) _x) (Equiv.instFunLikeEquiv.{u2, u1} α β) e y))
 Case conversion may be inaccurate. Consider using '#align equiv.symm_apply_eq Equiv.symm_apply_eqₓ'. -/
 theorem symm_apply_eq {α β} (e : α ≃ β) {x y} : e.symm x = y ↔ x = e y :=
   ⟨fun H => by simp [H.symm], fun H => by simp [H]⟩
@@ -508,7 +508,7 @@ theorem symm_apply_eq {α β} (e : α ≃ β) {x y} : e.symm x = y ↔ x = e y :
 lean 3 declaration is
   forall {α : Sort.{u1}} {β : Sort.{u2}} (e : Equiv.{u1, u2} α β) {x : β} {y : α}, Iff (Eq.{u1} α y (coeFn.{max 1 (imax u2 u1) (imax u1 u2), imax u2 u1} (Equiv.{u2, u1} β α) (fun (_x : Equiv.{u2, u1} β α) => β -> α) (Equiv.hasCoeToFun.{u2, u1} β α) (Equiv.symm.{u1, u2} α β e) x)) (Eq.{u2} β (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α β) (fun (_x : Equiv.{u1, u2} α β) => α -> β) (Equiv.hasCoeToFun.{u1, u2} α β) e y) x)
 but is expected to have type
-  forall {α : Sort.{u2}} {β : Sort.{u1}} (e : Equiv.{u2, u1} α β) {x : β} {y : (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : β) => α) x}, Iff (Eq.{u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : β) => α) x) y (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : β) => α) _x) (Equiv.instFunLikeEquiv.{u1, u2} β α) (Equiv.symm.{u2, u1} α β e) x)) (Eq.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α) => β) y) (FunLike.coe.{max (max 1 u1) u2, u2, u1} (Equiv.{u2, u1} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α) => β) _x) (Equiv.instFunLikeEquiv.{u2, u1} α β) e y) x)
+  forall {α : Sort.{u2}} {β : Sort.{u1}} (e : Equiv.{u2, u1} α β) {x : β} {y : (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => α) x}, Iff (Eq.{u2} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => α) x) y (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => α) _x) (Equiv.instFunLikeEquiv.{u1, u2} β α) (Equiv.symm.{u2, u1} α β e) x)) (Eq.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => β) y) (FunLike.coe.{max (max 1 u1) u2, u2, u1} (Equiv.{u2, u1} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => β) _x) (Equiv.instFunLikeEquiv.{u2, u1} α β) e y) x)
 Case conversion may be inaccurate. Consider using '#align equiv.eq_symm_apply Equiv.eq_symm_applyₓ'. -/
 theorem eq_symm_apply {α β} (e : α ≃ β) {x y} : y = e.symm x ↔ e y = x :=
   (eq_comm.trans e.symm_apply_eq).trans eq_comm
@@ -695,7 +695,7 @@ theorem equivCongr_trans {δ ε ζ} (ab : α ≃ β) (de : δ ≃ ε) (bc : β 
 lean 3 declaration is
   forall {α : Sort.{u1}} {β : Sort.{u2}} {γ : Sort.{u3}} (bg : Equiv.{u2, u3} β γ) (e : Equiv.{u1, u2} α β), Eq.{max 1 (imax u1 u3) (imax u3 u1)} (Equiv.{u1, u3} α γ) (coeFn.{max 1 (max (max 1 (imax u1 u2) (imax u2 u1)) 1 (imax u1 u3) (imax u3 u1)) (max 1 (imax u1 u3) (imax u3 u1)) 1 (imax u1 u2) (imax u2 u1), max (max 1 (imax u1 u2) (imax u2 u1)) 1 (imax u1 u3) (imax u3 u1)} (Equiv.{max 1 (imax u1 u2) (imax u2 u1), max 1 (imax u1 u3) (imax u3 u1)} (Equiv.{u1, u2} α β) (Equiv.{u1, u3} α γ)) (fun (_x : Equiv.{max 1 (imax u1 u2) (imax u2 u1), max 1 (imax u1 u3) (imax u3 u1)} (Equiv.{u1, u2} α β) (Equiv.{u1, u3} α γ)) => (Equiv.{u1, u2} α β) -> (Equiv.{u1, u3} α γ)) (Equiv.hasCoeToFun.{max 1 (imax u1 u2) (imax u2 u1), max 1 (imax u1 u3) (imax u3 u1)} (Equiv.{u1, u2} α β) (Equiv.{u1, u3} α γ)) (Equiv.equivCongr.{u1, u1, u2, u3} α α β γ (Equiv.refl.{u1} α) bg) e) (Equiv.trans.{u1, u2, u3} α β γ e bg)
 but is expected to have type
-  forall {α : Sort.{u3}} {β : Sort.{u2}} {γ : Sort.{u1}} (bg : Equiv.{u2, u1} β γ) (e : Equiv.{u3, u2} α β), Eq.{max (max 1 u1) u3} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Equiv.{u3, u2} α β) => Equiv.{u3, u1} α γ) e) (FunLike.coe.{max (max (max 1 u1) u2) u3, max (max 1 u2) u3, max (max 1 u1) u3} (Equiv.{max (max 1 u2) u3, max (max 1 u1) u3} (Equiv.{u3, u2} α β) (Equiv.{u3, u1} α γ)) (Equiv.{u3, u2} α β) (fun (_x : Equiv.{u3, u2} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Equiv.{u3, u2} α β) => Equiv.{u3, u1} α γ) _x) (Equiv.instFunLikeEquiv.{max (max 1 u2) u3, max (max 1 u1) u3} (Equiv.{u3, u2} α β) (Equiv.{u3, u1} α γ)) (Equiv.equivCongr.{u3, u3, u2, u1} α α β γ (Equiv.refl.{u3} α) bg) e) (Equiv.trans.{u3, u2, u1} α β γ e bg)
+  forall {α : Sort.{u3}} {β : Sort.{u2}} {γ : Sort.{u1}} (bg : Equiv.{u2, u1} β γ) (e : Equiv.{u3, u2} α β), Eq.{max (max 1 u1) u3} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Equiv.{u3, u2} α β) => Equiv.{u3, u1} α γ) e) (FunLike.coe.{max (max (max 1 u1) u2) u3, max (max 1 u2) u3, max (max 1 u1) u3} (Equiv.{max (max 1 u2) u3, max (max 1 u1) u3} (Equiv.{u3, u2} α β) (Equiv.{u3, u1} α γ)) (Equiv.{u3, u2} α β) (fun (_x : Equiv.{u3, u2} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Equiv.{u3, u2} α β) => Equiv.{u3, u1} α γ) _x) (Equiv.instFunLikeEquiv.{max (max 1 u2) u3, max (max 1 u1) u3} (Equiv.{u3, u2} α β) (Equiv.{u3, u1} α γ)) (Equiv.equivCongr.{u3, u3, u2, u1} α α β γ (Equiv.refl.{u3} α) bg) e) (Equiv.trans.{u3, u2, u1} α β γ e bg)
 Case conversion may be inaccurate. Consider using '#align equiv.equiv_congr_refl_left Equiv.equivCongr_refl_leftₓ'. -/
 @[simp]
 theorem equivCongr_refl_left {α β γ} (bg : β ≃ γ) (e : α ≃ β) :
@@ -707,7 +707,7 @@ theorem equivCongr_refl_left {α β γ} (bg : β ≃ γ) (e : α ≃ β) :
 lean 3 declaration is
   forall {α : Sort.{u1}} {β : Sort.{u2}} (ab : Equiv.{u1, u2} α β) (e : Equiv.{u1, u2} α β), Eq.{max 1 u2} (Equiv.{u2, u2} β β) (coeFn.{max 1 (max (max 1 (imax u1 u2) (imax u2 u1)) 1 u2) (max 1 u2) 1 (imax u1 u2) (imax u2 u1), max (max 1 (imax u1 u2) (imax u2 u1)) 1 u2} (Equiv.{max 1 (imax u1 u2) (imax u2 u1), max 1 u2} (Equiv.{u1, u2} α β) (Equiv.{u2, u2} β β)) (fun (_x : Equiv.{max 1 (imax u1 u2) (imax u2 u1), max 1 u2} (Equiv.{u1, u2} α β) (Equiv.{u2, u2} β β)) => (Equiv.{u1, u2} α β) -> (Equiv.{u2, u2} β β)) (Equiv.hasCoeToFun.{max 1 (imax u1 u2) (imax u2 u1), max 1 u2} (Equiv.{u1, u2} α β) (Equiv.{u2, u2} β β)) (Equiv.equivCongr.{u1, u2, u2, u2} α β β β ab (Equiv.refl.{u2} β)) e) (Equiv.trans.{u2, u1, u2} β α β (Equiv.symm.{u1, u2} α β ab) e)
 but is expected to have type
-  forall {α : Sort.{u2}} {β : Sort.{u1}} (ab : Equiv.{u2, u1} α β) (e : Equiv.{u2, u1} α β), Eq.{max 1 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Equiv.{u2, u1} α β) => Equiv.{u1, u1} β β) e) (FunLike.coe.{max (max 1 u1) u2, max (max 1 u1) u2, max 1 u1} (Equiv.{max (max 1 u1) u2, max 1 u1} (Equiv.{u2, u1} α β) (Equiv.{u1, u1} β β)) (Equiv.{u2, u1} α β) (fun (_x : Equiv.{u2, u1} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Equiv.{u2, u1} α β) => Equiv.{u1, u1} β β) _x) (Equiv.instFunLikeEquiv.{max (max 1 u1) u2, max 1 u1} (Equiv.{u2, u1} α β) (Equiv.{u1, u1} β β)) (Equiv.equivCongr.{u2, u1, u1, u1} α β β β ab (Equiv.refl.{u1} β)) e) (Equiv.trans.{u1, u2, u1} β α β (Equiv.symm.{u2, u1} α β ab) e)
+  forall {α : Sort.{u2}} {β : Sort.{u1}} (ab : Equiv.{u2, u1} α β) (e : Equiv.{u2, u1} α β), Eq.{max 1 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Equiv.{u2, u1} α β) => Equiv.{u1, u1} β β) e) (FunLike.coe.{max (max 1 u1) u2, max (max 1 u1) u2, max 1 u1} (Equiv.{max (max 1 u1) u2, max 1 u1} (Equiv.{u2, u1} α β) (Equiv.{u1, u1} β β)) (Equiv.{u2, u1} α β) (fun (_x : Equiv.{u2, u1} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Equiv.{u2, u1} α β) => Equiv.{u1, u1} β β) _x) (Equiv.instFunLikeEquiv.{max (max 1 u1) u2, max 1 u1} (Equiv.{u2, u1} α β) (Equiv.{u1, u1} β β)) (Equiv.equivCongr.{u2, u1, u1, u1} α β β β ab (Equiv.refl.{u1} β)) e) (Equiv.trans.{u1, u2, u1} β α β (Equiv.symm.{u2, u1} α β ab) e)
 Case conversion may be inaccurate. Consider using '#align equiv.equiv_congr_refl_right Equiv.equivCongr_refl_rightₓ'. -/
 @[simp]
 theorem equivCongr_refl_right {α β} (ab e : α ≃ β) :
@@ -719,7 +719,7 @@ theorem equivCongr_refl_right {α β} (ab e : α ≃ β) :
 lean 3 declaration is
   forall {α : Sort.{u1}} {β : Sort.{u2}} {γ : Sort.{u3}} {δ : Sort.{u4}} (ab : Equiv.{u1, u2} α β) (cd : Equiv.{u3, u4} γ δ) (e : Equiv.{u1, u3} α γ) (x : β), Eq.{u4} δ (coeFn.{max 1 (imax u2 u4) (imax u4 u2), imax u2 u4} (Equiv.{u2, u4} β δ) (fun (_x : Equiv.{u2, u4} β δ) => β -> δ) (Equiv.hasCoeToFun.{u2, u4} β δ) (coeFn.{max 1 (max (max 1 (imax u1 u3) (imax u3 u1)) 1 (imax u2 u4) (imax u4 u2)) (max 1 (imax u2 u4) (imax u4 u2)) 1 (imax u1 u3) (imax u3 u1), max (max 1 (imax u1 u3) (imax u3 u1)) 1 (imax u2 u4) (imax u4 u2)} (Equiv.{max 1 (imax u1 u3) (imax u3 u1), max 1 (imax u2 u4) (imax u4 u2)} (Equiv.{u1, u3} α γ) (Equiv.{u2, u4} β δ)) (fun (_x : Equiv.{max 1 (imax u1 u3) (imax u3 u1), max 1 (imax u2 u4) (imax u4 u2)} (Equiv.{u1, u3} α γ) (Equiv.{u2, u4} β δ)) => (Equiv.{u1, u3} α γ) -> (Equiv.{u2, u4} β δ)) (Equiv.hasCoeToFun.{max 1 (imax u1 u3) (imax u3 u1), max 1 (imax u2 u4) (imax u4 u2)} (Equiv.{u1, u3} α γ) (Equiv.{u2, u4} β δ)) (Equiv.equivCongr.{u1, u2, u3, u4} α β γ δ ab cd) e) x) (coeFn.{max 1 (imax u3 u4) (imax u4 u3), imax u3 u4} (Equiv.{u3, u4} γ δ) (fun (_x : Equiv.{u3, u4} γ δ) => γ -> δ) (Equiv.hasCoeToFun.{u3, u4} γ δ) cd (coeFn.{max 1 (imax u1 u3) (imax u3 u1), imax u1 u3} (Equiv.{u1, u3} α γ) (fun (_x : Equiv.{u1, u3} α γ) => α -> γ) (Equiv.hasCoeToFun.{u1, u3} α γ) e (coeFn.{max 1 (imax u2 u1) (imax u1 u2), imax u2 u1} (Equiv.{u2, u1} β α) (fun (_x : Equiv.{u2, u1} β α) => β -> α) (Equiv.hasCoeToFun.{u2, u1} β α) (Equiv.symm.{u1, u2} α β ab) x)))
 but is expected to have type
-  forall {α : Sort.{u2}} {β : Sort.{u3}} {γ : Sort.{u4}} {δ : Sort.{u1}} (ab : Equiv.{u2, u3} α β) (cd : Equiv.{u4, u1} γ δ) (e : Equiv.{u2, u4} α γ) (x : β), Eq.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : β) => δ) x) (FunLike.coe.{max (max 1 u3) u1, u3, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Equiv.{u2, u4} α γ) => Equiv.{u3, u1} β δ) e) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : β) => δ) _x) (Equiv.instFunLikeEquiv.{u3, u1} β δ) (FunLike.coe.{max (max (max (max 1 u2) u3) u4) u1, max (max 1 u2) u4, max (max 1 u3) u1} (Equiv.{max (max 1 u4) u2, max (max 1 u1) u3} (Equiv.{u2, u4} α γ) (Equiv.{u3, u1} β δ)) (Equiv.{u2, u4} α γ) (fun (_x : Equiv.{u2, u4} α γ) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Equiv.{u2, u4} α γ) => Equiv.{u3, u1} β δ) _x) (Equiv.instFunLikeEquiv.{max (max 1 u2) u4, max (max 1 u3) u1} (Equiv.{u2, u4} α γ) (Equiv.{u3, u1} β δ)) (Equiv.equivCongr.{u2, u3, u4, u1} α β γ δ ab cd) e) x) (FunLike.coe.{max (max 1 u4) u1, u4, u1} (Equiv.{u4, u1} γ δ) γ (fun (_x : γ) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : γ) => δ) _x) (Equiv.instFunLikeEquiv.{u4, u1} γ δ) cd (FunLike.coe.{max (max 1 u2) u4, u2, u4} (Equiv.{u2, u4} α γ) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α) => γ) _x) (Equiv.instFunLikeEquiv.{u2, u4} α γ) e (FunLike.coe.{max (max 1 u2) u3, u3, u2} (Equiv.{u3, u2} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : β) => α) _x) (Equiv.instFunLikeEquiv.{u3, u2} β α) (Equiv.symm.{u2, u3} α β ab) x)))
+  forall {α : Sort.{u2}} {β : Sort.{u3}} {γ : Sort.{u4}} {δ : Sort.{u1}} (ab : Equiv.{u2, u3} α β) (cd : Equiv.{u4, u1} γ δ) (e : Equiv.{u2, u4} α γ) (x : β), Eq.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => δ) x) (FunLike.coe.{max (max 1 u3) u1, u3, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Equiv.{u2, u4} α γ) => Equiv.{u3, u1} β δ) e) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => δ) _x) (Equiv.instFunLikeEquiv.{u3, u1} β δ) (FunLike.coe.{max (max (max (max 1 u2) u3) u4) u1, max (max 1 u2) u4, max (max 1 u3) u1} (Equiv.{max (max 1 u4) u2, max (max 1 u1) u3} (Equiv.{u2, u4} α γ) (Equiv.{u3, u1} β δ)) (Equiv.{u2, u4} α γ) (fun (_x : Equiv.{u2, u4} α γ) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Equiv.{u2, u4} α γ) => Equiv.{u3, u1} β δ) _x) (Equiv.instFunLikeEquiv.{max (max 1 u2) u4, max (max 1 u3) u1} (Equiv.{u2, u4} α γ) (Equiv.{u3, u1} β δ)) (Equiv.equivCongr.{u2, u3, u4, u1} α β γ δ ab cd) e) x) (FunLike.coe.{max (max 1 u4) u1, u4, u1} (Equiv.{u4, u1} γ δ) γ (fun (_x : γ) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : γ) => δ) _x) (Equiv.instFunLikeEquiv.{u4, u1} γ δ) cd (FunLike.coe.{max (max 1 u2) u4, u2, u4} (Equiv.{u2, u4} α γ) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => γ) _x) (Equiv.instFunLikeEquiv.{u2, u4} α γ) e (FunLike.coe.{max (max 1 u2) u3, u3, u2} (Equiv.{u3, u2} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => α) _x) (Equiv.instFunLikeEquiv.{u3, u2} β α) (Equiv.symm.{u2, u3} α β ab) x)))
 Case conversion may be inaccurate. Consider using '#align equiv.equiv_congr_apply_apply Equiv.equivCongr_apply_applyₓ'. -/
 @[simp]
 theorem equivCongr_apply_apply {δ} (ab : α ≃ β) (cd : γ ≃ δ) (e : α ≃ γ) (x) :
@@ -742,7 +742,7 @@ def permCongr : Perm α' ≃ Perm β' :=
 lean 3 declaration is
   forall {α' : Type.{u1}} {β' : Type.{u2}} (e : Equiv.{succ u1, succ u2} α' β') (p : Equiv.Perm.{succ u1} α'), Eq.{succ u2} (Equiv.Perm.{succ u2} β') (coeFn.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1), max (succ u1) (succ u2)} (Equiv.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) (fun (_x : Equiv.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) => (Equiv.Perm.{succ u1} α') -> (Equiv.Perm.{succ u2} β')) (Equiv.hasCoeToFun.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) (Equiv.permCongr.{u1, u2} α' β' e) p) (Equiv.trans.{succ u2, succ u1, succ u2} β' α' β' (Equiv.trans.{succ u2, succ u1, succ u1} β' α' α' (Equiv.symm.{succ u1, succ u2} α' β' e) p) e)
 but is expected to have type
-  forall {α' : Type.{u2}} {β' : Type.{u1}} (e : Equiv.{succ u2, succ u1} α' β') (p : Equiv.Perm.{succ u2} α'), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') p) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.Perm.{succ u2} α') (fun (_x : Equiv.Perm.{succ u2} α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.permCongr.{u2, u1} α' β' e) p) (Equiv.trans.{succ u1, succ u2, succ u1} β' α' β' (Equiv.trans.{succ u1, succ u2, succ u2} β' α' α' (Equiv.symm.{succ u2, succ u1} α' β' e) p) e)
+  forall {α' : Type.{u2}} {β' : Type.{u1}} (e : Equiv.{succ u2, succ u1} α' β') (p : Equiv.Perm.{succ u2} α'), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') p) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.Perm.{succ u2} α') (fun (_x : Equiv.Perm.{succ u2} α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.permCongr.{u2, u1} α' β' e) p) (Equiv.trans.{succ u1, succ u2, succ u1} β' α' β' (Equiv.trans.{succ u1, succ u2, succ u2} β' α' α' (Equiv.symm.{succ u2, succ u1} α' β' e) p) e)
 Case conversion may be inaccurate. Consider using '#align equiv.perm_congr_def Equiv.permCongr_defₓ'. -/
 theorem permCongr_def (p : Equiv.Perm α') : e.permCongr p = (e.symm.trans p).trans e :=
   rfl
@@ -769,7 +769,7 @@ theorem permCongr_symm : e.permCongr.symm = e.symm.permCongr :=
 lean 3 declaration is
   forall {α' : Type.{u1}} {β' : Type.{u2}} (e : Equiv.{succ u1, succ u2} α' β') (p : Equiv.Perm.{succ u1} α') (x : β'), Eq.{succ u2} β' (coeFn.{succ u2, succ u2} (Equiv.Perm.{succ u2} β') (fun (_x : Equiv.{succ u2, succ u2} β' β') => β' -> β') (Equiv.hasCoeToFun.{succ u2, succ u2} β' β') (coeFn.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1), max (succ u1) (succ u2)} (Equiv.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) (fun (_x : Equiv.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) => (Equiv.Perm.{succ u1} α') -> (Equiv.Perm.{succ u2} β')) (Equiv.hasCoeToFun.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) (Equiv.permCongr.{u1, u2} α' β' e) p) x) (coeFn.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1), max (succ u1) (succ u2)} (Equiv.{succ u1, succ u2} α' β') (fun (_x : Equiv.{succ u1, succ u2} α' β') => α' -> β') (Equiv.hasCoeToFun.{succ u1, succ u2} α' β') e (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α') (fun (_x : Equiv.{succ u1, succ u1} α' α') => α' -> α') (Equiv.hasCoeToFun.{succ u1, succ u1} α' α') p (coeFn.{max 1 (max (succ u2) (succ u1)) (succ u1) (succ u2), max (succ u2) (succ u1)} (Equiv.{succ u2, succ u1} β' α') (fun (_x : Equiv.{succ u2, succ u1} β' α') => β' -> α') (Equiv.hasCoeToFun.{succ u2, succ u1} β' α') (Equiv.symm.{succ u1, succ u2} α' β' e) x)))
 but is expected to have type
-  forall {α' : Type.{u2}} {β' : Type.{u1}} (e : Equiv.{succ u2, succ u1} α' β') (p : Equiv.Perm.{succ u2} α') (x : β'), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : β') => β') x) (FunLike.coe.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') p) β' (fun (_x : β') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : β') => β') _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} β' β') (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.Perm.{succ u2} α') (fun (_x : Equiv.Perm.{succ u2} α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.permCongr.{u2, u1} α' β' e) p) x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} α' β') α' (fun (_x : α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α') => β') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} α' β') e (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.Perm.{succ u2} α') α' (fun (_x : α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α') => α') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} α' α') p (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (Equiv.{succ u1, succ u2} β' α') β' (fun (_x : β') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : β') => α') _x) (Equiv.instFunLikeEquiv.{succ u1, succ u2} β' α') (Equiv.symm.{succ u2, succ u1} α' β' e) x)))
+  forall {α' : Type.{u2}} {β' : Type.{u1}} (e : Equiv.{succ u2, succ u1} α' β') (p : Equiv.Perm.{succ u2} α') (x : β'), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β') => β') x) (FunLike.coe.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') p) β' (fun (_x : β') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β') => β') _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} β' β') (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.Perm.{succ u2} α') (fun (_x : Equiv.Perm.{succ u2} α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.permCongr.{u2, u1} α' β' e) p) x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} α' β') α' (fun (_x : α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α') => β') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} α' β') e (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.Perm.{succ u2} α') α' (fun (_x : α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α') => α') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} α' α') p (FunLike.coe.{max (succ u2) (succ u1), succ u1, succ u2} (Equiv.{succ u1, succ u2} β' α') β' (fun (_x : β') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β') => α') _x) (Equiv.instFunLikeEquiv.{succ u1, succ u2} β' α') (Equiv.symm.{succ u2, succ u1} α' β' e) x)))
 Case conversion may be inaccurate. Consider using '#align equiv.perm_congr_apply Equiv.permCongr_applyₓ'. -/
 @[simp]
 theorem permCongr_apply (p : Equiv.Perm α') (x) : e.permCongr p x = e (p (e.symm x)) :=
@@ -786,7 +786,7 @@ theorem permCongr_symm_apply (p : Equiv.Perm β') (x) : e.permCongr.symm p x = e
 lean 3 declaration is
   forall {α' : Type.{u1}} {β' : Type.{u2}} (e : Equiv.{succ u1, succ u2} α' β') (p : Equiv.Perm.{succ u1} α') (p' : Equiv.Perm.{succ u1} α'), Eq.{succ u2} (Equiv.{succ u2, succ u2} β' β') (Equiv.trans.{succ u2, succ u2, succ u2} β' β' β' (coeFn.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1), max (succ u1) (succ u2)} (Equiv.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) (fun (_x : Equiv.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) => (Equiv.Perm.{succ u1} α') -> (Equiv.Perm.{succ u2} β')) (Equiv.hasCoeToFun.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) (Equiv.permCongr.{u1, u2} α' β' e) p) (coeFn.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1), max (succ u1) (succ u2)} (Equiv.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) (fun (_x : Equiv.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) => (Equiv.Perm.{succ u1} α') -> (Equiv.Perm.{succ u2} β')) (Equiv.hasCoeToFun.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) (Equiv.permCongr.{u1, u2} α' β' e) p')) (coeFn.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1), max (succ u1) (succ u2)} (Equiv.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) (fun (_x : Equiv.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) => (Equiv.Perm.{succ u1} α') -> (Equiv.Perm.{succ u2} β')) (Equiv.hasCoeToFun.{succ u1, succ u2} (Equiv.Perm.{succ u1} α') (Equiv.Perm.{succ u2} β')) (Equiv.permCongr.{u1, u2} α' β' e) (Equiv.trans.{succ u1, succ u1, succ u1} α' α' α' p p'))
 but is expected to have type
-  forall {α' : Type.{u2}} {β' : Type.{u1}} (e : Equiv.{succ u2, succ u1} α' β') (p : Equiv.Perm.{succ u2} α') (p' : Equiv.Perm.{succ u2} α'), Eq.{succ u1} (Equiv.{succ u1, succ u1} β' β') (Equiv.trans.{succ u1, succ u1, succ u1} β' β' β' (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.Perm.{succ u2} α') (fun (_x : Equiv.Perm.{succ u2} α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.permCongr.{u2, u1} α' β' e) p) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.Perm.{succ u2} α') (fun (_x : Equiv.Perm.{succ u2} α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.permCongr.{u2, u1} α' β' e) p')) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.Perm.{succ u2} α') (fun (_x : Equiv.Perm.{succ u2} α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.permCongr.{u2, u1} α' β' e) (Equiv.trans.{succ u2, succ u2, succ u2} α' α' α' p p'))
+  forall {α' : Type.{u2}} {β' : Type.{u1}} (e : Equiv.{succ u2, succ u1} α' β') (p : Equiv.Perm.{succ u2} α') (p' : Equiv.Perm.{succ u2} α'), Eq.{succ u1} (Equiv.{succ u1, succ u1} β' β') (Equiv.trans.{succ u1, succ u1, succ u1} β' β' β' (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.Perm.{succ u2} α') (fun (_x : Equiv.Perm.{succ u2} α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.permCongr.{u2, u1} α' β' e) p) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.Perm.{succ u2} α') (fun (_x : Equiv.Perm.{succ u2} α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.permCongr.{u2, u1} α' β' e) p')) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (Equiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.Perm.{succ u2} α') (fun (_x : Equiv.Perm.{succ u2} α') => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Equiv.Perm.{succ u2} α') => Equiv.Perm.{succ u1} β') _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} (Equiv.Perm.{succ u2} α') (Equiv.Perm.{succ u1} β')) (Equiv.permCongr.{u2, u1} α' β' e) (Equiv.trans.{succ u2, succ u2, succ u2} α' α' α' p p'))
 Case conversion may be inaccurate. Consider using '#align equiv.perm_congr_trans Equiv.permCongr_transₓ'. -/
 theorem permCongr_trans (p p' : Equiv.Perm α') :
     (e.permCongr p).trans (e.permCongr p') = e.permCongr (p.trans p') :=
@@ -913,7 +913,7 @@ def arrowCongr {α₁ β₁ α₂ β₂ : Sort _} (e₁ : α₁ ≃ α₂) (e₂
 lean 3 declaration is
   forall {α₁ : Sort.{u1}} {β₁ : Sort.{u2}} {γ₁ : Sort.{u3}} {α₂ : Sort.{u4}} {β₂ : Sort.{u5}} {γ₂ : Sort.{u6}} (ea : Equiv.{u1, u4} α₁ α₂) (eb : Equiv.{u2, u5} β₁ β₂) (ec : Equiv.{u3, u6} γ₁ γ₂) (f : α₁ -> β₁) (g : β₁ -> γ₁), Eq.{imax u4 u6} (α₂ -> γ₂) (coeFn.{max 1 (imax (imax u1 u3) u4 u6) (imax (imax u4 u6) u1 u3), imax (imax u1 u3) u4 u6} (Equiv.{imax u1 u3, imax u4 u6} (α₁ -> γ₁) (α₂ -> γ₂)) (fun (_x : Equiv.{imax u1 u3, imax u4 u6} (α₁ -> γ₁) (α₂ -> γ₂)) => (α₁ -> γ₁) -> α₂ -> γ₂) (Equiv.hasCoeToFun.{imax u1 u3, imax u4 u6} (α₁ -> γ₁) (α₂ -> γ₂)) (Equiv.arrowCongr.{u1, u3, u4, u6} α₁ γ₁ α₂ γ₂ ea ec) (Function.comp.{u1, u2, u3} α₁ β₁ γ₁ g f)) (Function.comp.{u4, u5, u6} α₂ β₂ γ₂ (coeFn.{max 1 (imax (imax u2 u3) u5 u6) (imax (imax u5 u6) u2 u3), imax (imax u2 u3) u5 u6} (Equiv.{imax u2 u3, imax u5 u6} (β₁ -> γ₁) (β₂ -> γ₂)) (fun (_x : Equiv.{imax u2 u3, imax u5 u6} (β₁ -> γ₁) (β₂ -> γ₂)) => (β₁ -> γ₁) -> β₂ -> γ₂) (Equiv.hasCoeToFun.{imax u2 u3, imax u5 u6} (β₁ -> γ₁) (β₂ -> γ₂)) (Equiv.arrowCongr.{u2, u3, u5, u6} β₁ γ₁ β₂ γ₂ eb ec) g) (coeFn.{max 1 (imax (imax u1 u2) u4 u5) (imax (imax u4 u5) u1 u2), imax (imax u1 u2) u4 u5} (Equiv.{imax u1 u2, imax u4 u5} (α₁ -> β₁) (α₂ -> β₂)) (fun (_x : Equiv.{imax u1 u2, imax u4 u5} (α₁ -> β₁) (α₂ -> β₂)) => (α₁ -> β₁) -> α₂ -> β₂) (Equiv.hasCoeToFun.{imax u1 u2, imax u4 u5} (α₁ -> β₁) (α₂ -> β₂)) (Equiv.arrowCongr.{u1, u2, u4, u5} α₁ β₁ α₂ β₂ ea eb) f))
 but is expected to have type
-  forall {α₁ : Sort.{u6}} {β₁ : Sort.{u5}} {γ₁ : Sort.{u4}} {α₂ : Sort.{u3}} {β₂ : Sort.{u2}} {γ₂ : Sort.{u1}} (ea : Equiv.{u6, u3} α₁ α₂) (eb : Equiv.{u5, u2} β₁ β₂) (ec : Equiv.{u4, u1} γ₁ γ₂) (f : α₁ -> β₁) (g : β₁ -> γ₁), Eq.{imax u3 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α₁ -> γ₁) => α₂ -> γ₂) (Function.comp.{u6, u5, u4} α₁ β₁ γ₁ g f)) (FunLike.coe.{max (max 1 (imax u6 u4)) (imax u3 u1), imax u6 u4, imax u3 u1} (Equiv.{imax u6 u4, imax u3 u1} (α₁ -> γ₁) (α₂ -> γ₂)) (α₁ -> γ₁) (fun (_x : α₁ -> γ₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α₁ -> γ₁) => α₂ -> γ₂) _x) (Equiv.instFunLikeEquiv.{imax u6 u4, imax u3 u1} (α₁ -> γ₁) (α₂ -> γ₂)) (Equiv.arrowCongr.{u6, u4, u3, u1} α₁ γ₁ α₂ γ₂ ea ec) (Function.comp.{u6, u5, u4} α₁ β₁ γ₁ g f)) (Function.comp.{u3, u2, u1} α₂ β₂ γ₂ (FunLike.coe.{max (max 1 (imax u5 u4)) (imax u2 u1), imax u5 u4, imax u2 u1} (Equiv.{imax u5 u4, imax u2 u1} (β₁ -> γ₁) (β₂ -> γ₂)) (β₁ -> γ₁) (fun (_x : β₁ -> γ₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : β₁ -> γ₁) => β₂ -> γ₂) _x) (Equiv.instFunLikeEquiv.{imax u5 u4, imax u2 u1} (β₁ -> γ₁) (β₂ -> γ₂)) (Equiv.arrowCongr.{u5, u4, u2, u1} β₁ γ₁ β₂ γ₂ eb ec) g) (FunLike.coe.{max (max 1 (imax u6 u5)) (imax u3 u2), imax u6 u5, imax u3 u2} (Equiv.{imax u6 u5, imax u3 u2} (α₁ -> β₁) (α₂ -> β₂)) (α₁ -> β₁) (fun (_x : α₁ -> β₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α₁ -> β₁) => α₂ -> β₂) _x) (Equiv.instFunLikeEquiv.{imax u6 u5, imax u3 u2} (α₁ -> β₁) (α₂ -> β₂)) (Equiv.arrowCongr.{u6, u5, u3, u2} α₁ β₁ α₂ β₂ ea eb) f))
+  forall {α₁ : Sort.{u6}} {β₁ : Sort.{u5}} {γ₁ : Sort.{u4}} {α₂ : Sort.{u3}} {β₂ : Sort.{u2}} {γ₂ : Sort.{u1}} (ea : Equiv.{u6, u3} α₁ α₂) (eb : Equiv.{u5, u2} β₁ β₂) (ec : Equiv.{u4, u1} γ₁ γ₂) (f : α₁ -> β₁) (g : β₁ -> γ₁), Eq.{imax u3 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α₁ -> γ₁) => α₂ -> γ₂) (Function.comp.{u6, u5, u4} α₁ β₁ γ₁ g f)) (FunLike.coe.{max (max 1 (imax u6 u4)) (imax u3 u1), imax u6 u4, imax u3 u1} (Equiv.{imax u6 u4, imax u3 u1} (α₁ -> γ₁) (α₂ -> γ₂)) (α₁ -> γ₁) (fun (_x : α₁ -> γ₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α₁ -> γ₁) => α₂ -> γ₂) _x) (Equiv.instFunLikeEquiv.{imax u6 u4, imax u3 u1} (α₁ -> γ₁) (α₂ -> γ₂)) (Equiv.arrowCongr.{u6, u4, u3, u1} α₁ γ₁ α₂ γ₂ ea ec) (Function.comp.{u6, u5, u4} α₁ β₁ γ₁ g f)) (Function.comp.{u3, u2, u1} α₂ β₂ γ₂ (FunLike.coe.{max (max 1 (imax u5 u4)) (imax u2 u1), imax u5 u4, imax u2 u1} (Equiv.{imax u5 u4, imax u2 u1} (β₁ -> γ₁) (β₂ -> γ₂)) (β₁ -> γ₁) (fun (_x : β₁ -> γ₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β₁ -> γ₁) => β₂ -> γ₂) _x) (Equiv.instFunLikeEquiv.{imax u5 u4, imax u2 u1} (β₁ -> γ₁) (β₂ -> γ₂)) (Equiv.arrowCongr.{u5, u4, u2, u1} β₁ γ₁ β₂ γ₂ eb ec) g) (FunLike.coe.{max (max 1 (imax u6 u5)) (imax u3 u2), imax u6 u5, imax u3 u2} (Equiv.{imax u6 u5, imax u3 u2} (α₁ -> β₁) (α₂ -> β₂)) (α₁ -> β₁) (fun (_x : α₁ -> β₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α₁ -> β₁) => α₂ -> β₂) _x) (Equiv.instFunLikeEquiv.{imax u6 u5, imax u3 u2} (α₁ -> β₁) (α₂ -> β₂)) (Equiv.arrowCongr.{u6, u5, u3, u2} α₁ β₁ α₂ β₂ ea eb) f))
 Case conversion may be inaccurate. Consider using '#align equiv.arrow_congr_comp Equiv.arrowCongr_compₓ'. -/
 theorem arrowCongr_comp {α₁ β₁ γ₁ α₂ β₂ γ₂ : Sort _} (ea : α₁ ≃ α₂) (eb : β₁ ≃ β₂) (ec : γ₁ ≃ γ₂)
     (f : α₁ → β₁) (g : β₁ → γ₁) :
@@ -1059,7 +1059,7 @@ theorem conj_comp (e : α ≃ β) (f₁ f₂ : α → α) : e.conj (f₁ ∘ f
 lean 3 declaration is
   forall {α : Sort.{u1}} {β : Sort.{u2}} {γ : Sort.{u3}} (e : Equiv.{u1, u2} α β) (f : β -> γ) (g : α -> γ), Iff (Eq.{imax u2 u3} (β -> γ) f (Function.comp.{u2, u1, u3} β α γ g (coeFn.{max 1 (imax u2 u1) (imax u1 u2), imax u2 u1} (Equiv.{u2, u1} β α) (fun (_x : Equiv.{u2, u1} β α) => β -> α) (Equiv.hasCoeToFun.{u2, u1} β α) (Equiv.symm.{u1, u2} α β e)))) (Eq.{imax u1 u3} (α -> γ) (Function.comp.{u1, u2, u3} α β γ f (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α β) (fun (_x : Equiv.{u1, u2} α β) => α -> β) (Equiv.hasCoeToFun.{u1, u2} α β) e)) g)
 but is expected to have type
-  forall {α : Sort.{u3}} {β : Sort.{u2}} {γ : Sort.{u1}} (e : Equiv.{u3, u2} α β) (f : β -> γ) (g : α -> γ), Iff (Eq.{imax u2 u1} (β -> γ) f (Function.comp.{u2, u3, u1} β α γ g (FunLike.coe.{max (max 1 u2) u3, u2, u3} (Equiv.{u2, u3} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : β) => α) _x) (Equiv.instFunLikeEquiv.{u2, u3} β α) (Equiv.symm.{u3, u2} α β e)))) (Eq.{imax u3 u1} (α -> γ) (Function.comp.{u3, u2, u1} α β γ f (FunLike.coe.{max (max 1 u2) u3, u3, u2} (Equiv.{u3, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α) => β) _x) (Equiv.instFunLikeEquiv.{u3, u2} α β) e)) g)
+  forall {α : Sort.{u3}} {β : Sort.{u2}} {γ : Sort.{u1}} (e : Equiv.{u3, u2} α β) (f : β -> γ) (g : α -> γ), Iff (Eq.{imax u2 u1} (β -> γ) f (Function.comp.{u2, u3, u1} β α γ g (FunLike.coe.{max (max 1 u2) u3, u2, u3} (Equiv.{u2, u3} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => α) _x) (Equiv.instFunLikeEquiv.{u2, u3} β α) (Equiv.symm.{u3, u2} α β e)))) (Eq.{imax u3 u1} (α -> γ) (Function.comp.{u3, u2, u1} α β γ f (FunLike.coe.{max (max 1 u2) u3, u3, u2} (Equiv.{u3, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => β) _x) (Equiv.instFunLikeEquiv.{u3, u2} α β) e)) g)
 Case conversion may be inaccurate. Consider using '#align equiv.eq_comp_symm Equiv.eq_comp_symmₓ'. -/
 theorem eq_comp_symm {α β γ} (e : α ≃ β) (f : β → γ) (g : α → γ) : f = g ∘ e.symm ↔ f ∘ e = g :=
   (e.arrowCongr (Equiv.refl γ)).symm_apply_eq.symm
@@ -1069,7 +1069,7 @@ theorem eq_comp_symm {α β γ} (e : α ≃ β) (f : β → γ) (g : α → γ)
 lean 3 declaration is
   forall {α : Sort.{u1}} {β : Sort.{u2}} {γ : Sort.{u3}} (e : Equiv.{u1, u2} α β) (f : β -> γ) (g : α -> γ), Iff (Eq.{imax u2 u3} (β -> γ) (Function.comp.{u2, u1, u3} β α γ g (coeFn.{max 1 (imax u2 u1) (imax u1 u2), imax u2 u1} (Equiv.{u2, u1} β α) (fun (_x : Equiv.{u2, u1} β α) => β -> α) (Equiv.hasCoeToFun.{u2, u1} β α) (Equiv.symm.{u1, u2} α β e))) f) (Eq.{imax u1 u3} (α -> γ) g (Function.comp.{u1, u2, u3} α β γ f (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α β) (fun (_x : Equiv.{u1, u2} α β) => α -> β) (Equiv.hasCoeToFun.{u1, u2} α β) e)))
 but is expected to have type
-  forall {α : Sort.{u3}} {β : Sort.{u2}} {γ : Sort.{u1}} (e : Equiv.{u3, u2} α β) (f : β -> γ) (g : α -> γ), Iff (Eq.{imax u2 u1} (β -> γ) (Function.comp.{u2, u3, u1} β α γ g (FunLike.coe.{max (max 1 u2) u3, u2, u3} (Equiv.{u2, u3} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : β) => α) _x) (Equiv.instFunLikeEquiv.{u2, u3} β α) (Equiv.symm.{u3, u2} α β e))) f) (Eq.{imax u3 u1} (α -> γ) g (Function.comp.{u3, u2, u1} α β γ f (FunLike.coe.{max (max 1 u2) u3, u3, u2} (Equiv.{u3, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α) => β) _x) (Equiv.instFunLikeEquiv.{u3, u2} α β) e)))
+  forall {α : Sort.{u3}} {β : Sort.{u2}} {γ : Sort.{u1}} (e : Equiv.{u3, u2} α β) (f : β -> γ) (g : α -> γ), Iff (Eq.{imax u2 u1} (β -> γ) (Function.comp.{u2, u3, u1} β α γ g (FunLike.coe.{max (max 1 u2) u3, u2, u3} (Equiv.{u2, u3} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => α) _x) (Equiv.instFunLikeEquiv.{u2, u3} β α) (Equiv.symm.{u3, u2} α β e))) f) (Eq.{imax u3 u1} (α -> γ) g (Function.comp.{u3, u2, u1} α β γ f (FunLike.coe.{max (max 1 u2) u3, u3, u2} (Equiv.{u3, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => β) _x) (Equiv.instFunLikeEquiv.{u3, u2} α β) e)))
 Case conversion may be inaccurate. Consider using '#align equiv.comp_symm_eq Equiv.comp_symm_eqₓ'. -/
 theorem comp_symm_eq {α β γ} (e : α ≃ β) (f : β → γ) (g : α → γ) : g ∘ e.symm = f ↔ g = f ∘ e :=
   (e.arrowCongr (Equiv.refl γ)).eq_symm_apply.symm
@@ -1079,7 +1079,7 @@ theorem comp_symm_eq {α β γ} (e : α ≃ β) (f : β → γ) (g : α → γ)
 lean 3 declaration is
   forall {α : Sort.{u1}} {β : Sort.{u2}} {γ : Sort.{u3}} (e : Equiv.{u1, u2} α β) (f : γ -> α) (g : γ -> β), Iff (Eq.{imax u3 u1} (γ -> α) f (Function.comp.{u3, u2, u1} γ β α (coeFn.{max 1 (imax u2 u1) (imax u1 u2), imax u2 u1} (Equiv.{u2, u1} β α) (fun (_x : Equiv.{u2, u1} β α) => β -> α) (Equiv.hasCoeToFun.{u2, u1} β α) (Equiv.symm.{u1, u2} α β e)) g)) (Eq.{imax u3 u2} (γ -> β) (Function.comp.{u3, u1, u2} γ α β (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α β) (fun (_x : Equiv.{u1, u2} α β) => α -> β) (Equiv.hasCoeToFun.{u1, u2} α β) e) f) g)
 but is expected to have type
-  forall {α : Sort.{u3}} {β : Sort.{u2}} {γ : Sort.{u1}} (e : Equiv.{u3, u2} α β) (f : γ -> α) (g : γ -> β), Iff (Eq.{imax u1 u3} (γ -> α) f (Function.comp.{u1, u2, u3} γ β α (FunLike.coe.{max (max 1 u2) u3, u2, u3} (Equiv.{u2, u3} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : β) => α) _x) (Equiv.instFunLikeEquiv.{u2, u3} β α) (Equiv.symm.{u3, u2} α β e)) g)) (Eq.{imax u1 u2} (γ -> β) (Function.comp.{u1, u3, u2} γ α β (FunLike.coe.{max (max 1 u2) u3, u3, u2} (Equiv.{u3, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α) => β) _x) (Equiv.instFunLikeEquiv.{u3, u2} α β) e) f) g)
+  forall {α : Sort.{u3}} {β : Sort.{u2}} {γ : Sort.{u1}} (e : Equiv.{u3, u2} α β) (f : γ -> α) (g : γ -> β), Iff (Eq.{imax u1 u3} (γ -> α) f (Function.comp.{u1, u2, u3} γ β α (FunLike.coe.{max (max 1 u2) u3, u2, u3} (Equiv.{u2, u3} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => α) _x) (Equiv.instFunLikeEquiv.{u2, u3} β α) (Equiv.symm.{u3, u2} α β e)) g)) (Eq.{imax u1 u2} (γ -> β) (Function.comp.{u1, u3, u2} γ α β (FunLike.coe.{max (max 1 u2) u3, u3, u2} (Equiv.{u3, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => β) _x) (Equiv.instFunLikeEquiv.{u3, u2} α β) e) f) g)
 Case conversion may be inaccurate. Consider using '#align equiv.eq_symm_comp Equiv.eq_symm_compₓ'. -/
 theorem eq_symm_comp {α β γ} (e : α ≃ β) (f : γ → α) (g : γ → β) : f = e.symm ∘ g ↔ e ∘ f = g :=
   ((Equiv.refl γ).arrowCongr e).eq_symm_apply
@@ -1089,7 +1089,7 @@ theorem eq_symm_comp {α β γ} (e : α ≃ β) (f : γ → α) (g : γ → β)
 lean 3 declaration is
   forall {α : Sort.{u1}} {β : Sort.{u2}} {γ : Sort.{u3}} (e : Equiv.{u1, u2} α β) (f : γ -> α) (g : γ -> β), Iff (Eq.{imax u3 u1} (γ -> α) (Function.comp.{u3, u2, u1} γ β α (coeFn.{max 1 (imax u2 u1) (imax u1 u2), imax u2 u1} (Equiv.{u2, u1} β α) (fun (_x : Equiv.{u2, u1} β α) => β -> α) (Equiv.hasCoeToFun.{u2, u1} β α) (Equiv.symm.{u1, u2} α β e)) g) f) (Eq.{imax u3 u2} (γ -> β) g (Function.comp.{u3, u1, u2} γ α β (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α β) (fun (_x : Equiv.{u1, u2} α β) => α -> β) (Equiv.hasCoeToFun.{u1, u2} α β) e) f))
 but is expected to have type
-  forall {α : Sort.{u3}} {β : Sort.{u2}} {γ : Sort.{u1}} (e : Equiv.{u3, u2} α β) (f : γ -> α) (g : γ -> β), Iff (Eq.{imax u1 u3} (γ -> α) (Function.comp.{u1, u2, u3} γ β α (FunLike.coe.{max (max 1 u2) u3, u2, u3} (Equiv.{u2, u3} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : β) => α) _x) (Equiv.instFunLikeEquiv.{u2, u3} β α) (Equiv.symm.{u3, u2} α β e)) g) f) (Eq.{imax u1 u2} (γ -> β) g (Function.comp.{u1, u3, u2} γ α β (FunLike.coe.{max (max 1 u2) u3, u3, u2} (Equiv.{u3, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α) => β) _x) (Equiv.instFunLikeEquiv.{u3, u2} α β) e) f))
+  forall {α : Sort.{u3}} {β : Sort.{u2}} {γ : Sort.{u1}} (e : Equiv.{u3, u2} α β) (f : γ -> α) (g : γ -> β), Iff (Eq.{imax u1 u3} (γ -> α) (Function.comp.{u1, u2, u3} γ β α (FunLike.coe.{max (max 1 u2) u3, u2, u3} (Equiv.{u2, u3} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => α) _x) (Equiv.instFunLikeEquiv.{u2, u3} β α) (Equiv.symm.{u3, u2} α β e)) g) f) (Eq.{imax u1 u2} (γ -> β) g (Function.comp.{u1, u3, u2} γ α β (FunLike.coe.{max (max 1 u2) u3, u3, u2} (Equiv.{u3, u2} α β) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => β) _x) (Equiv.instFunLikeEquiv.{u3, u2} α β) e) f))
 Case conversion may be inaccurate. Consider using '#align equiv.symm_comp_eq Equiv.symm_comp_eqₓ'. -/
 theorem symm_comp_eq {α β γ} (e : α ≃ β) (f : γ → α) (g : γ → β) : e.symm ∘ g = f ↔ g = e ∘ f :=
   ((Equiv.refl γ).arrowCongr e).symm_apply_eq
@@ -1418,7 +1418,7 @@ end Perm
 lean 3 declaration is
   forall {α₁ : Type.{u1}} {α₂ : Type.{u2}} {β : α₂ -> Type.{u3}} (e : Equiv.{succ u1, succ u2} α₁ α₂), Equiv.{max (succ u1) (succ u3), max (succ u2) (succ u3)} (Sigma.{u1, u3} α₁ (fun (a : α₁) => β (coeFn.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1), max (succ u1) (succ u2)} (Equiv.{succ u1, succ u2} α₁ α₂) (fun (_x : Equiv.{succ u1, succ u2} α₁ α₂) => α₁ -> α₂) (Equiv.hasCoeToFun.{succ u1, succ u2} α₁ α₂) e a))) (Sigma.{u2, u3} α₂ (fun (a : α₂) => β a))
 but is expected to have type
-  forall {α₁ : Type.{u1}} {α₂ : Type.{u2}} {β : α₁ -> Type.{u3}} (e : Equiv.{succ u2, succ u1} α₂ α₁), Equiv.{max (succ u3) (succ u2), max (succ u3) (succ u1)} (Sigma.{u2, u3} α₂ (fun (a : α₂) => β (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} (Equiv.{succ u2, succ u1} α₂ α₁) α₂ (fun (_x : α₂) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α₂) => α₁) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} α₂ α₁) e a))) (Sigma.{u1, u3} α₁ (fun (a : α₁) => β a))
+  forall {α₁ : Type.{u1}} {α₂ : Type.{u2}} {β : α₁ -> Type.{u3}} (e : Equiv.{succ u2, succ u1} α₂ α₁), Equiv.{max (succ u3) (succ u2), max (succ u3) (succ u1)} (Sigma.{u2, u3} α₂ (fun (a : α₂) => β (FunLike.coe.{max (succ u1) (succ u2), succ u2, succ u1} (Equiv.{succ u2, succ u1} α₂ α₁) α₂ (fun (_x : α₂) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α₂) => α₁) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u1} α₂ α₁) e a))) (Sigma.{u1, u3} α₁ (fun (a : α₁) => β a))
 Case conversion may be inaccurate. Consider using '#align equiv.sigma_congr_left Equiv.sigmaCongrLeftₓ'. -/
 /-- An equivalence `f : α₁ ≃ α₂` generates an equivalence between `Σ a, β (f a)` and `Σ a, β a`. -/
 @[simps apply]
@@ -1542,7 +1542,7 @@ variable {α₁ : Sort ua1} {α₂ : Sort ua2} {β₁ : Sort ub1} {β₂ : Sort
 lean 3 declaration is
   forall {α₁ : Sort.{u1}} {α₂ : Sort.{u2}} {β₁ : Sort.{u3}} {β₂ : Sort.{u4}} {p : α₁ -> β₁ -> Prop} {q : α₂ -> β₂ -> Prop} (eα : Equiv.{u1, u2} α₁ α₂) (eβ : Equiv.{u3, u4} β₁ β₂), (forall {x : α₁} {y : β₁}, Iff (p x y) (q (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α₁ α₂) (fun (_x : Equiv.{u1, u2} α₁ α₂) => α₁ -> α₂) (Equiv.hasCoeToFun.{u1, u2} α₁ α₂) eα x) (coeFn.{max 1 (imax u3 u4) (imax u4 u3), imax u3 u4} (Equiv.{u3, u4} β₁ β₂) (fun (_x : Equiv.{u3, u4} β₁ β₂) => β₁ -> β₂) (Equiv.hasCoeToFun.{u3, u4} β₁ β₂) eβ y))) -> (Iff (forall (x : α₁) (y : β₁), p x y) (forall (x : α₂) (y : β₂), q x y))
 but is expected to have type
-  forall {α₁ : Sort.{u4}} {α₂ : Sort.{u3}} {β₁ : Sort.{u2}} {β₂ : Sort.{u1}} {p : α₁ -> α₂ -> Prop} {q : β₁ -> β₂ -> Prop} (eα : Equiv.{u4, u2} α₁ β₁) (eβ : Equiv.{u3, u1} α₂ β₂), (forall {x : α₁} {y : α₂}, Iff (p x y) (q (FunLike.coe.{max (max 1 u4) u2, u4, u2} (Equiv.{u4, u2} α₁ β₁) α₁ (fun (_x : α₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α₁) => β₁) _x) (Equiv.instFunLikeEquiv.{u4, u2} α₁ β₁) eα x) (FunLike.coe.{max (max 1 u3) u1, u3, u1} (Equiv.{u3, u1} α₂ β₂) α₂ (fun (_x : α₂) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α₂) => β₂) _x) (Equiv.instFunLikeEquiv.{u3, u1} α₂ β₂) eβ y))) -> (Iff (forall (x : α₁) (y : α₂), p x y) (forall (x : β₁) (y : β₂), q x y))
+  forall {α₁ : Sort.{u4}} {α₂ : Sort.{u3}} {β₁ : Sort.{u2}} {β₂ : Sort.{u1}} {p : α₁ -> α₂ -> Prop} {q : β₁ -> β₂ -> Prop} (eα : Equiv.{u4, u2} α₁ β₁) (eβ : Equiv.{u3, u1} α₂ β₂), (forall {x : α₁} {y : α₂}, Iff (p x y) (q (FunLike.coe.{max (max 1 u4) u2, u4, u2} (Equiv.{u4, u2} α₁ β₁) α₁ (fun (_x : α₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α₁) => β₁) _x) (Equiv.instFunLikeEquiv.{u4, u2} α₁ β₁) eα x) (FunLike.coe.{max (max 1 u3) u1, u3, u1} (Equiv.{u3, u1} α₂ β₂) α₂ (fun (_x : α₂) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α₂) => β₂) _x) (Equiv.instFunLikeEquiv.{u3, u1} α₂ β₂) eβ y))) -> (Iff (forall (x : α₁) (y : α₂), p x y) (forall (x : β₁) (y : β₂), q x y))
 Case conversion may be inaccurate. Consider using '#align equiv.forall₂_congr Equiv.forall₂_congrₓ'. -/
 protected theorem forall₂_congr {p : α₁ → β₁ → Prop} {q : α₂ → β₂ → Prop} (eα : α₁ ≃ α₂)
     (eβ : β₁ ≃ β₂) (h : ∀ {x y}, p x y ↔ q (eα x) (eβ y)) : (∀ x y, p x y) ↔ ∀ x y, q x y :=
@@ -1558,7 +1558,7 @@ protected theorem forall₂_congr {p : α₁ → β₁ → Prop} {q : α₂ →
 lean 3 declaration is
   forall {α₁ : Sort.{u1}} {α₂ : Sort.{u2}} {β₁ : Sort.{u3}} {β₂ : Sort.{u4}} {p : α₁ -> β₁ -> Prop} {q : α₂ -> β₂ -> Prop} (eα : Equiv.{u1, u2} α₁ α₂) (eβ : Equiv.{u3, u4} β₁ β₂), (forall {x : α₂} {y : β₂}, Iff (p (coeFn.{max 1 (imax u2 u1) (imax u1 u2), imax u2 u1} (Equiv.{u2, u1} α₂ α₁) (fun (_x : Equiv.{u2, u1} α₂ α₁) => α₂ -> α₁) (Equiv.hasCoeToFun.{u2, u1} α₂ α₁) (Equiv.symm.{u1, u2} α₁ α₂ eα) x) (coeFn.{max 1 (imax u4 u3) (imax u3 u4), imax u4 u3} (Equiv.{u4, u3} β₂ β₁) (fun (_x : Equiv.{u4, u3} β₂ β₁) => β₂ -> β₁) (Equiv.hasCoeToFun.{u4, u3} β₂ β₁) (Equiv.symm.{u3, u4} β₁ β₂ eβ) y)) (q x y)) -> (Iff (forall (x : α₁) (y : β₁), p x y) (forall (x : α₂) (y : β₂), q x y))
 but is expected to have type
-  forall {α₁ : Sort.{u4}} {α₂ : Sort.{u3}} {β₁ : Sort.{u2}} {β₂ : Sort.{u1}} {p : α₁ -> α₂ -> Prop} {q : β₁ -> β₂ -> Prop} (eα : Equiv.{u4, u2} α₁ β₁) (eβ : Equiv.{u3, u1} α₂ β₂), (forall {x : β₁} {y : β₂}, Iff (p (FunLike.coe.{max (max 1 u4) u2, u2, u4} (Equiv.{u2, u4} β₁ α₁) β₁ (fun (_x : β₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : β₁) => α₁) _x) (Equiv.instFunLikeEquiv.{u2, u4} β₁ α₁) (Equiv.symm.{u4, u2} α₁ β₁ eα) x) (FunLike.coe.{max (max 1 u3) u1, u1, u3} (Equiv.{u1, u3} β₂ α₂) β₂ (fun (_x : β₂) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : β₂) => α₂) _x) (Equiv.instFunLikeEquiv.{u1, u3} β₂ α₂) (Equiv.symm.{u3, u1} α₂ β₂ eβ) y)) (q x y)) -> (Iff (forall (x : α₁) (y : α₂), p x y) (forall (x : β₁) (y : β₂), q x y))
+  forall {α₁ : Sort.{u4}} {α₂ : Sort.{u3}} {β₁ : Sort.{u2}} {β₂ : Sort.{u1}} {p : α₁ -> α₂ -> Prop} {q : β₁ -> β₂ -> Prop} (eα : Equiv.{u4, u2} α₁ β₁) (eβ : Equiv.{u3, u1} α₂ β₂), (forall {x : β₁} {y : β₂}, Iff (p (FunLike.coe.{max (max 1 u4) u2, u2, u4} (Equiv.{u2, u4} β₁ α₁) β₁ (fun (_x : β₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β₁) => α₁) _x) (Equiv.instFunLikeEquiv.{u2, u4} β₁ α₁) (Equiv.symm.{u4, u2} α₁ β₁ eα) x) (FunLike.coe.{max (max 1 u3) u1, u1, u3} (Equiv.{u1, u3} β₂ α₂) β₂ (fun (_x : β₂) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β₂) => α₂) _x) (Equiv.instFunLikeEquiv.{u1, u3} β₂ α₂) (Equiv.symm.{u3, u1} α₂ β₂ eβ) y)) (q x y)) -> (Iff (forall (x : α₁) (y : α₂), p x y) (forall (x : β₁) (y : β₂), q x y))
 Case conversion may be inaccurate. Consider using '#align equiv.forall₂_congr' Equiv.forall₂_congr'ₓ'. -/
 protected theorem forall₂_congr' {p : α₁ → β₁ → Prop} {q : α₂ → β₂ → Prop} (eα : α₁ ≃ α₂)
     (eβ : β₁ ≃ β₂) (h : ∀ {x y}, p (eα.symm x) (eβ.symm y) ↔ q x y) :
@@ -1570,7 +1570,7 @@ protected theorem forall₂_congr' {p : α₁ → β₁ → Prop} {q : α₂ →
 lean 3 declaration is
   forall {α₁ : Sort.{u1}} {α₂ : Sort.{u2}} {β₁ : Sort.{u3}} {β₂ : Sort.{u4}} {γ₁ : Sort.{u5}} {γ₂ : Sort.{u6}} {p : α₁ -> β₁ -> γ₁ -> Prop} {q : α₂ -> β₂ -> γ₂ -> Prop} (eα : Equiv.{u1, u2} α₁ α₂) (eβ : Equiv.{u3, u4} β₁ β₂) (eγ : Equiv.{u5, u6} γ₁ γ₂), (forall {x : α₁} {y : β₁} {z : γ₁}, Iff (p x y z) (q (coeFn.{max 1 (imax u1 u2) (imax u2 u1), imax u1 u2} (Equiv.{u1, u2} α₁ α₂) (fun (_x : Equiv.{u1, u2} α₁ α₂) => α₁ -> α₂) (Equiv.hasCoeToFun.{u1, u2} α₁ α₂) eα x) (coeFn.{max 1 (imax u3 u4) (imax u4 u3), imax u3 u4} (Equiv.{u3, u4} β₁ β₂) (fun (_x : Equiv.{u3, u4} β₁ β₂) => β₁ -> β₂) (Equiv.hasCoeToFun.{u3, u4} β₁ β₂) eβ y) (coeFn.{max 1 (imax u5 u6) (imax u6 u5), imax u5 u6} (Equiv.{u5, u6} γ₁ γ₂) (fun (_x : Equiv.{u5, u6} γ₁ γ₂) => γ₁ -> γ₂) (Equiv.hasCoeToFun.{u5, u6} γ₁ γ₂) eγ z))) -> (Iff (forall (x : α₁) (y : β₁) (z : γ₁), p x y z) (forall (x : α₂) (y : β₂) (z : γ₂), q x y z))
 but is expected to have type
-  forall {α₁ : Sort.{u6}} {α₂ : Sort.{u5}} {β₁ : Sort.{u4}} {β₂ : Sort.{u3}} {γ₁ : Sort.{u2}} {γ₂ : Sort.{u1}} {p : α₁ -> α₂ -> β₁ -> Prop} {q : β₂ -> γ₁ -> γ₂ -> Prop} (eα : Equiv.{u6, u3} α₁ β₂) (eβ : Equiv.{u5, u2} α₂ γ₁) (eγ : Equiv.{u4, u1} β₁ γ₂), (forall {x : α₁} {y : α₂} {z : β₁}, Iff (p x y z) (q (FunLike.coe.{max (max 1 u6) u3, u6, u3} (Equiv.{u6, u3} α₁ β₂) α₁ (fun (_x : α₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α₁) => β₂) _x) (Equiv.instFunLikeEquiv.{u6, u3} α₁ β₂) eα x) (FunLike.coe.{max (max 1 u5) u2, u5, u2} (Equiv.{u5, u2} α₂ γ₁) α₂ (fun (_x : α₂) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α₂) => γ₁) _x) (Equiv.instFunLikeEquiv.{u5, u2} α₂ γ₁) eβ y) (FunLike.coe.{max (max 1 u4) u1, u4, u1} (Equiv.{u4, u1} β₁ γ₂) β₁ (fun (_x : β₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : β₁) => γ₂) _x) (Equiv.instFunLikeEquiv.{u4, u1} β₁ γ₂) eγ z))) -> (Iff (forall (x : α₁) (y : α₂) (z : β₁), p x y z) (forall (x : β₂) (y : γ₁) (z : γ₂), q x y z))
+  forall {α₁ : Sort.{u6}} {α₂ : Sort.{u5}} {β₁ : Sort.{u4}} {β₂ : Sort.{u3}} {γ₁ : Sort.{u2}} {γ₂ : Sort.{u1}} {p : α₁ -> α₂ -> β₁ -> Prop} {q : β₂ -> γ₁ -> γ₂ -> Prop} (eα : Equiv.{u6, u3} α₁ β₂) (eβ : Equiv.{u5, u2} α₂ γ₁) (eγ : Equiv.{u4, u1} β₁ γ₂), (forall {x : α₁} {y : α₂} {z : β₁}, Iff (p x y z) (q (FunLike.coe.{max (max 1 u6) u3, u6, u3} (Equiv.{u6, u3} α₁ β₂) α₁ (fun (_x : α₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α₁) => β₂) _x) (Equiv.instFunLikeEquiv.{u6, u3} α₁ β₂) eα x) (FunLike.coe.{max (max 1 u5) u2, u5, u2} (Equiv.{u5, u2} α₂ γ₁) α₂ (fun (_x : α₂) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α₂) => γ₁) _x) (Equiv.instFunLikeEquiv.{u5, u2} α₂ γ₁) eβ y) (FunLike.coe.{max (max 1 u4) u1, u4, u1} (Equiv.{u4, u1} β₁ γ₂) β₁ (fun (_x : β₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β₁) => γ₂) _x) (Equiv.instFunLikeEquiv.{u4, u1} β₁ γ₂) eγ z))) -> (Iff (forall (x : α₁) (y : α₂) (z : β₁), p x y z) (forall (x : β₂) (y : γ₁) (z : γ₂), q x y z))
 Case conversion may be inaccurate. Consider using '#align equiv.forall₃_congr Equiv.forall₃_congrₓ'. -/
 protected theorem forall₃_congr {p : α₁ → β₁ → γ₁ → Prop} {q : α₂ → β₂ → γ₂ → Prop} (eα : α₁ ≃ α₂)
     (eβ : β₁ ≃ β₂) (eγ : γ₁ ≃ γ₂) (h : ∀ {x y z}, p x y z ↔ q (eα x) (eβ y) (eγ z)) :
@@ -1587,7 +1587,7 @@ protected theorem forall₃_congr {p : α₁ → β₁ → γ₁ → Prop} {q :
 lean 3 declaration is
   forall {α₁ : Sort.{u1}} {α₂ : Sort.{u2}} {β₁ : Sort.{u3}} {β₂ : Sort.{u4}} {γ₁ : Sort.{u5}} {γ₂ : Sort.{u6}} {p : α₁ -> β₁ -> γ₁ -> Prop} {q : α₂ -> β₂ -> γ₂ -> Prop} (eα : Equiv.{u1, u2} α₁ α₂) (eβ : Equiv.{u3, u4} β₁ β₂) (eγ : Equiv.{u5, u6} γ₁ γ₂), (forall {x : α₂} {y : β₂} {z : γ₂}, Iff (p (coeFn.{max 1 (imax u2 u1) (imax u1 u2), imax u2 u1} (Equiv.{u2, u1} α₂ α₁) (fun (_x : Equiv.{u2, u1} α₂ α₁) => α₂ -> α₁) (Equiv.hasCoeToFun.{u2, u1} α₂ α₁) (Equiv.symm.{u1, u2} α₁ α₂ eα) x) (coeFn.{max 1 (imax u4 u3) (imax u3 u4), imax u4 u3} (Equiv.{u4, u3} β₂ β₁) (fun (_x : Equiv.{u4, u3} β₂ β₁) => β₂ -> β₁) (Equiv.hasCoeToFun.{u4, u3} β₂ β₁) (Equiv.symm.{u3, u4} β₁ β₂ eβ) y) (coeFn.{max 1 (imax u6 u5) (imax u5 u6), imax u6 u5} (Equiv.{u6, u5} γ₂ γ₁) (fun (_x : Equiv.{u6, u5} γ₂ γ₁) => γ₂ -> γ₁) (Equiv.hasCoeToFun.{u6, u5} γ₂ γ₁) (Equiv.symm.{u5, u6} γ₁ γ₂ eγ) z)) (q x y z)) -> (Iff (forall (x : α₁) (y : β₁) (z : γ₁), p x y z) (forall (x : α₂) (y : β₂) (z : γ₂), q x y z))
 but is expected to have type
-  forall {α₁ : Sort.{u6}} {α₂ : Sort.{u5}} {β₁ : Sort.{u4}} {β₂ : Sort.{u3}} {γ₁ : Sort.{u2}} {γ₂ : Sort.{u1}} {p : α₁ -> α₂ -> β₁ -> Prop} {q : β₂ -> γ₁ -> γ₂ -> Prop} (eα : Equiv.{u6, u3} α₁ β₂) (eβ : Equiv.{u5, u2} α₂ γ₁) (eγ : Equiv.{u4, u1} β₁ γ₂), (forall {x : β₂} {y : γ₁} {z : γ₂}, Iff (p (FunLike.coe.{max (max 1 u6) u3, u3, u6} (Equiv.{u3, u6} β₂ α₁) β₂ (fun (_x : β₂) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : β₂) => α₁) _x) (Equiv.instFunLikeEquiv.{u3, u6} β₂ α₁) (Equiv.symm.{u6, u3} α₁ β₂ eα) x) (FunLike.coe.{max (max 1 u5) u2, u2, u5} (Equiv.{u2, u5} γ₁ α₂) γ₁ (fun (_x : γ₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : γ₁) => α₂) _x) (Equiv.instFunLikeEquiv.{u2, u5} γ₁ α₂) (Equiv.symm.{u5, u2} α₂ γ₁ eβ) y) (FunLike.coe.{max (max 1 u4) u1, u1, u4} (Equiv.{u1, u4} γ₂ β₁) γ₂ (fun (_x : γ₂) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : γ₂) => β₁) _x) (Equiv.instFunLikeEquiv.{u1, u4} γ₂ β₁) (Equiv.symm.{u4, u1} β₁ γ₂ eγ) z)) (q x y z)) -> (Iff (forall (x : α₁) (y : α₂) (z : β₁), p x y z) (forall (x : β₂) (y : γ₁) (z : γ₂), q x y z))
+  forall {α₁ : Sort.{u6}} {α₂ : Sort.{u5}} {β₁ : Sort.{u4}} {β₂ : Sort.{u3}} {γ₁ : Sort.{u2}} {γ₂ : Sort.{u1}} {p : α₁ -> α₂ -> β₁ -> Prop} {q : β₂ -> γ₁ -> γ₂ -> Prop} (eα : Equiv.{u6, u3} α₁ β₂) (eβ : Equiv.{u5, u2} α₂ γ₁) (eγ : Equiv.{u4, u1} β₁ γ₂), (forall {x : β₂} {y : γ₁} {z : γ₂}, Iff (p (FunLike.coe.{max (max 1 u6) u3, u3, u6} (Equiv.{u3, u6} β₂ α₁) β₂ (fun (_x : β₂) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β₂) => α₁) _x) (Equiv.instFunLikeEquiv.{u3, u6} β₂ α₁) (Equiv.symm.{u6, u3} α₁ β₂ eα) x) (FunLike.coe.{max (max 1 u5) u2, u2, u5} (Equiv.{u2, u5} γ₁ α₂) γ₁ (fun (_x : γ₁) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : γ₁) => α₂) _x) (Equiv.instFunLikeEquiv.{u2, u5} γ₁ α₂) (Equiv.symm.{u5, u2} α₂ γ₁ eβ) y) (FunLike.coe.{max (max 1 u4) u1, u1, u4} (Equiv.{u1, u4} γ₂ β₁) γ₂ (fun (_x : γ₂) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : γ₂) => β₁) _x) (Equiv.instFunLikeEquiv.{u1, u4} γ₂ β₁) (Equiv.symm.{u4, u1} β₁ γ₂ eγ) z)) (q x y z)) -> (Iff (forall (x : α₁) (y : α₂) (z : β₁), p x y z) (forall (x : β₂) (y : γ₁) (z : γ₂), q x y z))
 Case conversion may be inaccurate. Consider using '#align equiv.forall₃_congr' Equiv.forall₃_congr'ₓ'. -/
 protected theorem forall₃_congr' {p : α₁ → β₁ → γ₁ → Prop} {q : α₂ → β₂ → γ₂ → Prop} (eα : α₁ ≃ α₂)
     (eβ : β₁ ≃ β₂) (eγ : γ₁ ≃ γ₂) (h : ∀ {x y z}, p (eα.symm x) (eβ.symm y) (eγ.symm z) ↔ q x y z) :
@@ -1611,7 +1611,7 @@ protected theorem forall_congr_left {p : β → Prop} (f : α ≃ β) : (∀ x,
 lean 3 declaration is
   forall {α : Sort.{u1}} {β : Sort.{u2}} (f : Equiv.{u1, u2} α β) {p : α -> Prop}, Iff (Exists.{u1} α (fun (a : α) => p a)) (Exists.{u2} β (fun (b : β) => p (coeFn.{max 1 (imax u2 u1) (imax u1 u2), imax u2 u1} (Equiv.{u2, u1} β α) (fun (_x : Equiv.{u2, u1} β α) => β -> α) (Equiv.hasCoeToFun.{u2, u1} β α) (Equiv.symm.{u1, u2} α β f) b)))
 but is expected to have type
-  forall {α : Sort.{u2}} {β : Sort.{u1}} (f : Equiv.{u2, u1} α β) {p : α -> Prop}, Iff (Exists.{u2} α (fun (a : α) => p a)) (Exists.{u1} β (fun (b : β) => p (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : β) => α) _x) (Equiv.instFunLikeEquiv.{u1, u2} β α) (Equiv.symm.{u2, u1} α β f) b)))
+  forall {α : Sort.{u2}} {β : Sort.{u1}} (f : Equiv.{u2, u1} α β) {p : α -> Prop}, Iff (Exists.{u2} α (fun (a : α) => p a)) (Exists.{u1} β (fun (b : β) => p (FunLike.coe.{max (max 1 u1) u2, u1, u2} (Equiv.{u1, u2} β α) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => α) _x) (Equiv.instFunLikeEquiv.{u1, u2} β α) (Equiv.symm.{u2, u1} α β f) b)))
 Case conversion may be inaccurate. Consider using '#align equiv.exists_congr_left Equiv.exists_congr_leftₓ'. -/
 protected theorem exists_congr_left {α β} (f : α ≃ β) {p : α → Prop} :
     (∃ a, p a) ↔ ∃ b, p (f.symm b) :=

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

chore(Logic): reduce use of autoImplicit (#12135)

In one case, replacing this naively errored, so I just merged the single declaration using it.

Delete two unused variables in Logic/Basic.

f2658009

Diff

@@ -53,9 +53,6 @@ Many more such isomorphisms and operations are defined in `Logic.Equiv.Basic`.
 equivalence, congruence, bijective map
 -/
 
-set_option autoImplicit true
-
-
 open Function
 
 universe u v w z
@@ -320,7 +317,7 @@ theorem Perm.coe_subsingleton {α : Type*} [Subsingleton α] (e : Perm α) : (e
 theorem apply_eq_iff_eq (f : α ≃ β) {x y : α} : f x = f y ↔ x = y := EquivLike.apply_eq_iff_eq f
 #align equiv.apply_eq_iff_eq Equiv.apply_eq_iff_eq
 
-theorem apply_eq_iff_eq_symm_apply (f : α ≃ β) : f x = y ↔ x = f.symm y := by
+theorem apply_eq_iff_eq_symm_apply {x : α} {y : β} (f : α ≃ β) : f x = y ↔ x = f.symm y := by
   conv_lhs => rw [← apply_symm_apply f y]
   rw [apply_eq_iff_eq]
 #align equiv.apply_eq_iff_eq_symm_apply Equiv.apply_eq_iff_eq_symm_apply
@@ -408,7 +405,7 @@ theorem comp_bijective (f : α → β) (e : β ≃ γ) : Bijective (e ∘ f) ↔
 
 /-- If `α` is equivalent to `β` and `γ` is equivalent to `δ`, then the type of equivalences `α ≃ γ`
 is equivalent to the type of equivalences `β ≃ δ`. -/
-def equivCongr (ab : α ≃ β) (cd : γ ≃ δ) : (α ≃ γ) ≃ (β ≃ δ) where
+def equivCongr {δ : Sort*} (ab : α ≃ β) (cd : γ ≃ δ) : (α ≃ γ) ≃ (β ≃ δ) where
   toFun ac := (ab.symm.trans ac).trans cd
   invFun bd := ab.trans <| bd.trans <| cd.symm
   left_inv ac := by ext x; simp only [trans_apply, comp_apply, symm_apply_apply]
@@ -549,11 +546,12 @@ theorem arrowCongr_comp {α₁ β₁ γ₁ α₂ β₂ γ₂ : Sort*} (ea : α
     arrowCongr (Equiv.refl α) (Equiv.refl β) = Equiv.refl (α → β) := rfl
 #align equiv.arrow_congr_refl Equiv.arrowCongr_refl
 
-@[simp] theorem arrowCongr_trans (e₁ : α₁ ≃ α₂) (e₁' : β₁ ≃ β₂) (e₂ : α₂ ≃ α₃) (e₂' : β₂ ≃ β₃) :
+@[simp] theorem arrowCongr_trans {α₁ α₂ α₃ β₁ β₂ β₃ : Sort*}
+    (e₁ : α₁ ≃ α₂) (e₁' : β₁ ≃ β₂) (e₂ : α₂ ≃ α₃) (e₂' : β₂ ≃ β₃) :
     arrowCongr (e₁.trans e₂) (e₁'.trans e₂') = (arrowCongr e₁ e₁').trans (arrowCongr e₂ e₂') := rfl
 #align equiv.arrow_congr_trans Equiv.arrowCongr_trans
 
-@[simp] theorem arrowCongr_symm (e₁ : α₁ ≃ α₂) (e₂ : β₁ ≃ β₂) :
+@[simp] theorem arrowCongr_symm {α₁ α₂ β₁ β₂ : Sort*} (e₁ : α₁ ≃ α₂) (e₂ : β₁ ≃ β₂) :
     (arrowCongr e₁ e₂).symm = arrowCongr e₁.symm e₂.symm := rfl
 #align equiv.arrow_congr_symm Equiv.arrowCongr_symm
 
@@ -573,13 +571,13 @@ def arrowCongr' {α₁ β₁ α₂ β₂ : Type*} (hα : α₁ ≃ α₂) (hβ :
     arrowCongr' (Equiv.refl α) (Equiv.refl β) = Equiv.refl (α → β) := rfl
 #align equiv.arrow_congr'_refl Equiv.arrowCongr'_refl
 
-@[simp] theorem arrowCongr'_trans
+@[simp] theorem arrowCongr'_trans {α₁ α₂ β₁ β₂ α₃ β₃ : Type*}
     (e₁ : α₁ ≃ α₂) (e₁' : β₁ ≃ β₂) (e₂ : α₂ ≃ α₃) (e₂' : β₂ ≃ β₃) :
     arrowCongr' (e₁.trans e₂) (e₁'.trans e₂') = (arrowCongr' e₁ e₁').trans (arrowCongr' e₂ e₂') :=
   rfl
 #align equiv.arrow_congr'_trans Equiv.arrowCongr'_trans
 
-@[simp] theorem arrowCongr'_symm (e₁ : α₁ ≃ α₂) (e₂ : β₁ ≃ β₂) :
+@[simp] theorem arrowCongr'_symm {α₁ α₂ β₁ β₂ : Type*} (e₁ : α₁ ≃ α₂) (e₂ : β₁ ≃ β₂) :
     (arrowCongr' e₁ e₂).symm = arrowCongr' e₁.symm e₂.symm := rfl
 #align equiv.arrow_congr'_symm Equiv.arrowCongr'_symm
 
@@ -813,7 +811,7 @@ namespace Perm
 end Perm
 
 /-- An equivalence `f : α₁ ≃ α₂` generates an equivalence between `Σ a, β (f a)` and `Σ a, β a`. -/
-@[simps apply] def sigmaCongrLeft {β : α₂ → Sort _} (e : α₁ ≃ α₂) :
+@[simps apply] def sigmaCongrLeft {α₁ α₂ : Type*} {β : α₂ → Sort _} (e : α₁ ≃ α₂) :
     (Σ a : α₁, β (e a)) ≃ Σ a : α₂, β a where
   toFun a := ⟨e a.1, a.2⟩
   invFun a := ⟨e.symm a.1, (e.right_inv' a.1).symm ▸ a.2⟩
@@ -902,23 +900,26 @@ protected theorem forall_congr' {p : α → Prop} {q : β → Prop} (f : α ≃
 -- (Stopping at ternary functions seems reasonable: at least in 1-categorical mathematics,
 -- it's rare to have axioms involving more than 3 elements at once.)
 
-protected theorem forall₂_congr {p : α₁ → β₁ → Prop} {q : α₂ → β₂ → Prop} (eα : α₁ ≃ α₂)
-    (eβ : β₁ ≃ β₂) (h : ∀ {x y}, p x y ↔ q (eα x) (eβ y)) : (∀ x y, p x y) ↔ ∀ x y, q x y :=
+protected theorem forall₂_congr {α₁ α₂ β₁ β₂ : Sort*} {p : α₁ → β₁ → Prop} {q : α₂ → β₂ → Prop}
+    (eα : α₁ ≃ α₂) (eβ : β₁ ≃ β₂) (h : ∀ {x y}, p x y ↔ q (eα x) (eβ y)) :
+    (∀ x y, p x y) ↔ ∀ x y, q x y :=
   Equiv.forall_congr _ <| Equiv.forall_congr _ h
 #align equiv.forall₂_congr Equiv.forall₂_congr
 
-protected theorem forall₂_congr' {p : α₁ → β₁ → Prop} {q : α₂ → β₂ → Prop}
+protected theorem forall₂_congr' {α₁ α₂ β₁ β₂ : Sort*} {p : α₁ → β₁ → Prop} {q : α₂ → β₂ → Prop}
     (eα : α₁ ≃ α₂) (eβ : β₁ ≃ β₂) (h : ∀ {x y}, p (eα.symm x) (eβ.symm y) ↔ q x y) :
     (∀ x y, p x y) ↔ ∀ x y, q x y := (Equiv.forall₂_congr eα.symm eβ.symm h.symm).symm
 #align equiv.forall₂_congr' Equiv.forall₂_congr'
 
-protected theorem forall₃_congr {p : α₁ → β₁ → γ₁ → Prop} {q : α₂ → β₂ → γ₂ → Prop}
+protected theorem forall₃_congr
+    {α₁ α₂ β₁ β₂ γ₁ γ₂ : Sort*} {p : α₁ → β₁ → γ₁ → Prop} {q : α₂ → β₂ → γ₂ → Prop}
     (eα : α₁ ≃ α₂) (eβ : β₁ ≃ β₂) (eγ : γ₁ ≃ γ₂) (h : ∀ {x y z}, p x y z ↔ q (eα x) (eβ y) (eγ z)) :
     (∀ x y z, p x y z) ↔ ∀ x y z, q x y z :=
   Equiv.forall₂_congr _ _ <| Equiv.forall_congr _ h
 #align equiv.forall₃_congr Equiv.forall₃_congr
 
-protected theorem forall₃_congr' {p : α₁ → β₁ → γ₁ → Prop} {q : α₂ → β₂ → γ₂ → Prop}
+protected theorem forall₃_congr'
+    {α₁ α₂ β₁ β₂ γ₁ γ₂ : Sort*} {p : α₁ → β₁ → γ₁ → Prop} {q : α₂ → β₂ → γ₂ → Prop}
     (eα : α₁ ≃ α₂) (eβ : β₁ ≃ β₂) (eγ : γ₁ ≃ γ₂)
     (h : ∀ {x y z}, p (eα.symm x) (eβ.symm y) (eγ.symm z) ↔ q x y z) :
     (∀ x y z, p x y z) ↔ ∀ x y z, q x y z :=

golf: replace some apply foo.mpr by rw [foo] (#11515)

Sometimes, that line can be golfed into the next line. Inspired by a comment of @loefflerd; any decisions are my own.

fa3a2fdc

Diff

@@ -886,8 +886,8 @@ protected theorem exists_unique_congr_left {p : β → Prop} (f : α ≃ β) :
 protected theorem forall_congr {p : α → Prop} {q : β → Prop} (f : α ≃ β)
     (h : ∀ {x}, p x ↔ q (f x)) : (∀ x, p x) ↔ (∀ y, q y) := by
   constructor <;> intro h₂ x
-  · rw [← f.right_inv x]; apply h.mp; apply h₂
-  · apply h.mpr; apply h₂
+  · rw [← f.right_inv x]; exact h.mp (h₂ _)
+  · exact h.mpr (h₂ _)
 #align equiv.forall_congr Equiv.forall_congr
 
 protected theorem forall_congr' {p : α → Prop} {q : β → Prop} (f : α ≃ β)

chore: move Mathlib to v4.7.0-rc1 (#11162)

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

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

fa48894a

Diff

@@ -3,7 +3,6 @@ Copyright (c) 2015 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Leonardo de Moura, Mario Carneiro
 -/
-import Std.Tactic.CoeExt
 import Mathlib.Data.FunLike.Equiv
 import Mathlib.Data.Quot
 import Mathlib.Init.Data.Bool.Lemmas

style: homogenise porting notes (#11145)

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".

8be0b69c

Diff

@@ -190,7 +190,7 @@ protected def trans (e₁ : α ≃ β) (e₂ : β ≃ γ) : α ≃ γ :=
 instance : Trans Equiv Equiv Equiv where
   trans := Equiv.trans
 
--- porting note: this is not a syntactic tautology any more because
+-- Porting note: this is not a syntactic tautology any more because
 -- the coercion from `e` to a function is now `DFunLike.coe` not `e.toFun`
 @[simp, mfld_simps] theorem toFun_as_coe (e : α ≃ β) : e.toFun = e := rfl
 #align equiv.to_fun_as_coe Equiv.toFun_as_coe
@@ -268,7 +268,7 @@ theorem Perm.coe_subsingleton {α : Type*} [Subsingleton α] (e : Perm α) : (e
   rw [Perm.subsingleton_eq_refl e, coe_refl]
 #align equiv.perm.coe_subsingleton Equiv.Perm.coe_subsingleton
 
--- porting note: marking this as `@[simp]` because `simp` doesn't fire on `coe_refl`
+-- Porting note: marking this as `@[simp]` because `simp` doesn't fire on `coe_refl`
 -- in an expression such as `Equiv.refl a x`
 @[simp] theorem refl_apply (x : α) : Equiv.refl α x = x := rfl
 #align equiv.refl_apply Equiv.refl_apply
@@ -276,7 +276,7 @@ theorem Perm.coe_subsingleton {α : Type*} [Subsingleton α] (e : Perm α) : (e
 @[simp] theorem coe_trans (f : α ≃ β) (g : β ≃ γ) : (f.trans g : α → γ) = g ∘ f := rfl
 #align equiv.coe_trans Equiv.coe_trans
 
--- porting note: marking this as `@[simp]` because `simp` doesn't fire on `coe_trans`
+-- Porting note: marking this as `@[simp]` because `simp` doesn't fire on `coe_trans`
 -- in an expression such as `Equiv.trans f g x`
 @[simp] theorem trans_apply (f : α ≃ β) (g : β ≃ γ) (a : α) : (f.trans g) a = g (f a) := rfl
 #align equiv.trans_apply Equiv.trans_apply
@@ -530,7 +530,7 @@ def ofIff {P Q : Prop} (h : P ↔ Q) : P ≃ Q := ⟨h.mp, h.mpr, fun _ => rfl,
 
 /-- If `α₁` is equivalent to `α₂` and `β₁` is equivalent to `β₂`, then the type of maps `α₁ → β₁`
 is equivalent to the type of maps `α₂ → β₂`. -/
--- porting note: removing `congr` attribute
+-- Porting note: removing `congr` attribute
 @[simps apply]
 def arrowCongr {α₁ β₁ α₂ β₂ : Sort*} (e₁ : α₁ ≃ α₂) (e₂ : β₁ ≃ β₂) : (α₁ → β₁) ≃ (α₂ → β₂) where
   toFun f := e₂ ∘ f ∘ e₁.symm
@@ -563,7 +563,7 @@ theorem arrowCongr_comp {α₁ β₁ γ₁ α₂ β₂ γ₂ : Sort*} (ea : α
 The `equiv_rw` tactic is not able to use the default `Sort` level `Equiv.arrowCongr`,
 because Lean's universe rules will not unify `?l_1` with `imax (1 ?m_1)`.
 -/
--- porting note: removing `congr` attribute
+-- Porting note: removing `congr` attribute
 @[simps! apply]
 def arrowCongr' {α₁ β₁ α₂ β₂ : Type*} (hα : α₁ ≃ α₂) (hβ : β₁ ≃ β₂) : (α₁ → β₁) ≃ (α₂ → β₂) :=
   Equiv.arrowCongr hα hβ
@@ -818,7 +818,7 @@ end Perm
     (Σ a : α₁, β (e a)) ≃ Σ a : α₂, β a where
   toFun a := ⟨e a.1, a.2⟩
   invFun a := ⟨e.symm a.1, (e.right_inv' a.1).symm ▸ a.2⟩
-  -- porting note: this was a pretty gnarly match already, and it got worse after porting
+  -- Porting note: this was a pretty gnarly match already, and it got worse after porting
   left_inv := fun ⟨a, b⟩ =>
     match (motive := ∀ a' (h : a' = a), Sigma.mk _ (congr_arg e h.symm ▸ b) = ⟨a, b⟩)
       e.symm (e a), e.left_inv a with

feat(Logic/Equiv/Defs): composing an EquivLike with its symm (#10911)

If you convert an EquivLike to an Equiv in order to use symm, you can get combinations of the coercion of that EquivLike direct to a function, and the coercion of that symm to a function, which should simplify but simp fails to do anything with. Add four simp lemmas to enable simp to act on such combinations.

From AperiodicMonotilesLean.

df231e4c

Diff

@@ -293,6 +293,22 @@ theorem Perm.coe_subsingleton {α : Type*} [Subsingleton α] (e : Perm α) : (e
 @[simp] theorem self_comp_symm (e : α ≃ β) : e ∘ e.symm = id := funext e.apply_symm_apply
 #align equiv.self_comp_symm Equiv.self_comp_symm
 
+@[simp] lemma _root_.EquivLike.apply_coe_symm_apply {F} [EquivLike F α β] (e : F) (x : β) :
+    e ((e : α ≃ β).symm x) = x :=
+  (e : α ≃ β).apply_symm_apply x
+
+@[simp] lemma _root_.EquivLike.coe_symm_apply_apply {F} [EquivLike F α β] (e : F) (x : α) :
+    (e : α ≃ β).symm (e x) = x :=
+  (e : α ≃ β).symm_apply_apply x
+
+@[simp] lemma _root_.EquivLike.coe_symm_comp_self {F} [EquivLike F α β] (e : F) :
+    (e : α ≃ β).symm ∘ e = id :=
+  (e : α ≃ β).symm_comp_self
+
+@[simp] lemma _root_.EquivLike.self_comp_coe_symm {F} [EquivLike F α β] (e : F) :
+    e ∘ (e : α ≃ β).symm = id :=
+  (e : α ≃ β).self_comp_symm
+
 @[simp] theorem symm_trans_apply (f : α ≃ β) (g : β ≃ γ) (a : γ) :
     (f.trans g).symm a = f.symm (g.symm a) := rfl
 #align equiv.symm_trans_apply Equiv.symm_trans_apply

chore: classify simp can do this porting notes (#10619)

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

de765f60

Diff

@@ -705,19 +705,19 @@ def psigmaCongrRight {β₁ β₂ : α → Sort*} (F : ∀ a, β₁ a ≃ β₂
 #align equiv.psigma_congr_right Equiv.psigmaCongrRight
 #align equiv.psigma_congr_right_apply Equiv.psigmaCongrRight_apply
 
--- Porting note: simp can now simplify the LHS, so I have removed `@[simp]`
+-- Porting note (#10618): simp can now simplify the LHS, so I have removed `@[simp]`
 theorem psigmaCongrRight_trans {α} {β₁ β₂ β₃ : α → Sort*}
     (F : ∀ a, β₁ a ≃ β₂ a) (G : ∀ a, β₂ a ≃ β₃ a) :
     (psigmaCongrRight F).trans (psigmaCongrRight G) =
       psigmaCongrRight fun a => (F a).trans (G a) := rfl
 #align equiv.psigma_congr_right_trans Equiv.psigmaCongrRight_trans
 
--- Porting note: simp can now simplify the LHS, so I have removed `@[simp]`
+-- Porting note (#10618): simp can now simplify the LHS, so I have removed `@[simp]`
 theorem psigmaCongrRight_symm {α} {β₁ β₂ : α → Sort*} (F : ∀ a, β₁ a ≃ β₂ a) :
     (psigmaCongrRight F).symm = psigmaCongrRight fun a => (F a).symm := rfl
 #align equiv.psigma_congr_right_symm Equiv.psigmaCongrRight_symm
 
--- Porting note: simp can now prove this, so I have removed `@[simp]`
+-- Porting note (#10618): simp can now prove this, so I have removed `@[simp]`
 theorem psigmaCongrRight_refl {α} {β : α → Sort*} :
     (psigmaCongrRight fun a => Equiv.refl (β a)) = Equiv.refl (Σ' a, β a) := rfl
 #align equiv.psigma_congr_right_refl Equiv.psigmaCongrRight_refl
@@ -733,19 +733,19 @@ def sigmaCongrRight {α} {β₁ β₂ : α → Type*} (F : ∀ a, β₁ a ≃ β
 #align equiv.sigma_congr_right Equiv.sigmaCongrRight
 #align equiv.sigma_congr_right_apply Equiv.sigmaCongrRight_apply
 
--- Porting note: simp can now simplify the LHS, so I have removed `@[simp]`
+-- Porting note (#10618): simp can now simplify the LHS, so I have removed `@[simp]`
 theorem sigmaCongrRight_trans {α} {β₁ β₂ β₃ : α → Type*}
     (F : ∀ a, β₁ a ≃ β₂ a) (G : ∀ a, β₂ a ≃ β₃ a) :
     (sigmaCongrRight F).trans (sigmaCongrRight G) =
       sigmaCongrRight fun a => (F a).trans (G a) := rfl
 #align equiv.sigma_congr_right_trans Equiv.sigmaCongrRight_trans
 
--- Porting note: simp can now simplify the LHS, so I have removed `@[simp]`
+-- Porting note (#10618): simp can now simplify the LHS, so I have removed `@[simp]`
 theorem sigmaCongrRight_symm {α} {β₁ β₂ : α → Type*} (F : ∀ a, β₁ a ≃ β₂ a) :
     (sigmaCongrRight F).symm = sigmaCongrRight fun a => (F a).symm := rfl
 #align equiv.sigma_congr_right_symm Equiv.sigmaCongrRight_symm
 
--- Porting note: simp can now prove this, so I have removed `@[simp]`
+-- Porting note (#10618): simp can now prove this, so I have removed `@[simp]`
 theorem sigmaCongrRight_refl {α} {β : α → Type*} :
     (sigmaCongrRight fun a => Equiv.refl (β a)) = Equiv.refl (Σ a, β a) := rfl
 #align equiv.sigma_congr_right_refl Equiv.sigmaCongrRight_refl

refactor(Data/FunLike): use unbundled inheritance from FunLike (#8386)

The FunLike hierarchy is very big and gets scanned through each time we need a coercion (via the CoeFun instance). It looks like unbundled inheritance suits Lean 4 better here. The only class that still extends FunLike is EquivLike, since that has a custom coe_injective' field that is easier to implement. All other classes should take FunLike or EquivLike as a parameter.

Zulip thread

Important changes

Previously, morphism classes would be Type-valued and extend FunLike:

/-- `MyHomClass F A B` states that `F` is a type of `MyClass.op`-preserving morphisms.
You should extend this class when you extend `MyHom`. -/
class MyHomClass (F : Type*) (A B : outParam <| Type*) [MyClass A] [MyClass B]
  extends FunLike F A B :=
(map_op : ∀ (f : F) (x y : A), f (MyClass.op x y) = MyClass.op (f x) (f y))

After this PR, they should be Prop-valued and take FunLike as a parameter:

/-- `MyHomClass F A B` states that `F` is a type of `MyClass.op`-preserving morphisms.
You should extend this class when you extend `MyHom`. -/
class MyHomClass (F : Type*) (A B : outParam <| Type*) [MyClass A] [MyClass B]
  [FunLike F A B] : Prop :=
(map_op : ∀ (f : F) (x y : A), f (MyClass.op x y) = MyClass.op (f x) (f y))

(Note that A B stay marked as outParam even though they are not purely required to be so due to the FunLike parameter already filling them in. This is required to see through type synonyms, which is important in the category theory library. Also, I think keeping them as outParam is slightly faster.)

Similarly, MyEquivClass should take EquivLike as a parameter.

As a result, every mention of [MyHomClass F A B] should become [FunLike F A B] [MyHomClass F A B].

Remaining issues

Slower (failing) search

While overall this gives some great speedups, there are some cases that are noticeably slower. In particular, a failing application of a lemma such as map_mul is more expensive. This is due to suboptimal processing of arguments. For example:

variable [FunLike F M N] [Mul M] [Mul N] (f : F) (x : M) (y : M)

theorem map_mul [MulHomClass F M N] : f (x * y) = f x * f y

example [AddHomClass F A B] : f (x * y) = f x * f y := map_mul f _ _

Before this PR, applying map_mul f gives the goals [Mul ?M] [Mul ?N] [MulHomClass F ?M ?N]. Since M and N are out_params, [MulHomClass F ?M ?N] is synthesized first, supplies values for ?M and ?N and then the Mul M and Mul N instances can be found.

After this PR, the goals become [FunLike F ?M ?N] [Mul ?M] [Mul ?N] [MulHomClass F ?M ?N]. Now [FunLike F ?M ?N] is synthesized first, supplies values for ?M and ?N and then the Mul M and Mul N instances can be found, before trying MulHomClass F M N which fails. Since the Mul hierarchy is very big, this can be slow to fail, especially when there is no such Mul instance.

A long-term but harder to achieve solution would be to specify the order in which instance goals get solved. For example, we'd like to change the arguments to map_mul to look like [FunLike F M N] [Mul M] [Mul N] [highPriority <| MulHomClass F M N] because MulHomClass fails or succeeds much faster than the others.

As a consequence, the simpNF linter is much slower since by design it tries and fails to apply many map_ lemmas. The same issue occurs a few times in existing calls to simp [map_mul], where map_mul is tried "too soon" and fails. Thanks to the speedup of leanprover/lean4#2478 the impact is very limited, only in files that already were close to the timeout.

`simp` not firing sometimes

This affects map_smulₛₗ and related definitions. For simp lemmas Lean apparently uses a slightly different mechanism to find instances, so that rw can find every argument to map_smulₛₗ successfully but simp can't: leanprover/lean4#3701.

Missing instances due to unification failing

Especially in the category theory library, we might sometimes have a type A which is also accessible as a synonym (Bundled A hA).1. Instance synthesis doesn't always work if we have f : A →* B but x * y : (Bundled A hA).1 or vice versa. This seems to be mostly fixed by keeping A B as outParams in MulHomClass F A B. (Presumably because Lean will do a definitional check A =?= (Bundled A hA).1 instead of using the syntax in the discrimination tree.)

Workaround for issues

The timeouts can be worked around for now by specifying which map_mul we mean, either as map_mul f for some explicit f, or as e.g. MonoidHomClass.map_mul.

map_smulₛₗ not firing as simp lemma can be worked around by going back to the pre-FunLike situation and making LinearMap.map_smulₛₗ a simp lemma instead of the generic map_smulₛₗ. Writing simp [map_smulₛₗ _] also works.

Co-authored-by: Matthew Ballard <matt@mrb.email> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Scott Morrison <scott@tqft.net> Co-authored-by: Anne Baanen <Vierkantor@users.noreply.github.com>

c6a73d4f

Diff

@@ -103,9 +103,13 @@ instance : EquivLike (α ≃ β) α β where
   coe_injective' e₁ e₂ h₁ h₂ := by cases e₁; cases e₂; congr
 
 /-- Helper instance when inference gets stuck on following the normal chain
-`EquivLike → EmbeddingLike → FunLike → CoeFun`. -/
-instance : FunLike (α ≃ β) α β :=
-  EmbeddingLike.toDFunLike
+`EquivLike → FunLike`.
+
+TODO: this instance doesn't appear to be necessary: remove it (after benchmarking?)
+-/
+instance : FunLike (α ≃ β) α β where
+  coe := Equiv.toFun
+  coe_injective' := DFunLike.coe_injective
 
 @[simp, norm_cast]
 lemma _root_.EquivLike.coe_coe {F} [EquivLike F α β] (e : F) :

chore: reduce imports (#9830)

This uses the improved shake script from #9772 to reduce imports across mathlib. The corresponding noshake.json file has been added to #9772.

Co-authored-by: Mario Carneiro <di.gama@gmail.com>

f4c4ca61

Diff

@@ -3,6 +3,7 @@ Copyright (c) 2015 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Leonardo de Moura, Mario Carneiro
 -/
+import Std.Tactic.CoeExt
 import Mathlib.Data.FunLike.Equiv
 import Mathlib.Data.Quot
 import Mathlib.Init.Data.Bool.Lemmas

refactor(*): abbreviation for non-dependent FunLike (#9833)

This follows up from #9785, which renamed FunLike to DFunLike, by introducing a new abbreviation FunLike F α β := DFunLike F α (fun _ => β), to make the non-dependent use of FunLike easier.

I searched for the pattern DFunLike.*fun and DFunLike.*λ in all files to replace expressions of the form DFunLike F α (fun _ => β) with FunLike F α β. I did this everywhere except for extends clauses for two reasons: it would conflict with #8386, and more importantly extends must directly refer to a structure with no unfolding of defs or abbrevs.

54792e9e

Diff

@@ -102,8 +102,8 @@ instance : EquivLike (α ≃ β) α β where
   coe_injective' e₁ e₂ h₁ h₂ := by cases e₁; cases e₂; congr
 
 /-- Helper instance when inference gets stuck on following the normal chain
-`EquivLike → EmbeddingLike → DFunLike → CoeFun`. -/
-instance : DFunLike (α ≃ β) α (fun _ => β) :=
+`EquivLike → EmbeddingLike → FunLike → CoeFun`. -/
+instance : FunLike (α ≃ β) α β :=
   EmbeddingLike.toDFunLike
 
 @[simp, norm_cast]

chore(*): rename FunLike to DFunLike (#9785)

This prepares for the introduction of a non-dependent synonym of FunLike, which helps a lot with keeping #8386 readable.

This is entirely search-and-replace in 680197f combined with manual fixes in 4145626, e900597 and b8428f8. The commands that generated this change:

sed -i 's/\bFunLike\b/DFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/\btoFunLike\b/toDFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/import Mathlib.Data.DFunLike/import Mathlib.Data.FunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/\bHom_FunLike\b/Hom_DFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean     
sed -i 's/\binstFunLike\b/instDFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/\bfunLike\b/instDFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/\btoo many metavariables to apply `fun_like.has_coe_to_fun`/too many metavariables to apply `DFunLike.hasCoeToFun`/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean

Co-authored-by: Anne Baanen <Vierkantor@users.noreply.github.com>

82656743

Diff

@@ -102,9 +102,9 @@ instance : EquivLike (α ≃ β) α β where
   coe_injective' e₁ e₂ h₁ h₂ := by cases e₁; cases e₂; congr
 
 /-- Helper instance when inference gets stuck on following the normal chain
-`EquivLike → EmbeddingLike → FunLike → CoeFun`. -/
-instance : FunLike (α ≃ β) α (fun _ => β) :=
-  EmbeddingLike.toFunLike
+`EquivLike → EmbeddingLike → DFunLike → CoeFun`. -/
+instance : DFunLike (α ≃ β) α (fun _ => β) :=
+  EmbeddingLike.toDFunLike
 
 @[simp, norm_cast]
 lemma _root_.EquivLike.coe_coe {F} [EquivLike F α β] (e : F) :
@@ -116,25 +116,25 @@ lemma _root_.EquivLike.coe_coe {F} [EquivLike F α β] (e : F) :
 
 /-- The map `(r ≃ s) → (r → s)` is injective. -/
 theorem coe_fn_injective : @Function.Injective (α ≃ β) (α → β) (fun e => e) :=
-  FunLike.coe_injective'
+  DFunLike.coe_injective'
 #align equiv.coe_fn_injective Equiv.coe_fn_injective
 
 protected theorem coe_inj {e₁ e₂ : α ≃ β} : (e₁ : α → β) = e₂ ↔ e₁ = e₂ :=
-  @FunLike.coe_fn_eq _ _ _ _ e₁ e₂
+  @DFunLike.coe_fn_eq _ _ _ _ e₁ e₂
 #align equiv.coe_inj Equiv.coe_inj
 
-@[ext] theorem ext {f g : Equiv α β} (H : ∀ x, f x = g x) : f = g := FunLike.ext f g H
+@[ext] theorem ext {f g : Equiv α β} (H : ∀ x, f x = g x) : f = g := DFunLike.ext f g H
 #align equiv.ext Equiv.ext
 
 protected theorem congr_arg {f : Equiv α β} {x x' : α} : x = x' → f x = f x' :=
-  FunLike.congr_arg f
+  DFunLike.congr_arg f
 #align equiv.congr_arg Equiv.congr_arg
 
 protected theorem congr_fun {f g : Equiv α β} (h : f = g) (x : α) : f x = g x :=
-  FunLike.congr_fun h x
+  DFunLike.congr_fun h x
 #align equiv.congr_fun Equiv.congr_fun
 
-theorem ext_iff {f g : Equiv α β} : f = g ↔ ∀ x, f x = g x := FunLike.ext_iff
+theorem ext_iff {f g : Equiv α β} : f = g ↔ ∀ x, f x = g x := DFunLike.ext_iff
 #align equiv.ext_iff Equiv.ext_iff
 
 @[ext] theorem Perm.ext {σ τ : Equiv.Perm α} (H : ∀ x, σ x = τ x) : σ = τ := Equiv.ext H
@@ -186,7 +186,7 @@ instance : Trans Equiv Equiv Equiv where
   trans := Equiv.trans
 
 -- porting note: this is not a syntactic tautology any more because
--- the coercion from `e` to a function is now `FunLike.coe` not `e.toFun`
+-- the coercion from `e` to a function is now `DFunLike.coe` not `e.toFun`
 @[simp, mfld_simps] theorem toFun_as_coe (e : α ≃ β) : e.toFun = e := rfl
 #align equiv.to_fun_as_coe Equiv.toFun_as_coe

chore: Move Int and Nat cast lemmas (#9503)

Part of #9411

e1b05c51

Diff

@@ -918,6 +918,27 @@ protected theorem exists_congr_left {α β} (f : α ≃ β) {p : α → Prop} :
   ⟨fun ⟨a, h⟩ => ⟨f a, by simpa using h⟩, fun ⟨b, h⟩ => ⟨_, h⟩⟩
 #align equiv.exists_congr_left Equiv.exists_congr_left
 
+/-- If `f` is a bijective function, then its domain is equivalent to its codomain. -/
+@[simps apply]
+noncomputable def ofBijective (f : α → β) (hf : Bijective f) : α ≃ β where
+  toFun := f
+  invFun := surjInv hf.surjective
+  left_inv := leftInverse_surjInv hf
+  right_inv := rightInverse_surjInv _
+#align equiv.of_bijective Equiv.ofBijective
+#align equiv.of_bijective_apply Equiv.ofBijective_apply
+
+lemma ofBijective_apply_symm_apply (f : α → β) (hf : Bijective f) (x : β) :
+    f ((ofBijective f hf).symm x) = x :=
+  (ofBijective f hf).apply_symm_apply x
+#align equiv.of_bijective_apply_symm_apply Equiv.ofBijective_apply_symm_apply
+
+@[simp]
+lemma ofBijective_symm_apply_apply (f : α → β) (hf : Bijective f) (x : α) :
+    (ofBijective f hf).symm (f x) = x :=
+  (ofBijective f hf).symm_apply_apply x
+#align equiv.of_bijective_symm_apply_apply Equiv.ofBijective_symm_apply_apply
+
 end Equiv
 
 namespace Quot

chore: tidy various files (#9016)

95ddd894

Diff

@@ -630,7 +630,7 @@ def piUnique [Unique α] (β : α → Sort*) : (∀ i, β i) ≃ β default wher
   right_inv x := rfl
 
 /-- If `α` has a unique term, then the type of function `α → β` is equivalent to `β`. -/
-@[simps! (config := .asFn) apply]
+@[simps! (config := .asFn) apply symm_apply]
 def funUnique (α β) [Unique.{u} α] : (α → β) ≃ β := piUnique _
 #align equiv.fun_unique Equiv.funUnique
 #align equiv.fun_unique_apply Equiv.funUnique_apply

feat: Add API for AlgEquiv. (#8639)

Co-authored-by: Andrew Yang <36414270+erdOne@users.noreply.github.com>

bcd9607b

Diff

@@ -106,6 +106,10 @@ instance : EquivLike (α ≃ β) α β where
 instance : FunLike (α ≃ β) α (fun _ => β) :=
   EmbeddingLike.toFunLike
 
+@[simp, norm_cast]
+lemma _root_.EquivLike.coe_coe {F} [EquivLike F α β] (e : F) :
+    ((e : α ≃ β) : α → β) = e := rfl
+
 @[simp] theorem coe_fn_mk (f : α → β) (g l r) : (Equiv.mk f g l r : α → β) = f :=
   rfl
 #align equiv.coe_fn_mk Equiv.coe_fn_mk

feat(/Equiv/): Add symm_bijective lemmas next to symm_symms (#8444)

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: lines <34025592+linesthatinterlace@users.noreply.github.com>

e368f2a5

Diff

@@ -330,6 +330,9 @@ theorem eq_symm_apply {α β} (e : α ≃ β) {x y} : y = e.symm x ↔ e y = x :
 @[simp] theorem symm_symm (e : α ≃ β) : e.symm.symm = e := by cases e; rfl
 #align equiv.symm_symm Equiv.symm_symm
 
+theorem symm_bijective : Function.Bijective (Equiv.symm : (α ≃ β) → β ≃ α) :=
+  Function.bijective_iff_has_inverse.mpr ⟨_, symm_symm, symm_symm⟩
+
 @[simp] theorem trans_refl (e : α ≃ β) : e.trans (Equiv.refl β) = e := by cases e; rfl
 #align equiv.trans_refl Equiv.trans_refl

feat: measurability of uniqueElim and piFinsetUnion (#8249)

The extra import doesn't add any additional imports transitively
Also use implicit arguments for some MeasurableSpace arguments for consistency with other lemmas.
Redefine Equiv.piSubsingleton and MulEquiv.piSubsingleton to Equiv.piUnique and MulEquiv.piUnique.

76efc30c

Diff

@@ -614,20 +614,17 @@ def arrowPUnitEquivPUnit (α : Sort*) : (α → PUnit.{v}) ≃ PUnit.{w} :=
   ⟨fun _ => .unit, fun _ _ => .unit, fun _ => rfl, fun _ => rfl⟩
 #align equiv.arrow_punit_equiv_punit Equiv.arrowPUnitEquivPUnit
 
-/-- If `α` is `Subsingleton` and `a : α`, then the type of dependent functions `Π (i : α), β i`
-is equivalent to `β a`. -/
-@[simps] def piSubsingleton (β : α → Sort*) [Subsingleton α] (a : α) : (∀ a', β a') ≃ β a where
-  toFun := eval a
-  invFun x b := cast (congr_arg β <| Subsingleton.elim a b) x
-  left_inv _ := funext fun b => by rw [Subsingleton.elim b a]; rfl
-  right_inv _ := rfl
-#align equiv.Pi_subsingleton_apply Equiv.piSubsingleton_apply
-#align equiv.Pi_subsingleton_symm_apply Equiv.piSubsingleton_symm_apply
-#align equiv.Pi_subsingleton Equiv.piSubsingleton
+/-- The equivalence `(∀ i, β i) ≃ β ⋆` when the domain of `β` only contains `⋆` -/
+@[simps (config := .asFn)]
+def piUnique [Unique α] (β : α → Sort*) : (∀ i, β i) ≃ β default where
+  toFun f := f default
+  invFun := uniqueElim
+  left_inv f := by ext i; cases Unique.eq_default i; rfl
+  right_inv x := rfl
 
 /-- If `α` has a unique term, then the type of function `α → β` is equivalent to `β`. -/
 @[simps! (config := .asFn) apply]
-def funUnique (α β) [Unique.{u} α] : (α → β) ≃ β := piSubsingleton _ default
+def funUnique (α β) [Unique.{u} α] : (α → β) ≃ β := piUnique _
 #align equiv.fun_unique Equiv.funUnique
 #align equiv.fun_unique_apply Equiv.funUnique_apply

https://github.com/leanprover-community/mathlib4/blob/4055c8b471380825f07416b12cb0cf266da44d84/Mathlib/Tactic/Simps/Basic.lean#L843-L851

style: shorten simps configurations (#8296)

Use .asFn and .lemmasOnly as simps configuration options.

For reference, these are defined here:

e0637173

Diff

@@ -484,14 +484,14 @@ def propEquivPUnit {p : Prop} (h : p) : p ≃ PUnit.{0} := @equivPUnit p <| uniq
 #align equiv.prop_equiv_punit Equiv.propEquivPUnit
 
 /-- `ULift α` is equivalent to `α`. -/
-@[simps (config := { fullyApplied := false }) apply]
+@[simps (config := .asFn) apply]
 protected def ulift {α : Type v} : ULift.{u} α ≃ α :=
   ⟨ULift.down, ULift.up, ULift.up_down, ULift.down_up.{v, u}⟩
 #align equiv.ulift Equiv.ulift
 #align equiv.ulift_apply Equiv.ulift_apply
 
 /-- `PLift α` is equivalent to `α`. -/
-@[simps (config := { fullyApplied := false }) apply]
+@[simps (config := .asFn) apply]
 protected def plift : PLift α ≃ α := ⟨PLift.down, PLift.up, PLift.up_down, PLift.down_up⟩
 #align equiv.plift Equiv.plift
 #align equiv.plift_apply Equiv.plift_apply
@@ -626,7 +626,7 @@ is equivalent to `β a`. -/
 #align equiv.Pi_subsingleton Equiv.piSubsingleton
 
 /-- If `α` has a unique term, then the type of function `α → β` is equivalent to `β`. -/
-@[simps! (config := { fullyApplied := false }) apply]
+@[simps! (config := .asFn) apply]
 def funUnique (α β) [Unique.{u} α] : (α → β) ≃ β := piSubsingleton _ default
 #align equiv.fun_unique Equiv.funUnique
 #align equiv.fun_unique_apply Equiv.funUnique_apply

add @[inherit_doc] to equiv notation (#7998)

This makes hovering over ≃ display the docstring for Equiv (if I've understood things correctly).

2aead333

Diff

@@ -70,6 +70,7 @@ structure Equiv (α : Sort*) (β : Sort _) where
   protected right_inv : RightInverse invFun toFun
 #align equiv Equiv
 
+@[inherit_doc]
 infixl:25 " ≃ " => Equiv
 
 /-- Turn an element of a type `F` satisfying `EquivLike F α β` into an actual

chore: remove Equiv.toFun_as_coe_apply (#7902)

This simp lemma was added during the port but tagged as probably unnecessary after fixing https://github.com/leanprover/lean4/issues/1937. This PR confirms it is indeed no longer necessary. The only proofs that needed fixing were the one explicitly calling the new simp lemma.

The porting note can go too.

270b0eab

Diff

@@ -185,12 +185,6 @@ instance : Trans Equiv Equiv Equiv where
 @[simp, mfld_simps] theorem toFun_as_coe (e : α ≃ β) : e.toFun = e := rfl
 #align equiv.to_fun_as_coe Equiv.toFun_as_coe
 
--- porting note: `simp` should prove this using `toFun_as_coe`, but it doesn't.
--- This might be a bug in `simp` -- see https://github.com/leanprover/lean4/issues/1937
--- If this issue is fixed then the simp linter probably will start complaining, and
--- this theorem can be deleted hopefully without breaking any `simp` proofs.
-@[simp] theorem toFun_as_coe_apply (e : α ≃ β) (x : α) : e.toFun x = e x := rfl
-
 @[simp, mfld_simps] theorem invFun_as_coe (e : α ≃ β) : e.invFun = e.symm := rfl
 #align equiv.inv_fun_as_coe Equiv.invFun_as_coe

chore: add more pp_dot attributes (#7288)

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

bb438000

Diff

@@ -8,7 +8,6 @@ import Mathlib.Data.Quot
 import Mathlib.Init.Data.Bool.Lemmas
 import Mathlib.Logic.Unique
 import Mathlib.Tactic.Substs
-import Mathlib.Tactic.ProjectionNotation
 import Mathlib.Tactic.Conv
 
 #align_import logic.equiv.defs from "leanprover-community/mathlib"@"48fb5b5280e7c81672afc9524185ae994553ebf4"

chore: make fields of algebraic (iso)morphisms protected (#7150)

Pretty much all these fields are implementation details, and not intended as API. There is no point in open MonoidHom bringing toFun or map_mul' into the environment, as neither are the preferred way to spell those things.

fbed0880

Diff

@@ -65,10 +65,10 @@ variable {α : Sort u} {β : Sort v} {γ : Sort w}
 
 /-- `α ≃ β` is the type of functions from `α → β` with a two-sided inverse. -/
 structure Equiv (α : Sort*) (β : Sort _) where
-  toFun : α → β
-  invFun : β → α
-  left_inv : LeftInverse invFun toFun
-  right_inv : RightInverse invFun toFun
+  protected toFun : α → β
+  protected invFun : β → α
+  protected left_inv : LeftInverse invFun toFun
+  protected right_inv : RightInverse invFun toFun
 #align equiv Equiv
 
 infixl:25 " ≃ " => Equiv
@@ -95,10 +95,10 @@ def Equiv.Perm (α : Sort*) :=
 namespace Equiv
 
 instance : EquivLike (α ≃ β) α β where
-  coe := toFun
-  inv := invFun
-  left_inv := left_inv
-  right_inv := right_inv
+  coe := Equiv.toFun
+  inv := Equiv.invFun
+  left_inv := Equiv.left_inv
+  right_inv := Equiv.right_inv
   coe_injective' e₁ e₂ h₁ h₂ := by cases e₁; cases e₂; congr
 
 /-- Helper instance when inference gets stuck on following the normal chain

chore: delay import of Tactic.Common (#7000)

I know that this is contrary to what we've done previously, but:

I'm trying to upstream a great many tactics from Mathlib to Std (essentially, everything that non-mathematicians want too).
This makes it much easier for me to see what is going on, and understand the import requirements (particularly for the "big" tactics norm_num / ring / linarith)
It's actually not as bad as it looks here, because as these tactics move up to Std they will start disappearing again from explicit imports, but Mathlib can happily import all of Std.

(Oh

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

4f3418a7

Diff

@@ -7,6 +7,9 @@ import Mathlib.Data.FunLike.Equiv
 import Mathlib.Data.Quot
 import Mathlib.Init.Data.Bool.Lemmas
 import Mathlib.Logic.Unique
+import Mathlib.Tactic.Substs
+import Mathlib.Tactic.ProjectionNotation
+import Mathlib.Tactic.Conv
 
 #align_import logic.equiv.defs from "leanprover-community/mathlib"@"48fb5b5280e7c81672afc9524185ae994553ebf4"

fix: disable autoImplicit globally (#6528)

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.

0c24f831

Diff

@@ -51,6 +51,8 @@ Many more such isomorphisms and operations are defined in `Logic.Equiv.Basic`.
 equivalence, congruence, bijective map
 -/
 
+set_option autoImplicit true
+
 
 open Function

chore: banish Type _ and Sort _ (#6499)

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

This has nice performance benefits.

32de3f67

Diff

@@ -59,7 +59,7 @@ universe u v w z
 variable {α : Sort u} {β : Sort v} {γ : Sort w}
 
 /-- `α ≃ β` is the type of functions from `α → β` with a two-sided inverse. -/
-structure Equiv (α : Sort _) (β : Sort _) where
+structure Equiv (α : Sort*) (β : Sort _) where
   toFun : α → β
   invFun : β → α
   left_inv : LeftInverse invFun toFun
@@ -83,7 +83,7 @@ instance {F} [EquivLike F α β] : CoeTC F (α ≃ β) :=
 
 /-- `Perm α` is the type of bijections from `α` to itself. -/
 @[reducible]
-def Equiv.Perm (α : Sort _) :=
+def Equiv.Perm (α : Sort*) :=
   Equiv α α
 #align equiv.perm Equiv.Perm
 
@@ -143,7 +143,7 @@ theorem Perm.ext_iff {σ τ : Equiv.Perm α} : σ = τ ↔ ∀ x, σ x = τ x :=
 #align equiv.perm.ext_iff Equiv.Perm.ext_iff
 
 /-- Any type is equivalent to itself. -/
-@[refl] protected def refl (α : Sort _) : α ≃ α := ⟨id, id, fun _ => rfl, fun _ => rfl⟩
+@[refl] protected def refl (α : Sort*) : α ≃ α := ⟨id, id, fun _ => rfl, fun _ => rfl⟩
 #align equiv.refl Equiv.refl
 
 instance inhabited' : Inhabited (α ≃ α) := ⟨Equiv.refl α⟩
@@ -256,7 +256,7 @@ protected def cast {α β : Sort _} (h : α = β) : α ≃ β :=
 
 /-- This cannot be a `simp` lemmas as it incorrectly matches against `e : α ≃ synonym α`, when
 `synonym α` is semireducible. This makes a mess of `Multiplicative.ofAdd` etc. -/
-theorem Perm.coe_subsingleton {α : Type _} [Subsingleton α] (e : Perm α) : (e : α → α) = id := by
+theorem Perm.coe_subsingleton {α : Type*} [Subsingleton α] (e : Perm α) : (e : α → α) = id := by
   rw [Perm.subsingleton_eq_refl e, coe_refl]
 #align equiv.perm.coe_subsingleton Equiv.Perm.coe_subsingleton
 
@@ -416,7 +416,7 @@ def equivCongr (ab : α ≃ β) (cd : γ ≃ δ) : (α ≃ γ) ≃ (β ≃ δ) w
 
 section permCongr
 
-variable {α' β' : Type _} (e : α' ≃ β')
+variable {α' β' : Type*} (e : α' ≃ β')
 
 /-- If `α` is equivalent to `β`, then `Perm α` is equivalent to `Perm β`. -/
 def permCongr : Perm α' ≃ Perm β' := equivCongr e e
@@ -447,7 +447,7 @@ theorem permCongr_trans (p p' : Equiv.Perm α') :
 end permCongr
 
 /-- Two empty types are equivalent. -/
-def equivOfIsEmpty (α β : Sort _) [IsEmpty α] [IsEmpty β] : α ≃ β :=
+def equivOfIsEmpty (α β : Sort*) [IsEmpty α] [IsEmpty β] : α ≃ β :=
   ⟨isEmptyElim, isEmptyElim, isEmptyElim, isEmptyElim⟩
 #align equiv.equiv_of_is_empty Equiv.equivOfIsEmpty
 
@@ -505,7 +505,7 @@ def ofIff {P Q : Prop} (h : P ↔ Q) : P ≃ Q := ⟨h.mp, h.mpr, fun _ => rfl,
 is equivalent to the type of maps `α₂ → β₂`. -/
 -- porting note: removing `congr` attribute
 @[simps apply]
-def arrowCongr {α₁ β₁ α₂ β₂ : Sort _} (e₁ : α₁ ≃ α₂) (e₂ : β₁ ≃ β₂) : (α₁ → β₁) ≃ (α₂ → β₂) where
+def arrowCongr {α₁ β₁ α₂ β₂ : Sort*} (e₁ : α₁ ≃ α₂) (e₂ : β₁ ≃ β₂) : (α₁ → β₁) ≃ (α₂ → β₂) where
   toFun f := e₂ ∘ f ∘ e₁.symm
   invFun f := e₂.symm ∘ f ∘ e₁
   left_inv f := funext fun x => by simp only [comp_apply, symm_apply_apply]
@@ -513,13 +513,13 @@ def arrowCongr {α₁ β₁ α₂ β₂ : Sort _} (e₁ : α₁ ≃ α₂) (e₂
 #align equiv.arrow_congr_apply Equiv.arrowCongr_apply
 #align equiv.arrow_congr Equiv.arrowCongr
 
-theorem arrowCongr_comp {α₁ β₁ γ₁ α₂ β₂ γ₂ : Sort _} (ea : α₁ ≃ α₂) (eb : β₁ ≃ β₂) (ec : γ₁ ≃ γ₂)
+theorem arrowCongr_comp {α₁ β₁ γ₁ α₂ β₂ γ₂ : Sort*} (ea : α₁ ≃ α₂) (eb : β₁ ≃ β₂) (ec : γ₁ ≃ γ₂)
     (f : α₁ → β₁) (g : β₁ → γ₁) :
     arrowCongr ea ec (g ∘ f) = arrowCongr eb ec g ∘ arrowCongr ea eb f := by
   ext; simp only [comp, arrowCongr_apply, eb.symm_apply_apply]
 #align equiv.arrow_congr_comp Equiv.arrowCongr_comp
 
-@[simp] theorem arrowCongr_refl {α β : Sort _} :
+@[simp] theorem arrowCongr_refl {α β : Sort*} :
     arrowCongr (Equiv.refl α) (Equiv.refl β) = Equiv.refl (α → β) := rfl
 #align equiv.arrow_congr_refl Equiv.arrowCongr_refl
 
@@ -538,12 +538,12 @@ because Lean's universe rules will not unify `?l_1` with `imax (1 ?m_1)`.
 -/
 -- porting note: removing `congr` attribute
 @[simps! apply]
-def arrowCongr' {α₁ β₁ α₂ β₂ : Type _} (hα : α₁ ≃ α₂) (hβ : β₁ ≃ β₂) : (α₁ → β₁) ≃ (α₂ → β₂) :=
+def arrowCongr' {α₁ β₁ α₂ β₂ : Type*} (hα : α₁ ≃ α₂) (hβ : β₁ ≃ β₂) : (α₁ → β₁) ≃ (α₂ → β₂) :=
   Equiv.arrowCongr hα hβ
 #align equiv.arrow_congr' Equiv.arrowCongr'
 #align equiv.arrow_congr'_apply Equiv.arrowCongr'_apply
 
-@[simp] theorem arrowCongr'_refl {α β : Type _} :
+@[simp] theorem arrowCongr'_refl {α β : Type*} :
     arrowCongr' (Equiv.refl α) (Equiv.refl β) = Equiv.refl (α → β) := rfl
 #align equiv.arrow_congr'_refl Equiv.arrowCongr'_refl
 
@@ -611,13 +611,13 @@ noncomputable def propEquivBool : Prop ≃ Bool where
 section
 
 /-- The sort of maps to `PUnit.{v}` is equivalent to `PUnit.{w}`. -/
-def arrowPUnitEquivPUnit (α : Sort _) : (α → PUnit.{v}) ≃ PUnit.{w} :=
+def arrowPUnitEquivPUnit (α : Sort*) : (α → PUnit.{v}) ≃ PUnit.{w} :=
   ⟨fun _ => .unit, fun _ _ => .unit, fun _ => rfl, fun _ => rfl⟩
 #align equiv.arrow_punit_equiv_punit Equiv.arrowPUnitEquivPUnit
 
 /-- If `α` is `Subsingleton` and `a : α`, then the type of dependent functions `Π (i : α), β i`
 is equivalent to `β a`. -/
-@[simps] def piSubsingleton (β : α → Sort _) [Subsingleton α] (a : α) : (∀ a', β a') ≃ β a where
+@[simps] def piSubsingleton (β : α → Sort*) [Subsingleton α] (a : α) : (∀ a', β a') ≃ β a where
   toFun := eval a
   invFun x b := cast (congr_arg β <| Subsingleton.elim a b) x
   left_inv _ := funext fun b => by rw [Subsingleton.elim b a]; rfl
@@ -633,15 +633,15 @@ def funUnique (α β) [Unique.{u} α] : (α → β) ≃ β := piSubsingleton _ d
 #align equiv.fun_unique_apply Equiv.funUnique_apply
 
 /-- The sort of maps from `PUnit` is equivalent to the codomain. -/
-def punitArrowEquiv (α : Sort _) : (PUnit.{u} → α) ≃ α := funUnique PUnit.{u} α
+def punitArrowEquiv (α : Sort*) : (PUnit.{u} → α) ≃ α := funUnique PUnit.{u} α
 #align equiv.punit_arrow_equiv Equiv.punitArrowEquiv
 
 /-- The sort of maps from `True` is equivalent to the codomain. -/
-def trueArrowEquiv (α : Sort _) : (True → α) ≃ α := funUnique _ _
+def trueArrowEquiv (α : Sort*) : (True → α) ≃ α := funUnique _ _
 #align equiv.true_arrow_equiv Equiv.trueArrowEquiv
 
 /-- The sort of maps from a type that `IsEmpty` is equivalent to `PUnit`. -/
-def arrowPUnitOfIsEmpty (α β : Sort _) [IsEmpty α] : (α → β) ≃ PUnit.{u} where
+def arrowPUnitOfIsEmpty (α β : Sort*) [IsEmpty α] : (α → β) ≃ PUnit.{u} where
   toFun _ := PUnit.unit
   invFun _ := isEmptyElim
   left_inv _ := funext isEmptyElim
@@ -649,15 +649,15 @@ def arrowPUnitOfIsEmpty (α β : Sort _) [IsEmpty α] : (α → β) ≃ PUnit.{u
 #align equiv.arrow_punit_of_is_empty Equiv.arrowPUnitOfIsEmpty
 
 /-- The sort of maps from `Empty` is equivalent to `PUnit`. -/
-def emptyArrowEquivPUnit (α : Sort _) : (Empty → α) ≃ PUnit.{u} := arrowPUnitOfIsEmpty _ _
+def emptyArrowEquivPUnit (α : Sort*) : (Empty → α) ≃ PUnit.{u} := arrowPUnitOfIsEmpty _ _
 #align equiv.empty_arrow_equiv_punit Equiv.emptyArrowEquivPUnit
 
 /-- The sort of maps from `PEmpty` is equivalent to `PUnit`. -/
-def pemptyArrowEquivPUnit (α : Sort _) : (PEmpty → α) ≃ PUnit.{u} := arrowPUnitOfIsEmpty _ _
+def pemptyArrowEquivPUnit (α : Sort*) : (PEmpty → α) ≃ PUnit.{u} := arrowPUnitOfIsEmpty _ _
 #align equiv.pempty_arrow_equiv_punit Equiv.pemptyArrowEquivPUnit
 
 /-- The sort of maps from `False` is equivalent to `PUnit`. -/
-def falseArrowEquivPUnit (α : Sort _) : (False → α) ≃ PUnit.{u} := arrowPUnitOfIsEmpty _ _
+def falseArrowEquivPUnit (α : Sort*) : (False → α) ≃ PUnit.{u} := arrowPUnitOfIsEmpty _ _
 #align equiv.false_arrow_equiv_punit Equiv.falseArrowEquivPUnit
 
 end
@@ -666,7 +666,7 @@ section
 
 /-- A `PSigma`-type is equivalent to the corresponding `Sigma`-type. -/
 @[simps apply symm_apply]
-def psigmaEquivSigma {α} (β : α → Type _) : (Σ' i, β i) ≃ Σ i, β i where
+def psigmaEquivSigma {α} (β : α → Type*) : (Σ' i, β i) ≃ Σ i, β i where
   toFun a := ⟨a.1, a.2⟩
   invFun a := ⟨a.1, a.2⟩
   left_inv _ := rfl
@@ -677,7 +677,7 @@ def psigmaEquivSigma {α} (β : α → Type _) : (Σ' i, β i) ≃ Σ i, β i wh
 
 /-- A `PSigma`-type is equivalent to the corresponding `Sigma`-type. -/
 @[simps apply symm_apply]
-def psigmaEquivSigmaPLift {α} (β : α → Sort _) : (Σ' i, β i) ≃ Σ i : PLift α, PLift (β i.down) where
+def psigmaEquivSigmaPLift {α} (β : α → Sort*) : (Σ' i, β i) ≃ Σ i : PLift α, PLift (β i.down) where
   toFun a := ⟨PLift.up a.1, PLift.up a.2⟩
   invFun a := ⟨a.1.down, a.2.down⟩
   left_inv _ := rfl
@@ -689,7 +689,7 @@ def psigmaEquivSigmaPLift {α} (β : α → Sort _) : (Σ' i, β i) ≃ Σ i : P
 /-- A family of equivalences `Π a, β₁ a ≃ β₂ a` generates an equivalence between `Σ' a, β₁ a` and
 `Σ' a, β₂ a`. -/
 @[simps apply]
-def psigmaCongrRight {β₁ β₂ : α → Sort _} (F : ∀ a, β₁ a ≃ β₂ a) : (Σ' a, β₁ a) ≃ Σ' a, β₂ a where
+def psigmaCongrRight {β₁ β₂ : α → Sort*} (F : ∀ a, β₁ a ≃ β₂ a) : (Σ' a, β₁ a) ≃ Σ' a, β₂ a where
   toFun a := ⟨a.1, F a.1 a.2⟩
   invFun a := ⟨a.1, (F a.1).symm a.2⟩
   left_inv | ⟨a, b⟩ => congr_arg (PSigma.mk a) <| symm_apply_apply (F a) b
@@ -698,26 +698,26 @@ def psigmaCongrRight {β₁ β₂ : α → Sort _} (F : ∀ a, β₁ a ≃ β₂
 #align equiv.psigma_congr_right_apply Equiv.psigmaCongrRight_apply
 
 -- Porting note: simp can now simplify the LHS, so I have removed `@[simp]`
-theorem psigmaCongrRight_trans {α} {β₁ β₂ β₃ : α → Sort _}
+theorem psigmaCongrRight_trans {α} {β₁ β₂ β₃ : α → Sort*}
     (F : ∀ a, β₁ a ≃ β₂ a) (G : ∀ a, β₂ a ≃ β₃ a) :
     (psigmaCongrRight F).trans (psigmaCongrRight G) =
       psigmaCongrRight fun a => (F a).trans (G a) := rfl
 #align equiv.psigma_congr_right_trans Equiv.psigmaCongrRight_trans
 
 -- Porting note: simp can now simplify the LHS, so I have removed `@[simp]`
-theorem psigmaCongrRight_symm {α} {β₁ β₂ : α → Sort _} (F : ∀ a, β₁ a ≃ β₂ a) :
+theorem psigmaCongrRight_symm {α} {β₁ β₂ : α → Sort*} (F : ∀ a, β₁ a ≃ β₂ a) :
     (psigmaCongrRight F).symm = psigmaCongrRight fun a => (F a).symm := rfl
 #align equiv.psigma_congr_right_symm Equiv.psigmaCongrRight_symm
 
 -- Porting note: simp can now prove this, so I have removed `@[simp]`
-theorem psigmaCongrRight_refl {α} {β : α → Sort _} :
+theorem psigmaCongrRight_refl {α} {β : α → Sort*} :
     (psigmaCongrRight fun a => Equiv.refl (β a)) = Equiv.refl (Σ' a, β a) := rfl
 #align equiv.psigma_congr_right_refl Equiv.psigmaCongrRight_refl
 
 /-- A family of equivalences `Π a, β₁ a ≃ β₂ a` generates an equivalence between `Σ a, β₁ a` and
 `Σ a, β₂ a`. -/
 @[simps apply]
-def sigmaCongrRight {α} {β₁ β₂ : α → Type _} (F : ∀ a, β₁ a ≃ β₂ a) : (Σ a, β₁ a) ≃ Σ a, β₂ a where
+def sigmaCongrRight {α} {β₁ β₂ : α → Type*} (F : ∀ a, β₁ a ≃ β₂ a) : (Σ a, β₁ a) ≃ Σ a, β₂ a where
   toFun a := ⟨a.1, F a.1 a.2⟩
   invFun a := ⟨a.1, (F a.1).symm a.2⟩
   left_inv | ⟨a, b⟩ => congr_arg (Sigma.mk a) <| symm_apply_apply (F a) b
@@ -726,19 +726,19 @@ def sigmaCongrRight {α} {β₁ β₂ : α → Type _} (F : ∀ a, β₁ a ≃ 
 #align equiv.sigma_congr_right_apply Equiv.sigmaCongrRight_apply
 
 -- Porting note: simp can now simplify the LHS, so I have removed `@[simp]`
-theorem sigmaCongrRight_trans {α} {β₁ β₂ β₃ : α → Type _}
+theorem sigmaCongrRight_trans {α} {β₁ β₂ β₃ : α → Type*}
     (F : ∀ a, β₁ a ≃ β₂ a) (G : ∀ a, β₂ a ≃ β₃ a) :
     (sigmaCongrRight F).trans (sigmaCongrRight G) =
       sigmaCongrRight fun a => (F a).trans (G a) := rfl
 #align equiv.sigma_congr_right_trans Equiv.sigmaCongrRight_trans
 
 -- Porting note: simp can now simplify the LHS, so I have removed `@[simp]`
-theorem sigmaCongrRight_symm {α} {β₁ β₂ : α → Type _} (F : ∀ a, β₁ a ≃ β₂ a) :
+theorem sigmaCongrRight_symm {α} {β₁ β₂ : α → Type*} (F : ∀ a, β₁ a ≃ β₂ a) :
     (sigmaCongrRight F).symm = sigmaCongrRight fun a => (F a).symm := rfl
 #align equiv.sigma_congr_right_symm Equiv.sigmaCongrRight_symm
 
 -- Porting note: simp can now prove this, so I have removed `@[simp]`
-theorem sigmaCongrRight_refl {α} {β : α → Type _} :
+theorem sigmaCongrRight_refl {α} {β : α → Type*} :
     (sigmaCongrRight fun a => Equiv.refl (β a)) = Equiv.refl (Σ a, β a) := rfl
 #align equiv.sigma_congr_right_refl Equiv.sigmaCongrRight_refl
 
@@ -820,7 +820,7 @@ def sigmaCongr {α₁ α₂} {β₁ : α₁ → Sort _} {β₂ : α₂ → Sort
 
 /-- `Sigma` type with a constant fiber is equivalent to the product. -/
 @[simps (config := { attrs := [`mfld_simps] }) apply symm_apply]
-def sigmaEquivProd (α β : Type _) : (Σ _ : α, β) ≃ α × β :=
+def sigmaEquivProd (α β : Type*) : (Σ _ : α, β) ≃ α × β :=
   ⟨fun a => ⟨a.1, a.2⟩, fun a => ⟨a.1, a.2⟩, fun ⟨_, _⟩ => rfl, fun ⟨_, _⟩ => rfl⟩
 #align equiv.sigma_equiv_prod_apply Equiv.sigmaEquivProd_apply
 #align equiv.sigma_equiv_prod_symm_apply Equiv.sigmaEquivProd_symm_apply
@@ -833,7 +833,7 @@ def sigmaEquivProdOfEquiv {α β} {β₁ : α → Sort _} (F : ∀ a, β₁ a 
 #align equiv.sigma_equiv_prod_of_equiv Equiv.sigmaEquivProdOfEquiv
 
 /-- Dependent product of types is associative up to an equivalence. -/
-def sigmaAssoc {α : Type _} {β : α → Type _} (γ : ∀ a : α, β a → Type _) :
+def sigmaAssoc {α : Type*} {β : α → Type*} (γ : ∀ a : α, β a → Type*) :
     (Σ ab : Σ a : α, β a, γ ab.1 ab.2) ≃ Σ a : α, Σ b : β a, γ a b where
   toFun x := ⟨x.1.1, ⟨x.1.2, x.2⟩⟩
   invFun x := ⟨⟨x.1, x.2.1⟩, x.2.2⟩

chore: slightly golf Equiv.ulift (#6180)

Use ULift.down_up to provide a value for the field right_inv.

ee689443

Diff

@@ -487,7 +487,7 @@ def propEquivPUnit {p : Prop} (h : p) : p ≃ PUnit.{0} := @equivPUnit p <| uniq
 /-- `ULift α` is equivalent to `α`. -/
 @[simps (config := { fullyApplied := false }) apply]
 protected def ulift {α : Type v} : ULift.{u} α ≃ α :=
-  ⟨ULift.down, ULift.up, ULift.up_down, fun _ => rfl⟩
+  ⟨ULift.down, ULift.up, ULift.up_down, ULift.down_up.{v, u}⟩
 #align equiv.ulift Equiv.ulift
 #align equiv.ulift_apply Equiv.ulift_apply

chore: script to replace headers with #align_import statements (#5979)

depends on: #5966

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

89aa3a3b

Diff

@@ -2,17 +2,14 @@
 Copyright (c) 2015 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Leonardo de Moura, Mario Carneiro
-
-! This file was ported from Lean 3 source module logic.equiv.defs
-! leanprover-community/mathlib commit 48fb5b5280e7c81672afc9524185ae994553ebf4
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.FunLike.Equiv
 import Mathlib.Data.Quot
 import Mathlib.Init.Data.Bool.Lemmas
 import Mathlib.Logic.Unique
 
+#align_import logic.equiv.defs from "leanprover-community/mathlib"@"48fb5b5280e7c81672afc9524185ae994553ebf4"
+
 /-!
 # Equivalence between types

feat: pp_dot attribute to replace pp_extended_field_notation command (#5632)

760b24bf

Diff

@@ -152,12 +152,10 @@ theorem Perm.ext_iff {σ τ : Equiv.Perm α} : σ = τ ↔ ∀ x, σ x = τ x :=
 instance inhabited' : Inhabited (α ≃ α) := ⟨Equiv.refl α⟩
 
 /-- Inverse of an equivalence `e : α ≃ β`. -/
-@[symm]
+@[symm, pp_dot]
 protected def symm (e : α ≃ β) : β ≃ α := ⟨e.invFun, e.toFun, e.right_inv, e.left_inv⟩
 #align equiv.symm Equiv.symm
 
-pp_extended_field_notation Equiv.symm
-
 /-- See Note [custom simps projection] -/
 def Simps.symm_apply (e : α ≃ β) : β → α := e.symm
 #align equiv.simps.symm_apply Equiv.Simps.symm_apply
@@ -172,13 +170,11 @@ theorem left_inv' (e : α ≃ β) : Function.LeftInverse e.symm e := e.left_inv
 theorem right_inv' (e : α ≃ β) : Function.RightInverse e.symm e := e.right_inv
 
 /-- Composition of equivalences `e₁ : α ≃ β` and `e₂ : β ≃ γ`. -/
-@[trans]
+@[trans, pp_dot]
 protected def trans (e₁ : α ≃ β) (e₂ : β ≃ γ) : α ≃ γ :=
   ⟨e₂ ∘ e₁, e₁.symm ∘ e₂.symm, e₂.left_inv.comp e₁.left_inv, e₂.right_inv.comp e₁.right_inv⟩
 #align equiv.trans Equiv.trans
 
-pp_extended_field_notation Equiv.trans
-
 @[simps]
 instance : Trans Equiv Equiv Equiv where
   trans := Equiv.trans

style: add missing space (#5711)

3306b397

Diff

@@ -74,7 +74,7 @@ infixl:25 " ≃ " => Equiv
 /-- Turn an element of a type `F` satisfying `EquivLike F α β` into an actual
 `Equiv`. This is declared as the default coercion from `F` to `α ≃ β`. -/
 @[coe]
-def EquivLike.toEquiv {F} [EquivLike F α β] (f :F) : α ≃ β where
+def EquivLike.toEquiv {F} [EquivLike F α β] (f : F) : α ≃ β where
   toFun := f
   invFun := EquivLike.inv f
   left_inv := EquivLike.left_inv f

chore: fix focusing dots (#5708)

This PR is the result of running

find . -type f -name "*.lean" -exec sed -i -E 's/^( +)\. /\1· /' {} \;
find . -type f -name "*.lean" -exec sed -i -E 'N;s/^( +·)\n +(.*)$/\1 \2/;P;D' {} \;

which firstly replaces . focusing dots with · and secondly removes isolated instances of such dots, unifying them with the following line. A new rule is placed in the style linter to verify this.

cb02d09e

Diff

@@ -870,7 +870,7 @@ protected theorem exists_unique_congr_left {p : β → Prop} (f : α ≃ β) :
 protected theorem forall_congr {p : α → Prop} {q : β → Prop} (f : α ≃ β)
     (h : ∀ {x}, p x ↔ q (f x)) : (∀ x, p x) ↔ (∀ y, q y) := by
   constructor <;> intro h₂ x
-  . rw [← f.right_inv x]; apply h.mp; apply h₂
+  · rw [← f.right_inv x]; apply h.mp; apply h₂
   · apply h.mpr; apply h₂
 #align equiv.forall_congr Equiv.forall_congr

refactor: move all register_simp_attrs to 1 file (#5681)

There are slight differences between mathlib3 and mathlib4 (different set of attributes, different lemmas are in core/std), so I redid the same refactor instead of forward-porting changes.

mathlib3 PR: leanprover-community/mathlib#19223

ceaa4ecb

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Leonardo de Moura, Mario Carneiro
 
 ! This file was ported from Lean 3 source module logic.equiv.defs
-! leanprover-community/mathlib commit c4658a649d216f57e99621708b09dcb3dcccbd23
+! leanprover-community/mathlib commit 48fb5b5280e7c81672afc9524185ae994553ebf4
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -185,7 +185,7 @@ instance : Trans Equiv Equiv Equiv where
 
 -- porting note: this is not a syntactic tautology any more because
 -- the coercion from `e` to a function is now `FunLike.coe` not `e.toFun`
-@[simp] theorem toFun_as_coe (e : α ≃ β) : e.toFun = e := rfl
+@[simp, mfld_simps] theorem toFun_as_coe (e : α ≃ β) : e.toFun = e := rfl
 #align equiv.to_fun_as_coe Equiv.toFun_as_coe
 
 -- porting note: `simp` should prove this using `toFun_as_coe`, but it doesn't.
@@ -194,7 +194,7 @@ instance : Trans Equiv Equiv Equiv where
 -- this theorem can be deleted hopefully without breaking any `simp` proofs.
 @[simp] theorem toFun_as_coe_apply (e : α ≃ β) (x : α) : e.toFun x = e x := rfl
 
-@[simp] theorem invFun_as_coe (e : α ≃ β) : e.invFun = e.symm := rfl
+@[simp, mfld_simps] theorem invFun_as_coe (e : α ≃ β) : e.invFun = e.symm := rfl
 #align equiv.inv_fun_as_coe Equiv.invFun_as_coe
 
 protected theorem injective (e : α ≃ β) : Injective e := EquivLike.injective e
@@ -826,7 +826,8 @@ def sigmaCongr {α₁ α₂} {β₁ : α₁ → Sort _} {β₂ : α₂ → Sort
 #align equiv.sigma_congr Equiv.sigmaCongr
 
 /-- `Sigma` type with a constant fiber is equivalent to the product. -/
-@[simps apply symm_apply] def sigmaEquivProd (α β : Type _) : (Σ _ : α, β) ≃ α × β :=
+@[simps (config := { attrs := [`mfld_simps] }) apply symm_apply]
+def sigmaEquivProd (α β : Type _) : (Σ _ : α, β) ≃ α × β :=
   ⟨fun a => ⟨a.1, a.2⟩, fun a => ⟨a.1, a.2⟩, fun ⟨_, _⟩ => rfl, fun ⟨_, _⟩ => rfl⟩
 #align equiv.sigma_equiv_prod_apply Equiv.sigmaEquivProd_apply
 #align equiv.sigma_equiv_prod_symm_apply Equiv.sigmaEquivProd_symm_apply

chore: fix backtick in docs (#5077)

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

878d95c4

Diff

@@ -926,7 +926,7 @@ end Equiv
 namespace Quot
 
 /-- An equivalence `e : α ≃ β` generates an equivalence between quotient spaces,
-if `ra a₁ a₂ ↔ rb (e a₁) (e a₂). -/
+if `ra a₁ a₂ ↔ rb (e a₁) (e a₂)`. -/
 protected def congr {ra : α → α → Prop} {rb : β → β → Prop} (e : α ≃ β)
     (eq : ∀ a₁ a₂, ra a₁ a₂ ↔ rb (e a₁) (e a₂)) : Quot ra ≃ Quot rb where
   toFun := Quot.map e fun a₁ a₂ => (eq a₁ a₂).1
@@ -960,7 +960,7 @@ end Quot
 namespace Quotient
 
 /-- An equivalence `e : α ≃ β` generates an equivalence between quotient spaces,
-if `ra a₁ a₂ ↔ rb (e a₁) (e a₂). -/
+if `ra a₁ a₂ ↔ rb (e a₁) (e a₂)`. -/
 protected def congr {ra : Setoid α} {rb : Setoid β} (e : α ≃ β)
     (eq : ∀ a₁ a₂, @Setoid.r α ra a₁ a₂ ↔ @Setoid.r β rb (e a₁) (e a₂)) :
     Quotient ra ≃ Quotient rb := Quot.congr e eq

chore: convert lambda in docs to fun (#5045)

Found with git grep -n "λ [a-zA-Z_ ]*,"

1164cf04

Diff

@@ -581,7 +581,7 @@ def arrowCongr' {α₁ β₁ α₂ β₂ : Type _} (hα : α₁ ≃ α₂) (hβ
 
 -- This should not be a simp lemma as long as `(∘)` is reducible:
 -- when `(∘)` is reducible, Lean can unify `f₁ ∘ f₂` with any `g` using
--- `f₁ := g` and `f₂ := λ x, x`.  This causes nontermination.
+-- `f₁ := g` and `f₂ := fun x ↦ x`. This causes nontermination.
 theorem conj_comp (e : α ≃ β) (f₁ f₂ : α → α) : e.conj (f₁ ∘ f₂) = e.conj f₁ ∘ e.conj f₂ := by
   apply arrowCongr_comp
 #align equiv.conj_comp Equiv.conj_comp
@@ -763,7 +763,7 @@ def sigmaPLiftEquivSubtype {α : Type v} (P : α → Prop) : (Σ i, PLift (P i))
     (psigmaCongrRight fun _ => Equiv.plift)).trans (psigmaEquivSubtype P)
 #align equiv.sigma_plift_equiv_subtype Equiv.sigmaPLiftEquivSubtype
 
-/-- A `Sigma` with `λ i, ULift (PLift (P i))` fibers is equivalent to `{ x // P x }`.
+/-- A `Sigma` with `fun i ↦ ULift (PLift (P i))` fibers is equivalent to `{ x // P x }`.
 Variant of `sigmaPLiftEquivSubtype`.
 -/
 def sigmaULiftPLiftEquivSubtype {α : Type v} (P : α → Prop) :

chore: formatting issues (#4947)

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au> Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

5068808d

Diff

@@ -105,7 +105,7 @@ instance : FunLike (α ≃ β) α (fun _ => β) :=
   EmbeddingLike.toFunLike
 
 @[simp] theorem coe_fn_mk (f : α → β) (g l r) : (Equiv.mk f g l r : α → β) = f :=
-rfl
+  rfl
 #align equiv.coe_fn_mk Equiv.coe_fn_mk
 
 /-- The map `(r ≃ s) → (r → s)` is injective. -/

chore: fix many typos (#4535)

Run codespell Mathlib and keep some suggestions.

92f5c622

Diff

@@ -773,7 +773,7 @@ def sigmaULiftPLiftEquivSubtype {α : Type v} (P : α → Prop) :
 
 namespace Perm
 
-/-- A family of permutations `Π a, Perm (β a)` generates a permuation `Perm (Σ a, β₁ a)`. -/
+/-- A family of permutations `Π a, Perm (β a)` generates a permutation `Perm (Σ a, β₁ a)`. -/
 @[reducible] def sigmaCongrRight {α} {β : α → Sort _} (F : ∀ a, Perm (β a)) : Perm (Σ a, β a) :=
   Equiv.sigmaCongrRight F
 #align equiv.perm.sigma_congr_right Equiv.Perm.sigmaCongrRight

chore: fix upper/lowercase in comments (#4360)

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

27d257fc

Diff

@@ -41,7 +41,7 @@ Then we define
   instances from right to left.
 
   - `Equiv.inhabited` takes `e : α ≃ β` and `[Inhabited β]` and returns `Inhabited α`;
-  - `Equiv.unique` takes `e : α ≃ β` and `[Unique β]` and returns `unique α`;
+  - `Equiv.unique` takes `e : α ≃ β` and `[Unique β]` and returns `Unique α`;
   - `Equiv.decidableEq` takes `e : α ≃ β` and `[DecidableEq β]` and returns `DecidableEq α`.
 
   More definitions of this kind can be found in other files. E.g., `Data.Equiv.TransferInstance`
@@ -262,7 +262,7 @@ protected def cast {α β : Sort _} (h : α = β) : α ≃ β :=
 #align equiv.coe_refl Equiv.coe_refl
 
 /-- This cannot be a `simp` lemmas as it incorrectly matches against `e : α ≃ synonym α`, when
-`synonym α` is semireducible. This makes a mess of `multiplicative.of_add` etc. -/
+`synonym α` is semireducible. This makes a mess of `Multiplicative.ofAdd` etc. -/
 theorem Perm.coe_subsingleton {α : Type _} [Subsingleton α] (e : Perm α) : (e : α → α) = id := by
   rw [Perm.subsingleton_eq_refl e, coe_refl]
 #align equiv.perm.coe_subsingleton Equiv.Perm.coe_subsingleton
@@ -297,7 +297,7 @@ theorem Perm.coe_subsingleton {α : Type _} [Subsingleton α] (e : Perm α) : (e
 #align equiv.symm_trans_apply Equiv.symm_trans_apply
 
 -- The `simp` attribute is needed to make this a `dsimp` lemma.
--- `simp` will always rewrite with `equiv.symm_symm` before this has a chance to fire.
+-- `simp` will always rewrite with `Equiv.symm_symm` before this has a chance to fire.
 @[simp, nolint simpNF] theorem symm_symm_apply (f : α ≃ β) (b : α) : f.symm.symm b = f b := rfl
 #align equiv.symm_symm_apply Equiv.symm_symm_apply

feat: add Mathlib.Tactic.Common, and import (#4056)

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

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

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

a4eaf1c4

Diff

@@ -12,13 +12,6 @@ import Mathlib.Data.FunLike.Equiv
 import Mathlib.Data.Quot
 import Mathlib.Init.Data.Bool.Lemmas
 import Mathlib.Logic.Unique
-import Mathlib.Tactic.Conv
-import Mathlib.Tactic.ProjectionNotation
-import Mathlib.Tactic.Relation.Rfl
-import Mathlib.Tactic.Relation.Symm
-import Mathlib.Tactic.Relation.Trans
-import Mathlib.Tactic.Simps.Basic
-import Mathlib.Tactic.Substs
 
 /-!
 # Equivalence between types

feat: add some pp_extended_field_notations (#3592)

Add some pp_extended_field_notation, for opt-in cases with additional arguments.

Co-authored-by: Kyle Miller <kmill31415@gmail.com>

ae6decd5

Diff

@@ -13,6 +13,7 @@ import Mathlib.Data.Quot
 import Mathlib.Init.Data.Bool.Lemmas
 import Mathlib.Logic.Unique
 import Mathlib.Tactic.Conv
+import Mathlib.Tactic.ProjectionNotation
 import Mathlib.Tactic.Relation.Rfl
 import Mathlib.Tactic.Relation.Symm
 import Mathlib.Tactic.Relation.Trans
@@ -162,6 +163,8 @@ instance inhabited' : Inhabited (α ≃ α) := ⟨Equiv.refl α⟩
 protected def symm (e : α ≃ β) : β ≃ α := ⟨e.invFun, e.toFun, e.right_inv, e.left_inv⟩
 #align equiv.symm Equiv.symm
 
+pp_extended_field_notation Equiv.symm
+
 /-- See Note [custom simps projection] -/
 def Simps.symm_apply (e : α ≃ β) : β → α := e.symm
 #align equiv.simps.symm_apply Equiv.Simps.symm_apply
@@ -181,6 +184,8 @@ protected def trans (e₁ : α ≃ β) (e₂ : β ≃ γ) : α ≃ γ :=
   ⟨e₂ ∘ e₁, e₁.symm ∘ e₂.symm, e₂.left_inv.comp e₁.left_inv, e₂.right_inv.comp e₁.right_inv⟩
 #align equiv.trans Equiv.trans
 
+pp_extended_field_notation Equiv.trans
+
 @[simps]
 instance : Trans Equiv Equiv Equiv where
   trans := Equiv.trans

feat: initialize_simps_projections automatically finds coercions (#2045)

initialize_simps_projections automatically find coercions if there is a Funlike or SetLike instance defined by one of the projections.
Some improvements compared to Lean 3:
- Find coercions even if it is defined by a field of a parent structure
- Find SetLike coercions

Not yet implemented (and rarely - if ever - used in mathlib3):

Automatic custom projections for algebraic notation (like +,*,...)

Co-authored-by: Johan Commelin <johan@commelin.net>

b5daaa7b

Diff

@@ -162,8 +162,6 @@ instance inhabited' : Inhabited (α ≃ α) := ⟨Equiv.refl α⟩
 protected def symm (e : α ≃ β) : β ≃ α := ⟨e.invFun, e.toFun, e.right_inv, e.left_inv⟩
 #align equiv.symm Equiv.symm
 
-/-- See Note [custom simps projection] -/
-def Simps.apply (e : α ≃ β) : α → β := e
 /-- See Note [custom simps projection] -/
 def Simps.symm_apply (e : α ≃ β) : β → α := e.symm
 #align equiv.simps.symm_apply Equiv.Simps.symm_apply

fix: Add simps tag to Trans instance for Equiv (#2456)

See zulip discussion: https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/simps.20.2B.20Trans/near/329103653

0245850b

Diff

@@ -183,6 +183,7 @@ protected def trans (e₁ : α ≃ β) (e₂ : β ≃ γ) : α ≃ γ :=
   ⟨e₂ ∘ e₁, e₁.symm ∘ e₂.symm, e₂.left_inv.comp e₁.left_inv, e₂.right_inv.comp e₁.right_inv⟩
 #align equiv.trans Equiv.trans
 
+@[simps]
 instance : Trans Equiv Equiv Equiv where
   trans := Equiv.trans

feat: require @[simps!] if simps runs in expensive mode (#1885)

This does not change the behavior of simps, just raises a linter error if you run simps in a more expensive mode without writing !.
Fixed some incorrect occurrences of to_additive, simps. Will do that systematically in future PR.
Fix port of OmegaCompletePartialOrder.ContinuousHom.ofMono a bit

Co-authored-by: Yury G. Kudryashov <urkud@urkud.name>

52c04a34

Diff

@@ -547,7 +547,7 @@ The `equiv_rw` tactic is not able to use the default `Sort` level `Equiv.arrowCo
 because Lean's universe rules will not unify `?l_1` with `imax (1 ?m_1)`.
 -/
 -- porting note: removing `congr` attribute
-@[simps apply]
+@[simps! apply]
 def arrowCongr' {α₁ β₁ α₂ β₂ : Type _} (hα : α₁ ≃ α₂) (hβ : β₁ ≃ β₂) : (α₁ → β₁) ≃ (α₂ → β₂) :=
   Equiv.arrowCongr hα hβ
 #align equiv.arrow_congr' Equiv.arrowCongr'
@@ -568,7 +568,7 @@ def arrowCongr' {α₁ β₁ α₂ β₂ : Type _} (hα : α₁ ≃ α₂) (hβ
 #align equiv.arrow_congr'_symm Equiv.arrowCongr'_symm
 
 /-- Conjugate a map `f : α → α` by an equivalence `α ≃ β`. -/
-@[simps apply] def conj (e : α ≃ β) : (α → α) ≃ (β → β) :=   arrowCongr e e
+@[simps! apply] def conj (e : α ≃ β) : (α → α) ≃ (β → β) := arrowCongr e e
 #align equiv.conj Equiv.conj
 #align equiv.conj_apply Equiv.conj_apply
 
@@ -637,7 +637,7 @@ is equivalent to `β a`. -/
 #align equiv.Pi_subsingleton Equiv.piSubsingleton
 
 /-- If `α` has a unique term, then the type of function `α → β` is equivalent to `β`. -/
-@[simps (config := { fullyApplied := false }) apply]
+@[simps! (config := { fullyApplied := false }) apply]
 def funUnique (α β) [Unique.{u} α] : (α → β) ≃ β := piSubsingleton _ default
 #align equiv.fun_unique Equiv.funUnique
 #align equiv.fun_unique_apply Equiv.funUnique_apply

feat: port Order.Hom.Lattice (#1636)

Co-authored-by: Kevin Buzzard <k.buzzard@imperial.ac.uk> Co-authored-by: Yury G. Kudryashov <urkud@urkud.name> Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com> Co-authored-by: Vierkantor <vierkantor@vierkantor.com>

e7dba9c7

Diff

@@ -105,6 +105,11 @@ instance : EquivLike (α ≃ β) α β where
   right_inv := right_inv
   coe_injective' e₁ e₂ h₁ h₂ := by cases e₁; cases e₂; congr
 
+/-- Helper instance when inference gets stuck on following the normal chain
+`EquivLike → EmbeddingLike → FunLike → CoeFun`. -/
+instance : FunLike (α ≃ β) α (fun _ => β) :=
+  EmbeddingLike.toFunLike
+
 @[simp] theorem coe_fn_mk (f : α → β) (g l r) : (Equiv.mk f g l r : α → β) = f :=
 rfl
 #align equiv.coe_fn_mk Equiv.coe_fn_mk

chore: add missing #align statements (#1902)

This PR is the result of a slight variant on the following "algorithm"

take all mathlib 3 names, remove _ and make all uppercase letters into lowercase
take all mathlib 4 names, remove _ and make all uppercase letters into lowercase
look for matches, and create pairs (original_lean3_name, OriginalLean4Name)
for pairs that do not have an align statement:
- use Lean 4 to lookup the file + position of the Lean 4 name
- add an #align statement just before the next empty line
manually fix some tiny mistakes (e.g., empty lines in proofs might cause the #align statement to have been inserted too early)

b72bb858

Diff

@@ -73,6 +73,7 @@ structure Equiv (α : Sort _) (β : Sort _) where
   invFun : β → α
   left_inv : LeftInverse invFun toFun
   right_inv : RightInverse invFun toFun
+#align equiv Equiv
 
 infixl:25 " ≃ " => Equiv
 
@@ -93,6 +94,7 @@ instance {F} [EquivLike F α β] : CoeTC F (α ≃ β) :=
 @[reducible]
 def Equiv.Perm (α : Sort _) :=
   Equiv α α
+#align equiv.perm Equiv.Perm
 
 namespace Equiv
 
@@ -105,47 +107,61 @@ instance : EquivLike (α ≃ β) α β where
 
 @[simp] theorem coe_fn_mk (f : α → β) (g l r) : (Equiv.mk f g l r : α → β) = f :=
 rfl
+#align equiv.coe_fn_mk Equiv.coe_fn_mk
 
 /-- The map `(r ≃ s) → (r → s)` is injective. -/
 theorem coe_fn_injective : @Function.Injective (α ≃ β) (α → β) (fun e => e) :=
   FunLike.coe_injective'
+#align equiv.coe_fn_injective Equiv.coe_fn_injective
 
 protected theorem coe_inj {e₁ e₂ : α ≃ β} : (e₁ : α → β) = e₂ ↔ e₁ = e₂ :=
   @FunLike.coe_fn_eq _ _ _ _ e₁ e₂
+#align equiv.coe_inj Equiv.coe_inj
 
 @[ext] theorem ext {f g : Equiv α β} (H : ∀ x, f x = g x) : f = g := FunLike.ext f g H
+#align equiv.ext Equiv.ext
 
 protected theorem congr_arg {f : Equiv α β} {x x' : α} : x = x' → f x = f x' :=
   FunLike.congr_arg f
+#align equiv.congr_arg Equiv.congr_arg
 
 protected theorem congr_fun {f g : Equiv α β} (h : f = g) (x : α) : f x = g x :=
   FunLike.congr_fun h x
+#align equiv.congr_fun Equiv.congr_fun
 
 theorem ext_iff {f g : Equiv α β} : f = g ↔ ∀ x, f x = g x := FunLike.ext_iff
+#align equiv.ext_iff Equiv.ext_iff
 
 @[ext] theorem Perm.ext {σ τ : Equiv.Perm α} (H : ∀ x, σ x = τ x) : σ = τ := Equiv.ext H
+#align equiv.perm.ext Equiv.Perm.ext
 
 protected theorem Perm.congr_arg {f : Equiv.Perm α} {x x' : α} : x = x' → f x = f x' :=
   Equiv.congr_arg
+#align equiv.perm.congr_arg Equiv.Perm.congr_arg
 
 protected theorem Perm.congr_fun {f g : Equiv.Perm α} (h : f = g) (x : α) : f x = g x :=
   Equiv.congr_fun h x
+#align equiv.perm.congr_fun Equiv.Perm.congr_fun
 
 theorem Perm.ext_iff {σ τ : Equiv.Perm α} : σ = τ ↔ ∀ x, σ x = τ x := Equiv.ext_iff
+#align equiv.perm.ext_iff Equiv.Perm.ext_iff
 
 /-- Any type is equivalent to itself. -/
 @[refl] protected def refl (α : Sort _) : α ≃ α := ⟨id, id, fun _ => rfl, fun _ => rfl⟩
+#align equiv.refl Equiv.refl
 
 instance inhabited' : Inhabited (α ≃ α) := ⟨Equiv.refl α⟩
 
 /-- Inverse of an equivalence `e : α ≃ β`. -/
 @[symm]
 protected def symm (e : α ≃ β) : β ≃ α := ⟨e.invFun, e.toFun, e.right_inv, e.left_inv⟩
+#align equiv.symm Equiv.symm
 
 /-- See Note [custom simps projection] -/
 def Simps.apply (e : α ≃ β) : α → β := e
 /-- See Note [custom simps projection] -/
 def Simps.symm_apply (e : α ≃ β) : β → α := e.symm
+#align equiv.simps.symm_apply Equiv.Simps.symm_apply
 
 initialize_simps_projections Equiv (toFun → apply, invFun → symm_apply)
 
@@ -160,6 +176,7 @@ theorem right_inv' (e : α ≃ β) : Function.RightInverse e.symm e := e.right_i
 @[trans]
 protected def trans (e₁ : α ≃ β) (e₂ : β ≃ γ) : α ≃ γ :=
   ⟨e₂ ∘ e₁, e₁.symm ∘ e₂.symm, e₂.left_inv.comp e₁.left_inv, e₂.right_inv.comp e₁.right_inv⟩
+#align equiv.trans Equiv.trans
 
 instance : Trans Equiv Equiv Equiv where
   trans := Equiv.trans
@@ -193,9 +210,11 @@ protected theorem subsingleton (e : α ≃ β) [Subsingleton β] : Subsingleton
 
 protected theorem subsingleton.symm (e : α ≃ β) [Subsingleton α] : Subsingleton β :=
   e.symm.injective.subsingleton
+#align equiv.subsingleton.symm Equiv.subsingleton.symm
 
 theorem subsingleton_congr (e : α ≃ β) : Subsingleton α ↔ Subsingleton β :=
   ⟨fun _ => e.symm.subsingleton, fun _ => e.subsingleton⟩
+#align equiv.subsingleton_congr Equiv.subsingleton_congr
 
 instance equiv_subsingleton_cod [Subsingleton β] : Subsingleton (α ≃ β) :=
   ⟨fun _ _ => Equiv.ext fun _ => Subsingleton.elim _ _⟩
@@ -208,120 +227,163 @@ instance permUnique [Subsingleton α] : Unique (Perm α) :=
 
 theorem Perm.subsingleton_eq_refl [Subsingleton α] (e : Perm α) : e = Equiv.refl α :=
   Subsingleton.elim _ _
+#align equiv.perm.subsingleton_eq_refl Equiv.Perm.subsingleton_eq_refl
 
 /-- Transfer `DecidableEq` across an equivalence. -/
 protected def decidableEq (e : α ≃ β) [DecidableEq β] : DecidableEq α :=
   e.injective.decidableEq
+#align equiv.decidable_eq Equiv.decidableEq
 
 theorem nonempty_congr (e : α ≃ β) : Nonempty α ↔ Nonempty β := Nonempty.congr e e.symm
+#align equiv.nonempty_congr Equiv.nonempty_congr
 
 protected theorem nonempty (e : α ≃ β) [Nonempty β] : Nonempty α := e.nonempty_congr.mpr ‹_›
+#align equiv.nonempty Equiv.nonempty
 
 /-- If `α ≃ β` and `β` is inhabited, then so is `α`. -/
 protected def inhabited [Inhabited β] (e : α ≃ β) : Inhabited α := ⟨e.symm default⟩
+#align equiv.inhabited Equiv.inhabited
 
 /-- If `α ≃ β` and `β` is a singleton type, then so is `α`. -/
 protected def unique [Unique β] (e : α ≃ β) : Unique α := e.symm.surjective.unique
+#align equiv.unique Equiv.unique
 
 /-- Equivalence between equal types. -/
 protected def cast {α β : Sort _} (h : α = β) : α ≃ β :=
   ⟨cast h, cast h.symm, fun _ => by cases h; rfl, fun _ => by cases h; rfl⟩
+#align equiv.cast Equiv.cast
 
 @[simp] theorem coe_fn_symm_mk (f : α → β) (g l r) : ((Equiv.mk f g l r).symm : β → α) = g := rfl
+#align equiv.coe_fn_symm_mk Equiv.coe_fn_symm_mk
 
 @[simp] theorem coe_refl : (Equiv.refl α : α → α) = id := rfl
+#align equiv.coe_refl Equiv.coe_refl
 
 /-- This cannot be a `simp` lemmas as it incorrectly matches against `e : α ≃ synonym α`, when
 `synonym α` is semireducible. This makes a mess of `multiplicative.of_add` etc. -/
 theorem Perm.coe_subsingleton {α : Type _} [Subsingleton α] (e : Perm α) : (e : α → α) = id := by
   rw [Perm.subsingleton_eq_refl e, coe_refl]
+#align equiv.perm.coe_subsingleton Equiv.Perm.coe_subsingleton
 
 -- porting note: marking this as `@[simp]` because `simp` doesn't fire on `coe_refl`
 -- in an expression such as `Equiv.refl a x`
 @[simp] theorem refl_apply (x : α) : Equiv.refl α x = x := rfl
+#align equiv.refl_apply Equiv.refl_apply
 
 @[simp] theorem coe_trans (f : α ≃ β) (g : β ≃ γ) : (f.trans g : α → γ) = g ∘ f := rfl
+#align equiv.coe_trans Equiv.coe_trans
 
 -- porting note: marking this as `@[simp]` because `simp` doesn't fire on `coe_trans`
 -- in an expression such as `Equiv.trans f g x`
 @[simp] theorem trans_apply (f : α ≃ β) (g : β ≃ γ) (a : α) : (f.trans g) a = g (f a) := rfl
+#align equiv.trans_apply Equiv.trans_apply
 
 @[simp] theorem apply_symm_apply (e : α ≃ β) (x : β) : e (e.symm x) = x := e.right_inv x
+#align equiv.apply_symm_apply Equiv.apply_symm_apply
 
 @[simp] theorem symm_apply_apply (e : α ≃ β) (x : α) : e.symm (e x) = x := e.left_inv x
+#align equiv.symm_apply_apply Equiv.symm_apply_apply
 
 @[simp] theorem symm_comp_self (e : α ≃ β) : e.symm ∘ e = id := funext e.symm_apply_apply
+#align equiv.symm_comp_self Equiv.symm_comp_self
 
 @[simp] theorem self_comp_symm (e : α ≃ β) : e ∘ e.symm = id := funext e.apply_symm_apply
+#align equiv.self_comp_symm Equiv.self_comp_symm
 
 @[simp] theorem symm_trans_apply (f : α ≃ β) (g : β ≃ γ) (a : γ) :
     (f.trans g).symm a = f.symm (g.symm a) := rfl
+#align equiv.symm_trans_apply Equiv.symm_trans_apply
 
 -- The `simp` attribute is needed to make this a `dsimp` lemma.
 -- `simp` will always rewrite with `equiv.symm_symm` before this has a chance to fire.
 @[simp, nolint simpNF] theorem symm_symm_apply (f : α ≃ β) (b : α) : f.symm.symm b = f b := rfl
+#align equiv.symm_symm_apply Equiv.symm_symm_apply
 
 theorem apply_eq_iff_eq (f : α ≃ β) {x y : α} : f x = f y ↔ x = y := EquivLike.apply_eq_iff_eq f
+#align equiv.apply_eq_iff_eq Equiv.apply_eq_iff_eq
 
 theorem apply_eq_iff_eq_symm_apply (f : α ≃ β) : f x = y ↔ x = f.symm y := by
   conv_lhs => rw [← apply_symm_apply f y]
   rw [apply_eq_iff_eq]
+#align equiv.apply_eq_iff_eq_symm_apply Equiv.apply_eq_iff_eq_symm_apply
 
 @[simp] theorem cast_apply {α β} (h : α = β) (x : α) : Equiv.cast h x = cast h x := rfl
+#align equiv.cast_apply Equiv.cast_apply
 
 @[simp] theorem cast_symm {α β} (h : α = β) : (Equiv.cast h).symm = Equiv.cast h.symm := rfl
+#align equiv.cast_symm Equiv.cast_symm
 
 @[simp] theorem cast_refl {α} (h : α = α := rfl) : Equiv.cast h = Equiv.refl α := rfl
+#align equiv.cast_refl Equiv.cast_refl
 
 @[simp] theorem cast_trans {α β γ} (h : α = β) (h2 : β = γ) :
     (Equiv.cast h).trans (Equiv.cast h2) = Equiv.cast (h.trans h2) :=
   ext fun x => by substs h h2; rfl
+#align equiv.cast_trans Equiv.cast_trans
 
 theorem cast_eq_iff_heq {α β} (h : α = β) {a : α} {b : β} : Equiv.cast h a = b ↔ HEq a b := by
   subst h; simp [coe_refl]
+#align equiv.cast_eq_iff_heq Equiv.cast_eq_iff_heq
 
 theorem symm_apply_eq {α β} (e : α ≃ β) {x y} : e.symm x = y ↔ x = e y :=
   ⟨fun H => by simp [H.symm], fun H => by simp [H]⟩
+#align equiv.symm_apply_eq Equiv.symm_apply_eq
 
 theorem eq_symm_apply {α β} (e : α ≃ β) {x y} : y = e.symm x ↔ e y = x :=
   (eq_comm.trans e.symm_apply_eq).trans eq_comm
+#align equiv.eq_symm_apply Equiv.eq_symm_apply
 
 @[simp] theorem symm_symm (e : α ≃ β) : e.symm.symm = e := by cases e; rfl
+#align equiv.symm_symm Equiv.symm_symm
 
 @[simp] theorem trans_refl (e : α ≃ β) : e.trans (Equiv.refl β) = e := by cases e; rfl
+#align equiv.trans_refl Equiv.trans_refl
 
 @[simp] theorem refl_symm : (Equiv.refl α).symm = Equiv.refl α := rfl
+#align equiv.refl_symm Equiv.refl_symm
 
 @[simp] theorem refl_trans (e : α ≃ β) : (Equiv.refl α).trans e = e := by cases e; rfl
+#align equiv.refl_trans Equiv.refl_trans
 
 @[simp] theorem symm_trans_self (e : α ≃ β) : e.symm.trans e = Equiv.refl β := ext <| by simp
+#align equiv.symm_trans_self Equiv.symm_trans_self
 
 @[simp] theorem self_trans_symm (e : α ≃ β) : e.trans e.symm = Equiv.refl α := ext <| by simp
+#align equiv.self_trans_symm Equiv.self_trans_symm
 
 theorem trans_assoc {δ} (ab : α ≃ β) (bc : β ≃ γ) (cd : γ ≃ δ) :
     (ab.trans bc).trans cd = ab.trans (bc.trans cd) := Equiv.ext fun _ => rfl
+#align equiv.trans_assoc Equiv.trans_assoc
 
 theorem leftInverse_symm (f : Equiv α β) : LeftInverse f.symm f := f.left_inv
+#align equiv.left_inverse_symm Equiv.leftInverse_symm
 
 theorem rightInverse_symm (f : Equiv α β) : Function.RightInverse f.symm f := f.right_inv
+#align equiv.right_inverse_symm Equiv.rightInverse_symm
 
 theorem injective_comp (e : α ≃ β) (f : β → γ) : Injective (f ∘ e) ↔ Injective f :=
   EquivLike.injective_comp e f
+#align equiv.injective_comp Equiv.injective_comp
 
 theorem comp_injective (f : α → β) (e : β ≃ γ) : Injective (e ∘ f) ↔ Injective f :=
   EquivLike.comp_injective f e
+#align equiv.comp_injective Equiv.comp_injective
 
 theorem surjective_comp (e : α ≃ β) (f : β → γ) : Surjective (f ∘ e) ↔ Surjective f :=
   EquivLike.surjective_comp e f
+#align equiv.surjective_comp Equiv.surjective_comp
 
 theorem comp_surjective (f : α → β) (e : β ≃ γ) : Surjective (e ∘ f) ↔ Surjective f :=
   EquivLike.comp_surjective f e
+#align equiv.comp_surjective Equiv.comp_surjective
 
 theorem bijective_comp (e : α ≃ β) (f : β → γ) : Bijective (f ∘ e) ↔ Bijective f :=
   EquivLike.bijective_comp e f
+#align equiv.bijective_comp Equiv.bijective_comp
 
 theorem comp_bijective (f : α → β) (e : β ≃ γ) : Bijective (e ∘ f) ↔ Bijective f :=
   EquivLike.comp_bijective f e
+#align equiv.comp_bijective Equiv.comp_bijective
 
 /-- If `α` is equivalent to `β` and `γ` is equivalent to `δ`, then the type of equivalences `α ≃ γ`
 is equivalent to the type of equivalences `β ≃ δ`. -/
@@ -330,6 +392,7 @@ def equivCongr (ab : α ≃ β) (cd : γ ≃ δ) : (α ≃ γ) ≃ (β ≃ δ) w
   invFun bd := ab.trans <| bd.trans <| cd.symm
   left_inv ac := by ext x; simp only [trans_apply, comp_apply, symm_apply_apply]
   right_inv ac := by ext x; simp only [trans_apply, comp_apply, apply_symm_apply]
+#align equiv.equiv_congr Equiv.equivCongr
 
 @[simp] theorem equivCongr_refl {α β} :
     (Equiv.refl α).equivCongr (Equiv.refl β) = Equiv.refl (α ≃ β) := by ext; rfl
@@ -362,6 +425,7 @@ variable {α' β' : Type _} (e : α' ≃ β')
 
 /-- If `α` is equivalent to `β`, then `Perm α` is equivalent to `Perm β`. -/
 def permCongr : Perm α' ≃ Perm β' := equivCongr e e
+#align equiv.perm_congr Equiv.permCongr
 
 theorem permCongr_def (p : Equiv.Perm α') : e.permCongr p = (e.symm.trans p).trans e := rfl
 #align equiv.perm_congr_def Equiv.permCongr_def
@@ -390,9 +454,11 @@ end permCongr
 /-- Two empty types are equivalent. -/
 def equivOfIsEmpty (α β : Sort _) [IsEmpty α] [IsEmpty β] : α ≃ β :=
   ⟨isEmptyElim, isEmptyElim, isEmptyElim, isEmptyElim⟩
+#align equiv.equiv_of_is_empty Equiv.equivOfIsEmpty
 
 /-- If `α` is an empty type, then it is equivalent to the `Empty` type. -/
 def equivEmpty (α : Sort u) [IsEmpty α] : α ≃ Empty := equivOfIsEmpty α _
+#align equiv.equiv_empty Equiv.equivEmpty
 
 /-- If `α` is an empty type, then it is equivalent to the `PEmpty` type in any universe. -/
 def equivPEmpty (α : Sort v) [IsEmpty α] : α ≃ PEmpty.{u} := equivOfIsEmpty α _
@@ -413,6 +479,7 @@ def equivOfUnique (α β : Sort _) [Unique.{u} α] [Unique.{v} β] : α ≃ β w
   invFun := default
   left_inv _ := Subsingleton.elim _ _
   right_inv _ := Subsingleton.elim _ _
+#align equiv.equiv_of_unique Equiv.equivOfUnique
 
 /-- If `α` has a unique element, then it is equivalent to any `PUnit`. -/
 def equivPUnit (α : Sort u) [Unique α] : α ≃ PUnit.{v} := equivOfUnique α _
@@ -426,13 +493,18 @@ def propEquivPUnit {p : Prop} (h : p) : p ≃ PUnit.{0} := @equivPUnit p <| uniq
 @[simps (config := { fullyApplied := false }) apply]
 protected def ulift {α : Type v} : ULift.{u} α ≃ α :=
   ⟨ULift.down, ULift.up, ULift.up_down, fun _ => rfl⟩
+#align equiv.ulift Equiv.ulift
+#align equiv.ulift_apply Equiv.ulift_apply
 
 /-- `PLift α` is equivalent to `α`. -/
 @[simps (config := { fullyApplied := false }) apply]
 protected def plift : PLift α ≃ α := ⟨PLift.down, PLift.up, PLift.up_down, PLift.down_up⟩
+#align equiv.plift Equiv.plift
+#align equiv.plift_apply Equiv.plift_apply
 
 /-- equivalence of propositions is the same as iff -/
 def ofIff {P Q : Prop} (h : P ↔ Q) : P ≃ Q := ⟨h.mp, h.mpr, fun _ => rfl, fun _ => rfl⟩
+#align equiv.of_iff Equiv.ofIff
 
 /-- If `α₁` is equivalent to `α₂` and `β₁` is equivalent to `β₂`, then the type of maps `α₁ → β₁`
 is equivalent to the type of maps `α₂ → β₂`. -/
@@ -444,6 +516,7 @@ def arrowCongr {α₁ β₁ α₂ β₂ : Sort _} (e₁ : α₁ ≃ α₂) (e₂
   left_inv f := funext fun x => by simp only [comp_apply, symm_apply_apply]
   right_inv f := funext fun x => by simp only [comp_apply, apply_symm_apply]
 #align equiv.arrow_congr_apply Equiv.arrowCongr_apply
+#align equiv.arrow_congr Equiv.arrowCongr
 
 theorem arrowCongr_comp {α₁ β₁ γ₁ α₂ β₂ γ₂ : Sort _} (ea : α₁ ≃ α₂) (eb : β₁ ≃ β₂) (ec : γ₁ ≃ γ₂)
     (f : α₁ → β₁) (g : β₁ → γ₁) :
@@ -472,6 +545,8 @@ because Lean's universe rules will not unify `?l_1` with `imax (1 ?m_1)`.
 @[simps apply]
 def arrowCongr' {α₁ β₁ α₂ β₂ : Type _} (hα : α₁ ≃ α₂) (hβ : β₁ ≃ β₂) : (α₁ → β₁) ≃ (α₂ → β₂) :=
   Equiv.arrowCongr hα hβ
+#align equiv.arrow_congr' Equiv.arrowCongr'
+#align equiv.arrow_congr'_apply Equiv.arrowCongr'_apply
 
 @[simp] theorem arrowCongr'_refl {α β : Type _} :
     arrowCongr' (Equiv.refl α) (Equiv.refl β) = Equiv.refl (α → β) := rfl
@@ -489,31 +564,41 @@ def arrowCongr' {α₁ β₁ α₂ β₂ : Type _} (hα : α₁ ≃ α₂) (hβ
 
 /-- Conjugate a map `f : α → α` by an equivalence `α ≃ β`. -/
 @[simps apply] def conj (e : α ≃ β) : (α → α) ≃ (β → β) :=   arrowCongr e e
+#align equiv.conj Equiv.conj
+#align equiv.conj_apply Equiv.conj_apply
 
 @[simp] theorem conj_refl : conj (Equiv.refl α) = Equiv.refl (α → α) := rfl
+#align equiv.conj_refl Equiv.conj_refl
 
 @[simp] theorem conj_symm (e : α ≃ β) : e.conj.symm = e.symm.conj := rfl
+#align equiv.conj_symm Equiv.conj_symm
 
 @[simp] theorem conj_trans (e₁ : α ≃ β) (e₂ : β ≃ γ) :
     (e₁.trans e₂).conj = e₁.conj.trans e₂.conj := rfl
+#align equiv.conj_trans Equiv.conj_trans
 
 -- This should not be a simp lemma as long as `(∘)` is reducible:
 -- when `(∘)` is reducible, Lean can unify `f₁ ∘ f₂` with any `g` using
 -- `f₁ := g` and `f₂ := λ x, x`.  This causes nontermination.
 theorem conj_comp (e : α ≃ β) (f₁ f₂ : α → α) : e.conj (f₁ ∘ f₂) = e.conj f₁ ∘ e.conj f₂ := by
   apply arrowCongr_comp
+#align equiv.conj_comp Equiv.conj_comp
 
 theorem eq_comp_symm {α β γ} (e : α ≃ β) (f : β → γ) (g : α → γ) : f = g ∘ e.symm ↔ f ∘ e = g :=
   (e.arrowCongr (Equiv.refl γ)).symm_apply_eq.symm
+#align equiv.eq_comp_symm Equiv.eq_comp_symm
 
 theorem comp_symm_eq {α β γ} (e : α ≃ β) (f : β → γ) (g : α → γ) : g ∘ e.symm = f ↔ g = f ∘ e :=
   (e.arrowCongr (Equiv.refl γ)).eq_symm_apply.symm
+#align equiv.comp_symm_eq Equiv.comp_symm_eq
 
 theorem eq_symm_comp {α β γ} (e : α ≃ β) (f : γ → α) (g : γ → β) : f = e.symm ∘ g ↔ e ∘ f = g :=
   ((Equiv.refl γ).arrowCongr e).eq_symm_apply
+#align equiv.eq_symm_comp Equiv.eq_symm_comp
 
 theorem symm_comp_eq {α β γ} (e : α ≃ β) (f : γ → α) (g : γ → β) : e.symm ∘ g = f ↔ g = e ∘ f :=
   ((Equiv.refl γ).arrowCongr e).symm_apply_eq
+#align equiv.symm_comp_eq Equiv.symm_comp_eq
 
 /-- `PUnit` sorts in any two universes are equivalent. -/
 def punitEquivPUnit : PUnit.{v} ≃ PUnit.{w} :=
@@ -526,6 +611,7 @@ noncomputable def propEquivBool : Prop ≃ Bool where
   invFun b := b
   left_inv p := by simp [@Bool.decide_iff p (Classical.propDecidable _)]
   right_inv b := by cases b <;> simp
+#align equiv.Prop_equiv_bool Equiv.propEquivBool
 
 section
 
@@ -541,16 +627,23 @@ is equivalent to `β a`. -/
   invFun x b := cast (congr_arg β <| Subsingleton.elim a b) x
   left_inv _ := funext fun b => by rw [Subsingleton.elim b a]; rfl
   right_inv _ := rfl
+#align equiv.Pi_subsingleton_apply Equiv.piSubsingleton_apply
+#align equiv.Pi_subsingleton_symm_apply Equiv.piSubsingleton_symm_apply
+#align equiv.Pi_subsingleton Equiv.piSubsingleton
 
 /-- If `α` has a unique term, then the type of function `α → β` is equivalent to `β`. -/
 @[simps (config := { fullyApplied := false }) apply]
 def funUnique (α β) [Unique.{u} α] : (α → β) ≃ β := piSubsingleton _ default
+#align equiv.fun_unique Equiv.funUnique
+#align equiv.fun_unique_apply Equiv.funUnique_apply
 
 /-- The sort of maps from `PUnit` is equivalent to the codomain. -/
 def punitArrowEquiv (α : Sort _) : (PUnit.{u} → α) ≃ α := funUnique PUnit.{u} α
+#align equiv.punit_arrow_equiv Equiv.punitArrowEquiv
 
 /-- The sort of maps from `True` is equivalent to the codomain. -/
 def trueArrowEquiv (α : Sort _) : (True → α) ≃ α := funUnique _ _
+#align equiv.true_arrow_equiv Equiv.trueArrowEquiv
 
 /-- The sort of maps from a type that `IsEmpty` is equivalent to `PUnit`. -/
 def arrowPUnitOfIsEmpty (α β : Sort _) [IsEmpty α] : (α → β) ≃ PUnit.{u} where
@@ -583,6 +676,9 @@ def psigmaEquivSigma {α} (β : α → Type _) : (Σ' i, β i) ≃ Σ i, β i wh
   invFun a := ⟨a.1, a.2⟩
   left_inv _ := rfl
   right_inv _ := rfl
+#align equiv.psigma_equiv_sigma Equiv.psigmaEquivSigma
+#align equiv.psigma_equiv_sigma_symm_apply Equiv.psigmaEquivSigma_symm_apply
+#align equiv.psigma_equiv_sigma_apply Equiv.psigmaEquivSigma_apply
 
 /-- A `PSigma`-type is equivalent to the corresponding `Sigma`-type. -/
 @[simps apply symm_apply]
@@ -592,6 +688,8 @@ def psigmaEquivSigmaPLift {α} (β : α → Sort _) : (Σ' i, β i) ≃ Σ i : P
   left_inv _ := rfl
   right_inv _ := rfl
 #align equiv.psigma_equiv_sigma_plift Equiv.psigmaEquivSigmaPLift
+#align equiv.psigma_equiv_sigma_plift_symm_apply Equiv.psigmaEquivSigmaPLift_symm_apply
+#align equiv.psigma_equiv_sigma_plift_apply Equiv.psigmaEquivSigmaPLift_apply
 
 /-- A family of equivalences `Π a, β₁ a ≃ β₂ a` generates an equivalence between `Σ' a, β₁ a` and
 `Σ' a, β₂ a`. -/
@@ -601,6 +699,8 @@ def psigmaCongrRight {β₁ β₂ : α → Sort _} (F : ∀ a, β₁ a ≃ β₂
   invFun a := ⟨a.1, (F a.1).symm a.2⟩
   left_inv | ⟨a, b⟩ => congr_arg (PSigma.mk a) <| symm_apply_apply (F a) b
   right_inv | ⟨a, b⟩ => congr_arg (PSigma.mk a) <| apply_symm_apply (F a) b
+#align equiv.psigma_congr_right Equiv.psigmaCongrRight
+#align equiv.psigma_congr_right_apply Equiv.psigmaCongrRight_apply
 
 -- Porting note: simp can now simplify the LHS, so I have removed `@[simp]`
 theorem psigmaCongrRight_trans {α} {β₁ β₂ β₃ : α → Sort _}
@@ -628,6 +728,7 @@ def sigmaCongrRight {α} {β₁ β₂ : α → Type _} (F : ∀ a, β₁ a ≃ 
   left_inv | ⟨a, b⟩ => congr_arg (Sigma.mk a) <| symm_apply_apply (F a) b
   right_inv | ⟨a, b⟩ => congr_arg (Sigma.mk a) <| apply_symm_apply (F a) b
 #align equiv.sigma_congr_right Equiv.sigmaCongrRight
+#align equiv.sigma_congr_right_apply Equiv.sigmaCongrRight_apply
 
 -- Porting note: simp can now simplify the LHS, so I have removed `@[simp]`
 theorem sigmaCongrRight_trans {α} {β₁ β₂ β₃ : α → Type _}
@@ -652,6 +753,7 @@ def psigmaEquivSubtype {α : Type v} (P : α → Prop) : (Σ' i, P i) ≃ Subtyp
   invFun x := ⟨x.1, x.2⟩
   left_inv _ := rfl
   right_inv _ := rfl
+#align equiv.psigma_equiv_subtype Equiv.psigmaEquivSubtype
 
 /-- A `Sigma` with `PLift` fibers is equivalent to the subtype. -/
 def sigmaPLiftEquivSubtype {α : Type v} (P : α → Prop) : (Σ i, PLift (P i)) ≃ Subtype P :=
@@ -672,6 +774,7 @@ namespace Perm
 /-- A family of permutations `Π a, Perm (β a)` generates a permuation `Perm (Σ a, β₁ a)`. -/
 @[reducible] def sigmaCongrRight {α} {β : α → Sort _} (F : ∀ a, Perm (β a)) : Perm (Σ a, β a) :=
   Equiv.sigmaCongrRight F
+#align equiv.perm.sigma_congr_right Equiv.Perm.sigmaCongrRight
 
 @[simp] theorem sigmaCongrRight_trans {α} {β : α → Sort _}
     (F : ∀ a, Perm (β a)) (G : ∀ a, Perm (β a)) :
@@ -705,25 +808,33 @@ end Perm
     match (motive := ∀ a' (h : a' = a), Sigma.mk a' (h.symm ▸ b) = ⟨a, b⟩)
       e (e.symm a), e.apply_symm_apply _ with
     | _, rfl => rfl
+#align equiv.sigma_congr_left_apply Equiv.sigmaCongrLeft_apply
+#align equiv.sigma_congr_left Equiv.sigmaCongrLeft
 
 /-- Transporting a sigma type through an equivalence of the base -/
 def sigmaCongrLeft' {α₁ α₂} {β : α₁ → Sort _} (f : α₁ ≃ α₂) :
     (Σ a : α₁, β a) ≃ Σ a : α₂, β (f.symm a) := (sigmaCongrLeft f.symm).symm
+#align equiv.sigma_congr_left' Equiv.sigmaCongrLeft'
 
 /-- Transporting a sigma type through an equivalence of the base and a family of equivalences
 of matching fibers -/
 def sigmaCongr {α₁ α₂} {β₁ : α₁ → Sort _} {β₂ : α₂ → Sort _} (f : α₁ ≃ α₂)
     (F : ∀ a, β₁ a ≃ β₂ (f a)) : Sigma β₁ ≃ Sigma β₂ :=
   (sigmaCongrRight F).trans (sigmaCongrLeft f)
+#align equiv.sigma_congr Equiv.sigmaCongr
 
 /-- `Sigma` type with a constant fiber is equivalent to the product. -/
 @[simps apply symm_apply] def sigmaEquivProd (α β : Type _) : (Σ _ : α, β) ≃ α × β :=
   ⟨fun a => ⟨a.1, a.2⟩, fun a => ⟨a.1, a.2⟩, fun ⟨_, _⟩ => rfl, fun ⟨_, _⟩ => rfl⟩
+#align equiv.sigma_equiv_prod_apply Equiv.sigmaEquivProd_apply
+#align equiv.sigma_equiv_prod_symm_apply Equiv.sigmaEquivProd_symm_apply
+#align equiv.sigma_equiv_prod Equiv.sigmaEquivProd
 
 /-- If each fiber of a `Sigma` type is equivalent to a fixed type, then the sigma type
 is equivalent to the product. -/
 def sigmaEquivProdOfEquiv {α β} {β₁ : α → Sort _} (F : ∀ a, β₁ a ≃ β) : Sigma β₁ ≃ α × β :=
   (sigmaCongrRight F).trans (sigmaEquivProd α β)
+#align equiv.sigma_equiv_prod_of_equiv Equiv.sigmaEquivProdOfEquiv
 
 /-- Dependent product of types is associative up to an equivalence. -/
 def sigmaAssoc {α : Type _} {β : α → Type _} (γ : ∀ a : α, β a → Type _) :
@@ -732,6 +843,7 @@ def sigmaAssoc {α : Type _} {β : α → Type _} (γ : ∀ a : α, β a → Typ
   invFun x := ⟨⟨x.1, x.2.1⟩, x.2.2⟩
   left_inv _ := rfl
   right_inv _ := rfl
+#align equiv.sigma_assoc Equiv.sigmaAssoc
 
 end
 
@@ -742,22 +854,27 @@ protected theorem exists_unique_congr {p : α → Prop} {q : β → Prop}
     exact ⟨f a, h.1 ha₁, fun b hb => f.symm_apply_eq.1 (ha₂ (f.symm b) (h.2 (by simpa using hb)))⟩
   · rintro ⟨b, hb₁, hb₂⟩
     exact ⟨f.symm b, h.2 (by simpa using hb₁), fun y hy => (eq_symm_apply f).2 (hb₂ _ (h.1 hy))⟩
+#align equiv.exists_unique_congr Equiv.exists_unique_congr
 
 protected theorem exists_unique_congr_left' {p : α → Prop} (f : α ≃ β) :
     (∃! x, p x) ↔ ∃! y, p (f.symm y) := Equiv.exists_unique_congr f fun {_} => by simp
+#align equiv.exists_unique_congr_left' Equiv.exists_unique_congr_left'
 
 protected theorem exists_unique_congr_left {p : β → Prop} (f : α ≃ β) :
     (∃! x, p (f x)) ↔ ∃! y, p y := (Equiv.exists_unique_congr_left' f.symm).symm
+#align equiv.exists_unique_congr_left Equiv.exists_unique_congr_left
 
 protected theorem forall_congr {p : α → Prop} {q : β → Prop} (f : α ≃ β)
     (h : ∀ {x}, p x ↔ q (f x)) : (∀ x, p x) ↔ (∀ y, q y) := by
   constructor <;> intro h₂ x
   . rw [← f.right_inv x]; apply h.mp; apply h₂
   · apply h.mpr; apply h₂
+#align equiv.forall_congr Equiv.forall_congr
 
 protected theorem forall_congr' {p : α → Prop} {q : β → Prop} (f : α ≃ β)
     (h : ∀ {x}, p (f.symm x) ↔ q x) : (∀ x, p x) ↔ ∀ y, q y :=
   (Equiv.forall_congr f.symm h.symm).symm
+#align equiv.forall_congr' Equiv.forall_congr'
 
 -- We next build some higher arity versions of `Equiv.forall_congr`.
 -- Although they appear to just be repeated applications of `Equiv.forall_congr`,
@@ -769,31 +886,38 @@ protected theorem forall_congr' {p : α → Prop} {q : β → Prop} (f : α ≃
 protected theorem forall₂_congr {p : α₁ → β₁ → Prop} {q : α₂ → β₂ → Prop} (eα : α₁ ≃ α₂)
     (eβ : β₁ ≃ β₂) (h : ∀ {x y}, p x y ↔ q (eα x) (eβ y)) : (∀ x y, p x y) ↔ ∀ x y, q x y :=
   Equiv.forall_congr _ <| Equiv.forall_congr _ h
+#align equiv.forall₂_congr Equiv.forall₂_congr
 
 protected theorem forall₂_congr' {p : α₁ → β₁ → Prop} {q : α₂ → β₂ → Prop}
     (eα : α₁ ≃ α₂) (eβ : β₁ ≃ β₂) (h : ∀ {x y}, p (eα.symm x) (eβ.symm y) ↔ q x y) :
     (∀ x y, p x y) ↔ ∀ x y, q x y := (Equiv.forall₂_congr eα.symm eβ.symm h.symm).symm
+#align equiv.forall₂_congr' Equiv.forall₂_congr'
 
 protected theorem forall₃_congr {p : α₁ → β₁ → γ₁ → Prop} {q : α₂ → β₂ → γ₂ → Prop}
     (eα : α₁ ≃ α₂) (eβ : β₁ ≃ β₂) (eγ : γ₁ ≃ γ₂) (h : ∀ {x y z}, p x y z ↔ q (eα x) (eβ y) (eγ z)) :
     (∀ x y z, p x y z) ↔ ∀ x y z, q x y z :=
   Equiv.forall₂_congr _ _ <| Equiv.forall_congr _ h
+#align equiv.forall₃_congr Equiv.forall₃_congr
 
 protected theorem forall₃_congr' {p : α₁ → β₁ → γ₁ → Prop} {q : α₂ → β₂ → γ₂ → Prop}
     (eα : α₁ ≃ α₂) (eβ : β₁ ≃ β₂) (eγ : γ₁ ≃ γ₂)
     (h : ∀ {x y z}, p (eα.symm x) (eβ.symm y) (eγ.symm z) ↔ q x y z) :
     (∀ x y z, p x y z) ↔ ∀ x y z, q x y z :=
   (Equiv.forall₃_congr eα.symm eβ.symm eγ.symm h.symm).symm
+#align equiv.forall₃_congr' Equiv.forall₃_congr'
 
 protected theorem forall_congr_left' {p : α → Prop} (f : α ≃ β) : (∀ x, p x) ↔ ∀ y, p (f.symm y) :=
   Equiv.forall_congr f <| by simp
+#align equiv.forall_congr_left' Equiv.forall_congr_left'
 
 protected theorem forall_congr_left {p : β → Prop} (f : α ≃ β) : (∀ x, p (f x)) ↔ ∀ y, p y :=
   (Equiv.forall_congr_left' f.symm).symm
+#align equiv.forall_congr_left Equiv.forall_congr_left
 
 protected theorem exists_congr_left {α β} (f : α ≃ β) {p : α → Prop} :
     (∃ a, p a) ↔ ∃ b, p (f.symm b) :=
   ⟨fun ⟨a, h⟩ => ⟨f a, by simpa using h⟩, fun ⟨b, h⟩ => ⟨_, h⟩⟩
+#align equiv.exists_congr_left Equiv.exists_congr_left
 
 end Equiv
 
@@ -809,21 +933,25 @@ protected def congr {ra : α → α → Prop} {rb : β → β → Prop} (e : α
       ((e.apply_symm_apply b₁).symm ▸ (e.apply_symm_apply b₂).symm ▸ h)
   left_inv := by rintro ⟨a⟩; simp only [Quot.map, Equiv.symm_apply_apply]
   right_inv := by rintro ⟨a⟩; simp only [Quot.map, Equiv.apply_symm_apply]
+#align quot.congr Quot.congr
 
 @[simp] theorem congr_mk {ra : α → α → Prop} {rb : β → β → Prop} (e : α ≃ β)
     (eq : ∀ a₁ a₂ : α, ra a₁ a₂ ↔ rb (e a₁) (e a₂)) (a : α) :
     Quot.congr e eq (Quot.mk ra a) = Quot.mk rb (e a) := rfl
+#align quot.congr_mk Quot.congr_mk
 
 /-- Quotients are congruent on equivalences under equality of their relation.
 An alternative is just to use rewriting with `eq`, but then computational proofs get stuck. -/
 protected def congrRight {r r' : α → α → Prop} (eq : ∀ a₁ a₂, r a₁ a₂ ↔ r' a₁ a₂) :
     Quot r ≃ Quot r' := Quot.congr (Equiv.refl α) eq
+#align quot.congr_right Quot.congrRight
 
 /-- An equivalence `e : α ≃ β` generates an equivalence between the quotient space of `α`
 by a relation `ra` and the quotient space of `β` by the image of this relation under `e`. -/
 protected def congrLeft {r : α → α → Prop} (e : α ≃ β) :
     Quot r ≃ Quot fun b b' => r (e.symm b) (e.symm b') :=
   Quot.congr e fun _ _ => by simp only [e.symm_apply_apply]
+#align quot.congr_left Quot.congrLeft
 
 end Quot
 
@@ -834,15 +962,18 @@ if `ra a₁ a₂ ↔ rb (e a₁) (e a₂). -/
 protected def congr {ra : Setoid α} {rb : Setoid β} (e : α ≃ β)
     (eq : ∀ a₁ a₂, @Setoid.r α ra a₁ a₂ ↔ @Setoid.r β rb (e a₁) (e a₂)) :
     Quotient ra ≃ Quotient rb := Quot.congr e eq
+#align quotient.congr Quotient.congr
 
 @[simp] theorem congr_mk {ra : Setoid α} {rb : Setoid β} (e : α ≃ β)
     (eq : ∀ a₁ a₂ : α, Setoid.r a₁ a₂ ↔ Setoid.r (e a₁) (e a₂)) (a : α) :
     Quotient.congr e eq (Quotient.mk ra a) = Quotient.mk rb (e a) := rfl
+#align quotient.congr_mk Quotient.congr_mk
 
 /-- Quotients are congruent on equivalences under equality of their relation.
 An alternative is just to use rewriting with `eq`, but then computational proofs get stuck. -/
 protected def congrRight {r r' : Setoid α}
     (eq : ∀ a₁ a₂, @Setoid.r α r a₁ a₂ ↔ @Setoid.r α r' a₁ a₂) : Quotient r ≃ Quotient r' :=
   Quot.congrRight eq
+#align quotient.congr_right Quotient.congrRight
 
 end Quotient

feat: port GroupTheory.GroupAction.Basic (#1845)

dd0b3ae2

Diff

@@ -627,13 +627,14 @@ def sigmaCongrRight {α} {β₁ β₂ : α → Type _} (F : ∀ a, β₁ a ≃ 
   invFun a := ⟨a.1, (F a.1).symm a.2⟩
   left_inv | ⟨a, b⟩ => congr_arg (Sigma.mk a) <| symm_apply_apply (F a) b
   right_inv | ⟨a, b⟩ => congr_arg (Sigma.mk a) <| apply_symm_apply (F a) b
+#align equiv.sigma_congr_right Equiv.sigmaCongrRight
 
 -- Porting note: simp can now simplify the LHS, so I have removed `@[simp]`
 theorem sigmaCongrRight_trans {α} {β₁ β₂ β₃ : α → Type _}
     (F : ∀ a, β₁ a ≃ β₂ a) (G : ∀ a, β₂ a ≃ β₃ a) :
     (sigmaCongrRight F).trans (sigmaCongrRight G) =
       sigmaCongrRight fun a => (F a).trans (G a) := rfl
-#align equiv.sigma_congr_right Equiv.sigmaCongrRight_trans
+#align equiv.sigma_congr_right_trans Equiv.sigmaCongrRight_trans
 
 -- Porting note: simp can now simplify the LHS, so I have removed `@[simp]`
 theorem sigmaCongrRight_symm {α} {β₁ β₂ : α → Type _} (F : ∀ a, β₁ a ≃ β₂ a) :

chore: fix most phantom #aligns (#1794)

3d3fb046

Diff

@@ -558,7 +558,7 @@ def arrowPUnitOfIsEmpty (α β : Sort _) [IsEmpty α] : (α → β) ≃ PUnit.{u
   invFun _ := isEmptyElim
   left_inv _ := funext isEmptyElim
   right_inv _ := rfl
-#align equiv.arrow_punit_of_is_empy Equiv.arrowPUnitOfIsEmpty
+#align equiv.arrow_punit_of_is_empty Equiv.arrowPUnitOfIsEmpty
 
 /-- The sort of maps from `Empty` is equivalent to `PUnit`. -/
 def emptyArrowEquivPUnit (α : Sort _) : (Empty → α) ≃ PUnit.{u} := arrowPUnitOfIsEmpty _ _
@@ -633,7 +633,7 @@ theorem sigmaCongrRight_trans {α} {β₁ β₂ β₃ : α → Type _}
     (F : ∀ a, β₁ a ≃ β₂ a) (G : ∀ a, β₂ a ≃ β₃ a) :
     (sigmaCongrRight F).trans (sigmaCongrRight G) =
       sigmaCongrRight fun a => (F a).trans (G a) := rfl
-#align equiv.sigmaCongrRight Equiv.sigmaCongrRight_trans
+#align equiv.sigma_congr_right Equiv.sigmaCongrRight_trans
 
 -- Porting note: simp can now simplify the LHS, so I have removed `@[simp]`
 theorem sigmaCongrRight_symm {α} {β₁ β₂ : α → Type _} (F : ∀ a, β₁ a ≃ β₂ a) :

feat port: Logic.Equiv.LocalEquiv (#1052)

aba57d4d

Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com> Co-authored-by: Winston Yin <winstonyin@gmail.com> Co-authored-by: Johan Commelin <johan@commelin.net>

956714e4

Diff

@@ -48,7 +48,7 @@ Then we define
 
   - `Equiv.inhabited` takes `e : α ≃ β` and `[Inhabited β]` and returns `Inhabited α`;
   - `Equiv.unique` takes `e : α ≃ β` and `[Unique β]` and returns `unique α`;
-  - `Equiv.decidable_eq` takes `e : α ≃ β` and `[DecidableEq β]` and returns `DecidableEq α`.
+  - `Equiv.decidableEq` takes `e : α ≃ β` and `[DecidableEq β]` and returns `DecidableEq α`.
 
   More definitions of this kind can be found in other files. E.g., `Data.Equiv.TransferInstance`
   does it for many algebraic type classes like `Group`, `Module`, etc.
@@ -167,6 +167,7 @@ instance : Trans Equiv Equiv Equiv where
 -- porting note: this is not a syntactic tautology any more because
 -- the coercion from `e` to a function is now `FunLike.coe` not `e.toFun`
 @[simp] theorem toFun_as_coe (e : α ≃ β) : e.toFun = e := rfl
+#align equiv.to_fun_as_coe Equiv.toFun_as_coe
 
 -- porting note: `simp` should prove this using `toFun_as_coe`, but it doesn't.
 -- This might be a bug in `simp` -- see https://github.com/leanprover/lean4/issues/1937
@@ -175,6 +176,7 @@ instance : Trans Equiv Equiv Equiv where
 @[simp] theorem toFun_as_coe_apply (e : α ≃ β) (x : α) : e.toFun x = e x := rfl
 
 @[simp] theorem invFun_as_coe (e : α ≃ β) : e.invFun = e.symm := rfl
+#align equiv.inv_fun_as_coe Equiv.invFun_as_coe
 
 protected theorem injective (e : α ≃ β) : Injective e := EquivLike.injective e
 #align equiv.injective Equiv.injective

chore: fix casing per naming scheme (#1183)

Fix a lot of wrong casing mostly in the docstrings but also sometimes in def/theorem names. E.g. fin 2 --> Fin 2, add_monoid_hom --> AddMonoidHom

Remove \n from to_additive docstrings that were inserted by mathport.

Move files and directories with Gcd and Smul to GCD and SMul

71723d8b

Diff

@@ -24,36 +24,36 @@ import Mathlib.Tactic.Substs
 
 In this file we define two types:
 
-* `equiv α β` a.k.a. `α ≃ β`: a bijective map `α → β` bundled with its inverse map; we use this (and
+* `Equiv α β` a.k.a. `α ≃ β`: a bijective map `α → β` bundled with its inverse map; we use this (and
   not equality!) to express that various `Type`s or `Sort`s are equivalent.
 
-* `equiv.perm α`: the group of permutations `α ≃ α`. More lemmas about `equiv.perm` can be found in
-  `group_theory/perm`.
+* `Equiv.Perm α`: the group of permutations `α ≃ α`. More lemmas about `Equiv.Perm` can be found in
+  `GroupTheory.Perm`.
 
 Then we define
 
 * canonical isomorphisms between various types: e.g.,
 
-  - `equiv.refl α` is the identity map interpreted as `α ≃ α`;
+  - `Equiv.refl α` is the identity map interpreted as `α ≃ α`;
 
 * operations on equivalences: e.g.,
 
-  - `equiv.symm e : β ≃ α` is the inverse of `e : α ≃ β`;
+  - `Equiv.symm e : β ≃ α` is the inverse of `e : α ≃ β`;
 
-  - `equiv.trans e₁ e₂ : α ≃ γ` is the composition of `e₁ : α ≃ β` and `e₂ : β ≃ γ` (note the order
+  - `Equiv.trans e₁ e₂ : α ≃ γ` is the composition of `e₁ : α ≃ β` and `e₂ : β ≃ γ` (note the order
     of the arguments!);
 
 * definitions that transfer some instances along an equivalence. By convention, we transfer
   instances from right to left.
 
-  - `equiv.inhabited` takes `e : α ≃ β` and `[inhabited β]` and returns `inhabited α`;
-  - `equiv.unique` takes `e : α ≃ β` and `[unique β]` and returns `unique α`;
-  - `equiv.decidable_eq` takes `e : α ≃ β` and `[decidable_eq β]` and returns `decidable_eq α`.
+  - `Equiv.inhabited` takes `e : α ≃ β` and `[Inhabited β]` and returns `Inhabited α`;
+  - `Equiv.unique` takes `e : α ≃ β` and `[Unique β]` and returns `unique α`;
+  - `Equiv.decidable_eq` takes `e : α ≃ β` and `[DecidableEq β]` and returns `DecidableEq α`.
 
-  More definitions of this kind can be found in other files. E.g., `data/equiv/transfer_instance`
-  does it for many algebraic type classes like `group`, `module`, etc.
+  More definitions of this kind can be found in other files. E.g., `Data.Equiv.TransferInstance`
+  does it for many algebraic type classes like `Group`, `Module`, etc.
 
-Many more such isomorphisms and operations are defined in `logic/equiv/basic`.
+Many more such isomorphisms and operations are defined in `Logic.Equiv.Basic`.
 
 ## Tags
 
@@ -166,15 +166,15 @@ instance : Trans Equiv Equiv Equiv where
 
 -- porting note: this is not a syntactic tautology any more because
 -- the coercion from `e` to a function is now `FunLike.coe` not `e.toFun`
-@[simp] theorem to_fun_as_coe (e : α ≃ β) : e.toFun = e := rfl
+@[simp] theorem toFun_as_coe (e : α ≃ β) : e.toFun = e := rfl
 
--- porting note: `simp` should prove this using `to_fun_as_coe`, but it doesn't.
+-- porting note: `simp` should prove this using `toFun_as_coe`, but it doesn't.
 -- This might be a bug in `simp` -- see https://github.com/leanprover/lean4/issues/1937
 -- If this issue is fixed then the simp linter probably will start complaining, and
 -- this theorem can be deleted hopefully without breaking any `simp` proofs.
-@[simp] theorem to_fun_as_coe_apply (e : α ≃ β) (x : α) : e.toFun x = e x := rfl
+@[simp] theorem toFun_as_coe_apply (e : α ≃ β) (x : α) : e.toFun x = e x := rfl
 
-@[simp] theorem inv_fun_as_coe (e : α ≃ β) : e.invFun = e.symm := rfl
+@[simp] theorem invFun_as_coe (e : α ≃ β) : e.invFun = e.symm := rfl
 
 protected theorem injective (e : α ≃ β) : Injective e := EquivLike.injective e
 #align equiv.injective Equiv.injective
@@ -207,7 +207,7 @@ instance permUnique [Subsingleton α] : Unique (Perm α) :=
 theorem Perm.subsingleton_eq_refl [Subsingleton α] (e : Perm α) : e = Equiv.refl α :=
   Subsingleton.elim _ _
 
-/-- Transfer `decidableEq` across an equivalence. -/
+/-- Transfer `DecidableEq` across an equivalence. -/
 protected def decidableEq (e : α ≃ β) [DecidableEq β] : DecidableEq α :=
   e.injective.decidableEq
 
@@ -358,7 +358,7 @@ section permCongr
 
 variable {α' β' : Type _} (e : α' ≃ β')
 
-/-- If `α` is equivalent to `β`, then `perm α` is equivalent to `perm β`. -/
+/-- If `α` is equivalent to `β`, then `Perm α` is equivalent to `Perm β`. -/
 def permCongr : Perm α' ≃ Perm β' := equivCongr e e
 
 theorem permCongr_def (p : Equiv.Perm α') : e.permCongr p = (e.symm.trans p).trans e := rfl
@@ -582,7 +582,7 @@ def psigmaEquivSigma {α} (β : α → Type _) : (Σ' i, β i) ≃ Σ i, β i wh
   left_inv _ := rfl
   right_inv _ := rfl
 
-/-- A `psigma`-type is equivalent to the corresponding `sigma`-type. -/
+/-- A `PSigma`-type is equivalent to the corresponding `Sigma`-type. -/
 @[simps apply symm_apply]
 def psigmaEquivSigmaPLift {α} (β : α → Sort _) : (Σ' i, β i) ≃ Σ i : PLift α, PLift (β i.down) where
   toFun a := ⟨PLift.up a.1, PLift.up a.2⟩
@@ -643,21 +643,21 @@ theorem sigmaCongrRight_refl {α} {β : α → Type _} :
     (sigmaCongrRight fun a => Equiv.refl (β a)) = Equiv.refl (Σ a, β a) := rfl
 #align equiv.sigma_congr_right_refl Equiv.sigmaCongrRight_refl
 
-/-- A `psigma` with `Prop` fibers is equivalent to the subtype.  -/
+/-- A `PSigma` with `Prop` fibers is equivalent to the subtype.  -/
 def psigmaEquivSubtype {α : Type v} (P : α → Prop) : (Σ' i, P i) ≃ Subtype P where
   toFun x := ⟨x.1, x.2⟩
   invFun x := ⟨x.1, x.2⟩
   left_inv _ := rfl
   right_inv _ := rfl
 
-/-- A `sigma` with `plift` fibers is equivalent to the subtype. -/
+/-- A `Sigma` with `PLift` fibers is equivalent to the subtype. -/
 def sigmaPLiftEquivSubtype {α : Type v} (P : α → Prop) : (Σ i, PLift (P i)) ≃ Subtype P :=
   ((psigmaEquivSigma _).symm.trans
     (psigmaCongrRight fun _ => Equiv.plift)).trans (psigmaEquivSubtype P)
 #align equiv.sigma_plift_equiv_subtype Equiv.sigmaPLiftEquivSubtype
 
-/-- A `sigma` with `λ i, ulift (plift (P i))` fibers is equivalent to `{ x // P x }`.
-Variant of `sigma_plift_equiv_subtype`.
+/-- A `Sigma` with `λ i, ULift (PLift (P i))` fibers is equivalent to `{ x // P x }`.
+Variant of `sigmaPLiftEquivSubtype`.
 -/
 def sigmaULiftPLiftEquivSubtype {α : Type v} (P : α → Prop) :
     (Σ i, ULift (PLift (P i))) ≃ Subtype P :=
@@ -666,7 +666,7 @@ def sigmaULiftPLiftEquivSubtype {α : Type v} (P : α → Prop) :
 
 namespace Perm
 
-/-- A family of permutations `Π a, perm (β a)` generates a permuation `perm (Σ a, β₁ a)`. -/
+/-- A family of permutations `Π a, Perm (β a)` generates a permuation `Perm (Σ a, β₁ a)`. -/
 @[reducible] def sigmaCongrRight {α} {β : α → Sort _} (F : ∀ a, Perm (β a)) : Perm (Σ a, β a) :=
   Equiv.sigmaCongrRight F
 
@@ -713,11 +713,11 @@ def sigmaCongr {α₁ α₂} {β₁ : α₁ → Sort _} {β₂ : α₂ → Sort
     (F : ∀ a, β₁ a ≃ β₂ (f a)) : Sigma β₁ ≃ Sigma β₂ :=
   (sigmaCongrRight F).trans (sigmaCongrLeft f)
 
-/-- `sigma` type with a constant fiber is equivalent to the product. -/
+/-- `Sigma` type with a constant fiber is equivalent to the product. -/
 @[simps apply symm_apply] def sigmaEquivProd (α β : Type _) : (Σ _ : α, β) ≃ α × β :=
   ⟨fun a => ⟨a.1, a.2⟩, fun a => ⟨a.1, a.2⟩, fun ⟨_, _⟩ => rfl, fun ⟨_, _⟩ => rfl⟩
 
-/-- If each fiber of a `sigma` type is equivalent to a fixed type, then the sigma type
+/-- If each fiber of a `Sigma` type is equivalent to a fixed type, then the sigma type
 is equivalent to the product. -/
 def sigmaEquivProdOfEquiv {α β} {β₁ : α → Sort _} (F : ∀ a, β₁ a ≃ β) : Sigma β₁ ≃ α × β :=
   (sigmaCongrRight F).trans (sigmaEquivProd α β)
@@ -756,8 +756,8 @@ protected theorem forall_congr' {p : α → Prop} {q : β → Prop} (f : α ≃
     (h : ∀ {x}, p (f.symm x) ↔ q x) : (∀ x, p x) ↔ ∀ y, q y :=
   (Equiv.forall_congr f.symm h.symm).symm
 
--- We next build some higher arity versions of `equiv.forall_congr`.
--- Although they appear to just be repeated applications of `equiv.forall_congr`,
+-- We next build some higher arity versions of `Equiv.forall_congr`.
+-- Although they appear to just be repeated applications of `Equiv.forall_congr`,
 -- unification of metavariables works better with these versions.
 -- In particular, they are necessary in `equiv_rw`.
 -- (Stopping at ternary functions seems reasonable: at least in 1-categorical mathematics,

feat: better coercions from hom classes to hom types (#1150)

Discussed here

e8655308

Diff

@@ -76,12 +76,18 @@ structure Equiv (α : Sort _) (β : Sort _) where
 
 infixl:25 " ≃ " => Equiv
 
+/-- Turn an element of a type `F` satisfying `EquivLike F α β` into an actual
+`Equiv`. This is declared as the default coercion from `F` to `α ≃ β`. -/
+@[coe]
+def EquivLike.toEquiv {F} [EquivLike F α β] (f :F) : α ≃ β where
+  toFun := f
+  invFun := EquivLike.inv f
+  left_inv := EquivLike.left_inv f
+  right_inv := EquivLike.right_inv f
+
+/-- Any type satisfying `EquivLike` can be cast into `Equiv` via `EquivLike.toEquiv`. -/
 instance {F} [EquivLike F α β] : CoeTC F (α ≃ β) :=
-  ⟨fun f =>
-    { toFun := f,
-      invFun := EquivLike.inv f,
-      left_inv := EquivLike.left_inv f,
-      right_inv := EquivLike.right_inv f }⟩
+  ⟨EquivLike.toEquiv⟩
 
 /-- `Perm α` is the type of bijections from `α` to itself. -/
 @[reducible]

feat: port Dynamics.Basic (#1120)

893f77fc

Diff

@@ -293,9 +293,9 @@ theorem eq_symm_apply {α β} (e : α ≃ β) {x y} : y = e.symm x ↔ e y = x :
 theorem trans_assoc {δ} (ab : α ≃ β) (bc : β ≃ γ) (cd : γ ≃ δ) :
     (ab.trans bc).trans cd = ab.trans (bc.trans cd) := Equiv.ext fun _ => rfl
 
-theorem left_inverse_symm (f : Equiv α β) : LeftInverse f.symm f := f.left_inv
+theorem leftInverse_symm (f : Equiv α β) : LeftInverse f.symm f := f.left_inv
 
-theorem right_inverse_symm (f : Equiv α β) : Function.RightInverse f.symm f := f.right_inv
+theorem rightInverse_symm (f : Equiv α β) : Function.RightInverse f.symm f := f.right_inv
 
 theorem injective_comp (e : α ≃ β) (f : β → γ) : Injective (f ∘ e) ↔ Injective f :=
   EquivLike.injective_comp e f

fix: reintroduce to_fun_as_coe as simp lemma (#931)

This is a proposed fix for the broken simp calls in #922. See https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/.60simp.60.20calls.20broken.20in.20mathlib4.23922/near/314783451 for more details. Note that to_fun_as_coe was a syntactic tautology when it was ported, but this is no longer the case because we now have FunLike.

a2d69bdf

Diff

@@ -158,8 +158,15 @@ protected def trans (e₁ : α ≃ β) (e₂ : β ≃ γ) : α ≃ γ :=
 instance : Trans Equiv Equiv Equiv where
   trans := Equiv.trans
 
--- porting note: this lemma is now useless since coercions are eagerly unfolded
--- @[simp] theorem to_fun_as_coe (e : α ≃ β) : e.toFun = e := rfl
+-- porting note: this is not a syntactic tautology any more because
+-- the coercion from `e` to a function is now `FunLike.coe` not `e.toFun`
+@[simp] theorem to_fun_as_coe (e : α ≃ β) : e.toFun = e := rfl
+
+-- porting note: `simp` should prove this using `to_fun_as_coe`, but it doesn't.
+-- This might be a bug in `simp` -- see https://github.com/leanprover/lean4/issues/1937
+-- If this issue is fixed then the simp linter probably will start complaining, and
+-- this theorem can be deleted hopefully without breaking any `simp` proofs.
+@[simp] theorem to_fun_as_coe_apply (e : α ≃ β) (x : α) : e.toFun x = e x := rfl
 
 @[simp] theorem inv_fun_as_coe (e : α ≃ β) : e.invFun = e.symm := rfl

chore: update lean4/std4 (#1096)

a9a1f7d7

Diff

@@ -807,7 +807,7 @@ protected def congrRight {r r' : α → α → Prop} (eq : ∀ a₁ a₂, r a₁
 by a relation `ra` and the quotient space of `β` by the image of this relation under `e`. -/
 protected def congrLeft {r : α → α → Prop} (e : α ≃ β) :
     Quot r ≃ Quot fun b b' => r (e.symm b) (e.symm b') :=
-  Quot.congr e fun _ _ => by simp only [e.symm_apply_apply]; rfl
+  Quot.congr e fun _ _ => by simp only [e.symm_apply_apply]
 
 end Quot