ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- HomologicalComplex₂.ι_totalDesc
@[reassoc (attr := simp)]
lemma ι_totalDesc (i₁ : I₁) (i₂ : I₂) (hi : ComplexShape.π c₁ c₂ c₁₂ (i₁, i₂) = i₁₂) :
    K.ιTotal c₁₂ i₁ i₂ i₁₂ hi ≫ K.totalDesc f = f i₁ i₂ hi 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_5, u_1} C] [CategoryTheory.Preadditive C] {I₁ : Type u_2} {I₂ : Type u_3} {I₁₂ : Type u_4} {c₁ : ComplexShape I₁} {c₂ : ComplexShape I₂} (K : HomologicalComplex₂ C c₁ c₂) {c₁₂ : ComplexShape I₁₂} [DecidableEq I₁₂] [TotalComplexShape c₁ c₂ c₁₂] [K.HasTotal c₁₂] {A : C} {i₁₂ : I₁₂} (f : (i₁ : I₁) → (i₂ : I₂) → c₁.π c₂ c₁₂ (i₁, i₂) = i₁₂ → ((K.X i₁).X i₂ ⟶ A)) (i₁ : I₁) (i₂ : I₂) (hi : c₁.π c₂ c₁₂ (i₁, i₂) = i₁₂)
Goal: K.ιTotal c₁₂ i₁ i₂ i₁₂ hi ≫ K.totalDesc f = f i₁ i₂ hi
-- HomologicalComplex₂.total.hom_ext
@[ext]
lemma hom_ext {A : C} {i₁₂ : I₁₂} {f g : (K.total c₁₂).X i₁₂ ⟶ A}
    (h : ∀ (i₁ : I₁) (i₂ : I₂) (hi : ComplexShape.π c₁ c₂ c₁₂ (i₁, i₂) = i₁₂),
      K.ιTotal c₁₂ i₁ i₂ i₁₂ hi ≫ f = K.ιTotal c₁₂ i₁ i₂ i₁₂ hi ≫ g) : f = g 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_5, u_1} C] [CategoryTheory.Preadditive C] {I₁ : Type u_2} {I₂ : Type u_3} {I₁₂ : Type u_4} {c₁ : ComplexShape I₁} {c₂ : ComplexShape I₂} {K : HomologicalComplex₂ C c₁ c₂} (c₁₂ : ComplexShape I₁₂) [DecidableEq I₁₂] [TotalComplexShape c₁ c₂ c₁₂] [K.HasTotal c₁₂] {A : C} {i₁₂ : I₁₂} {f g : (K.total c₁₂).X i₁₂ ⟶ A} (h :
  ∀ (i₁ : I₁) (i₂ : I₂) (hi : c₁.π c₂ c₁₂ (i₁, i₂) = i₁₂),
    K.ιTotal c₁₂ i₁ i₂ i₁₂ hi ≫ f = K.ιTotal c₁₂ i₁ i₂ i₁₂ hi ≫ g)
Goal: f = g
-- HomologicalComplex₂.total.mapAux.d₁_mapMap
@[reassoc (attr := simp)]
lemma d₁_mapMap (i₁ : I₁) (i₂ : I₂) (i₁₂ : I₁₂) :
    K.d₁ c₁₂ i₁ i₂ i₁₂ ≫ GradedObject.mapMap (toGradedObjectMap φ) _ i₁₂ =
    (φ.f i₁).f i₂ ≫ L.d₁ c₁₂ i₁ i₂ i₁₂ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_5, u_1} C] [CategoryTheory.Preadditive C] {I₁ : Type u_2} {I₂ : Type u_3} {I₁₂ : Type u_4} {c₁ : ComplexShape I₁} {c₂ : ComplexShape I₂} {K L : HomologicalComplex₂ C c₁ c₂} (φ : K ⟶ L) (c₁₂ : ComplexShape I₁₂) [DecidableEq I₁₂] [TotalComplexShape c₁ c₂ c₁₂] [K.HasTotal c₁₂] [L.HasTotal c₁₂] (i₁ : I₁) (i₂ : I₂) (i₁₂ : I₁₂)
Goal: K.d₁ c₁₂ i₁ i₂ i₁₂ ≫ CategoryTheory.GradedObject.mapMap (HomologicalComplex₂.toGradedObjectMap φ) (c₁.π c₂ c₁₂) i₁₂ =
  (φ.f i₁).f i₂ ≫ L.d₁ c₁₂ i₁ i₂ i₁₂
-- HomologicalComplex₂.total.mapAux.d₂_mapMap
@[reassoc (attr := simp)]
lemma d₂_mapMap (i₁ : I₁) (i₂ : I₂) (i₁₂ : I₁₂) :
    K.d₂ c₁₂ i₁ i₂ i₁₂ ≫ GradedObject.mapMap (toGradedObjectMap φ) _ i₁₂ =
    (φ.f i₁).f i₂ ≫ L.d₂ c₁₂ i₁ i₂ i₁₂ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_5, u_1} C] [CategoryTheory.Preadditive C] {I₁ : Type u_2} {I₂ : Type u_3} {I₁₂ : Type u_4} {c₁ : ComplexShape I₁} {c₂ : ComplexShape I₂} {K L : HomologicalComplex₂ C c₁ c₂} (φ : K ⟶ L) (c₁₂ : ComplexShape I₁₂) [DecidableEq I₁₂] [TotalComplexShape c₁ c₂ c₁₂] [K.HasTotal c₁₂] [L.HasTotal c₁₂] (i₁ : I₁) (i₂ : I₂) (i₁₂ : I₁₂)
Goal: K.d₂ c₁₂ i₁ i₂ i₁₂ ≫ CategoryTheory.GradedObject.mapMap (HomologicalComplex₂.toGradedObjectMap φ) (c₁.π c₂ c₁₂) i₁₂ =
  (φ.f i₁).f i₂ ≫ L.d₂ c₁₂ i₁ i₂ i₁₂
-- HomologicalComplex₂.total.mapAux.mapMap_D₁
@[reassoc]
lemma mapMap_D₁ (i₁₂ i₁₂' : I₁₂) :
    GradedObject.mapMap (toGradedObjectMap φ) _ i₁₂ ≫ L.D₁ c₁₂ i₁₂ i₁₂' =
      K.D₁ c₁₂ i₁₂ i₁₂' ≫ GradedObject.mapMap (toGradedObjectMap φ) _ i₁₂' 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_5, u_1} C] [CategoryTheory.Preadditive C] {I₁ : Type u_2} {I₂ : Type u_3} {I₁₂ : Type u_4} {c₁ : ComplexShape I₁} {c₂ : ComplexShape I₂} {K L : HomologicalComplex₂ C c₁ c₂} (φ : K ⟶ L) (c₁₂ : ComplexShape I₁₂) [DecidableEq I₁₂] [TotalComplexShape c₁ c₂ c₁₂] [K.HasTotal c₁₂] [L.HasTotal c₁₂] (i₁₂ i₁₂' : I₁₂)
Goal: CategoryTheory.GradedObject.mapMap (HomologicalComplex₂.toGradedObjectMap φ) (c₁.π c₂ c₁₂) i₁₂ ≫ L.D₁ c₁₂ i₁₂ i₁₂' =
  K.D₁ c₁₂ i₁₂ i₁₂' ≫ CategoryTheory.GradedObject.mapMap (HomologicalComplex₂.toGradedObjectMap φ) (c₁.π c₂ c₁₂) i₁₂'
-- HomologicalComplex₂.total.mapAux.mapMap_D₂
@[reassoc]
lemma mapMap_D₂ (i₁₂ i₁₂' : I₁₂) :
    GradedObject.mapMap (toGradedObjectMap φ) _ i₁₂ ≫ L.D₂ c₁₂ i₁₂ i₁₂' =
      K.D₂ c₁₂ i₁₂ i₁₂' ≫ GradedObject.mapMap (toGradedObjectMap φ) _ i₁₂' 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_5, u_1} C] [CategoryTheory.Preadditive C] {I₁ : Type u_2} {I₂ : Type u_3} {I₁₂ : Type u_4} {c₁ : ComplexShape I₁} {c₂ : ComplexShape I₂} {K L : HomologicalComplex₂ C c₁ c₂} (φ : K ⟶ L) (c₁₂ : ComplexShape I₁₂) [DecidableEq I₁₂] [TotalComplexShape c₁ c₂ c₁₂] [K.HasTotal c₁₂] [L.HasTotal c₁₂] (i₁₂ i₁₂' : I₁₂)
Goal: CategoryTheory.GradedObject.mapMap (HomologicalComplex₂.toGradedObjectMap φ) (c₁.π c₂ c₁₂) i₁₂ ≫ L.D₂ c₁₂ i₁₂ i₁₂' =
  K.D₂ c₁₂ i₁₂ i₁₂' ≫ CategoryTheory.GradedObject.mapMap (HomologicalComplex₂.toGradedObjectMap φ) (c₁.π c₂ c₁₂) i₁₂'
-- HomologicalComplex₂.total.forget_map
@[simp]
lemma forget_map :
    (HomologicalComplex.forget C c₁₂).map (map φ c₁₂) =
      GradedObject.mapMap (toGradedObjectMap φ) _ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_5, u_1} C] [CategoryTheory.Preadditive C] {I₁ : Type u_2} {I₂ : Type u_3} {I₁₂ : Type u_4} {c₁ : ComplexShape I₁} {c₂ : ComplexShape I₂} {K L : HomologicalComplex₂ C c₁ c₂} (φ : K ⟶ L) (c₁₂ : ComplexShape I₁₂) [DecidableEq I₁₂] [TotalComplexShape c₁ c₂ c₁₂] [K.HasTotal c₁₂] [L.HasTotal c₁₂]
Goal: (HomologicalComplex.forget C c₁₂).map (HomologicalComplex₂.total.map φ c₁₂) =
  CategoryTheory.GradedObject.mapMap (HomologicalComplex₂.toGradedObjectMap φ) (c₁.π c₂ c₁₂)
-- HomologicalComplex₂.total.map_id
@[simp]
lemma map_id : map (𝟙 K) c₁₂ = 𝟙 _ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_5, u_1} C] [CategoryTheory.Preadditive C] {I₁ : Type u_2} {I₂ : Type u_3} {I₁₂ : Type u_4} {c₁ : ComplexShape I₁} {c₂ : ComplexShape I₂} (K : HomologicalComplex₂ C c₁ c₂) (c₁₂ : ComplexShape I₁₂) [DecidableEq I₁₂] [TotalComplexShape c₁ c₂ c₁₂] [K.HasTotal c₁₂]
Goal: HomologicalComplex₂.total.map (𝟙 K) c₁₂ = 𝟙 (K.total c₁₂)
-- HomologicalComplex₂.total.map_comp
@[simp, reassoc]
lemma map_comp : map (φ ≫ ψ) c₁₂ = map φ c₁₂ ≫ map ψ c₁₂ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_5, u_1} C] [CategoryTheory.Preadditive C] {I₁ : Type u_2} {I₂ : Type u_3} {I₁₂ : Type u_4} {c₁ : ComplexShape I₁} {c₂ : ComplexShape I₂} {K L M : HomologicalComplex₂ C c₁ c₂} (φ : K ⟶ L) (ψ : L ⟶ M) (c₁₂ : ComplexShape I₁₂) [DecidableEq I₁₂] [TotalComplexShape c₁ c₂ c₁₂] [K.HasTotal c₁₂] [L.HasTotal c₁₂] [M.HasTotal c₁₂]
Goal: HomologicalComplex₂.total.map (φ ≫ ψ) c₁₂ = HomologicalComplex₂.total.map φ c₁₂ ≫ HomologicalComplex₂.total.map ψ c₁₂
-- HomologicalComplex₂.total.mapIso_inv
@[simps]
noncomputable def mapIso : K.total c₁₂ ≅ L.total c₁₂ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_5, u_1} C] [CategoryTheory.Preadditive C] {I₁ : Type u_2} {I₂ : Type u_3} {I₁₂ : Type u_4} {c₁ : ComplexShape I₁} {c₂ : ComplexShape I₂} {K L : HomologicalComplex₂ C c₁ c₂} (e : K ≅ L) (c₁₂ : ComplexShape I₁₂) [DecidableEq I₁₂] [TotalComplexShape c₁ c₂ c₁₂] [K.HasTotal c₁₂] [L.HasTotal c₁₂]
Goal: (HomologicalComplex₂.total.mapIso e c₁₂).inv = HomologicalComplex₂.total.map e.inv c₁₂
-- HomologicalComplex₂.total.mapIso_hom
@[simps]
noncomputable def mapIso : K.total c₁₂ ≅ L.total c₁₂ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_5, u_1} C] [CategoryTheory.Preadditive C] {I₁ : Type u_2} {I₂ : Type u_3} {I₁₂ : Type u_4} {c₁ : ComplexShape I₁} {c₂ : ComplexShape I₂} {K L : HomologicalComplex₂ C c₁ c₂} (e : K ≅ L) (c₁₂ : ComplexShape I₁₂) [DecidableEq I₁₂] [TotalComplexShape c₁ c₂ c₁₂] [K.HasTotal c₁₂] [L.HasTotal c₁₂]
Goal: (HomologicalComplex₂.total.mapIso e c₁₂).hom = HomologicalComplex₂.total.map e.hom c₁₂
-- HomologicalComplex₂.ιTotal_map
@[reassoc (attr := simp)]
lemma ιTotal_map (i₁ : I₁) (i₂ : I₂) (i₁₂ : I₁₂) (h : ComplexShape.π c₁ c₂ c₁₂ (i₁, i₂) = i₁₂) :
    K.ιTotal c₁₂ i₁ i₂ i₁₂ h ≫ (total.map φ c₁₂).f i₁₂ =
      (φ.f i₁).f i₂ ≫ L.ιTotal c₁₂ i₁ i₂ i₁₂ h 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_5, u_1} C] [CategoryTheory.Preadditive C] {I₁ : Type u_2} {I₂ : Type u_3} {I₁₂ : Type u_4} {c₁ : ComplexShape I₁} {c₂ : ComplexShape I₂} (K L : HomologicalComplex₂ C c₁ c₂) (φ : K ⟶ L) (c₁₂ : ComplexShape I₁₂) [DecidableEq I₁₂] [TotalComplexShape c₁ c₂ c₁₂] [K.HasTotal c₁₂] [L.HasTotal c₁₂] (i₁ : I₁) (i₂ : I₂) (i₁₂ : I₁₂) (h : c₁.π c₂ c₁₂ (i₁, i₂) = i₁₂)
Goal: K.ιTotal c₁₂ i₁ i₂ i₁₂ h ≫ (HomologicalComplex₂.total.map φ c₁₂).f i₁₂ = (φ.f i₁).f i₂ ≫ L.ιTotal c₁₂ i₁ i₂ i₁₂ h
-- HomologicalComplex₂.ιTotalOrZero_map
@[reassoc (attr := simp)]
lemma ιTotalOrZero_map (i₁ : I₁) (i₂ : I₂) (i₁₂ : I₁₂) :
    K.ιTotalOrZero c₁₂ i₁ i₂ i₁₂ ≫ (total.map φ c₁₂).f i₁₂ =
      (φ.f i₁).f i₂ ≫ L.ιTotalOrZero c₁₂ i₁ i₂ i₁₂ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_5, u_1} C] [CategoryTheory.Preadditive C] {I₁ : Type u_2} {I₂ : Type u_3} {I₁₂ : Type u_4} {c₁ : ComplexShape I₁} {c₂ : ComplexShape I₂} (K L : HomologicalComplex₂ C c₁ c₂) (φ : K ⟶ L) (c₁₂ : ComplexShape I₁₂) [DecidableEq I₁₂] [TotalComplexShape c₁ c₂ c₁₂] [K.HasTotal c₁₂] [L.HasTotal c₁₂] (i₁ : I₁) (i₂ : I₂) (i₁₂ : I₁₂)
Goal: K.ιTotalOrZero c₁₂ i₁ i₂ i₁₂ ≫ (HomologicalComplex₂.total.map φ c₁₂).f i₁₂ =
  (φ.f i₁).f i₂ ≫ L.ιTotalOrZero c₁₂ i₁ i₂ i₁₂
-- HomologicalComplex₂.totalFunctor_map
@[simps]
noncomputable def totalFunctor :
    HomologicalComplex₂ C c₁ c₂ ⥤ HomologicalComplex C c₁₂ 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_5, u_1} C] [CategoryTheory.Preadditive C] {I₁ : Type u_2} {I₂ : Type u_3} {I₁₂ : Type u_4} (c₁ : ComplexShape I₁) (c₂ : ComplexShape I₂) (c₁₂ : ComplexShape I₁₂) [DecidableEq I₁₂] [TotalComplexShape c₁ c₂ c₁₂] [∀ (K : HomologicalComplex₂ C c₁ c₂), K.HasTotal c₁₂]
Goal: ∀ {X Y : HomologicalComplex₂ C c₁ c₂} (φ : X ⟶ Y),
  (HomologicalComplex₂.totalFunctor C c₁ c₂ c₁₂).map φ = HomologicalComplex₂.total.map φ c₁₂
-- HomologicalComplex₂.totalFunctor_obj
@[simps]
noncomputable def totalFunctor :
    HomologicalComplex₂ C c₁ c₂ ⥤ HomologicalComplex C c₁₂ 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_5, u_1} C] [CategoryTheory.Preadditive C] {I₁ : Type u_2} {I₂ : Type u_3} {I₁₂ : Type u_4} (c₁ : ComplexShape I₁) (c₂ : ComplexShape I₂) (c₁₂ : ComplexShape I₁₂) [DecidableEq I₁₂] [TotalComplexShape c₁ c₂ c₁₂] [∀ (K : HomologicalComplex₂ C c₁ c₂), K.HasTotal c₁₂] (K : HomologicalComplex₂ C c₁ c₂)
Goal: (HomologicalComplex₂.totalFunctor C c₁ c₂ c₁₂).obj K = K.total c₁₂
-- GenContFract.IntFractPair.coe_to_intFractPair
@[simp, norm_cast]
theorem coe_to_intFractPair {b : ℤ} {fr : K} :
    (↑(IntFractPair.mk b fr) : IntFractPair β) = IntFractPair.mk b (↑fr : β) 
Arguments: {K : Type u_1} {β : Type u_2} [Coe K β] {b : ℤ} {fr : K}
Goal: ↑{ b := b, fr := fr } = { b := b, fr := Coe.coe fr }
-- GenContFract.IntFractPair.stream_isSeq
theorem stream_isSeq (v : K) : (IntFractPair.stream v).IsSeq 
Arguments: {K : Type u_1} [LinearOrderedField K] [FloorRing K] (v : K)
Goal: (GenContFract.IntFractPair.stream v).IsSeq
-- Shelf.self_distrib
class Shelf (α : Type u) where
    act : α → α → α
    self_distrib : ∀ {x y z : α}, act x (act y z) = act (act x y) (act x z)
Arguments: {α : Type u} [self : Shelf α] {x y z : α}
Goal: x ◃ y ◃ z = (x ◃ y) ◃ x ◃ z
-- UnitalShelf.one_act
class UnitalShelf (α : Type u) extends Shelf α, One α :=
(one_act : ∀ a : α, act 1 a = a)
(act_one : ∀ a : α, act a 1 = a)
Arguments: {α : Type u} [self : UnitalShelf α] (a : α)
Goal: 1 ◃ a = a
-- UnitalShelf.act_one
class UnitalShelf (α : Type u) extends Shelf α, One α :=
(one_act : ∀ a : α, act 1 a = a)
(act_one : ∀ a : α, act a 1 = a)
Arguments: {α : Type u} [self : UnitalShelf α] (a : α)
Goal: a ◃ 1 = a
-- ShelfHom.map_act'
@[ext]
structure ShelfHom (S₁ : Type*) (S₂ : Type*) [Shelf S₁] [Shelf S₂] where
    toFun : S₁ → S₂
    map_act' : ∀ {x y : S₁}, toFun (Shelf.act x y) = Shelf.act (toFun x) (toFun y)
Arguments: {S₁ : Type u_1} {S₂ : Type u_2} [Shelf S₁] [Shelf S₂] (self : S₁ →◃ S₂) {x y : S₁}
Goal: self.toFun (x ◃ y) = self.toFun x ◃ self.toFun y
-- Rack.left_inv
class Rack (α : Type u) extends Shelf α where
    invAct : α → α → α
    left_inv : ∀ x, Function.LeftInverse (invAct x) (act x)
    right_inv : ∀ x, Function.RightInverse (invAct x) (act x)
Arguments: {α : Type u} [self : Rack α] (x : α)
Goal: Function.LeftInverse (Rack.invAct x) (Shelf.act x)
-- Rack.right_inv
class Rack (α : Type u) extends Shelf α where
    invAct : α → α → α
    left_inv : ∀ x, Function.LeftInverse (invAct x) (act x)
    right_inv : ∀ x, Function.RightInverse (invAct x) (act x)
Arguments: {α : Type u} [self : Rack α] (x : α)
Goal: Function.RightInverse (Rack.invAct x) (Shelf.act x)
-- UnitalShelf.act_act_self_eq
lemma act_act_self_eq (x y : S) : (x ◃ y) ◃ x = x ◃ y 
Arguments: {S : Type u_1} [UnitalShelf S] (x y : S)
Goal: (x ◃ y) ◃ x = x ◃ y
-- UnitalShelf.act_idem
lemma act_idem (x : S) : (x ◃ x) = x 
Arguments: {S : Type u_1} [UnitalShelf S] (x : S)
Goal: x ◃ x = x
-- UnitalShelf.act_self_act_eq
lemma act_self_act_eq (x y : S) : x ◃ (x ◃ y) = x ◃ y 
Arguments: {S : Type u_1} [UnitalShelf S] (x y : S)
Goal: x ◃ x ◃ y = x ◃ y
-- UnitalShelf.assoc
lemma assoc (x y z : S) : (x ◃ y) ◃ z = x ◃ y ◃ z 
Arguments: {S : Type u_1} [UnitalShelf S] (x y z : S)
Goal: (x ◃ y) ◃ z = x ◃ y ◃ z
-- Rack.act'_apply
@[simp]
theorem act'_apply (x y : R) : act' x y = x ◃ y 
Arguments: {R : Type u_1} [Rack R] (x y : R)
Goal: (Rack.act' x) y = x ◃ y
-- Rack.act'_symm_apply
@[simp]
theorem act'_symm_apply (x y : R) : (act' x).symm y = x ◃⁻¹ y 
Arguments: {R : Type u_1} [Rack R] (x y : R)
Goal: (Rack.act' x).symm y = x ◃⁻¹ y
-- Rack.invAct_apply
@[simp]
theorem invAct_apply (x y : R) : (act' x)⁻¹ y = x ◃⁻¹ y 
Arguments: {R : Type u_1} [Rack R] (x y : R)
Goal: (Rack.act' x)⁻¹ y = x ◃⁻¹ y
-- Rack.invAct_act_eq
@[simp]
theorem invAct_act_eq (x y : R) : x ◃⁻¹ x ◃ y = y 
Arguments: {R : Type u_1} [Rack R] (x y : R)
Goal: x ◃⁻¹ x ◃ y = y
-- Rack.act_invAct_eq
@[simp]
theorem act_invAct_eq (x y : R) : x ◃ x ◃⁻¹ y = y 
Arguments: {R : Type u_1} [Rack R] (x y : R)
Goal: x ◃ x ◃⁻¹ y = y
-- Rack.left_cancel
theorem left_cancel (x : R) {y y' : R} : x ◃ y = x ◃ y' ↔ y = y' 
Arguments: {R : Type u_1} [Rack R] (x : R) {y y' : R}
Goal: x ◃ y = x ◃ y' ↔ y = y'
-- Rack.left_cancel_inv
theorem left_cancel_inv (x : R) {y y' : R} : x ◃⁻¹ y = x ◃⁻¹ y' ↔ y = y' 
Arguments: {R : Type u_1} [Rack R] (x : R) {y y' : R}
Goal: x ◃⁻¹ y = x ◃⁻¹ y' ↔ y = y'
-- Rack.self_distrib_inv
theorem self_distrib_inv {x y z : R} : x ◃⁻¹ y ◃⁻¹ z = (x ◃⁻¹ y) ◃⁻¹ x ◃⁻¹ z 
Arguments: {R : Type u_1} [Rack R] {x y z : R}
Goal: x ◃⁻¹ y ◃⁻¹ z = (x ◃⁻¹ y) ◃⁻¹ x ◃⁻¹ z
-- Rack.ad_conj
theorem ad_conj {R : Type*} [Rack R] (x y : R) : act' (x ◃ y) = act' x * act' y * (act' x)⁻¹ 
Arguments: {R : Type u_2} [Rack R] (x y : R)
Goal: Rack.act' (x ◃ y) = Rack.act' x * Rack.act' y * (Rack.act' x)⁻¹
-- Rack.op_act_op_eq
@[simp]
theorem op_act_op_eq {x y : R} : op x ◃ op y = op (x ◃⁻¹ y) 
Arguments: {R : Type u_1} [Rack R] {x y : R}
Goal: MulOpposite.op x ◃ MulOpposite.op y = MulOpposite.op (x ◃⁻¹ y)
-- Rack.op_invAct_op_eq
@[simp]
theorem op_invAct_op_eq {x y : R} : op x ◃⁻¹ op y = op (x ◃ y) 
Arguments: {R : Type u_1} [Rack R] {x y : R}
Goal: MulOpposite.op x ◃⁻¹ MulOpposite.op y = MulOpposite.op (x ◃ y)
-- Rack.self_act_act_eq
@[simp]
theorem self_act_act_eq {x y : R} : (x ◃ x) ◃ y = x ◃ y 
Arguments: {R : Type u_1} [Rack R] {x y : R}
Goal: (x ◃ x) ◃ y = x ◃ y
-- Rack.self_invAct_invAct_eq
@[simp]
theorem self_invAct_invAct_eq {x y : R} : (x ◃⁻¹ x) ◃⁻¹ y = x ◃⁻¹ y 
Arguments: {R : Type u_1} [Rack R] {x y : R}
Goal: (x ◃⁻¹ x) ◃⁻¹ y = x ◃⁻¹ y
-- Rack.self_act_invAct_eq
@[simp]
theorem self_act_invAct_eq {x y : R} : (x ◃ x) ◃⁻¹ y = x ◃⁻¹ y 
Arguments: {R : Type u_1} [Rack R] {x y : R}
Goal: (x ◃ x) ◃⁻¹ y = x ◃⁻¹ y
-- Rack.self_invAct_act_eq
@[simp]
theorem self_invAct_act_eq {x y : R} : (x ◃⁻¹ x) ◃ y = x ◃ y 
Arguments: {R : Type u_1} [Rack R] {x y : R}
Goal: (x ◃⁻¹ x) ◃ y = x ◃ y
-- Rack.self_act_eq_iff_eq
theorem self_act_eq_iff_eq {x y : R} : x ◃ x = y ◃ y ↔ x = y 
Arguments: {R : Type u_1} [Rack R] {x y : R}
Goal: x ◃ x = y ◃ y ↔ x = y
-- Rack.self_invAct_eq_iff_eq
theorem self_invAct_eq_iff_eq {x y : R} : x ◃⁻¹ x = y ◃⁻¹ y ↔ x = y 
Arguments: {R : Type u_1} [Rack R] {x y : R}
Goal: x ◃⁻¹ x = y ◃⁻¹ y ↔ x = y
-- Rack.involutory_invAct_eq_act
theorem involutory_invAct_eq_act {R : Type*} [Rack R] (h : IsInvolutory R) (x y : R) :
    x ◃⁻¹ y = x ◃ y 
Arguments: {R : Type u_2} [Rack R] (h : Rack.IsInvolutory R) (x y : R)
Goal: x ◃⁻¹ y = x ◃ y
-- Rack.assoc_iff_id
theorem assoc_iff_id {R : Type*} [Rack R] {x y z : R} : x ◃ y ◃ z = (x ◃ y) ◃ z ↔ x ◃ z = z 
Arguments: {R : Type u_2} [Rack R] {x y z : R}
Goal: x ◃ y ◃ z = (x ◃ y) ◃ z ↔ x ◃ z = z
-- ShelfHom.toFun_eq_coe
@[simp] theorem toFun_eq_coe (f : S₁ →◃ S₂) : f.toFun = f 
Arguments: {S₁ : Type u_1} {S₂ : Type u_2} [Shelf S₁] [Shelf S₂] (f : S₁ →◃ S₂)
Goal: f.toFun = ⇑f
-- ShelfHom.map_act
@[simp]
theorem map_act (f : S₁ →◃ S₂) {x y : S₁} : f (x ◃ y) = f x ◃ f y 
Arguments: {S₁ : Type u_1} {S₂ : Type u_2} [Shelf S₁] [Shelf S₂] (f : S₁ →◃ S₂) {x y : S₁}
Goal: f (x ◃ y) = f x ◃ f y
-- ShelfHom.comp_apply
@[simp]
theorem comp_apply (g : S₂ →◃ S₃) (f : S₁ →◃ S₂) (x : S₁) : (g.comp f) x = g (f x) 
Arguments: {S₁ : Type u_1} {S₂ : Type u_2} {S₃ : Type u_3} [Shelf S₁] [Shelf S₂] [Shelf S₃] (g : S₂ →◃ S₃) (f : S₁ →◃ S₂) (x : S₁)
Goal: (g.comp f) x = g (f x)
-- Quandle.fix
class Quandle (α : Type*) extends Rack α where
    fix : ∀ {x : α}, act x x = x
Arguments: {α : Type u_1} [self : Quandle α] {x : α}
Goal: x ◃ x = x
-- Quandle.fix_inv
@[simp]
theorem fix_inv {x : Q} : x ◃⁻¹ x = x 
Arguments: {Q : Type u_1} [Quandle Q] {x : Q}
Goal: x ◃⁻¹ x = x
-- 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) 
Arguments: {G : Type u_2} [Group G] (x y : Quandle.Conj G)
Goal: x ◃ y = x * y * x⁻¹
-- Quandle.conj_swap
theorem conj_swap {G : Type*} [Group G] (x y : Conj G) : x ◃ y = y ↔ y ◃ x = x 
Arguments: {G : Type u_2} [Group G] (x y : Quandle.Conj G)
Goal: x ◃ y = y ↔ y ◃ x = x
-- Quandle.dihedralAct.inv
theorem dihedralAct.inv (n : ℕ) (a : ZMod n) : Function.Involutive (dihedralAct n a) 
Arguments: (n : ℕ) (a : ZMod n)
Goal: Function.Involutive (Quandle.dihedralAct n a)
-- Rack.PreEnvelGroupRel'.rel
theorem PreEnvelGroupRel'.rel {R : Type u} [Rack R] {a b : PreEnvelGroup R} :
    PreEnvelGroupRel' R a b → PreEnvelGroupRel R a b 
Arguments: {R : Type u} [Rack R] {a b : Rack.PreEnvelGroup R}
Goal: Rack.PreEnvelGroupRel' R a b → Rack.PreEnvelGroupRel R a b
-- Rack.PreEnvelGroupRel.refl
@[refl]
theorem PreEnvelGroupRel.refl {R : Type u} [Rack R] {a : PreEnvelGroup R} :
    PreEnvelGroupRel R a a 
Arguments: {R : Type u} [Rack R] {a : Rack.PreEnvelGroup R}
Goal: Rack.PreEnvelGroupRel R a a
-- Rack.PreEnvelGroupRel.symm
@[symm]
theorem PreEnvelGroupRel.symm {R : Type u} [Rack R] {a b : PreEnvelGroup R} :
    PreEnvelGroupRel R a b → PreEnvelGroupRel R b a
  
Arguments: {R : Type u} [Rack R] {a b : Rack.PreEnvelGroup R}
Goal: Rack.PreEnvelGroupRel R a b → Rack.PreEnvelGroupRel R b a
-- Rack.PreEnvelGroupRel.trans
@[trans]
theorem PreEnvelGroupRel.trans {R : Type u} [Rack R] {a b c : PreEnvelGroup R} :
    PreEnvelGroupRel R a b → PreEnvelGroupRel R b c → PreEnvelGroupRel R a c
  
Arguments: {R : Type u} [Rack R] {a b c : Rack.PreEnvelGroup R}
Goal: Rack.PreEnvelGroupRel R a b → Rack.PreEnvelGroupRel R b c → Rack.PreEnvelGroupRel R a c
-- Rack.toEnvelGroup.mapAux.well_def
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
  
Arguments: {R : Type u_1} [Rack R] {G : Type u_2} [Group G] (f : R →◃ Quandle.Conj G) {a b : Rack.PreEnvelGroup R}
Goal: Rack.PreEnvelGroupRel' R a b → Rack.toEnvelGroup.mapAux f a = Rack.toEnvelGroup.mapAux f b
-- Rack.toEnvelGroup.univ
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 
Arguments: (R : Type u_1) [Rack R] (G : Type u_2) [Group G] (f : R →◃ Quandle.Conj G)
Goal: (Quandle.Conj.map (Rack.toEnvelGroup.map f)).comp (Rack.toEnvelGroup R) = f
-- Rack.toEnvelGroup.univ_uniq
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 
Arguments: (R : Type u_1) [Rack R] (G : Type u_2) [Group G] (f : R →◃ Quandle.Conj G) (g : Rack.EnvelGroup R →* G) (h : f = (Quandle.Conj.map g).comp (Rack.toEnvelGroup R))
Goal: g = Rack.toEnvelGroup.map f
-- Rack.envelAction_prop
@[simp]
theorem envelAction_prop {R : Type*} [Rack R] (x y : R) :
    envelAction (toEnvelGroup R x) y = x ◃ y 
Arguments: {R : Type u_1} [Rack R] (x y : R)
Goal: (Rack.envelAction ((Rack.toEnvelGroup R) x)) y = x ◃ y
-- DirectSum.GAlgebra.smul_def
class GAlgebra where
  toFun : R →+ A 0
  map_one : toFun 1 = GradedMonoid.GOne.one
  map_mul :
    ∀ r s, GradedMonoid.mk _ (toFun (r * s)) = .mk _ (GradedMonoid.GMul.mul (toFun r) (toFun s))
  commutes : ∀ (r) (x : GradedMonoid A), .mk _ (toFun r) * x = x * .mk _ (toFun r)
  smul_def : ∀ (r) (x : GradedMonoid A), r • x = .mk _ (toFun r) * x
Arguments: {ι : Type uι} {R : Type uR} {A : ι → Type uA} [DecidableEq ι] [CommSemiring R] [(i : ι) → AddCommMonoid (A i)] [(i : ι) → Module R (A i)] [AddMonoid ι] [DirectSum.GSemiring A] [self : DirectSum.GAlgebra R A] (r : R) (x : GradedMonoid A)
Goal: r • x = GradedMonoid.mk 0 (DirectSum.GAlgebra.toFun r) * x
-- DirectSum.GAlgebra.map_one
class GAlgebra where
  toFun : R →+ A 0
  map_one : toFun 1 = GradedMonoid.GOne.one
  map_mul :
    ∀ r s, GradedMonoid.mk _ (toFun (r * s)) = .mk _ (GradedMonoid.GMul.mul (toFun r) (toFun s))
  commutes : ∀ (r) (x : GradedMonoid A), .mk _ (toFun r) * x = x * .mk _ (toFun r)
  smul_def : ∀ (r) (x : GradedMonoid A), r • x = .mk _ (toFun r) * x
Arguments: {ι : Type uι} {R : Type uR} {A : ι → Type uA} [DecidableEq ι] [CommSemiring R] [(i : ι) → AddCommMonoid (A i)] [(i : ι) → Module R (A i)] [AddMonoid ι] [DirectSum.GSemiring A] [self : DirectSum.GAlgebra R A]
Goal: DirectSum.GAlgebra.toFun 1 = GradedMonoid.GOne.one
-- DirectSum.GAlgebra.map_mul
class GAlgebra where
  toFun : R →+ A 0
  map_one : toFun 1 = GradedMonoid.GOne.one
  map_mul :
    ∀ r s, GradedMonoid.mk _ (toFun (r * s)) = .mk _ (GradedMonoid.GMul.mul (toFun r) (toFun s))
  commutes : ∀ (r) (x : GradedMonoid A), .mk _ (toFun r) * x = x * .mk _ (toFun r)
  smul_def : ∀ (r) (x : GradedMonoid A), r • x = .mk _ (toFun r) * x
Arguments: {ι : Type uι} {R : Type uR} {A : ι → Type uA} [DecidableEq ι] [CommSemiring R] [(i : ι) → AddCommMonoid (A i)] [(i : ι) → Module R (A i)] [AddMonoid ι] [DirectSum.GSemiring A] [self : DirectSum.GAlgebra R A] (r s : R)
Goal: GradedMonoid.mk 0 (DirectSum.GAlgebra.toFun (r * s)) =
  GradedMonoid.mk (0 + 0) (GradedMonoid.GMul.mul (DirectSum.GAlgebra.toFun r) (DirectSum.GAlgebra.toFun s))
-- DirectSum.GAlgebra.commutes
class GAlgebra where
  toFun : R →+ A 0
  map_one : toFun 1 = GradedMonoid.GOne.one
  map_mul :
    ∀ r s, GradedMonoid.mk _ (toFun (r * s)) = .mk _ (GradedMonoid.GMul.mul (toFun r) (toFun s))
  commutes : ∀ (r) (x : GradedMonoid A), .mk _ (toFun r) * x = x * .mk _ (toFun r)
  smul_def : ∀ (r) (x : GradedMonoid A), r • x = .mk _ (toFun r) * x
Arguments: {ι : Type uι} {R : Type uR} {A : ι → Type uA} [DecidableEq ι] [CommSemiring R] [(i : ι) → AddCommMonoid (A i)] [(i : ι) → Module R (A i)] [AddMonoid ι] [DirectSum.GSemiring A] [self : DirectSum.GAlgebra R A] (r : R) (x : GradedMonoid A)
Goal: GradedMonoid.mk 0 (DirectSum.GAlgebra.toFun r) * x = x * GradedMonoid.mk 0 (DirectSum.GAlgebra.toFun r)
-- DirectSum.algebraMap_apply
theorem algebraMap_apply (r : R) :
    algebraMap R (⨁ i, A i) r = DirectSum.of A 0 (GAlgebra.toFun r) 
Arguments: {ι : Type uι} (R : Type uR) (A : ι → Type uA) [DecidableEq ι] [CommSemiring R] [(i : ι) → AddCommMonoid (A i)] [(i : ι) → Module R (A i)] [AddMonoid ι] [DirectSum.GSemiring A] [DirectSum.GAlgebra R A] (r : R)
Goal: (algebraMap R (DirectSum ι fun i => A i)) r = (DirectSum.of A 0) (DirectSum.GAlgebra.toFun r)