algebra.quandle | Mathlib porting status

Changes since the initial port

The following section lists changes to this file in mathlib3 and mathlib4 that occured after the initial port. Most recent changes are shown first. Hovering over a commit will show all commits associated with the same mathlib3 commit.

Changes in mathlib3

28aa996f

(last sync)

feat(algebra/quandle): Unital shelves (#17839)

Extend shelves to include the unital case, as well as a few basic results about unital shelves from https://arxiv.org/pdf/1603.08590.pdf

This culminates in providing a monoid instance for a unital shelf.

Co-authored-by: Jim Fowler <fowler@math.osu.edu> Co-authored-by: Yaël Dillies <yael.dillies@gmail.com>

Diff

@@ -34,7 +34,7 @@ complements that is analogous to the fundamental group of the
 exterior, and he showed that the quandle associated to an oriented
 knot is invariant up to orientation-reversed mirror image.  Racks were
 used by Fenn and Rourke for framed codimension-2 knots and
-links.[FennRourke1992]
+links in [FennRourke1992].  Unital shelves are discussed in [crans2017].
 
 The name "rack" came from wordplay by Conway and Wraith for the "wrack
 and ruin" of forgetting everything but the conjugation operation for a
@@ -43,6 +43,7 @@ group.
 ## Main definitions
 
 * `shelf` is a type with a self-distributive action
+* `unital_shelf` is a shelf with a left and right unit
 * `rack` is a shelf whose action for each element is invertible
 * `quandle` is a rack whose action for an element fixes that element
 * `quandle.conj` defines a quandle of a group acting on itself by conjugation.
@@ -54,6 +55,11 @@ group.
 * `rack.envel_group` is left adjoint to `quandle.conj` (`to_envel_group.map`).
   The universality statements are `to_envel_group.univ` and `to_envel_group.univ_uniq`.
 
+## Implementation notes
+
+"Unital racks" are uninteresting (see `rack.assoc_iff_id`, `unital_shelf.assoc`), so we do not
+define them.
+
 ## Notation
 
 The following notation is localized in `quandles`:
@@ -92,6 +98,14 @@ class shelf (α : Type u) :=
 (act : α → α → α)
 (self_distrib : ∀ {x y z : α}, act x (act y z) = act (act x y) (act x z))
 
+/--
+A *unital shelf* is a shelf equipped with an element `1` such that, for all elements `x`,
+we have both `x ◃ 1` and `1 ◃ x` equal `x`.
+-/
+class unital_shelf (α : Type u) extends shelf α, has_one α :=
+(one_act : ∀ a : α, act 1 a = a)
+(act_one : ∀ a : α, act a 1 = a)
+
 /--
 The type of homomorphisms between shelves.
 This is also the notion of rack and quandle homomorphisms.
@@ -120,6 +134,38 @@ localized "infixr (name := shelf_hom) ` →◃ `:25 := shelf_hom" in quandles
 
 open_locale quandles
 
+namespace unital_shelf
+open shelf
+
+variables {S : Type*} [unital_shelf S]
+
+/--
+A monoid is *graphic* if, for all `x` and `y`, the *graphic identity*
+`(x * y) * x = x * y` holds.  For a unital shelf, this graphic
+identity holds.
+-/
+lemma act_act_self_eq (x y : S) : (x ◃ y) ◃ x = x ◃ y :=
+begin
+  have h : (x ◃ y) ◃ x = (x ◃ y) ◃ (x ◃ 1) := by rw act_one,
+  rw [h, ←shelf.self_distrib, act_one],
+end
+
+lemma act_idem (x : S) : (x ◃ x) = x := by rw [←act_one x, ←shelf.self_distrib, act_one, act_one]
+
+lemma act_self_act_eq (x y : S) : x ◃ (x ◃ y) = x ◃ y :=
+begin
+  have h : x ◃ (x ◃ y) = (x ◃ 1) ◃ (x ◃ y) := by rw act_one,
+  rw [h, ←shelf.self_distrib, one_act],
+end
+
+/--
+The associativity of a unital shelf comes for free.
+-/
+lemma assoc (x y z : S) : (x ◃ y) ◃ z = x ◃ y ◃ z :=
+by rw [self_distrib, self_distrib, act_act_self_eq, act_self_act_eq]
+
+end unital_shelf
+
 namespace rack
 variables {R : Type*} [rack R]

8631e2d5

(first ported)

Changes in mathlib3port

mathlib3

mathlib3port

28aa996f

bump to nightly-2024-04-06-08

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

e34029c9

Diff

@@ -3,9 +3,9 @@ Copyright (c) 2020 Kyle Miller. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kyle Miller
 -/
-import Algebra.Hom.Equiv.Basic
-import Algebra.Hom.Aut
-import Data.Zmod.Defs
+import Algebra.Group.Equiv.Basic
+import Algebra.Group.Aut
+import Data.ZMod.Defs
 import Tactic.Group
 
 #align_import algebra.quandle from "leanprover-community/mathlib"@"28aa996fc6fb4317f0083c4e6daf79878d81be33"

28aa996f

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,10 +3,10 @@ Copyright (c) 2020 Kyle Miller. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kyle Miller
 -/
-import Mathbin.Algebra.Hom.Equiv.Basic
-import Mathbin.Algebra.Hom.Aut
-import Mathbin.Data.Zmod.Defs
-import Mathbin.Tactic.Group
+import Algebra.Hom.Equiv.Basic
+import Algebra.Hom.Aut
+import Data.Zmod.Defs
+import Tactic.Group
 
 #align_import algebra.quandle from "leanprover-community/mathlib"@"28aa996fc6fb4317f0083c4e6daf79878d81be33"

28aa996f

bump to nightly-2023-08-17-09

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

60285dcc

Diff

@@ -778,7 +778,7 @@ instance (R : Type _) [Rack R] : DivInvMonoid (EnvelGroup R)
 
 instance (R : Type _) [Rack R] : Group (EnvelGroup R) :=
   { EnvelGroup.divInvMonoid _ with
-    mul_left_inv := fun a =>
+    hMul_left_inv := fun a =>
       Quotient.inductionOn a fun a => Quotient.sound (PreEnvelGroupRel'.mul_left_inv a).Rel }
 
 #print Rack.EnvelGroup.inhabited /-

28aa996f

bump to nightly-2023-08-10-09

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

d9066f6f

Diff

@@ -408,10 +408,12 @@ variable {S₁ : Type _} {S₂ : Type _} {S₃ : Type _} [Shelf S₁] [Shelf S
 instance : CoeFun (S₁ →◃ S₂) fun _ => S₁ → S₂ :=
   ⟨ShelfHom.toFun⟩
 
+#print ShelfHom.toFun_eq_coe /-
 @[simp]
 theorem toFun_eq_coe (f : S₁ →◃ S₂) : f.toFun = f :=
   rfl
 #align shelf_hom.to_fun_eq_coe ShelfHom.toFun_eq_coe
+-/
 
 #print ShelfHom.map_act /-
 @[simp]

28aa996f

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,17 +2,14 @@
 Copyright (c) 2020 Kyle Miller. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kyle Miller
-
-! This file was ported from Lean 3 source module algebra.quandle
-! leanprover-community/mathlib commit 28aa996fc6fb4317f0083c4e6daf79878d81be33
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.Hom.Equiv.Basic
 import Mathbin.Algebra.Hom.Aut
 import Mathbin.Data.Zmod.Defs
 import Mathbin.Tactic.Group
 
+#align_import algebra.quandle from "leanprover-community/mathlib"@"28aa996fc6fb4317f0083c4e6daf79878d81be33"
+
 /-!
 # Racks and Quandles

28aa996f

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -143,13 +143,10 @@ class Rack (α : Type u) extends Shelf α where
 #align rack Rack
 -/
 
--- mathport name: shelf.act
 scoped[Quandles] infixr:65 " ◃ " => Shelf.act
 
--- mathport name: rack.inv_act
 scoped[Quandles] infixr:65 " ◃⁻¹ " => Rack.invAct
 
--- mathport name: shelf_hom
 scoped[Quandles] infixr:25 " →◃ " => ShelfHom
 
 open scoped Quandles
@@ -269,6 +266,7 @@ theorem self_distrib_inv {x y z : R} : x ◃⁻¹ y ◃⁻¹ z = (x ◃⁻¹ y)
 #align rack.self_distrib_inv Rack.self_distrib_inv
 -/
 
+#print Rack.ad_conj /-
 /-- The *adjoint action* of a rack on itself is `op'`, and the adjoint
 action of `x ◃ y` is the conjugate of the action of `y` by the action
 of `x`. It is another way to understand the self-distributivity axiom.
@@ -281,6 +279,7 @@ theorem ad_conj {R : Type _} [Rack R] (x y : R) : act' (x ◃ y) = act' x * act'
   rw [eq_mul_inv_iff_mul_eq]; ext z
   apply self_distrib.symm
 #align rack.ad_conj Rack.ad_conj
+-/
 
 #print Rack.oppositeRack /-
 /-- The opposite rack, swapping the roles of `◃` and `◃⁻¹`.
@@ -417,10 +416,12 @@ theorem toFun_eq_coe (f : S₁ →◃ S₂) : f.toFun = f :=
   rfl
 #align shelf_hom.to_fun_eq_coe ShelfHom.toFun_eq_coe
 
+#print ShelfHom.map_act /-
 @[simp]
 theorem map_act (f : S₁ →◃ S₂) {x y : S₁} : f (x ◃ y) = f x ◃ f y :=
   map_act' f
 #align shelf_hom.map_act ShelfHom.map_act
+-/
 
 #print ShelfHom.id /-
 /-- The identity homomorphism -/
@@ -445,10 +446,12 @@ def comp (g : S₂ →◃ S₃) (f : S₁ →◃ S₂) : S₁ →◃ S₃
 #align shelf_hom.comp ShelfHom.comp
 -/
 
+#print ShelfHom.comp_apply /-
 @[simp]
 theorem comp_apply (g : S₂ →◃ S₃) (f : S₁ →◃ S₂) (x : S₁) : (g.comp f) x = g (f x) :=
   rfl
 #align shelf_hom.comp_apply ShelfHom.comp_apply
+-/
 
 end ShelfHom
 
@@ -504,11 +507,13 @@ instance Conj.quandle (G : Type _) [Group G] : Quandle (Conj G)
 #align quandle.conj.quandle Quandle.Conj.quandle
 -/
 
+#print Quandle.conj_act_eq_conj /-
 @[simp]
 theorem conj_act_eq_conj {G : Type _} [Group G] (x y : Conj G) :
     x ◃ y = ((x : G) * (y : G) * (x : G)⁻¹ : G) :=
   rfl
 #align quandle.conj_act_eq_conj Quandle.conj_act_eq_conj
+-/
 
 #print Quandle.conj_swap /-
 theorem conj_swap {G : Type _} [Group G] (x y : Conj G) : x ◃ y = y ↔ y ◃ x = x :=
@@ -783,6 +788,7 @@ instance EnvelGroup.inhabited (R : Type _) [Rack R] : Inhabited (EnvelGroup R) :
 #align rack.envel_group.inhabited Rack.EnvelGroup.inhabited
 -/
 
+#print Rack.toEnvelGroup /-
 /-- The canonical homomorphism from a rack to its enveloping group.
 Satisfies universal properties given by `to_envel_group.map` and `to_envel_group.univ`.
 -/
@@ -791,6 +797,7 @@ def toEnvelGroup (R : Type _) [Rack R] : R →◃ Quandle.Conj (EnvelGroup R)
   toFun x := ⟦incl x⟧
   map_act' x y := Quotient.sound (PreEnvelGroupRel'.act_incl x y).symm.Rel
 #align rack.to_envel_group Rack.toEnvelGroup
+-/
 
 #print Rack.toEnvelGroup.mapAux /-
 /-- The preliminary definition of the induced map from the enveloping group.
@@ -809,6 +816,7 @@ namespace ToEnvelGroup.MapAux
 
 open PreEnvelGroupRel'
 
+#print Rack.toEnvelGroup.mapAux.well_def /-
 /-- Show that `to_envel_group.map_aux` sends equivalent expressions to equal terms.
 -/
 theorem well_def {R : Type _} [Rack R] {G : Type _} [Group G] (f : R →◃ Quandle.Conj G) :
@@ -825,9 +833,11 @@ theorem well_def {R : Type _} [Rack R] {G : Type _} [Group G] (f : R →◃ Quan
   | _, _, mul_left_inv a => by simp [to_envel_group.map_aux]
   | _, _, act_incl x y => by simp [to_envel_group.map_aux]
 #align rack.to_envel_group.map_aux.well_def Rack.toEnvelGroup.mapAux.well_def
+-/
 
 end ToEnvelGroup.MapAux
 
+#print Rack.toEnvelGroup.map /-
 /-- Given a map from a rack to a group, lift it to being a map from the enveloping group.
 More precisely, the `envel_group` functor is left adjoint to `quandle.conj`.
 -/
@@ -860,14 +870,18 @@ def toEnvelGroup.map {R : Type _} [Rack R] {G : Type _} [Group G] :
         · have hm : ⟦x_a.inv⟧ = @Inv.inv (envel_group R) _ ⟦x_a⟧ := rfl
           rw [hm, F.map_inv, MonoidHom.map_inv, x_ih]
 #align rack.to_envel_group.map Rack.toEnvelGroup.map
+-/
 
+#print Rack.toEnvelGroup.univ /-
 /-- Given a homomorphism from a rack to a group, it factors through the enveloping group.
 -/
 theorem toEnvelGroup.univ (R : Type _) [Rack R] (G : Type _) [Group G] (f : R →◃ Quandle.Conj G) :
     (Quandle.Conj.map (toEnvelGroup.map f)).comp (toEnvelGroup R) = f :=
   toEnvelGroup.map.symm_apply_apply f
 #align rack.to_envel_group.univ Rack.toEnvelGroup.univ
+-/
 
+#print Rack.toEnvelGroup.univ_uniq /-
 /-- The homomorphism `to_envel_group.map f` is the unique map that fits into the commutative
 triangle in `to_envel_group.univ`.
 -/
@@ -876,7 +890,9 @@ theorem toEnvelGroup.univ_uniq (R : Type _) [Rack R] (G : Type _) [Group G]
     (h : f = (Quandle.Conj.map g).comp (toEnvelGroup R)) : g = toEnvelGroup.map f :=
   h.symm ▸ (toEnvelGroup.map.apply_symm_apply g).symm
 #align rack.to_envel_group.univ_uniq Rack.toEnvelGroup.univ_uniq
+-/
 
+#print Rack.envelAction /-
 /-- The induced group homomorphism from the enveloping group into bijections of the rack,
 using `rack.to_conj`. Satisfies the property `envel_action_prop`.
 
@@ -885,6 +901,7 @@ This gives the rack `R` the structure of an augmented rack over `envel_group R`.
 def envelAction {R : Type _} [Rack R] : EnvelGroup R →* R ≃ R :=
   toEnvelGroup.map (toConj R)
 #align rack.envel_action Rack.envelAction
+-/
 
 #print Rack.envelAction_prop /-
 @[simp]

28aa996f

bump to nightly-2023-06-01-04

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

4d9eaa85

Diff

@@ -412,12 +412,10 @@ variable {S₁ : Type _} {S₂ : Type _} {S₃ : Type _} [Shelf S₁] [Shelf S
 instance : CoeFun (S₁ →◃ S₂) fun _ => S₁ → S₂ :=
   ⟨ShelfHom.toFun⟩
 
-/- warning: shelf_hom.to_fun_eq_coe clashes with [anonymous] -> [anonymous]
-Case conversion may be inaccurate. Consider using '#align shelf_hom.to_fun_eq_coe [anonymous]ₓ'. -/
 @[simp]
-theorem [anonymous] (f : S₁ →◃ S₂) : f.toFun = f :=
+theorem toFun_eq_coe (f : S₁ →◃ S₂) : f.toFun = f :=
   rfl
-#align shelf_hom.to_fun_eq_coe [anonymous]
+#align shelf_hom.to_fun_eq_coe ShelfHom.toFun_eq_coe
 
 @[simp]
 theorem map_act (f : S₁ →◃ S₂) {x y : S₁} : f (x ◃ y) = f x ◃ f y :=

28aa996f

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -152,7 +152,7 @@ scoped[Quandles] infixr:65 " ◃⁻¹ " => Rack.invAct
 -- mathport name: shelf_hom
 scoped[Quandles] infixr:25 " →◃ " => ShelfHom
 
-open Quandles
+open scoped Quandles
 
 namespace UnitalShelf

28aa996f

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -269,12 +269,6 @@ theorem self_distrib_inv {x y z : R} : x ◃⁻¹ y ◃⁻¹ z = (x ◃⁻¹ y)
 #align rack.self_distrib_inv Rack.self_distrib_inv
 -/
 
-/- warning: rack.ad_conj -> Rack.ad_conj is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_2 : Rack.{u1} R] (x : R) (y : R), Eq.{succ u1} (Equiv.{succ u1, succ u1} R R) (Rack.act'.{u1} R _inst_2 (Shelf.act.{u1} R (Rack.toShelf.{u1} R _inst_2) x y)) (HMul.hMul.{u1, u1, u1} (Equiv.{succ u1, succ u1} R R) (Equiv.{succ u1, succ u1} R R) (Equiv.{succ u1, succ u1} R R) (instHMul.{u1} (Equiv.{succ u1, succ u1} R R) (MulOneClass.toHasMul.{u1} (Equiv.{succ u1, succ u1} R R) (Monoid.toMulOneClass.{u1} (Equiv.{succ u1, succ u1} R R) (DivInvMonoid.toMonoid.{u1} (Equiv.{succ u1, succ u1} R R) (Group.toDivInvMonoid.{u1} (Equiv.{succ u1, succ u1} R R) (Equiv.Perm.permGroup.{u1} R)))))) (HMul.hMul.{u1, u1, u1} (Equiv.{succ u1, succ u1} R R) (Equiv.{succ u1, succ u1} R R) (Equiv.{succ u1, succ u1} R R) (instHMul.{u1} (Equiv.{succ u1, succ u1} R R) (MulOneClass.toHasMul.{u1} (Equiv.{succ u1, succ u1} R R) (Monoid.toMulOneClass.{u1} (Equiv.{succ u1, succ u1} R R) (DivInvMonoid.toMonoid.{u1} (Equiv.{succ u1, succ u1} R R) (Group.toDivInvMonoid.{u1} (Equiv.{succ u1, succ u1} R R) (Equiv.Perm.permGroup.{u1} R)))))) (Rack.act'.{u1} R _inst_2 x) (Rack.act'.{u1} R _inst_2 y)) (Inv.inv.{u1} (Equiv.{succ u1, succ u1} R R) (DivInvMonoid.toHasInv.{u1} (Equiv.{succ u1, succ u1} R R) (Group.toDivInvMonoid.{u1} (Equiv.{succ u1, succ u1} R R) (Equiv.Perm.permGroup.{u1} R))) (Rack.act'.{u1} R _inst_2 x)))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_2 : Rack.{u1} R] (x : R) (y : R), Eq.{succ u1} (Equiv.{succ u1, succ u1} R R) (Rack.act'.{u1} R _inst_2 (Shelf.act.{u1} R (Rack.toShelf.{u1} R _inst_2) x y)) (HMul.hMul.{u1, u1, u1} (Equiv.{succ u1, succ u1} R R) (Equiv.{succ u1, succ u1} R R) (Equiv.{succ u1, succ u1} R R) (instHMul.{u1} (Equiv.{succ u1, succ u1} R R) (MulOneClass.toMul.{u1} (Equiv.{succ u1, succ u1} R R) (Monoid.toMulOneClass.{u1} (Equiv.{succ u1, succ u1} R R) (DivInvMonoid.toMonoid.{u1} (Equiv.{succ u1, succ u1} R R) (Group.toDivInvMonoid.{u1} (Equiv.{succ u1, succ u1} R R) (Equiv.Perm.permGroup.{u1} R)))))) (HMul.hMul.{u1, u1, u1} (Equiv.{succ u1, succ u1} R R) (Equiv.{succ u1, succ u1} R R) (Equiv.{succ u1, succ u1} R R) (instHMul.{u1} (Equiv.{succ u1, succ u1} R R) (MulOneClass.toMul.{u1} (Equiv.{succ u1, succ u1} R R) (Monoid.toMulOneClass.{u1} (Equiv.{succ u1, succ u1} R R) (DivInvMonoid.toMonoid.{u1} (Equiv.{succ u1, succ u1} R R) (Group.toDivInvMonoid.{u1} (Equiv.{succ u1, succ u1} R R) (Equiv.Perm.permGroup.{u1} R)))))) (Rack.act'.{u1} R _inst_2 x) (Rack.act'.{u1} R _inst_2 y)) (Inv.inv.{u1} (Equiv.{succ u1, succ u1} R R) (InvOneClass.toInv.{u1} (Equiv.{succ u1, succ u1} R R) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.{succ u1, succ u1} R R) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.{succ u1, succ u1} R R) (Group.toDivisionMonoid.{u1} (Equiv.{succ u1, succ u1} R R) (Equiv.Perm.permGroup.{u1} R))))) (Rack.act'.{u1} R _inst_2 x)))
-Case conversion may be inaccurate. Consider using '#align rack.ad_conj Rack.ad_conjₓ'. -/
 /-- The *adjoint action* of a rack on itself is `op'`, and the adjoint
 action of `x ◃ y` is the conjugate of the action of `y` by the action
 of `x`. It is another way to understand the self-distributivity axiom.
@@ -419,23 +413,12 @@ instance : CoeFun (S₁ →◃ S₂) fun _ => S₁ → S₂ :=
   ⟨ShelfHom.toFun⟩
 
 /- warning: shelf_hom.to_fun_eq_coe clashes with [anonymous] -> [anonymous]
-warning: shelf_hom.to_fun_eq_coe -> [anonymous] is a dubious translation:
-lean 3 declaration is
-  forall {S₁ : Type.{u1}} {S₂ : Type.{u2}} [_inst_1 : Shelf.{u1} S₁] [_inst_2 : Shelf.{u2} S₂] (f : ShelfHom.{u1, u2} S₁ S₂ _inst_1 _inst_2), Eq.{max (succ u1) (succ u2)} (S₁ -> S₂) (ShelfHom.toFun.{u1, u2} S₁ S₂ _inst_1 _inst_2 f) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (ShelfHom.{u1, u2} S₁ S₂ _inst_1 _inst_2) (fun (_x : ShelfHom.{u1, u2} S₁ S₂ _inst_1 _inst_2) => S₁ -> S₂) (ShelfHom.hasCoeToFun.{u1, u2} S₁ S₂ _inst_1 _inst_2) f)
-but is expected to have type
-  forall {S₁ : Type.{u1}} {S₂ : Type.{u2}}, (Nat -> S₁ -> S₂) -> Nat -> (List.{u1} S₁) -> (List.{u2} S₂)
 Case conversion may be inaccurate. Consider using '#align shelf_hom.to_fun_eq_coe [anonymous]ₓ'. -/
 @[simp]
 theorem [anonymous] (f : S₁ →◃ S₂) : f.toFun = f :=
   rfl
 #align shelf_hom.to_fun_eq_coe [anonymous]
 
-/- warning: shelf_hom.map_act -> ShelfHom.map_act is a dubious translation:
-lean 3 declaration is
-  forall {S₁ : Type.{u1}} {S₂ : Type.{u2}} [_inst_1 : Shelf.{u1} S₁] [_inst_2 : Shelf.{u2} S₂] (f : ShelfHom.{u1, u2} S₁ S₂ _inst_1 _inst_2) {x : S₁} {y : S₁}, Eq.{succ u2} S₂ (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (ShelfHom.{u1, u2} S₁ S₂ _inst_1 _inst_2) (fun (_x : ShelfHom.{u1, u2} S₁ S₂ _inst_1 _inst_2) => S₁ -> S₂) (ShelfHom.hasCoeToFun.{u1, u2} S₁ S₂ _inst_1 _inst_2) f (Shelf.act.{u1} S₁ _inst_1 x y)) (Shelf.act.{u2} S₂ _inst_2 (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (ShelfHom.{u1, u2} S₁ S₂ _inst_1 _inst_2) (fun (_x : ShelfHom.{u1, u2} S₁ S₂ _inst_1 _inst_2) => S₁ -> S₂) (ShelfHom.hasCoeToFun.{u1, u2} S₁ S₂ _inst_1 _inst_2) f x) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (ShelfHom.{u1, u2} S₁ S₂ _inst_1 _inst_2) (fun (_x : ShelfHom.{u1, u2} S₁ S₂ _inst_1 _inst_2) => S₁ -> S₂) (ShelfHom.hasCoeToFun.{u1, u2} S₁ S₂ _inst_1 _inst_2) f y))
-but is expected to have type
-  forall {S₁ : Type.{u2}} {S₂ : Type.{u1}} [_inst_1 : Shelf.{u2} S₁] [_inst_2 : Shelf.{u1} S₂] (f : ShelfHom.{u2, u1} S₁ S₂ _inst_1 _inst_2) {x : S₁} {y : S₁}, Eq.{succ u1} S₂ (ShelfHom.toFun.{u2, u1} S₁ S₂ _inst_1 _inst_2 f (Shelf.act.{u2} S₁ _inst_1 x y)) (Shelf.act.{u1} S₂ _inst_2 (ShelfHom.toFun.{u2, u1} S₁ S₂ _inst_1 _inst_2 f x) (ShelfHom.toFun.{u2, u1} S₁ S₂ _inst_1 _inst_2 f y))
-Case conversion may be inaccurate. Consider using '#align shelf_hom.map_act ShelfHom.map_actₓ'. -/
 @[simp]
 theorem map_act (f : S₁ →◃ S₂) {x y : S₁} : f (x ◃ y) = f x ◃ f y :=
   map_act' f
@@ -464,12 +447,6 @@ def comp (g : S₂ →◃ S₃) (f : S₁ →◃ S₂) : S₁ →◃ S₃
 #align shelf_hom.comp ShelfHom.comp
 -/
 
-/- warning: shelf_hom.comp_apply -> ShelfHom.comp_apply is a dubious translation:
-lean 3 declaration is
-  forall {S₁ : Type.{u1}} {S₂ : Type.{u2}} {S₃ : Type.{u3}} [_inst_1 : Shelf.{u1} S₁] [_inst_2 : Shelf.{u2} S₂] [_inst_3 : Shelf.{u3} S₃] (g : ShelfHom.{u2, u3} S₂ S₃ _inst_2 _inst_3) (f : ShelfHom.{u1, u2} S₁ S₂ _inst_1 _inst_2) (x : S₁), Eq.{succ u3} S₃ (coeFn.{max (succ u1) (succ u3), max (succ u1) (succ u3)} (ShelfHom.{u1, u3} S₁ S₃ _inst_1 _inst_3) (fun (_x : ShelfHom.{u1, u3} S₁ S₃ _inst_1 _inst_3) => S₁ -> S₃) (ShelfHom.hasCoeToFun.{u1, u3} S₁ S₃ _inst_1 _inst_3) (ShelfHom.comp.{u1, u2, u3} S₁ S₂ S₃ _inst_1 _inst_2 _inst_3 g f) x) (coeFn.{max (succ u2) (succ u3), max (succ u2) (succ u3)} (ShelfHom.{u2, u3} S₂ S₃ _inst_2 _inst_3) (fun (_x : ShelfHom.{u2, u3} S₂ S₃ _inst_2 _inst_3) => S₂ -> S₃) (ShelfHom.hasCoeToFun.{u2, u3} S₂ S₃ _inst_2 _inst_3) g (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (ShelfHom.{u1, u2} S₁ S₂ _inst_1 _inst_2) (fun (_x : ShelfHom.{u1, u2} S₁ S₂ _inst_1 _inst_2) => S₁ -> S₂) (ShelfHom.hasCoeToFun.{u1, u2} S₁ S₂ _inst_1 _inst_2) f x))
-but is expected to have type
-  forall {S₁ : Type.{u1}} {S₂ : Type.{u3}} {S₃ : Type.{u2}} [_inst_1 : Shelf.{u1} S₁] [_inst_2 : Shelf.{u3} S₂] [_inst_3 : Shelf.{u2} S₃] (g : ShelfHom.{u3, u2} S₂ S₃ _inst_2 _inst_3) (f : ShelfHom.{u1, u3} S₁ S₂ _inst_1 _inst_2) (x : S₁), Eq.{succ u2} S₃ (ShelfHom.toFun.{u1, u2} S₁ S₃ _inst_1 _inst_3 (ShelfHom.comp.{u1, u3, u2} S₁ S₂ S₃ _inst_1 _inst_2 _inst_3 g f) x) (ShelfHom.toFun.{u3, u2} S₂ S₃ _inst_2 _inst_3 g (ShelfHom.toFun.{u1, u3} S₁ S₂ _inst_1 _inst_2 f x))
-Case conversion may be inaccurate. Consider using '#align shelf_hom.comp_apply ShelfHom.comp_applyₓ'. -/
 @[simp]
 theorem comp_apply (g : S₂ →◃ S₃) (f : S₁ →◃ S₂) (x : S₁) : (g.comp f) x = g (f x) :=
   rfl
@@ -529,12 +506,6 @@ instance Conj.quandle (G : Type _) [Group G] : Quandle (Conj G)
 #align quandle.conj.quandle Quandle.Conj.quandle
 -/
 
-/- warning: quandle.conj_act_eq_conj -> Quandle.conj_act_eq_conj is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_2 : Group.{u1} G] (x : Quandle.Conj.{u1} G) (y : Quandle.Conj.{u1} G), Eq.{succ u1} (Quandle.Conj.{u1} G) (Shelf.act.{u1} (Quandle.Conj.{u1} G) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2))) x y) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))))) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))))) x y) (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)) x))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_2 : Group.{u1} G] (x : Quandle.Conj.{u1} G) (y : Quandle.Conj.{u1} G), Eq.{succ u1} (Quandle.Conj.{u1} G) (Shelf.act.{u1} (Quandle.Conj.{u1} G) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2))) x y) (HMul.hMul.{u1, u1, u1} (Quandle.Conj.{u1} G) (Quandle.Conj.{u1} G) (Quandle.Conj.{u1} G) (instHMul.{u1} (Quandle.Conj.{u1} G) (MulOneClass.toMul.{u1} (Quandle.Conj.{u1} G) (Monoid.toMulOneClass.{u1} (Quandle.Conj.{u1} G) (DivInvMonoid.toMonoid.{u1} (Quandle.Conj.{u1} G) (Group.toDivInvMonoid.{u1} (Quandle.Conj.{u1} G) _inst_2))))) (HMul.hMul.{u1, u1, u1} (Quandle.Conj.{u1} G) (Quandle.Conj.{u1} G) (Quandle.Conj.{u1} G) (instHMul.{u1} (Quandle.Conj.{u1} G) (MulOneClass.toMul.{u1} (Quandle.Conj.{u1} G) (Monoid.toMulOneClass.{u1} (Quandle.Conj.{u1} G) (DivInvMonoid.toMonoid.{u1} (Quandle.Conj.{u1} G) (Group.toDivInvMonoid.{u1} (Quandle.Conj.{u1} G) _inst_2))))) x y) (Inv.inv.{u1} (Quandle.Conj.{u1} G) (InvOneClass.toInv.{u1} (Quandle.Conj.{u1} G) (DivInvOneMonoid.toInvOneClass.{u1} (Quandle.Conj.{u1} G) (DivisionMonoid.toDivInvOneMonoid.{u1} (Quandle.Conj.{u1} G) (Group.toDivisionMonoid.{u1} (Quandle.Conj.{u1} G) _inst_2)))) x))
-Case conversion may be inaccurate. Consider using '#align quandle.conj_act_eq_conj Quandle.conj_act_eq_conjₓ'. -/
 @[simp]
 theorem conj_act_eq_conj {G : Type _} [Group G] (x y : Conj G) :
     x ◃ y = ((x : G) * (y : G) * (x : G)⁻¹ : G) :=
@@ -814,12 +785,6 @@ instance EnvelGroup.inhabited (R : Type _) [Rack R] : Inhabited (EnvelGroup R) :
 #align rack.envel_group.inhabited Rack.EnvelGroup.inhabited
 -/
 
-/- warning: rack.to_envel_group -> Rack.toEnvelGroup is a dubious translation:
-lean 3 declaration is
-  forall (R : Type.{u1}) [_inst_1 : Rack.{u1} R], ShelfHom.{u1, u1} R (Quandle.Conj.{u1} (Rack.EnvelGroup.{u1} R _inst_1)) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} (Rack.EnvelGroup.{u1} R _inst_1)) (Quandle.toRack.{u1} (Quandle.Conj.{u1} (Rack.EnvelGroup.{u1} R _inst_1)) (Quandle.Conj.quandle.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.group.{u1} R _inst_1))))
-but is expected to have type
-  forall (R : Type.{u1}) [_inst_1 : Rack.{u1} R], ShelfHom.{u1, u1} R (Quandle.Conj.{u1} (Rack.EnvelGroup.{u1} R _inst_1)) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} (Rack.EnvelGroup.{u1} R _inst_1)) (Quandle.toRack.{u1} (Quandle.Conj.{u1} (Rack.EnvelGroup.{u1} R _inst_1)) (Quandle.Conj.quandle.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.instGroupEnvelGroup.{u1} R _inst_1))))
-Case conversion may be inaccurate. Consider using '#align rack.to_envel_group Rack.toEnvelGroupₓ'. -/
 /-- The canonical homomorphism from a rack to its enveloping group.
 Satisfies universal properties given by `to_envel_group.map` and `to_envel_group.univ`.
 -/
@@ -846,12 +811,6 @@ namespace ToEnvelGroup.MapAux
 
 open PreEnvelGroupRel'
 
-/- warning: rack.to_envel_group.map_aux.well_def -> Rack.toEnvelGroup.mapAux.well_def is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : Rack.{u1} R] {G : Type.{u2}} [_inst_2 : Group.{u2} G] (f : ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) {a : Rack.PreEnvelGroup.{u1} R} {b : Rack.PreEnvelGroup.{u1} R}, (Rack.PreEnvelGroupRel'.{u1} R _inst_1 a b) -> (Eq.{succ u2} G (Rack.toEnvelGroup.mapAux.{u1, u2} R _inst_1 G _inst_2 f a) (Rack.toEnvelGroup.mapAux.{u1, u2} R _inst_1 G _inst_2 f b))
-but is expected to have type
-  forall {R : Type.{u2}} [_inst_1 : Rack.{u2} R] {G : Type.{u1}} [_inst_2 : Group.{u1} G] (f : ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) {a : Rack.PreEnvelGroup.{u2} R} {b : Rack.PreEnvelGroup.{u2} R}, (Rack.PreEnvelGroupRel'.{u2} R _inst_1 a b) -> (Eq.{succ u1} G (Rack.toEnvelGroup.mapAux.{u2, u1} R _inst_1 G _inst_2 f a) (Rack.toEnvelGroup.mapAux.{u2, u1} R _inst_1 G _inst_2 f b))
-Case conversion may be inaccurate. Consider using '#align rack.to_envel_group.map_aux.well_def Rack.toEnvelGroup.mapAux.well_defₓ'. -/
 /-- Show that `to_envel_group.map_aux` sends equivalent expressions to equal terms.
 -/
 theorem well_def {R : Type _} [Rack R] {G : Type _} [Group G] (f : R →◃ Quandle.Conj G) :
@@ -871,12 +830,6 @@ theorem well_def {R : Type _} [Rack R] {G : Type _} [Group G] (f : R →◃ Quan
 
 end ToEnvelGroup.MapAux
 
-/- warning: rack.to_envel_group.map -> Rack.toEnvelGroup.map is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : Rack.{u1} R] {G : Type.{u2}} [_inst_2 : Group.{u2} G], Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) (MonoidHom.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Monoid.toMulOneClass.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.divInvMonoid.{u1} R _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : Rack.{u1} R] {G : Type.{u2}} [_inst_2 : Group.{u2} G], Equiv.{max (succ u2) (succ u1), max (succ u2) (succ u1)} (ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) (MonoidHom.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Monoid.toMulOneClass.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u1} R _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))))
-Case conversion may be inaccurate. Consider using '#align rack.to_envel_group.map Rack.toEnvelGroup.mapₓ'. -/
 /-- Given a map from a rack to a group, lift it to being a map from the enveloping group.
 More precisely, the `envel_group` functor is left adjoint to `quandle.conj`.
 -/
@@ -910,12 +863,6 @@ def toEnvelGroup.map {R : Type _} [Rack R] {G : Type _} [Group G] :
           rw [hm, F.map_inv, MonoidHom.map_inv, x_ih]
 #align rack.to_envel_group.map Rack.toEnvelGroup.map
 
-/- warning: rack.to_envel_group.univ -> Rack.toEnvelGroup.univ is a dubious translation:
-lean 3 declaration is
-  forall (R : Type.{u1}) [_inst_1 : Rack.{u1} R] (G : Type.{u2}) [_inst_2 : Group.{u2} G] (f : ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))), Eq.{max (succ u1) (succ u2)} (ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) (ShelfHom.comp.{u1, u1, u2} R (Quandle.Conj.{u1} (Rack.EnvelGroup.{u1} R _inst_1)) (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} (Rack.EnvelGroup.{u1} R _inst_1)) (Quandle.toRack.{u1} (Quandle.Conj.{u1} (Rack.EnvelGroup.{u1} R _inst_1)) (Quandle.Conj.quandle.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.group.{u1} R _inst_1)))) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2))) (Quandle.Conj.map.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Rack.EnvelGroup.group.{u1} R _inst_1) _inst_2 (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) (MonoidHom.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Monoid.toMulOneClass.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.divInvMonoid.{u1} R _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) (MonoidHom.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Monoid.toMulOneClass.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.divInvMonoid.{u1} R _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))))) => (ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) -> (MonoidHom.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Monoid.toMulOneClass.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.divInvMonoid.{u1} R _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) (MonoidHom.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Monoid.toMulOneClass.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.divInvMonoid.{u1} R _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))))) (Rack.toEnvelGroup.map.{u1, u2} R _inst_1 G _inst_2) f)) (Rack.toEnvelGroup.{u1} R _inst_1)) f
-but is expected to have type
-  forall (R : Type.{u2}) [_inst_1 : Rack.{u2} R] (G : Type.{u1}) [_inst_2 : Group.{u1} G] (f : ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))), Eq.{max (succ u2) (succ u1)} (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (ShelfHom.comp.{u2, u2, u1} R (Quandle.Conj.{u2} (Rack.EnvelGroup.{u2} R _inst_1)) (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} (Rack.EnvelGroup.{u2} R _inst_1)) (Quandle.toRack.{u2} (Quandle.Conj.{u2} (Rack.EnvelGroup.{u2} R _inst_1)) (Quandle.Conj.quandle.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instGroupEnvelGroup.{u2} R _inst_1)))) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2))) (Quandle.Conj.map.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Rack.instGroupEnvelGroup.{u2} R _inst_1) _inst_2 (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))))) (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (fun (_x : ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) => MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))))) (Rack.toEnvelGroup.map.{u2, u1} R _inst_1 G _inst_2) f)) (Rack.toEnvelGroup.{u2} R _inst_1)) f
-Case conversion may be inaccurate. Consider using '#align rack.to_envel_group.univ Rack.toEnvelGroup.univₓ'. -/
 /-- Given a homomorphism from a rack to a group, it factors through the enveloping group.
 -/
 theorem toEnvelGroup.univ (R : Type _) [Rack R] (G : Type _) [Group G] (f : R →◃ Quandle.Conj G) :
@@ -923,12 +870,6 @@ theorem toEnvelGroup.univ (R : Type _) [Rack R] (G : Type _) [Group G] (f : R 
   toEnvelGroup.map.symm_apply_apply f
 #align rack.to_envel_group.univ Rack.toEnvelGroup.univ
 
-/- warning: rack.to_envel_group.univ_uniq -> Rack.toEnvelGroup.univ_uniq is a dubious translation:
-lean 3 declaration is
-  forall (R : Type.{u1}) [_inst_1 : Rack.{u1} R] (G : Type.{u2}) [_inst_2 : Group.{u2} G] (f : ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) (g : MonoidHom.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Monoid.toMulOneClass.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.divInvMonoid.{u1} R _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))), (Eq.{max (succ u1) (succ u2)} (ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) f (ShelfHom.comp.{u1, u1, u2} R (Quandle.Conj.{u1} (Rack.EnvelGroup.{u1} R _inst_1)) (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} (Rack.EnvelGroup.{u1} R _inst_1)) (Quandle.toRack.{u1} (Quandle.Conj.{u1} (Rack.EnvelGroup.{u1} R _inst_1)) (Quandle.Conj.quandle.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.group.{u1} R _inst_1)))) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2))) (Quandle.Conj.map.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Rack.EnvelGroup.group.{u1} R _inst_1) _inst_2 g) (Rack.toEnvelGroup.{u1} R _inst_1))) -> (Eq.{max (succ u2) (succ u1)} (MonoidHom.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Monoid.toMulOneClass.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.divInvMonoid.{u1} R _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))) g (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) (MonoidHom.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Monoid.toMulOneClass.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.divInvMonoid.{u1} R _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) (MonoidHom.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Monoid.toMulOneClass.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.divInvMonoid.{u1} R _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))))) => (ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) -> (MonoidHom.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Monoid.toMulOneClass.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.divInvMonoid.{u1} R _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) (MonoidHom.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Monoid.toMulOneClass.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.divInvMonoid.{u1} R _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))))) (Rack.toEnvelGroup.map.{u1, u2} R _inst_1 G _inst_2) f))
-but is expected to have type
-  forall (R : Type.{u2}) [_inst_1 : Rack.{u2} R] (G : Type.{u1}) [_inst_2 : Group.{u1} G] (f : ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (g : MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))), (Eq.{max (succ u2) (succ u1)} (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) f (ShelfHom.comp.{u2, u2, u1} R (Quandle.Conj.{u2} (Rack.EnvelGroup.{u2} R _inst_1)) (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} (Rack.EnvelGroup.{u2} R _inst_1)) (Quandle.toRack.{u2} (Quandle.Conj.{u2} (Rack.EnvelGroup.{u2} R _inst_1)) (Quandle.Conj.quandle.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instGroupEnvelGroup.{u2} R _inst_1)))) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2))) (Quandle.Conj.map.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Rack.instGroupEnvelGroup.{u2} R _inst_1) _inst_2 g) (Rack.toEnvelGroup.{u2} R _inst_1))) -> (Eq.{max (succ u2) (succ u1)} (MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) g (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))))) (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (fun (_x : ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) => MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))))) (Rack.toEnvelGroup.map.{u2, u1} R _inst_1 G _inst_2) f))
-Case conversion may be inaccurate. Consider using '#align rack.to_envel_group.univ_uniq Rack.toEnvelGroup.univ_uniqₓ'. -/
 /-- The homomorphism `to_envel_group.map f` is the unique map that fits into the commutative
 triangle in `to_envel_group.univ`.
 -/
@@ -938,12 +879,6 @@ theorem toEnvelGroup.univ_uniq (R : Type _) [Rack R] (G : Type _) [Group G]
   h.symm ▸ (toEnvelGroup.map.apply_symm_apply g).symm
 #align rack.to_envel_group.univ_uniq Rack.toEnvelGroup.univ_uniq
 
-/- warning: rack.envel_action -> Rack.envelAction is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : Rack.{u1} R], MonoidHom.{u1, u1} (Rack.EnvelGroup.{u1} R _inst_1) (Equiv.{succ u1, succ u1} R R) (Monoid.toMulOneClass.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.divInvMonoid.{u1} R _inst_1))) (Monoid.toMulOneClass.{u1} (Equiv.{succ u1, succ u1} R R) (DivInvMonoid.toMonoid.{u1} (Equiv.{succ u1, succ u1} R R) (Group.toDivInvMonoid.{u1} (Equiv.{succ u1, succ u1} R R) (Equiv.Perm.permGroup.{u1} R))))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : Rack.{u1} R], MonoidHom.{u1, u1} (Rack.EnvelGroup.{u1} R _inst_1) (Equiv.{succ u1, succ u1} R R) (Monoid.toMulOneClass.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u1} R _inst_1))) (Monoid.toMulOneClass.{u1} (Equiv.{succ u1, succ u1} R R) (DivInvMonoid.toMonoid.{u1} (Equiv.{succ u1, succ u1} R R) (Group.toDivInvMonoid.{u1} (Equiv.{succ u1, succ u1} R R) (Equiv.Perm.permGroup.{u1} R))))
-Case conversion may be inaccurate. Consider using '#align rack.envel_action Rack.envelActionₓ'. -/
 /-- The induced group homomorphism from the enveloping group into bijections of the rack,
 using `rack.to_conj`. Satisfies the property `envel_action_prop`.

28aa996f

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -250,22 +250,14 @@ theorem act_invAct_eq (x y : R) : x ◃ x ◃⁻¹ y = y :=
 -/
 
 #print Rack.left_cancel /-
-theorem left_cancel (x : R) {y y' : R} : x ◃ y = x ◃ y' ↔ y = y' :=
-  by
-  constructor
-  apply (act x).Injective
-  rintro rfl
-  rfl
+theorem left_cancel (x : R) {y y' : R} : x ◃ y = x ◃ y' ↔ y = y' := by constructor;
+  apply (act x).Injective; rintro rfl; rfl
 #align rack.left_cancel Rack.left_cancel
 -/
 
 #print Rack.left_cancel_inv /-
-theorem left_cancel_inv (x : R) {y y' : R} : x ◃⁻¹ y = x ◃⁻¹ y' ↔ y = y' :=
-  by
-  constructor
-  apply (act x).symm.Injective
-  rintro rfl
-  rfl
+theorem left_cancel_inv (x : R) {y y' : R} : x ◃⁻¹ y = x ◃⁻¹ y' ↔ y = y' := by constructor;
+  apply (act x).symm.Injective; rintro rfl; rfl
 #align rack.left_cancel_inv Rack.left_cancel_inv
 -/
 
@@ -336,30 +328,22 @@ theorem self_act_act_eq {x y : R} : (x ◃ x) ◃ y = x ◃ y := by rw [← righ
 
 #print Rack.self_invAct_invAct_eq /-
 @[simp]
-theorem self_invAct_invAct_eq {x y : R} : (x ◃⁻¹ x) ◃⁻¹ y = x ◃⁻¹ y :=
-  by
-  have h := @self_act_act_eq _ _ (op x) (op y)
-  simpa using h
+theorem self_invAct_invAct_eq {x y : R} : (x ◃⁻¹ x) ◃⁻¹ y = x ◃⁻¹ y := by
+  have h := @self_act_act_eq _ _ (op x) (op y); simpa using h
 #align rack.self_inv_act_inv_act_eq Rack.self_invAct_invAct_eq
 -/
 
 #print Rack.self_act_invAct_eq /-
 @[simp]
-theorem self_act_invAct_eq {x y : R} : (x ◃ x) ◃⁻¹ y = x ◃⁻¹ y :=
-  by
-  rw [← left_cancel (x ◃ x)]
-  rw [right_inv]
-  rw [self_act_act_eq]
-  rw [right_inv]
+theorem self_act_invAct_eq {x y : R} : (x ◃ x) ◃⁻¹ y = x ◃⁻¹ y := by rw [← left_cancel (x ◃ x)];
+  rw [right_inv]; rw [self_act_act_eq]; rw [right_inv]
 #align rack.self_act_inv_act_eq Rack.self_act_invAct_eq
 -/
 
 #print Rack.self_invAct_act_eq /-
 @[simp]
-theorem self_invAct_act_eq {x y : R} : (x ◃⁻¹ x) ◃ y = x ◃ y :=
-  by
-  have h := @self_act_inv_act_eq _ _ (op x) (op y)
-  simpa using h
+theorem self_invAct_act_eq {x y : R} : (x ◃⁻¹ x) ◃ y = x ◃ y := by
+  have h := @self_act_inv_act_eq _ _ (op x) (op y); simpa using h
 #align rack.self_inv_act_act_eq Rack.self_invAct_act_eq
 -/
 
@@ -375,10 +359,8 @@ theorem self_act_eq_iff_eq {x y : R} : x ◃ x = y ◃ y ↔ x = y :=
 -/
 
 #print Rack.self_invAct_eq_iff_eq /-
-theorem self_invAct_eq_iff_eq {x y : R} : x ◃⁻¹ x = y ◃⁻¹ y ↔ x = y :=
-  by
-  have h := @self_act_eq_iff_eq _ _ (op x) (op y)
-  simpa using h
+theorem self_invAct_eq_iff_eq {x y : R} : x ◃⁻¹ x = y ◃⁻¹ y ↔ x = y := by
+  have h := @self_act_eq_iff_eq _ _ (op x) (op y); simpa using h
 #align rack.self_inv_act_eq_iff_eq Rack.self_invAct_eq_iff_eq
 -/
 
@@ -422,10 +404,8 @@ def IsAbelian (R : Type _) [Rack R] : Prop :=
 #print Rack.assoc_iff_id /-
 /-- Associative racks are uninteresting.
 -/
-theorem assoc_iff_id {R : Type _} [Rack R] {x y z : R} : x ◃ y ◃ z = (x ◃ y) ◃ z ↔ x ◃ z = z :=
-  by
-  rw [self_distrib]
-  rw [left_cancel]
+theorem assoc_iff_id {R : Type _} [Rack R] {x y z : R} : x ◃ y ◃ z = (x ◃ y) ◃ z ↔ x ◃ z = z := by
+  rw [self_distrib]; rw [left_cancel]
 #align rack.assoc_iff_id Rack.assoc_iff_id
 -/
 
@@ -515,18 +495,12 @@ attribute [simp] fix
 
 #print Quandle.fix_inv /-
 @[simp]
-theorem fix_inv {x : Q} : x ◃⁻¹ x = x :=
-  by
-  rw [← left_cancel x]
-  simp
+theorem fix_inv {x : Q} : x ◃⁻¹ x = x := by rw [← left_cancel x]; simp
 #align quandle.fix_inv Quandle.fix_inv
 -/
 
 #print Quandle.oppositeQuandle /-
-instance oppositeQuandle : Quandle Qᵐᵒᵖ
-    where fix x := by
-    induction x using MulOpposite.rec'
-    simp
+instance oppositeQuandle : Quandle Qᵐᵒᵖ where fix x := by induction x using MulOpposite.rec'; simp
 #align quandle.opposite_quandle Quandle.oppositeQuandle
 -/
 
@@ -549,12 +523,8 @@ instance Conj.quandle (G : Type _) [Group G] : Quandle (Conj G)
     dsimp only [MulEquiv.coe_toEquiv, MulAut.conj_apply, conj]
     group
   invAct x := (@MulAut.conj G _ x).symm
-  left_inv x y := by
-    dsimp [act, conj]
-    group
-  right_inv x y := by
-    dsimp [act, conj]
-    group
+  left_inv x y := by dsimp [act, conj]; group
+  right_inv x y := by dsimp [act, conj]; group
   fix x := by simp
 #align quandle.conj.quandle Quandle.Conj.quandle
 -/
@@ -612,11 +582,8 @@ def dihedralAct (n : ℕ) (a : ZMod n) : ZMod n → ZMod n := fun b => 2 * a - b
 -/
 
 #print Quandle.dihedralAct.inv /-
-theorem dihedralAct.inv (n : ℕ) (a : ZMod n) : Function.Involutive (dihedralAct n a) :=
-  by
-  intro b
-  dsimp [dihedral_act]
-  ring
+theorem dihedralAct.inv (n : ℕ) (a : ZMod n) : Function.Involutive (dihedralAct n a) := by intro b;
+  dsimp [dihedral_act]; ring
 #align quandle.dihedral_act.inv Quandle.dihedralAct.inv
 -/
 
@@ -930,9 +897,7 @@ def toEnvelGroup.map {R : Type _} [Rack R] {G : Type _} [Group G] :
           change Quotient.liftOn ⟦mul x y⟧ (to_envel_group.map_aux f) _ = _
           simp [to_envel_group.map_aux] }
   invFun F := (Quandle.Conj.map F).comp (toEnvelGroup R)
-  left_inv f := by
-    ext
-    rfl
+  left_inv f := by ext; rfl
   right_inv F :=
     MonoidHom.ext fun x =>
       Quotient.inductionOn x fun x => by

28aa996f

bump to nightly-2023-05-19-16

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

a31df521

Diff

@@ -949,7 +949,7 @@ def toEnvelGroup.map {R : Type _} [Rack R] {G : Type _} [Group G] :
 lean 3 declaration is
   forall (R : Type.{u1}) [_inst_1 : Rack.{u1} R] (G : Type.{u2}) [_inst_2 : Group.{u2} G] (f : ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))), Eq.{max (succ u1) (succ u2)} (ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) (ShelfHom.comp.{u1, u1, u2} R (Quandle.Conj.{u1} (Rack.EnvelGroup.{u1} R _inst_1)) (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} (Rack.EnvelGroup.{u1} R _inst_1)) (Quandle.toRack.{u1} (Quandle.Conj.{u1} (Rack.EnvelGroup.{u1} R _inst_1)) (Quandle.Conj.quandle.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.group.{u1} R _inst_1)))) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2))) (Quandle.Conj.map.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Rack.EnvelGroup.group.{u1} R _inst_1) _inst_2 (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) (MonoidHom.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Monoid.toMulOneClass.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.divInvMonoid.{u1} R _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) (MonoidHom.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Monoid.toMulOneClass.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.divInvMonoid.{u1} R _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))))) => (ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) -> (MonoidHom.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Monoid.toMulOneClass.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.divInvMonoid.{u1} R _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) (MonoidHom.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Monoid.toMulOneClass.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.divInvMonoid.{u1} R _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))))) (Rack.toEnvelGroup.map.{u1, u2} R _inst_1 G _inst_2) f)) (Rack.toEnvelGroup.{u1} R _inst_1)) f
 but is expected to have type
-  forall (R : Type.{u2}) [_inst_1 : Rack.{u2} R] (G : Type.{u1}) [_inst_2 : Group.{u1} G] (f : ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))), Eq.{max (succ u2) (succ u1)} (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (ShelfHom.comp.{u2, u2, u1} R (Quandle.Conj.{u2} (Rack.EnvelGroup.{u2} R _inst_1)) (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} (Rack.EnvelGroup.{u2} R _inst_1)) (Quandle.toRack.{u2} (Quandle.Conj.{u2} (Rack.EnvelGroup.{u2} R _inst_1)) (Quandle.Conj.quandle.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instGroupEnvelGroup.{u2} R _inst_1)))) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2))) (Quandle.Conj.map.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Rack.instGroupEnvelGroup.{u2} R _inst_1) _inst_2 (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))))) (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (fun (_x : ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) => MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))))) (Rack.toEnvelGroup.map.{u2, u1} R _inst_1 G _inst_2) f)) (Rack.toEnvelGroup.{u2} R _inst_1)) f
+  forall (R : Type.{u2}) [_inst_1 : Rack.{u2} R] (G : Type.{u1}) [_inst_2 : Group.{u1} G] (f : ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))), Eq.{max (succ u2) (succ u1)} (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (ShelfHom.comp.{u2, u2, u1} R (Quandle.Conj.{u2} (Rack.EnvelGroup.{u2} R _inst_1)) (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} (Rack.EnvelGroup.{u2} R _inst_1)) (Quandle.toRack.{u2} (Quandle.Conj.{u2} (Rack.EnvelGroup.{u2} R _inst_1)) (Quandle.Conj.quandle.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instGroupEnvelGroup.{u2} R _inst_1)))) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2))) (Quandle.Conj.map.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Rack.instGroupEnvelGroup.{u2} R _inst_1) _inst_2 (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))))) (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (fun (_x : ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) => MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))))) (Rack.toEnvelGroup.map.{u2, u1} R _inst_1 G _inst_2) f)) (Rack.toEnvelGroup.{u2} R _inst_1)) f
 Case conversion may be inaccurate. Consider using '#align rack.to_envel_group.univ Rack.toEnvelGroup.univₓ'. -/
 /-- Given a homomorphism from a rack to a group, it factors through the enveloping group.
 -/
@@ -962,7 +962,7 @@ theorem toEnvelGroup.univ (R : Type _) [Rack R] (G : Type _) [Group G] (f : R 
 lean 3 declaration is
   forall (R : Type.{u1}) [_inst_1 : Rack.{u1} R] (G : Type.{u2}) [_inst_2 : Group.{u2} G] (f : ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) (g : MonoidHom.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Monoid.toMulOneClass.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.divInvMonoid.{u1} R _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))), (Eq.{max (succ u1) (succ u2)} (ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) f (ShelfHom.comp.{u1, u1, u2} R (Quandle.Conj.{u1} (Rack.EnvelGroup.{u1} R _inst_1)) (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} (Rack.EnvelGroup.{u1} R _inst_1)) (Quandle.toRack.{u1} (Quandle.Conj.{u1} (Rack.EnvelGroup.{u1} R _inst_1)) (Quandle.Conj.quandle.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.group.{u1} R _inst_1)))) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2))) (Quandle.Conj.map.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Rack.EnvelGroup.group.{u1} R _inst_1) _inst_2 g) (Rack.toEnvelGroup.{u1} R _inst_1))) -> (Eq.{max (succ u2) (succ u1)} (MonoidHom.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Monoid.toMulOneClass.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.divInvMonoid.{u1} R _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))) g (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) (MonoidHom.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Monoid.toMulOneClass.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.divInvMonoid.{u1} R _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) (MonoidHom.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Monoid.toMulOneClass.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.divInvMonoid.{u1} R _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))))) => (ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) -> (MonoidHom.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Monoid.toMulOneClass.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.divInvMonoid.{u1} R _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) (MonoidHom.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Monoid.toMulOneClass.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.divInvMonoid.{u1} R _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))))) (Rack.toEnvelGroup.map.{u1, u2} R _inst_1 G _inst_2) f))
 but is expected to have type
-  forall (R : Type.{u2}) [_inst_1 : Rack.{u2} R] (G : Type.{u1}) [_inst_2 : Group.{u1} G] (f : ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (g : MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))), (Eq.{max (succ u2) (succ u1)} (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) f (ShelfHom.comp.{u2, u2, u1} R (Quandle.Conj.{u2} (Rack.EnvelGroup.{u2} R _inst_1)) (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} (Rack.EnvelGroup.{u2} R _inst_1)) (Quandle.toRack.{u2} (Quandle.Conj.{u2} (Rack.EnvelGroup.{u2} R _inst_1)) (Quandle.Conj.quandle.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instGroupEnvelGroup.{u2} R _inst_1)))) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2))) (Quandle.Conj.map.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Rack.instGroupEnvelGroup.{u2} R _inst_1) _inst_2 g) (Rack.toEnvelGroup.{u2} R _inst_1))) -> (Eq.{max (succ u2) (succ u1)} (MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) g (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))))) (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (fun (_x : ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) => MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))))) (Rack.toEnvelGroup.map.{u2, u1} R _inst_1 G _inst_2) f))
+  forall (R : Type.{u2}) [_inst_1 : Rack.{u2} R] (G : Type.{u1}) [_inst_2 : Group.{u1} G] (f : ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (g : MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))), (Eq.{max (succ u2) (succ u1)} (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) f (ShelfHom.comp.{u2, u2, u1} R (Quandle.Conj.{u2} (Rack.EnvelGroup.{u2} R _inst_1)) (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} (Rack.EnvelGroup.{u2} R _inst_1)) (Quandle.toRack.{u2} (Quandle.Conj.{u2} (Rack.EnvelGroup.{u2} R _inst_1)) (Quandle.Conj.quandle.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instGroupEnvelGroup.{u2} R _inst_1)))) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2))) (Quandle.Conj.map.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Rack.instGroupEnvelGroup.{u2} R _inst_1) _inst_2 g) (Rack.toEnvelGroup.{u2} R _inst_1))) -> (Eq.{max (succ u2) (succ u1)} (MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) g (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))))) (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (fun (_x : ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) => MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))))) (Rack.toEnvelGroup.map.{u2, u1} R _inst_1 G _inst_2) f))
 Case conversion may be inaccurate. Consider using '#align rack.to_envel_group.univ_uniq Rack.toEnvelGroup.univ_uniqₓ'. -/
 /-- The homomorphism `to_envel_group.map f` is the unique map that fits into the commutative
 triangle in `to_envel_group.univ`.

28aa996f

bump to nightly-2023-03-11-22

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

a8ee822f

Diff

@@ -949,7 +949,7 @@ def toEnvelGroup.map {R : Type _} [Rack R] {G : Type _} [Group G] :
 lean 3 declaration is
   forall (R : Type.{u1}) [_inst_1 : Rack.{u1} R] (G : Type.{u2}) [_inst_2 : Group.{u2} G] (f : ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))), Eq.{max (succ u1) (succ u2)} (ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) (ShelfHom.comp.{u1, u1, u2} R (Quandle.Conj.{u1} (Rack.EnvelGroup.{u1} R _inst_1)) (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} (Rack.EnvelGroup.{u1} R _inst_1)) (Quandle.toRack.{u1} (Quandle.Conj.{u1} (Rack.EnvelGroup.{u1} R _inst_1)) (Quandle.Conj.quandle.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.group.{u1} R _inst_1)))) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2))) (Quandle.Conj.map.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Rack.EnvelGroup.group.{u1} R _inst_1) _inst_2 (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) (MonoidHom.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Monoid.toMulOneClass.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.divInvMonoid.{u1} R _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) (MonoidHom.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Monoid.toMulOneClass.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.divInvMonoid.{u1} R _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))))) => (ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) -> (MonoidHom.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Monoid.toMulOneClass.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.divInvMonoid.{u1} R _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) (MonoidHom.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Monoid.toMulOneClass.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.divInvMonoid.{u1} R _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))))) (Rack.toEnvelGroup.map.{u1, u2} R _inst_1 G _inst_2) f)) (Rack.toEnvelGroup.{u1} R _inst_1)) f
 but is expected to have type
-  forall (R : Type.{u2}) [_inst_1 : Rack.{u2} R] (G : Type.{u1}) [_inst_2 : Group.{u1} G] (f : ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))), Eq.{max (succ u2) (succ u1)} (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (ShelfHom.comp.{u2, u2, u1} R (Quandle.Conj.{u2} (Rack.EnvelGroup.{u2} R _inst_1)) (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} (Rack.EnvelGroup.{u2} R _inst_1)) (Quandle.toRack.{u2} (Quandle.Conj.{u2} (Rack.EnvelGroup.{u2} R _inst_1)) (Quandle.Conj.quandle.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instGroupEnvelGroup.{u2} R _inst_1)))) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2))) (Quandle.Conj.map.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Rack.instGroupEnvelGroup.{u2} R _inst_1) _inst_2 (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))))) (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (fun (_x : ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) => MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))))) (Rack.toEnvelGroup.map.{u2, u1} R _inst_1 G _inst_2) f)) (Rack.toEnvelGroup.{u2} R _inst_1)) f
+  forall (R : Type.{u2}) [_inst_1 : Rack.{u2} R] (G : Type.{u1}) [_inst_2 : Group.{u1} G] (f : ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))), Eq.{max (succ u2) (succ u1)} (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (ShelfHom.comp.{u2, u2, u1} R (Quandle.Conj.{u2} (Rack.EnvelGroup.{u2} R _inst_1)) (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} (Rack.EnvelGroup.{u2} R _inst_1)) (Quandle.toRack.{u2} (Quandle.Conj.{u2} (Rack.EnvelGroup.{u2} R _inst_1)) (Quandle.Conj.quandle.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instGroupEnvelGroup.{u2} R _inst_1)))) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2))) (Quandle.Conj.map.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Rack.instGroupEnvelGroup.{u2} R _inst_1) _inst_2 (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))))) (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (fun (_x : ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) => MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))))) (Rack.toEnvelGroup.map.{u2, u1} R _inst_1 G _inst_2) f)) (Rack.toEnvelGroup.{u2} R _inst_1)) f
 Case conversion may be inaccurate. Consider using '#align rack.to_envel_group.univ Rack.toEnvelGroup.univₓ'. -/
 /-- Given a homomorphism from a rack to a group, it factors through the enveloping group.
 -/
@@ -962,7 +962,7 @@ theorem toEnvelGroup.univ (R : Type _) [Rack R] (G : Type _) [Group G] (f : R 
 lean 3 declaration is
   forall (R : Type.{u1}) [_inst_1 : Rack.{u1} R] (G : Type.{u2}) [_inst_2 : Group.{u2} G] (f : ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) (g : MonoidHom.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Monoid.toMulOneClass.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.divInvMonoid.{u1} R _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))), (Eq.{max (succ u1) (succ u2)} (ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) f (ShelfHom.comp.{u1, u1, u2} R (Quandle.Conj.{u1} (Rack.EnvelGroup.{u1} R _inst_1)) (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} (Rack.EnvelGroup.{u1} R _inst_1)) (Quandle.toRack.{u1} (Quandle.Conj.{u1} (Rack.EnvelGroup.{u1} R _inst_1)) (Quandle.Conj.quandle.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.group.{u1} R _inst_1)))) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2))) (Quandle.Conj.map.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Rack.EnvelGroup.group.{u1} R _inst_1) _inst_2 g) (Rack.toEnvelGroup.{u1} R _inst_1))) -> (Eq.{max (succ u2) (succ u1)} (MonoidHom.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Monoid.toMulOneClass.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.divInvMonoid.{u1} R _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2)))) g (coeFn.{max 1 (max (max (succ u1) (succ u2)) (succ u2) (succ u1)) (max (succ u2) (succ u1)) (succ u1) (succ u2), max (max (succ u1) (succ u2)) (succ u2) (succ u1)} (Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) (MonoidHom.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Monoid.toMulOneClass.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.divInvMonoid.{u1} R _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))))) (fun (_x : Equiv.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) (MonoidHom.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Monoid.toMulOneClass.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.divInvMonoid.{u1} R _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))))) => (ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) -> (MonoidHom.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Monoid.toMulOneClass.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.divInvMonoid.{u1} R _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))))) (Equiv.hasCoeToFun.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (ShelfHom.{u1, u2} R (Quandle.Conj.{u2} G) (Rack.toShelf.{u1} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} G) (Quandle.toRack.{u2} (Quandle.Conj.{u2} G) (Quandle.Conj.quandle.{u2} G _inst_2)))) (MonoidHom.{u1, u2} (Rack.EnvelGroup.{u1} R _inst_1) G (Monoid.toMulOneClass.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Rack.EnvelGroup.{u1} R _inst_1) (Rack.EnvelGroup.divInvMonoid.{u1} R _inst_1))) (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_2))))) (Rack.toEnvelGroup.map.{u1, u2} R _inst_1 G _inst_2) f))
 but is expected to have type
-  forall (R : Type.{u2}) [_inst_1 : Rack.{u2} R] (G : Type.{u1}) [_inst_2 : Group.{u1} G] (f : ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (g : MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))), (Eq.{max (succ u2) (succ u1)} (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) f (ShelfHom.comp.{u2, u2, u1} R (Quandle.Conj.{u2} (Rack.EnvelGroup.{u2} R _inst_1)) (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} (Rack.EnvelGroup.{u2} R _inst_1)) (Quandle.toRack.{u2} (Quandle.Conj.{u2} (Rack.EnvelGroup.{u2} R _inst_1)) (Quandle.Conj.quandle.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instGroupEnvelGroup.{u2} R _inst_1)))) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2))) (Quandle.Conj.map.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Rack.instGroupEnvelGroup.{u2} R _inst_1) _inst_2 g) (Rack.toEnvelGroup.{u2} R _inst_1))) -> (Eq.{max (succ u2) (succ u1)} (MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) g (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))))) (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (fun (_x : ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) => MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))))) (Rack.toEnvelGroup.map.{u2, u1} R _inst_1 G _inst_2) f))
+  forall (R : Type.{u2}) [_inst_1 : Rack.{u2} R] (G : Type.{u1}) [_inst_2 : Group.{u1} G] (f : ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (g : MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))), (Eq.{max (succ u2) (succ u1)} (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) f (ShelfHom.comp.{u2, u2, u1} R (Quandle.Conj.{u2} (Rack.EnvelGroup.{u2} R _inst_1)) (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u2} (Quandle.Conj.{u2} (Rack.EnvelGroup.{u2} R _inst_1)) (Quandle.toRack.{u2} (Quandle.Conj.{u2} (Rack.EnvelGroup.{u2} R _inst_1)) (Quandle.Conj.quandle.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instGroupEnvelGroup.{u2} R _inst_1)))) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2))) (Quandle.Conj.map.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Rack.instGroupEnvelGroup.{u2} R _inst_1) _inst_2 g) (Rack.toEnvelGroup.{u2} R _inst_1))) -> (Eq.{max (succ u2) (succ u1)} (MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) g (FunLike.coe.{max (succ u1) (succ u2), max (succ u1) (succ u2), max (succ u1) (succ u2)} (Equiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))))) (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (fun (_x : ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) => MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2)))) _x) (Equiv.instFunLikeEquiv.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (ShelfHom.{u2, u1} R (Quandle.Conj.{u1} G) (Rack.toShelf.{u2} R _inst_1) (Rack.toShelf.{u1} (Quandle.Conj.{u1} G) (Quandle.toRack.{u1} (Quandle.Conj.{u1} G) (Quandle.Conj.quandle.{u1} G _inst_2)))) (MonoidHom.{u2, u1} (Rack.EnvelGroup.{u2} R _inst_1) G (Monoid.toMulOneClass.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (DivInvMonoid.toMonoid.{u2} (Rack.EnvelGroup.{u2} R _inst_1) (Rack.instDivInvMonoidEnvelGroup.{u2} R _inst_1))) (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_2))))) (Rack.toEnvelGroup.map.{u2, u1} R _inst_1 G _inst_2) f))
 Case conversion may be inaccurate. Consider using '#align rack.to_envel_group.univ_uniq Rack.toEnvelGroup.univ_uniqₓ'. -/
 /-- The homomorphism `to_envel_group.map f` is the unique map that fits into the commutative
 triangle in `to_envel_group.univ`.

28aa996f

bump to nightly-2023-02-28-18

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

15328211

Diff

@@ -107,6 +107,7 @@ class Shelf (α : Type u) where
 #align shelf Shelf
 -/
 
+#print UnitalShelf /-
 /-- A *unital shelf* is a shelf equipped with an element `1` such that, for all elements `x`,
 we have both `x ◃ 1` and `1 ◃ x` equal `x`.
 -/
@@ -114,6 +115,7 @@ class UnitalShelf (α : Type u) extends Shelf α, One α where
   one_act : ∀ a : α, act 1 a = a
   act_one : ∀ a : α, act a 1 = a
 #align unital_shelf UnitalShelf
+-/
 
 #print ShelfHom /-
 /-- The type of homomorphisms between shelves.
@@ -158,6 +160,7 @@ open Shelf
 
 variable {S : Type _} [UnitalShelf S]
 
+#print UnitalShelf.act_act_self_eq /-
 /-- A monoid is *graphic* if, for all `x` and `y`, the *graphic identity*
 `(x * y) * x = x * y` holds.  For a unital shelf, this graphic
 identity holds.
@@ -167,21 +170,28 @@ theorem act_act_self_eq (x y : S) : (x ◃ y) ◃ x = x ◃ y :=
   have h : (x ◃ y) ◃ x = (x ◃ y) ◃ x ◃ 1 := by rw [act_one]
   rw [h, ← Shelf.self_distrib, act_one]
 #align unital_shelf.act_act_self_eq UnitalShelf.act_act_self_eq
+-/
 
+#print UnitalShelf.act_idem /-
 theorem act_idem (x : S) : x ◃ x = x := by rw [← act_one x, ← Shelf.self_distrib, act_one, act_one]
 #align unital_shelf.act_idem UnitalShelf.act_idem
+-/
 
+#print UnitalShelf.act_self_act_eq /-
 theorem act_self_act_eq (x y : S) : x ◃ x ◃ y = x ◃ y :=
   by
   have h : x ◃ x ◃ y = (x ◃ 1) ◃ x ◃ y := by rw [act_one]
   rw [h, ← Shelf.self_distrib, one_act]
 #align unital_shelf.act_self_act_eq UnitalShelf.act_self_act_eq
+-/
 
+#print UnitalShelf.assoc /-
 /-- The associativity of a unital shelf comes for free.
 -/
 theorem assoc (x y z : S) : (x ◃ y) ◃ z = x ◃ y ◃ z := by
   rw [self_distrib, self_distrib, act_act_self_eq, act_self_act_eq]
 #align unital_shelf.assoc UnitalShelf.assoc
+-/
 
 end UnitalShelf

28aa996f

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

28aa996f

chore: adapt to multiple goal linter 1 (#12338)

A PR accompanying #12339.

Zulip discussion

45f93f3f

Diff

@@ -224,14 +224,14 @@ theorem act_invAct_eq (x y : R) : x ◃ x ◃⁻¹ y = y :=
 
 theorem left_cancel (x : R) {y y' : R} : x ◃ y = x ◃ y' ↔ y = y' := by
   constructor
-  apply (act' x).injective
+  · apply (act' x).injective
   rintro rfl
   rfl
 #align rack.left_cancel Rack.left_cancel
 
 theorem left_cancel_inv (x : R) {y y' : R} : x ◃⁻¹ y = x ◃⁻¹ y' ↔ y = y' := by
   constructor
-  apply (act' x).symm.injective
+  · apply (act' x).symm.injective
   rintro rfl
   rfl
 #align rack.left_cancel_inv Rack.left_cancel_inv
@@ -305,11 +305,12 @@ theorem self_invAct_act_eq {x y : R} : (x ◃⁻¹ x) ◃ y = x ◃ y := by
 #align rack.self_inv_act_act_eq Rack.self_invAct_act_eq
 
 theorem self_act_eq_iff_eq {x y : R} : x ◃ x = y ◃ y ↔ x = y := by
-  constructor; swap; rintro rfl; rfl
+  constructor; swap
+  · rintro rfl; rfl
   intro h
   trans (x ◃ x) ◃⁻¹ x ◃ x
-  rw [← left_cancel (x ◃ x), right_inv, self_act_act_eq]
-  rw [h, ← left_cancel (y ◃ y), right_inv, self_act_act_eq]
+  · rw [← left_cancel (x ◃ x), right_inv, self_act_act_eq]
+  · rw [h, ← left_cancel (y ◃ y), right_inv, self_act_act_eq]
 #align rack.self_act_eq_iff_eq Rack.self_act_eq_iff_eq
 
 theorem self_invAct_eq_iff_eq {x y : R} : x ◃⁻¹ x = y ◃⁻¹ y ↔ x = y := by

28aa996f

style: replace '/--A' by '/-- A' for each letter A. (#11939)

Also do the same for "/-A". This is a purely aesthetic change (and exhaustive).

af58f9f3

Diff

@@ -95,7 +95,7 @@ The binary operation is regarded as a left action of the type on itself.
 class Shelf (α : Type u) where
   /-- The action of the `Shelf` over `α`-/
   act : α → α → α
-  /--A verification that `act` is self-distributive-/
+  /-- A verification that `act` is self-distributive-/
   self_distrib : ∀ {x y z : α}, act x (act y z) = act (act x y) (act x z)
 #align shelf Shelf

28aa996f

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

@@ -184,7 +184,7 @@ namespace Rack
 
 variable {R : Type*} [Rack R]
 
---porting note: No longer a need for `Rack.self_distrib`
+-- Porting note: No longer a need for `Rack.self_distrib`
 export Shelf (self_distrib)
 
 -- porting note, changed name to `act'` to not conflict with `Shelf.act`
@@ -425,7 +425,7 @@ instance oppositeQuandle : Quandle Qᵐᵒᵖ where
 /-- The conjugation quandle of a group.  Each element of the group acts by
 the corresponding inner automorphism.
 -/
---porting note: no need for `nolint` and added `reducible`
+-- Porting note: no need for `nolint` and added `reducible`
 @[reducible]
 def Conj (G : Type*) := G
 #align quandle.conj Quandle.Conj
@@ -464,7 +464,7 @@ def Conj.map {G : Type*} {H : Type*} [Group G] [Group H] (f : G →* H) : Conj G
   map_act' := by simp
 #align quandle.conj.map Quandle.Conj.map
 
--- porting note: I don't think HasLift exists
+-- Porting note: I don't think HasLift exists
 -- instance {G : Type*} {H : Type*} [Group G] [Group H] : HasLift (G →* H) (Conj G →◃ Conj H)
 --     where lift := Conj.map
 
@@ -472,7 +472,7 @@ def Conj.map {G : Type*} {H : Type*} [Group G] [Group H] (f : G →* H) : Conj G
 
 Used for Fox n-colorings of knots.
 -/
--- porting note: Removed nolint
+-- Porting note: Removed nolint
 def Dihedral (n : ℕ) :=
   ZMod n
 #align quandle.dihedral Quandle.Dihedral

28aa996f

chore: Remove unnecessary "rw"s (#10704)

Remove unnecessary "rw"s.

db5a9376

Diff

@@ -163,7 +163,7 @@ lemma act_act_self_eq (x y : S) : (x ◃ y) ◃ x = x ◃ y := by
   rw [h, ← Shelf.self_distrib, act_one]
 #align unital_shelf.act_act_self_eq UnitalShelf.act_act_self_eq
 
-lemma act_idem (x : S) : (x ◃ x) = x := by rw [← act_one x, ← Shelf.self_distrib, act_one, act_one]
+lemma act_idem (x : S) : (x ◃ x) = x := by rw [← act_one x, ← Shelf.self_distrib, act_one]
 #align unital_shelf.act_idem UnitalShelf.act_idem
 
 lemma act_self_act_eq (x y : S) : x ◃ (x ◃ y) = x ◃ y := by

28aa996f

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

@@ -358,7 +358,7 @@ namespace ShelfHom
 
 variable {S₁ : Type*} {S₂ : Type*} {S₃ : Type*} [Shelf S₁] [Shelf S₂] [Shelf S₃]
 
-instance : DFunLike (S₁ →◃ S₂) S₁ fun _ => S₂ where
+instance : FunLike (S₁ →◃ S₂) S₁ S₂ where
   coe := toFun
   coe_injective' | ⟨_, _⟩, ⟨_, _⟩, rfl => rfl

28aa996f

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

@@ -358,7 +358,7 @@ namespace ShelfHom
 
 variable {S₁ : Type*} {S₂ : Type*} {S₃ : Type*} [Shelf S₁] [Shelf S₂] [Shelf S₃]
 
-instance : FunLike (S₁ →◃ S₂) S₁ fun _ => S₂ where
+instance : DFunLike (S₁ →◃ S₂) S₁ fun _ => S₂ where
   coe := toFun
   coe_injective' | ⟨_, _⟩, ⟨_, _⟩, rfl => rfl

28aa996f

chore: space after ← (#8178)

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

5fb9beab

Diff

@@ -160,15 +160,15 @@ identity holds.
 -/
 lemma act_act_self_eq (x y : S) : (x ◃ y) ◃ x = x ◃ y := by
   have h : (x ◃ y) ◃ x = (x ◃ y) ◃ (x ◃ 1) := by rw [act_one]
-  rw [h, ←Shelf.self_distrib, act_one]
+  rw [h, ← Shelf.self_distrib, act_one]
 #align unital_shelf.act_act_self_eq UnitalShelf.act_act_self_eq
 
-lemma act_idem (x : S) : (x ◃ x) = x := by rw [←act_one x, ←Shelf.self_distrib, act_one, act_one]
+lemma act_idem (x : S) : (x ◃ x) = x := by rw [← act_one x, ← Shelf.self_distrib, act_one, act_one]
 #align unital_shelf.act_idem UnitalShelf.act_idem
 
 lemma act_self_act_eq (x y : S) : x ◃ (x ◃ y) = x ◃ y := by
   have h : x ◃ (x ◃ y) = (x ◃ 1) ◃ (x ◃ y) := by rw [act_one]
-  rw [h, ←Shelf.self_distrib, one_act]
+  rw [h, ← Shelf.self_distrib, one_act]
 #align unital_shelf.act_self_act_eq UnitalShelf.act_self_act_eq
 
 /--

28aa996f

refactor(Algebra/Hom): transpose Hom and file name (#8095)

I believe the file defining a type of morphisms belongs alongside the file defining the structure this morphism works on. So I would like to reorganize the files in the Mathlib.Algebra.Hom folder so that e.g. Mathlib.Algebra.Hom.Ring becomes Mathlib.Algebra.Ring.Hom and Mathlib.Algebra.Hom.NonUnitalAlg becomes Mathlib.Algebra.Algebra.NonUnitalHom.

While fixing the imports I went ahead and sorted them for good luck.

The full list of changes is: renamed: Mathlib/Algebra/Hom/NonUnitalAlg.lean -> Mathlib/Algebra/Algebra/NonUnitalHom.lean renamed: Mathlib/Algebra/Hom/Aut.lean -> Mathlib/Algebra/Group/Aut.lean renamed: Mathlib/Algebra/Hom/Commute.lean -> Mathlib/Algebra/Group/Commute/Hom.lean renamed: Mathlib/Algebra/Hom/Embedding.lean -> Mathlib/Algebra/Group/Embedding.lean renamed: Mathlib/Algebra/Hom/Equiv/Basic.lean -> Mathlib/Algebra/Group/Equiv/Basic.lean renamed: Mathlib/Algebra/Hom/Equiv/TypeTags.lean -> Mathlib/Algebra/Group/Equiv/TypeTags.lean renamed: Mathlib/Algebra/Hom/Equiv/Units/Basic.lean -> Mathlib/Algebra/Group/Units/Equiv.lean renamed: Mathlib/Algebra/Hom/Equiv/Units/GroupWithZero.lean -> Mathlib/Algebra/GroupWithZero/Units/Equiv.lean renamed: Mathlib/Algebra/Hom/Freiman.lean -> Mathlib/Algebra/Group/Freiman.lean renamed: Mathlib/Algebra/Hom/Group/Basic.lean -> Mathlib/Algebra/Group/Hom/Basic.lean renamed: Mathlib/Algebra/Hom/Group/Defs.lean -> Mathlib/Algebra/Group/Hom/Defs.lean renamed: Mathlib/Algebra/Hom/GroupAction.lean -> Mathlib/GroupTheory/GroupAction/Hom.lean renamed: Mathlib/Algebra/Hom/GroupInstances.lean -> Mathlib/Algebra/Group/Hom/Instances.lean renamed: Mathlib/Algebra/Hom/Iterate.lean -> Mathlib/Algebra/GroupPower/IterateHom.lean renamed: Mathlib/Algebra/Hom/Centroid.lean -> Mathlib/Algebra/Ring/CentroidHom.lean renamed: Mathlib/Algebra/Hom/Ring/Basic.lean -> Mathlib/Algebra/Ring/Hom/Basic.lean renamed: Mathlib/Algebra/Hom/Ring/Defs.lean -> Mathlib/Algebra/Ring/Hom/Defs.lean renamed: Mathlib/Algebra/Hom/Units.lean -> Mathlib/Algebra/Group/Units/Hom.lean

Zulip thread: https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/Reorganizing.20.60Mathlib.2EAlgebra.2EHom.60

92fe122e

Diff

@@ -3,8 +3,8 @@ Copyright (c) 2020 Kyle Miller. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kyle Miller
 -/
-import Mathlib.Algebra.Hom.Equiv.Basic
-import Mathlib.Algebra.Hom.Aut
+import Mathlib.Algebra.Group.Equiv.Basic
+import Mathlib.Algebra.Group.Aut
 import Mathlib.Data.ZMod.Defs
 import Mathlib.Tactic.Ring

28aa996f

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

@@ -112,7 +112,7 @@ class UnitalShelf (α : Type u) extends Shelf α, One α :=
 This is also the notion of rack and quandle homomorphisms.
 -/
 @[ext]
-structure ShelfHom (S₁ : Type _) (S₂ : Type _) [Shelf S₁] [Shelf S₂] where
+structure ShelfHom (S₁ : Type*) (S₂ : Type*) [Shelf S₁] [Shelf S₂] where
   /-- The function under the Shelf Homomorphism -/
   toFun : S₁ → S₂
   /-- The homomorphism property of a Shelf Homomorphism-/
@@ -151,7 +151,7 @@ open Quandles
 namespace UnitalShelf
 open Shelf
 
-variable {S : Type _} [UnitalShelf S]
+variable {S : Type*} [UnitalShelf S]
 
 /--
 A monoid is *graphic* if, for all `x` and `y`, the *graphic identity*
@@ -182,7 +182,7 @@ end UnitalShelf
 
 namespace Rack
 
-variable {R : Type _} [Rack R]
+variable {R : Type*} [Rack R]
 
 --porting note: No longer a need for `Rack.self_distrib`
 export Shelf (self_distrib)
@@ -248,7 +248,7 @@ of `x`. It is another way to understand the self-distributivity axiom.
 This is used in the natural rack homomorphism `toConj` from `R` to
 `Conj (R ≃ R)` defined by `op'`.
 -/
-theorem ad_conj {R : Type _} [Rack R] (x y : R) : act' (x ◃ y) = act' x * act' y * (act' x)⁻¹ := by
+theorem ad_conj {R : Type*} [Rack R] (x y : R) : act' (x ◃ y) = act' x * act' y * (act' x)⁻¹ := by
   rw [eq_mul_inv_iff_mul_eq]; ext z
   apply self_distrib.symm
 #align rack.ad_conj Rack.ad_conj
@@ -320,7 +320,7 @@ theorem self_invAct_eq_iff_eq {x y : R} : x ◃⁻¹ x = y ◃⁻¹ y ↔ x = y
 /-- The map `x ↦ x ◃ x` is a bijection.  (This has applications for the
 regular isotopy version of the Reidemeister I move for knot diagrams.)
 -/
-def selfApplyEquiv (R : Type _) [Rack R] : R ≃ R
+def selfApplyEquiv (R : Type*) [Rack R] : R ≃ R
     where
   toFun x := x ◃ x
   invFun x := x ◃⁻¹ x
@@ -330,24 +330,24 @@ def selfApplyEquiv (R : Type _) [Rack R] : R ≃ R
 
 /-- An involutory rack is one for which `Rack.oppositeRack R x` is an involution for every x.
 -/
-def IsInvolutory (R : Type _) [Rack R] : Prop :=
+def IsInvolutory (R : Type*) [Rack R] : Prop :=
   ∀ x : R, Function.Involutive (Shelf.act x)
 #align rack.is_involutory Rack.IsInvolutory
 
-theorem involutory_invAct_eq_act {R : Type _} [Rack R] (h : IsInvolutory R) (x y : R) :
+theorem involutory_invAct_eq_act {R : Type*} [Rack R] (h : IsInvolutory R) (x y : R) :
     x ◃⁻¹ y = x ◃ y := by
   rw [← left_cancel x, right_inv, h x]
 #align rack.involutory_inv_act_eq_act Rack.involutory_invAct_eq_act
 
 /-- An abelian rack is one for which the mediality axiom holds.
 -/
-def IsAbelian (R : Type _) [Rack R] : Prop :=
+def IsAbelian (R : Type*) [Rack R] : Prop :=
   ∀ x y z w : R, (x ◃ y) ◃ z ◃ w = (x ◃ z) ◃ y ◃ w
 #align rack.is_abelian Rack.IsAbelian
 
 /-- Associative racks are uninteresting.
 -/
-theorem assoc_iff_id {R : Type _} [Rack R] {x y z : R} : x ◃ y ◃ z = (x ◃ y) ◃ z ↔ x ◃ z = z := by
+theorem assoc_iff_id {R : Type*} [Rack R] {x y z : R} : x ◃ y ◃ z = (x ◃ y) ◃ z ↔ x ◃ z = z := by
   rw [self_distrib]
   rw [left_cancel]
 #align rack.assoc_iff_id Rack.assoc_iff_id
@@ -356,7 +356,7 @@ end Rack
 
 namespace ShelfHom
 
-variable {S₁ : Type _} {S₂ : Type _} {S₃ : Type _} [Shelf S₁] [Shelf S₂] [Shelf S₃]
+variable {S₁ : Type*} {S₂ : Type*} {S₃ : Type*} [Shelf S₁] [Shelf S₂] [Shelf S₃]
 
 instance : FunLike (S₁ →◃ S₂) S₁ fun _ => S₂ where
   coe := toFun
@@ -371,12 +371,12 @@ theorem map_act (f : S₁ →◃ S₂) {x y : S₁} : f (x ◃ y) = f x ◃ f y
 #align shelf_hom.map_act ShelfHom.map_act
 
 /-- The identity homomorphism -/
-def id (S : Type _) [Shelf S] : S →◃ S where
+def id (S : Type*) [Shelf S] : S →◃ S where
   toFun := fun x => x
   map_act' := by simp
 #align shelf_hom.id ShelfHom.id
 
-instance inhabited (S : Type _) [Shelf S] : Inhabited (S →◃ S) :=
+instance inhabited (S : Type*) [Shelf S] : Inhabited (S →◃ S) :=
   ⟨id S⟩
 #align shelf_hom.inhabited ShelfHom.inhabited
 
@@ -396,7 +396,7 @@ end ShelfHom
 
 /-- A quandle is a rack such that each automorphism fixes its corresponding element.
 -/
-class Quandle (α : Type _) extends Rack α where
+class Quandle (α : Type*) extends Rack α where
   /-- The fixing property of a Quandle -/
   fix : ∀ {x : α}, act x x = x
 #align quandle Quandle
@@ -405,7 +405,7 @@ namespace Quandle
 
 open Rack
 
-variable {Q : Type _} [Quandle Q]
+variable {Q : Type*} [Quandle Q]
 
 attribute [simp] fix
 
@@ -427,10 +427,10 @@ the corresponding inner automorphism.
 -/
 --porting note: no need for `nolint` and added `reducible`
 @[reducible]
-def Conj (G : Type _) := G
+def Conj (G : Type*) := G
 #align quandle.conj Quandle.Conj
 
-instance Conj.quandle (G : Type _) [Group G] : Quandle (Conj G)
+instance Conj.quandle (G : Type*) [Group G] : Quandle (Conj G)
     where
   act x := @MulAut.conj G _ x
   self_distrib := by
@@ -446,26 +446,26 @@ instance Conj.quandle (G : Type _) [Group G] : Quandle (Conj G)
 #align quandle.conj.quandle Quandle.Conj.quandle
 
 @[simp]
-theorem conj_act_eq_conj {G : Type _} [Group G] (x y : Conj G) :
+theorem conj_act_eq_conj {G : Type*} [Group G] (x y : Conj G) :
     x ◃ y = ((x : G) * (y : G) * (x : G)⁻¹ : G) :=
   rfl
 #align quandle.conj_act_eq_conj Quandle.conj_act_eq_conj
 
-theorem conj_swap {G : Type _} [Group G] (x y : Conj G) : x ◃ y = y ↔ y ◃ x = x := by
+theorem conj_swap {G : Type*} [Group G] (x y : Conj G) : x ◃ y = y ↔ y ◃ x = x := by
   dsimp [Conj] at *; constructor
   repeat' intro h; conv_rhs => rw [eq_mul_inv_of_mul_eq (eq_mul_inv_of_mul_eq h)]; simp
 #align quandle.conj_swap Quandle.conj_swap
 
 /-- `Conj` is functorial
 -/
-def Conj.map {G : Type _} {H : Type _} [Group G] [Group H] (f : G →* H) : Conj G →◃ Conj H
+def Conj.map {G : Type*} {H : Type*} [Group G] [Group H] (f : G →* H) : Conj G →◃ Conj H
     where
   toFun := f
   map_act' := by simp
 #align quandle.conj.map Quandle.Conj.map
 
 -- porting note: I don't think HasLift exists
--- instance {G : Type _} {H : Type _} [Group G] [Group H] : HasLift (G →* H) (Conj G →◃ Conj H)
+-- instance {G : Type*} {H : Type*} [Group G] [Group H] : HasLift (G →* H) (Conj G →◃ Conj H)
 --     where lift := Conj.map
 
 /-- The dihedral quandle. This is the conjugation quandle of the dihedral group restrict to flips.
@@ -511,7 +511,7 @@ namespace Rack
 /-- This is the natural rack homomorphism to the conjugation quandle of the group `R ≃ R`
 that acts on the rack.
 -/
-def toConj (R : Type _) [Rack R] : R →◃ Quandle.Conj (R ≃ R)
+def toConj (R : Type*) [Rack R] : R →◃ Quandle.Conj (R ≃ R)
     where
   toFun := act'
   map_act' := by
@@ -653,7 +653,7 @@ theorem PreEnvelGroupRel.trans {R : Type u} [Rack R] {a b c : PreEnvelGroup R} :
   | ⟨rab⟩, ⟨rbc⟩ => (rab.trans rbc).rel
 #align rack.pre_envel_group_rel.trans Rack.PreEnvelGroupRel.trans
 
-instance PreEnvelGroup.setoid (R : Type _) [Rack R] : Setoid (PreEnvelGroup R)
+instance PreEnvelGroup.setoid (R : Type*) [Rack R] : Setoid (PreEnvelGroup R)
     where
   r := PreEnvelGroupRel R
   iseqv := by
@@ -664,13 +664,13 @@ instance PreEnvelGroup.setoid (R : Type _) [Rack R] : Setoid (PreEnvelGroup R)
 #align rack.pre_envel_group.setoid Rack.PreEnvelGroup.setoid
 /-- The universal enveloping group for the rack R.
 -/
-def EnvelGroup (R : Type _) [Rack R] :=
+def EnvelGroup (R : Type*) [Rack R] :=
   Quotient (PreEnvelGroup.setoid R)
 #align rack.envel_group Rack.EnvelGroup
 
 -- Define the `Group` instances in two steps so `inv` can be inferred correctly.
 -- TODO: is there a non-invasive way of defining the instance directly?
-instance (R : Type _) [Rack R] : DivInvMonoid (EnvelGroup R)
+instance (R : Type*) [Rack R] : DivInvMonoid (EnvelGroup R)
     where
   mul a b :=
     Quotient.liftOn₂ a b (fun a b => ⟦PreEnvelGroup.mul a b⟧) fun a b a' b' ⟨ha⟩ ⟨hb⟩ =>
@@ -684,18 +684,18 @@ instance (R : Type _) [Rack R] : DivInvMonoid (EnvelGroup R)
   one_mul a := Quotient.inductionOn a fun a => Quotient.sound (PreEnvelGroupRel'.one_mul a).rel
   mul_one a := Quotient.inductionOn a fun a => Quotient.sound (PreEnvelGroupRel'.mul_one a).rel
 
-instance (R : Type _) [Rack R] : Group (EnvelGroup R) :=
+instance (R : Type*) [Rack R] : Group (EnvelGroup R) :=
   { mul_left_inv := fun a =>
       Quotient.inductionOn a fun a => Quotient.sound (PreEnvelGroupRel'.mul_left_inv a).rel }
 
-instance EnvelGroup.inhabited (R : Type _) [Rack R] : Inhabited (EnvelGroup R) :=
+instance EnvelGroup.inhabited (R : Type*) [Rack R] : Inhabited (EnvelGroup R) :=
   ⟨1⟩
 #align rack.envel_group.inhabited Rack.EnvelGroup.inhabited
 
 /-- The canonical homomorphism from a rack to its enveloping group.
 Satisfies universal properties given by `toEnvelGroup.map` and `toEnvelGroup.univ`.
 -/
-def toEnvelGroup (R : Type _) [Rack R] : R →◃ Quandle.Conj (EnvelGroup R)
+def toEnvelGroup (R : Type*) [Rack R] : R →◃ Quandle.Conj (EnvelGroup R)
     where
   toFun x := ⟦incl x⟧
   map_act' := @fun x y => Quotient.sound (PreEnvelGroupRel'.act_incl x y).symm.rel
@@ -704,7 +704,7 @@ def toEnvelGroup (R : Type _) [Rack R] : R →◃ Quandle.Conj (EnvelGroup R)
 /-- The preliminary definition of the induced map from the enveloping group.
 See `toEnvelGroup.map`.
 -/
-def toEnvelGroup.mapAux {R : Type _} [Rack R] {G : Type _} [Group G] (f : R →◃ Quandle.Conj G) :
+def toEnvelGroup.mapAux {R : Type*} [Rack R] {G : Type*} [Group G] (f : R →◃ Quandle.Conj G) :
     PreEnvelGroup R → G
   | .unit => 1
   | .incl x => f x
@@ -718,7 +718,7 @@ open PreEnvelGroupRel'
 
 /-- Show that `toEnvelGroup.mapAux` sends equivalent expressions to equal terms.
 -/
-theorem well_def {R : Type _} [Rack R] {G : Type _} [Group G] (f : R →◃ Quandle.Conj G) :
+theorem well_def {R : Type*} [Rack R] {G : Type*} [Group G] (f : R →◃ Quandle.Conj G) :
     ∀ {a b : PreEnvelGroup R},
       PreEnvelGroupRel' R a b → toEnvelGroup.mapAux f a = toEnvelGroup.mapAux f b
   | a, _, PreEnvelGroupRel'.refl => rfl
@@ -739,7 +739,7 @@ end toEnvelGroup.mapAux
 /-- Given a map from a rack to a group, lift it to being a map from the enveloping group.
 More precisely, the `EnvelGroup` functor is left adjoint to `Quandle.Conj`.
 -/
-def toEnvelGroup.map {R : Type _} [Rack R] {G : Type _} [Group G] :
+def toEnvelGroup.map {R : Type*} [Rack R] {G : Type*} [Group G] :
     (R →◃ Quandle.Conj G) ≃ (EnvelGroup R →* G)
     where
   toFun f :=
@@ -774,7 +774,7 @@ def toEnvelGroup.map {R : Type _} [Rack R] {G : Type _} [Group G] :
 
 /-- Given a homomorphism from a rack to a group, it factors through the enveloping group.
 -/
-theorem toEnvelGroup.univ (R : Type _) [Rack R] (G : Type _) [Group G] (f : R →◃ Quandle.Conj G) :
+theorem toEnvelGroup.univ (R : Type*) [Rack R] (G : Type*) [Group G] (f : R →◃ Quandle.Conj G) :
     (Quandle.Conj.map (toEnvelGroup.map f)).comp (toEnvelGroup R) = f :=
   toEnvelGroup.map.symm_apply_apply f
 #align rack.to_envel_group.univ Rack.toEnvelGroup.univ
@@ -782,7 +782,7 @@ theorem toEnvelGroup.univ (R : Type _) [Rack R] (G : Type _) [Group G] (f : R 
 /-- The homomorphism `toEnvelGroup.map f` is the unique map that fits into the commutative
 triangle in `toEnvelGroup.univ`.
 -/
-theorem toEnvelGroup.univ_uniq (R : Type _) [Rack R] (G : Type _) [Group G]
+theorem toEnvelGroup.univ_uniq (R : Type*) [Rack R] (G : Type*) [Group G]
     (f : R →◃ Quandle.Conj G) (g : EnvelGroup R →* G)
     (h : f = (Quandle.Conj.map g).comp (toEnvelGroup R)) : g = toEnvelGroup.map f :=
   h.symm ▸ (toEnvelGroup.map.apply_symm_apply g).symm
@@ -793,12 +793,12 @@ using `Rack.toConj`. Satisfies the property `envelAction_prop`.
 
 This gives the rack `R` the structure of an augmented rack over `EnvelGroup R`.
 -/
-def envelAction {R : Type _} [Rack R] : EnvelGroup R →* R ≃ R :=
+def envelAction {R : Type*} [Rack R] : EnvelGroup R →* R ≃ R :=
   toEnvelGroup.map (toConj R)
 #align rack.envel_action Rack.envelAction
 
 @[simp]
-theorem envelAction_prop {R : Type _} [Rack R] (x y : R) :
+theorem envelAction_prop {R : Type*} [Rack R] (x y : R) :
     envelAction (toEnvelGroup R x) y = x ◃ y :=
   rfl
 #align rack.envel_action_prop Rack.envelAction_prop

28aa996f

chore(Algebra/Quandle): use FunLike (#6463)

ee7bea2f

Diff

@@ -358,14 +358,12 @@ namespace ShelfHom
 
 variable {S₁ : Type _} {S₂ : Type _} {S₃ : Type _} [Shelf S₁] [Shelf S₂] [Shelf S₃]
 
-instance : CoeFun (S₁ →◃ S₂) fun _ => S₁ → S₂ :=
-  ⟨ShelfHom.toFun⟩
-
--- Porting Note: Syntactically equal in Lean4
--- @[simp]
--- theorem toFun_eq_coe (f : S₁ →◃ S₂) : f.toFun = f :=
---   rfl
-#noalign shelf_hom.to_fun_eq_coe
+instance : FunLike (S₁ →◃ S₂) S₁ fun _ => S₂ where
+  coe := toFun
+  coe_injective' | ⟨_, _⟩, ⟨_, _⟩, rfl => rfl
+
+@[simp] theorem toFun_eq_coe (f : S₁ →◃ S₂) : f.toFun = f := rfl
+#align shelf_hom.to_fun_eq_coe ShelfHom.toFun_eq_coe
 
 @[simp]
 theorem map_act (f : S₁ →◃ S₂) {x y : S₁} : f (x ◃ y) = f x ◃ f y :=

28aa996f

chore: tidy various files (#6158)

0bcfc2d2

Diff

@@ -660,9 +660,9 @@ instance PreEnvelGroup.setoid (R : Type _) [Rack R] : Setoid (PreEnvelGroup R)
   r := PreEnvelGroupRel R
   iseqv := by
     constructor
-    apply PreEnvelGroupRel.refl
-    apply PreEnvelGroupRel.symm
-    apply PreEnvelGroupRel.trans
+    · apply PreEnvelGroupRel.refl
+    · apply PreEnvelGroupRel.symm
+    · apply PreEnvelGroupRel.trans
 #align rack.pre_envel_group.setoid Rack.PreEnvelGroup.setoid
 /-- The universal enveloping group for the rack R.
 -/

28aa996f

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,16 +2,13 @@
 Copyright (c) 2020 Kyle Miller. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kyle Miller
-
-! This file was ported from Lean 3 source module algebra.quandle
-! leanprover-community/mathlib commit 28aa996fc6fb4317f0083c4e6daf79878d81be33
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Hom.Equiv.Basic
 import Mathlib.Algebra.Hom.Aut
 import Mathlib.Data.ZMod.Defs
 import Mathlib.Tactic.Ring
+
+#align_import algebra.quandle from "leanprover-community/mathlib"@"28aa996fc6fb4317f0083c4e6daf79878d81be33"
 /-!
 # Racks and Quandles

28aa996f

chore: remove occurrences of semicolon after space (#5713)

This is the second half of the changes originally in #5699, removing all occurrences of ; after a space and implementing a linter rule to enforce it.

In most cases this 2-character substring has a space after it, so the following command was run first:

find . -type f -name "*.lean" -exec sed -i -E 's/ ; /; /g' {} \;

The remaining cases were few enough in number that they were done manually.

c795bd35

Diff

@@ -760,7 +760,7 @@ def toEnvelGroup.map {R : Type _} [Rack R] {G : Type _} [Group G] :
           change Quotient.liftOn ⟦mul x y⟧ (toEnvelGroup.mapAux f) _ = _
           simp [toEnvelGroup.mapAux] }
   invFun F := (Quandle.Conj.map F).comp (toEnvelGroup R)
-  left_inv f := by ext ; rfl
+  left_inv f := by ext; rfl
   right_inv F :=
     MonoidHom.ext fun x =>
       Quotient.inductionOn x fun x => by

28aa996f

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

@@ -568,7 +568,7 @@ group `EnvelGroup`.
 For a homomorphism `f : R →◃ Conj G`, how does
 `EnvelGroup.map f : EnvelGroup R →* G` work?  Let's think of `G` as
 being a 2-category with one object, a 1-morphism per element of `G`,
-and a single 2-morphism called `eq.refl` for each 1-morphism.  We
+and a single 2-morphism called `Eq.refl` for each 1-morphism.  We
 define the map using a "higher `Quotient.lift`" -- not only do we
 evaluate elements of `PreEnvelGroup` as expressions in `G` (this is
 `toEnvelGroup.mapAux`), but we evaluate elements of

28aa996f

refactor: make MulOpposite = AddOpposite (#4050)

It turns out to be convenient to have MulOpposite α = AddOpposite α true by definition, in the same way that it is convenient to have Additive α = α; this means that we also get the defeq AddOpposite (Additive α) = MulOpposite α, which is convenient when working with quotients. This is a compromise between making MulOpposite α = AddOpposite α = α (what we had in Lean 3) and having no defeqs within those three types (which we had as of #1036).

This is motivated by #3333

598588db

Diff

@@ -266,7 +266,7 @@ instance oppositeRack : Rack Rᵐᵒᵖ
     induction x using MulOpposite.rec'
     induction y using MulOpposite.rec'
     induction z using MulOpposite.rec'
-    simp only [op.injEq]
+    simp only [op_inj, unop_op, op_unop]
     rw [self_distrib_inv]
   invAct x y := op (Shelf.act (unop x) (unop y))
   left_inv := MulOpposite.rec' fun x => MulOpposite.rec' fun y => by simp

28aa996f

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

@@ -11,7 +11,6 @@ Authors: Kyle Miller
 import Mathlib.Algebra.Hom.Equiv.Basic
 import Mathlib.Algebra.Hom.Aut
 import Mathlib.Data.ZMod.Defs
-import Mathlib.Tactic.ScopedNS
 import Mathlib.Tactic.Ring
 /-!
 # Racks and Quandles

28aa996f

chore: add explicit instance names for MulOpposite (#3032)

Using explicit names makes it easier to refer to instances from docstrings and Zulip.

This probably isn't exhaustive, but does most of the algebra hierarchy.

Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

82964aac

Diff

@@ -712,10 +712,10 @@ See `toEnvelGroup.map`.
 -/
 def toEnvelGroup.mapAux {R : Type _} [Rack R] {G : Type _} [Group G] (f : R →◃ Quandle.Conj G) :
     PreEnvelGroup R → G
-  | unit => 1
-  | incl x => f x
-  | mul a b => toEnvelGroup.mapAux f a * toEnvelGroup.mapAux f b
-  | inv a => (toEnvelGroup.mapAux f a)⁻¹
+  | .unit => 1
+  | .incl x => f x
+  | .mul a b => toEnvelGroup.mapAux f a * toEnvelGroup.mapAux f b
+  | .inv a => (toEnvelGroup.mapAux f a)⁻¹
 #align rack.to_envel_group.map_aux Rack.toEnvelGroup.mapAux
 
 namespace toEnvelGroup.mapAux

28aa996f

chore: tidy various files (#2742)

8c7b65ad

Diff

@@ -69,7 +69,7 @@ The following notation is localized in `quandles`:
 * `x ◃⁻¹ y` is `Rack.inv_act x y`
 * `S →◃ S'` is `ShelfHom S S'`
 
-Use `open_locale quandles` to use these.
+Use `open quandles` to use these.
 
 ## Todo

28aa996f

fix: ring_nf should rewrite expressions which reduce to atoms (#2708)

Closes #2171.

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

8bcf75b6

Diff

@@ -509,7 +509,6 @@ instance (n : ℕ) : Quandle (Dihedral n)
     intro x
     simp only [dihedralAct]
     ring_nf
-    rw [mul_two, add_sub_cancel]
 
 end Quandle

28aa996f

feat: port unital shelves to Algebra.Quandle (#2393)

algebra.quandle@8631e2d5ea77f6c13054d9151d82b83069680cb1..28aa996fc6fb4317f0083c4e6daf79878d81be33

af933241

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kyle Miller
 
 ! This file was ported from Lean 3 source module algebra.quandle
-! leanprover-community/mathlib commit 8631e2d5ea77f6c13054d9151d82b83069680cb1
+! leanprover-community/mathlib commit 28aa996fc6fb4317f0083c4e6daf79878d81be33
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -36,7 +36,7 @@ complements that is analogous to the fundamental group of the
 exterior, and he showed that the quandle associated to an oriented
 knot is invariant up to orientation-reversed mirror image.  Racks were
 used by Fenn and Rourke for framed codimension-2 knots and
-links.[FennRourke1992]
+links in [FennRourke1992]. Unital shelves are discussed in [crans2017].
 
 The name "rack" came from wordplay by Conway and Wraith for the "wrack
 and ruin" of forgetting everything but the conjugation operation for a
@@ -45,6 +45,7 @@ group.
 ## Main definitions
 
 * `Shelf` is a type with a self-distributive action
+* `UnitalShelf` is a shelf with a left and right unit
 * `Rack` is a shelf whose action for each element is invertible
 * `Quandle` is a rack whose action for an element fixes that element
 * `Quandle.conj` defines a quandle of a group acting on itself by conjugation.
@@ -56,6 +57,10 @@ group.
 * `Rack.EnvelGroup` is left adjoint to `Quandle.Conj` (`toEnvelGroup.map`).
   The universality statements are `toEnvelGroup.univ` and `toEnvelGroup.univ_uniq`.
 
+## Implementation notes
+"Unital racks" are uninteresting (see `Rack.assoc_iff_id`, `UnitalShelf.assoc`), so we do not
+define them.
+
 ## Notation
 
 The following notation is localized in `quandles`:
@@ -98,6 +103,15 @@ class Shelf (α : Type u) where
   self_distrib : ∀ {x y z : α}, act x (act y z) = act (act x y) (act x z)
 #align shelf Shelf
 
+/--
+A *unital shelf* is a shelf equipped with an element `1` such that, for all elements `x`,
+we have both `x ◃ 1` and `1 ◃ x` equal `x`.
+-/
+class UnitalShelf (α : Type u) extends Shelf α, One α :=
+(one_act : ∀ a : α, act 1 a = a)
+(act_one : ∀ a : α, act a 1 = a)
+#align unital_shelf UnitalShelf
+
 /-- The type of homomorphisms between shelves.
 This is also the notion of rack and quandle homomorphisms.
 -/
@@ -138,6 +152,38 @@ scoped[Quandles] infixr:25 " →◃ " => ShelfHom
 
 open Quandles
 
+namespace UnitalShelf
+open Shelf
+
+variable {S : Type _} [UnitalShelf S]
+
+/--
+A monoid is *graphic* if, for all `x` and `y`, the *graphic identity*
+`(x * y) * x = x * y` holds.  For a unital shelf, this graphic
+identity holds.
+-/
+lemma act_act_self_eq (x y : S) : (x ◃ y) ◃ x = x ◃ y := by
+  have h : (x ◃ y) ◃ x = (x ◃ y) ◃ (x ◃ 1) := by rw [act_one]
+  rw [h, ←Shelf.self_distrib, act_one]
+#align unital_shelf.act_act_self_eq UnitalShelf.act_act_self_eq
+
+lemma act_idem (x : S) : (x ◃ x) = x := by rw [←act_one x, ←Shelf.self_distrib, act_one, act_one]
+#align unital_shelf.act_idem UnitalShelf.act_idem
+
+lemma act_self_act_eq (x y : S) : x ◃ (x ◃ y) = x ◃ y := by
+  have h : x ◃ (x ◃ y) = (x ◃ 1) ◃ (x ◃ y) := by rw [act_one]
+  rw [h, ←Shelf.self_distrib, one_act]
+#align unital_shelf.act_self_act_eq UnitalShelf.act_self_act_eq
+
+/--
+The associativity of a unital shelf comes for free.
+-/
+lemma assoc (x y z : S) : (x ◃ y) ◃ z = x ◃ y ◃ z := by
+  rw [self_distrib, self_distrib, act_act_self_eq, act_self_act_eq]
+#align unital_shelf.assoc UnitalShelf.assoc
+
+end UnitalShelf
+
 namespace Rack
 
 variable {R : Type _} [Rack R]

8631e2d5

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

@@ -108,6 +108,8 @@ structure ShelfHom (S₁ : Type _) (S₂ : Type _) [Shelf S₁] [Shelf S₂] whe
   /-- The homomorphism property of a Shelf Homomorphism-/
   map_act' : ∀ {x y : S₁}, toFun (Shelf.act x y) = Shelf.act (toFun x) (toFun y)
 #align shelf_hom ShelfHom
+#align shelf_hom.ext_iff ShelfHom.ext_iff
+#align shelf_hom.ext ShelfHom.ext
 
 /-- A *rack* is an automorphic set (a set with an action on itself by
 bijections) that is self-distributive.  It is a shelf such that each

8631e2d5

feat: Port Algebra.Quandle (#1817)

e32b06c8

`algebra.quandle` ⟷ `Mathlib.Algebra.Quandle`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 3 + 193

algebra.quandle ⟷ Mathlib.Algebra.Quandle

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 3 + 193

`algebra.quandle` ⟷ `Mathlib.Algebra.Quandle`