ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Homotopy.nullHomotopicMap_f_eq_zero
@[simp]
theorem nullHomotopicMap_f_eq_zero {k₀ : ι} (hk₀ : ∀ l : ι, ¬c.Rel k₀ l)
    (hk₀' : ∀ l : ι, ¬c.Rel l k₀) (hom : ∀ i j, C.X i ⟶ D.X j) :
    (nullHomotopicMap hom).f k₀ = 0 
Arguments: {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Preadditive V] {c : ComplexShape ι} {C D : HomologicalComplex V c} {k₀ : ι} (hk₀ : ∀ (l : ι), ¬c.Rel k₀ l) (hk₀' : ∀ (l : ι), ¬c.Rel l k₀) (hom : (i j : ι) → C.X i ⟶ D.X j)
Goal: (Homotopy.nullHomotopicMap hom).f k₀ = 0
-- Homotopy.nullHomotopicMap'_f_eq_zero
@[simp]
theorem nullHomotopicMap'_f_eq_zero {k₀ : ι} (hk₀ : ∀ l : ι, ¬c.Rel k₀ l)
    (hk₀' : ∀ l : ι, ¬c.Rel l k₀) (h : ∀ i j, c.Rel j i → (C.X i ⟶ D.X j)) :
    (nullHomotopicMap' h).f k₀ = 0 
Arguments: {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Preadditive V] {c : ComplexShape ι} {C D : HomologicalComplex V c} {k₀ : ι} (hk₀ : ∀ (l : ι), ¬c.Rel k₀ l) (hk₀' : ∀ (l : ι), ¬c.Rel l k₀) (h : (i j : ι) → c.Rel j i → (C.X i ⟶ D.X j))
Goal: (Homotopy.nullHomotopicMap' h).f k₀ = 0
-- Homotopy.prevD_chainComplex
@[simp 1100]
theorem prevD_chainComplex (f : ∀ i j, P.X i ⟶ Q.X j) (j : ℕ) :
    prevD j f = f j (j + 1) ≫ Q.d _ _ 
Arguments: {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Preadditive V] {P Q : ChainComplex V ℕ} (f : (i j : ℕ) → P.X i ⟶ Q.X j) (j : ℕ)
Goal: (prevD j) f = f j (j + 1) ≫ Q.d (j + 1) j
-- Homotopy.dNext_succ_chainComplex
@[simp 1100]
theorem dNext_succ_chainComplex (f : ∀ i j, P.X i ⟶ Q.X j) (i : ℕ) :
    dNext (i + 1) f = P.d _ _ ≫ f i (i + 1) 
Arguments: {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Preadditive V] {P Q : ChainComplex V ℕ} (f : (i j : ℕ) → P.X i ⟶ Q.X j) (i : ℕ)
Goal: (dNext (i + 1)) f = P.d (i + 1) i ≫ f i (i + 1)
-- Homotopy.dNext_zero_chainComplex
@[simp 1100]
theorem dNext_zero_chainComplex (f : ∀ i j, P.X i ⟶ Q.X j) : dNext 0 f = 0 
Arguments: {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Preadditive V] {P Q : ChainComplex V ℕ} (f : (i j : ℕ) → P.X i ⟶ Q.X j)
Goal: (dNext 0) f = 0
-- Homotopy.mkInductiveAux₂_zero
@[simp] theorem mkInductiveAux₂_zero :
    mkInductiveAux₂ e zero comm_zero one comm_one succ 0 =
      ⟨0, zero ≫ (Q.xPrevIso rfl).inv, mkInductiveAux₂.proof_2 e zero comm_zero⟩ 
Arguments: {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Preadditive V] {P Q : ChainComplex V ℕ} (e : P ⟶ Q) (zero : P.X 0 ⟶ Q.X 1) (comm_zero : e.f 0 = zero ≫ Q.d 1 0) (one : P.X 1 ⟶ Q.X 2) (comm_one : e.f 1 = P.d 1 0 ≫ zero + one ≫ Q.d 2 1) (succ :
  (n : ℕ) →
    (p :
        (f : P.X n ⟶ Q.X (n + 1)) ×'
          (f' : P.X (n + 1) ⟶ Q.X (n + 2)) ×' e.f (n + 1) = P.d (n + 1) n ≫ f + f' ≫ Q.d (n + 2) (n + 1)) →
      (f'' : P.X (n + 2) ⟶ Q.X (n + 3)) ×' e.f (n + 2) = P.d (n + 2) (n + 1) ≫ p.snd.fst + f'' ≫ Q.d (n + 3) (n + 2))
Goal: Homotopy.mkInductiveAux₂ e zero comm_zero one comm_one succ 0 = ⟨0, ⟨zero ≫ (HomologicalComplex.xPrevIso Q ⋯).inv, ⋯⟩⟩
-- Homotopy.mkInductiveAux₂_add_one
@[simp] theorem mkInductiveAux₂_add_one (n) :
    mkInductiveAux₂ e zero comm_zero one comm_one succ (n + 1) =
      let I := mkInductiveAux₁ e zero one comm_one succ n
      ⟨(P.xNextIso rfl).hom ≫ I.1, I.2.1 ≫ (Q.xPrevIso rfl).inv,
        mkInductiveAux₂.proof_5 e zero one comm_one succ n⟩ 
Arguments: {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Preadditive V] {P Q : ChainComplex V ℕ} (e : P ⟶ Q) (zero : P.X 0 ⟶ Q.X 1) (comm_zero : e.f 0 = zero ≫ Q.d 1 0) (one : P.X 1 ⟶ Q.X 2) (comm_one : e.f 1 = P.d 1 0 ≫ zero + one ≫ Q.d 2 1) (succ :
  (n : ℕ) →
    (p :
        (f : P.X n ⟶ Q.X (n + 1)) ×'
          (f' : P.X (n + 1) ⟶ Q.X (n + 2)) ×' e.f (n + 1) = P.d (n + 1) n ≫ f + f' ≫ Q.d (n + 2) (n + 1)) →
      (f'' : P.X (n + 2) ⟶ Q.X (n + 3)) ×' e.f (n + 2) = P.d (n + 2) (n + 1) ≫ p.snd.fst + f'' ≫ Q.d (n + 3) (n + 2)) (n : ℕ)
Goal: Homotopy.mkInductiveAux₂ e zero comm_zero one comm_one succ (n + 1) =
  let I := Homotopy.mkInductiveAux₁ e zero one comm_one succ n;
  ⟨(HomologicalComplex.xNextIso P ⋯).hom ≫ I.fst, ⟨I.snd.fst ≫ (HomologicalComplex.xPrevIso Q ⋯).inv, ⋯⟩⟩
-- Homotopy.mkInductiveAux₃
theorem mkInductiveAux₃ (i j : ℕ) (h : i + 1 = j) :
    (mkInductiveAux₂ e zero comm_zero one comm_one succ i).2.1 ≫ (Q.xPrevIso h).hom =
      (P.xNextIso h).inv ≫ (mkInductiveAux₂ e zero comm_zero one comm_one succ j).1 
Arguments: {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Preadditive V] {P Q : ChainComplex V ℕ} (e : P ⟶ Q) (zero : P.X 0 ⟶ Q.X 1) (comm_zero : e.f 0 = zero ≫ Q.d 1 0) (one : P.X 1 ⟶ Q.X 2) (comm_one : e.f 1 = P.d 1 0 ≫ zero + one ≫ Q.d 2 1) (succ :
  (n : ℕ) →
    (p :
        (f : P.X n ⟶ Q.X (n + 1)) ×'
          (f' : P.X (n + 1) ⟶ Q.X (n + 2)) ×' e.f (n + 1) = P.d (n + 1) n ≫ f + f' ≫ Q.d (n + 2) (n + 1)) →
      (f'' : P.X (n + 2) ⟶ Q.X (n + 3)) ×' e.f (n + 2) = P.d (n + 2) (n + 1) ≫ p.snd.fst + f'' ≫ Q.d (n + 3) (n + 2)) (i j : ℕ) (h : i + 1 = j)
Goal: (Homotopy.mkInductiveAux₂ e zero comm_zero one comm_one succ i).snd.fst ≫ (HomologicalComplex.xPrevIso Q h).hom =
  (HomologicalComplex.xNextIso P h).inv ≫ (Homotopy.mkInductiveAux₂ e zero comm_zero one comm_one succ j).fst
-- Homotopy.dNext_cochainComplex
@[simp 1100]
theorem dNext_cochainComplex (f : ∀ i j, P.X i ⟶ Q.X j) (j : ℕ) :
    dNext j f = P.d _ _ ≫ f (j + 1) j 
Arguments: {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Preadditive V] {P Q : CochainComplex V ℕ} (f : (i j : ℕ) → P.X i ⟶ Q.X j) (j : ℕ)
Goal: (dNext j) f = P.d j (j + 1) ≫ f (j + 1) j
-- Homotopy.prevD_succ_cochainComplex
@[simp 1100]
theorem prevD_succ_cochainComplex (f : ∀ i j, P.X i ⟶ Q.X j) (i : ℕ) :
    prevD (i + 1) f = f (i + 1) _ ≫ Q.d i (i + 1) 
Arguments: {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Preadditive V] {P Q : CochainComplex V ℕ} (f : (i j : ℕ) → P.X i ⟶ Q.X j) (i : ℕ)
Goal: (prevD (i + 1)) f = f (i + 1) i ≫ Q.d i (i + 1)
-- Homotopy.prevD_zero_cochainComplex
@[simp 1100]
theorem prevD_zero_cochainComplex (f : ∀ i j, P.X i ⟶ Q.X j) : prevD 0 f = 0 
Arguments: {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Preadditive V] {P Q : CochainComplex V ℕ} (f : (i j : ℕ) → P.X i ⟶ Q.X j)
Goal: (prevD 0) f = 0
-- Homotopy.mkCoinductiveAux₂_zero
@[simp] theorem mkCoinductiveAux₂_zero :
    mkCoinductiveAux₂ e zero comm_zero one comm_one succ 0 =
      ⟨0, (P.xNextIso rfl).hom ≫ zero, mkCoinductiveAux₂.proof_2 e zero comm_zero⟩ 
Arguments: {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Preadditive V] {P Q : CochainComplex V ℕ} (e : P ⟶ Q) (zero : P.X 1 ⟶ Q.X 0) (comm_zero : e.f 0 = P.d 0 1 ≫ zero) (one : P.X 2 ⟶ Q.X 1) (comm_one : e.f 1 = zero ≫ Q.d 0 1 + P.d 1 2 ≫ one) (succ :
  (n : ℕ) →
    (p :
        (f : P.X (n + 1) ⟶ Q.X n) ×'
          (f' : P.X (n + 2) ⟶ Q.X (n + 1)) ×' e.f (n + 1) = f ≫ Q.d n (n + 1) + P.d (n + 1) (n + 2) ≫ f') →
      (f'' : P.X (n + 3) ⟶ Q.X (n + 2)) ×' e.f (n + 2) = p.snd.fst ≫ Q.d (n + 1) (n + 2) + P.d (n + 2) (n + 3) ≫ f'')
Goal: Homotopy.mkCoinductiveAux₂ e zero comm_zero one comm_one succ 0 = ⟨0, ⟨(HomologicalComplex.xNextIso P ⋯).hom ≫ zero, ⋯⟩⟩
-- Homotopy.mkCoinductiveAux₂_add_one
@[simp] theorem mkCoinductiveAux₂_add_one (n) :
    mkCoinductiveAux₂ e zero comm_zero one comm_one succ (n + 1) =
      let I := mkCoinductiveAux₁ e zero one comm_one succ n
      ⟨I.1 ≫ (Q.xPrevIso rfl).inv, (P.xNextIso rfl).hom ≫ I.2.1,
        mkCoinductiveAux₂.proof_5 e zero one comm_one succ n⟩ 
Arguments: {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Preadditive V] {P Q : CochainComplex V ℕ} (e : P ⟶ Q) (zero : P.X 1 ⟶ Q.X 0) (comm_zero : e.f 0 = P.d 0 1 ≫ zero) (one : P.X 2 ⟶ Q.X 1) (comm_one : e.f 1 = zero ≫ Q.d 0 1 + P.d 1 2 ≫ one) (succ :
  (n : ℕ) →
    (p :
        (f : P.X (n + 1) ⟶ Q.X n) ×'
          (f' : P.X (n + 2) ⟶ Q.X (n + 1)) ×' e.f (n + 1) = f ≫ Q.d n (n + 1) + P.d (n + 1) (n + 2) ≫ f') →
      (f'' : P.X (n + 3) ⟶ Q.X (n + 2)) ×' e.f (n + 2) = p.snd.fst ≫ Q.d (n + 1) (n + 2) + P.d (n + 2) (n + 3) ≫ f'') (n : ℕ)
Goal: Homotopy.mkCoinductiveAux₂ e zero comm_zero one comm_one succ (n + 1) =
  let I := Homotopy.mkCoinductiveAux₁ e zero one comm_one succ n;
  ⟨I.fst ≫ (HomologicalComplex.xPrevIso Q ⋯).inv, ⟨(HomologicalComplex.xNextIso P ⋯).hom ≫ I.snd.fst, ⋯⟩⟩
-- Homotopy.mkCoinductiveAux₃
theorem mkCoinductiveAux₃ (i j : ℕ) (h : i + 1 = j) :
    (P.xNextIso h).inv ≫ (mkCoinductiveAux₂ e zero comm_zero one comm_one succ i).2.1 =
      (mkCoinductiveAux₂ e zero comm_zero one comm_one succ j).1 ≫ (Q.xPrevIso h).hom 
Arguments: {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Preadditive V] {P Q : CochainComplex V ℕ} (e : P ⟶ Q) (zero : P.X 1 ⟶ Q.X 0) (comm_zero : e.f 0 = P.d 0 1 ≫ zero) (one : P.X 2 ⟶ Q.X 1) (comm_one : e.f 1 = zero ≫ Q.d 0 1 + P.d 1 2 ≫ one) (succ :
  (n : ℕ) →
    (p :
        (f : P.X (n + 1) ⟶ Q.X n) ×'
          (f' : P.X (n + 2) ⟶ Q.X (n + 1)) ×' e.f (n + 1) = f ≫ Q.d n (n + 1) + P.d (n + 1) (n + 2) ≫ f') →
      (f'' : P.X (n + 3) ⟶ Q.X (n + 2)) ×' e.f (n + 2) = p.snd.fst ≫ Q.d (n + 1) (n + 2) + P.d (n + 2) (n + 3) ≫ f'') (i j : ℕ) (h : i + 1 = j)
Goal: (HomologicalComplex.xNextIso P h).inv ≫ (Homotopy.mkCoinductiveAux₂ e zero comm_zero one comm_one succ i).snd.fst =
  (Homotopy.mkCoinductiveAux₂ e zero comm_zero one comm_one succ j).fst ≫ (HomologicalComplex.xPrevIso Q h).hom
-- CategoryTheory.Functor.mapHomotopy_hom
@[simps]
def Functor.mapHomotopy (F : V ⥤ W) [F.Additive] {f g : C ⟶ D} (h : Homotopy f g) :
    Homotopy ((F.mapHomologicalComplex c).map f) ((F.mapHomologicalComplex c).map g) 
Arguments: {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Preadditive V] {c : ComplexShape ι} {C D : HomologicalComplex V c} {W : Type u_2} [CategoryTheory.Category.{u_3, u_2} W] [CategoryTheory.Preadditive W] (F : V ⥤ W) [F.Additive] {f g : C ⟶ D} (h : Homotopy f g) (i j : ι)
Goal: (F.mapHomotopy h).hom i j = F.map (h.hom i j)
-- CategoryTheory.Functor.mapHomotopyEquiv_inv
@[simps]
def Functor.mapHomotopyEquiv (F : V ⥤ W) [F.Additive] (h : HomotopyEquiv C D) :
    HomotopyEquiv ((F.mapHomologicalComplex c).obj C) ((F.mapHomologicalComplex c).obj D) 
Arguments: {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Preadditive V] {c : ComplexShape ι} {C D : HomologicalComplex V c} {W : Type u_2} [CategoryTheory.Category.{u_3, u_2} W] [CategoryTheory.Preadditive W] (F : V ⥤ W) [F.Additive] (h : HomotopyEquiv C D)
Goal: (F.mapHomotopyEquiv h).inv = (F.mapHomologicalComplex c).map h.inv
-- CategoryTheory.Functor.mapHomotopyEquiv_homotopyInvHomId
@[simps]
def Functor.mapHomotopyEquiv (F : V ⥤ W) [F.Additive] (h : HomotopyEquiv C D) :
    HomotopyEquiv ((F.mapHomologicalComplex c).obj C) ((F.mapHomologicalComplex c).obj D) 
Arguments: {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Preadditive V] {c : ComplexShape ι} {C D : HomologicalComplex V c} {W : Type u_2} [CategoryTheory.Category.{u_3, u_2} W] [CategoryTheory.Preadditive W] (F : V ⥤ W) [F.Additive] (h : HomotopyEquiv C D)
Goal: (F.mapHomotopyEquiv h).homotopyInvHomId = ⋯.mpr (⋯.mpr (F.mapHomotopy h.homotopyInvHomId))
-- CategoryTheory.Functor.mapHomotopyEquiv_hom
@[simps]
def Functor.mapHomotopyEquiv (F : V ⥤ W) [F.Additive] (h : HomotopyEquiv C D) :
    HomotopyEquiv ((F.mapHomologicalComplex c).obj C) ((F.mapHomologicalComplex c).obj D) 
Arguments: {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Preadditive V] {c : ComplexShape ι} {C D : HomologicalComplex V c} {W : Type u_2} [CategoryTheory.Category.{u_3, u_2} W] [CategoryTheory.Preadditive W] (F : V ⥤ W) [F.Additive] (h : HomotopyEquiv C D)
Goal: (F.mapHomotopyEquiv h).hom = (F.mapHomologicalComplex c).map h.hom
-- CategoryTheory.Functor.mapHomotopyEquiv_homotopyHomInvId
@[simps]
def Functor.mapHomotopyEquiv (F : V ⥤ W) [F.Additive] (h : HomotopyEquiv C D) :
    HomotopyEquiv ((F.mapHomologicalComplex c).obj C) ((F.mapHomologicalComplex c).obj D) 
Arguments: {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Preadditive V] {c : ComplexShape ι} {C D : HomologicalComplex V c} {W : Type u_2} [CategoryTheory.Category.{u_3, u_2} W] [CategoryTheory.Preadditive W] (F : V ⥤ W) [F.Additive] (h : HomotopyEquiv C D)
Goal: (F.mapHomotopyEquiv h).homotopyHomInvId = ⋯.mpr (⋯.mpr (F.mapHomotopy h.homotopyHomInvId))
-- Homotopy.homologyMap_eq
lemma Homotopy.homologyMap_eq (ho : Homotopy f g) (i : ι) [K.HasHomology i] [L.HasHomology i] :
    homologyMap f i = homologyMap g i 
Arguments: {C : Type u_2} [CategoryTheory.Category.{u_3, u_2} C] [CategoryTheory.Preadditive C] {ι : Type u_4} {c : ComplexShape ι} [DecidableRel c.Rel] {K L : HomologicalComplex C c} {f g : K ⟶ L} (ho : Homotopy f g) (i : ι) [K.HasHomology i] [L.HasHomology i]
Goal: HomologicalComplex.homologyMap f i = HomologicalComplex.homologyMap g i
-- commute_iff_eq
@[to_additive]
theorem commute_iff_eq [Mul S] (a b : S) : Commute a b ↔ a * b = b * a 
Arguments: {S : Type u_3} [Mul S] (a b : S)
Goal: Commute a b ↔ a * b = b * a
-- addCommute_iff_eq
@[to_additive]
theorem commute_iff_eq [Mul S] (a b : S) : Commute a b ↔ a * b = b * a 
Arguments: {S : Type u_3} [Add S] (a b : S)
Goal: AddCommute a b ↔ a + b = b + a
-- Commute.eq
@[to_additive "Equality behind `AddCommute a b`; useful for rewriting."]
protected theorem eq {a b : S} (h : Commute a b) : a * b = b * a 
Arguments: {S : Type u_3} [Mul S] {a b : S} (h : Commute a b)
Goal: a * b = b * a
-- AddCommute.eq
@[to_additive "Equality behind `AddCommute a b`; useful for rewriting."]
protected theorem eq {a b : S} (h : Commute a b) : a * b = b * a 
Arguments: {S : Type u_3} [Add S] {a b : S} (h : AddCommute a b)
Goal: a + b = b + a
-- AddCommute.refl
@[to_additive (attr := refl, simp) "Any element commutes with itself."]
protected theorem refl (a : S) : Commute a a 
Arguments: {S : Type u_3} [Add S] (a : S)
Goal: AddCommute a a
-- Commute.refl
@[to_additive (attr := refl, simp) "Any element commutes with itself."]
protected theorem refl (a : S) : Commute a a 
Arguments: {S : Type u_3} [Mul S] (a : S)
Goal: Commute a a
-- Commute.symm
@[to_additive (attr := symm) "If `a` commutes with `b`, then `b` commutes with `a`."]
protected theorem symm {a b : S} (h : Commute a b) : Commute b a 
Arguments: {S : Type u_3} [Mul S] {a b : S} (h : Commute a b)
Goal: Commute b a
-- AddCommute.symm
@[to_additive (attr := symm) "If `a` commutes with `b`, then `b` commutes with `a`."]
protected theorem symm {a b : S} (h : Commute a b) : Commute b a 
Arguments: {S : Type u_3} [Add S] {a b : S} (h : AddCommute a b)
Goal: AddCommute b a
-- Commute.semiconjBy
@[to_additive]
protected theorem semiconjBy {a b : S} (h : Commute a b) : SemiconjBy a b b 
Arguments: {S : Type u_3} [Mul S] {a b : S} (h : Commute a b)
Goal: SemiconjBy a b b
-- AddCommute.addSemiconjBy
@[to_additive]
protected theorem semiconjBy {a b : S} (h : Commute a b) : SemiconjBy a b b 
Arguments: {S : Type u_3} [Add S] {a b : S} (h : AddCommute a b)
Goal: AddSemiconjBy a b b
-- Commute.symm_iff
@[to_additive]
protected theorem symm_iff {a b : S} : Commute a b ↔ Commute b a 
Arguments: {S : Type u_3} [Mul S] {a b : S}
Goal: Commute a b ↔ Commute b a
-- AddCommute.symm_iff
@[to_additive]
protected theorem symm_iff {a b : S} : Commute a b ↔ Commute b a 
Arguments: {S : Type u_3} [Add S] {a b : S}
Goal: AddCommute a b ↔ AddCommute b a
-- AddCommute.add_right
@[to_additive (attr := simp)
"If `a` commutes with both `b` and `c`, then it commutes with their sum."]
theorem mul_right (hab : Commute a b) (hac : Commute a c) : Commute a (b * c) 
Arguments: {S : Type u_3} [AddSemigroup S] {a b c : S} (hab : AddCommute a b) (hac : AddCommute a c)
Goal: AddCommute a (b + c)
-- Commute.mul_right
@[to_additive (attr := simp)
"If `a` commutes with both `b` and `c`, then it commutes with their sum."]
theorem mul_right (hab : Commute a b) (hac : Commute a c) : Commute a (b * c) 
Arguments: {S : Type u_3} [Semigroup S] {a b c : S} (hab : Commute a b) (hac : Commute a c)
Goal: Commute a (b * c)
-- AddCommute.add_left
@[to_additive (attr := simp)
"If both `a` and `b` commute with `c`, then their product commutes with `c`."]
theorem mul_left (hac : Commute a c) (hbc : Commute b c) : Commute (a * b) c 
Arguments: {S : Type u_3} [AddSemigroup S] {a b c : S} (hac : AddCommute a c) (hbc : AddCommute b c)
Goal: AddCommute (a + b) c
-- Commute.mul_left
@[to_additive (attr := simp)
"If both `a` and `b` commute with `c`, then their product commutes with `c`."]
theorem mul_left (hac : Commute a c) (hbc : Commute b c) : Commute (a * b) c 
Arguments: {S : Type u_3} [Semigroup S] {a b c : S} (hac : Commute a c) (hbc : Commute b c)
Goal: Commute (a * b) c
-- AddCommute.right_comm
@[to_additive]
protected theorem right_comm (h : Commute b c) (a : S) : a * b * c = a * c * b 
Arguments: {S : Type u_3} [AddSemigroup S] {b c : S} (h : AddCommute b c) (a : S)
Goal: a + b + c = a + c + b
-- Commute.right_comm
@[to_additive]
protected theorem right_comm (h : Commute b c) (a : S) : a * b * c = a * c * b 
Arguments: {S : Type u_3} [Semigroup S] {b c : S} (h : Commute b c) (a : S)
Goal: a * b * c = a * c * b
-- Commute.left_comm
@[to_additive]
protected theorem left_comm (h : Commute a b) (c) : a * (b * c) = b * (a * c) 
Arguments: {S : Type u_3} [Semigroup S] {a b : S} (h : Commute a b) (c : S)
Goal: a * (b * c) = b * (a * c)
-- AddCommute.left_comm
@[to_additive]
protected theorem left_comm (h : Commute a b) (c) : a * (b * c) = b * (a * c) 
Arguments: {S : Type u_3} [AddSemigroup S] {a b : S} (h : AddCommute a b) (c : S)
Goal: a + (b + c) = b + (a + c)
-- Commute.mul_mul_mul_comm
@[to_additive]
protected theorem mul_mul_mul_comm (hbc : Commute b c) (a d : S) :
    a * b * (c * d) = a * c * (b * d) 
Arguments: {S : Type u_3} [Semigroup S] {b c : S} (hbc : Commute b c) (a d : S)
Goal: a * b * (c * d) = a * c * (b * d)
-- AddCommute.add_add_add_comm
@[to_additive]
protected theorem mul_mul_mul_comm (hbc : Commute b c) (a d : S) :
    a * b * (c * d) = a * c * (b * d) 
Arguments: {S : Type u_3} [AddSemigroup S] {b c : S} (hbc : AddCommute b c) (a d : S)
Goal: a + b + (c + d) = a + c + (b + d)
-- AddCommute.all
@[to_additive]
protected theorem all [CommMagma S] (a b : S) : Commute a b 
Arguments: {S : Type u_3} [AddCommMagma S] (a b : S)
Goal: AddCommute a b
-- Commute.all
@[to_additive]
protected theorem all [CommMagma S] (a b : S) : Commute a b 
Arguments: {S : Type u_3} [CommMagma S] (a b : S)
Goal: Commute a b
-- Commute.one_right
@[to_additive (attr := simp)]
theorem one_right (a : M) : Commute a 1 
Arguments: {M : Type u_2} [MulOneClass M] (a : M)
Goal: Commute a 1
-- AddCommute.zero_right
@[to_additive (attr := simp)]
theorem one_right (a : M) : Commute a 1 
Arguments: {M : Type u_2} [AddZeroClass M] (a : M)
Goal: AddCommute a 0
-- Commute.one_left
@[to_additive (attr := simp)]
theorem one_left (a : M) : Commute 1 a 
Arguments: {M : Type u_2} [MulOneClass M] (a : M)
Goal: Commute 1 a
-- AddCommute.zero_left
@[to_additive (attr := simp)]
theorem one_left (a : M) : Commute 1 a 
Arguments: {M : Type u_2} [AddZeroClass M] (a : M)
Goal: AddCommute 0 a
-- Commute.pow_right
@[to_additive (attr := simp)]
theorem pow_right (h : Commute a b) (n : ℕ) : Commute a (b ^ n) 
Arguments: {M : Type u_2} [Monoid M] {a b : M} (h : Commute a b) (n : ℕ)
Goal: Commute a (b ^ n)
-- AddCommute.nsmul_right
@[to_additive (attr := simp)]
theorem pow_right (h : Commute a b) (n : ℕ) : Commute a (b ^ n) 
Arguments: {M : Type u_2} [AddMonoid M] {a b : M} (h : AddCommute a b) (n : ℕ)
Goal: AddCommute a (n • b)
-- AddCommute.nsmul_left
@[to_additive (attr := simp)]
theorem pow_left (h : Commute a b) (n : ℕ) : Commute (a ^ n) b 
Arguments: {M : Type u_2} [AddMonoid M] {a b : M} (h : AddCommute a b) (n : ℕ)
Goal: AddCommute (n • a) b
-- Commute.pow_left
@[to_additive (attr := simp)]
theorem pow_left (h : Commute a b) (n : ℕ) : Commute (a ^ n) b 
Arguments: {M : Type u_2} [Monoid M] {a b : M} (h : Commute a b) (n : ℕ)
Goal: Commute (a ^ n) b
-- AddCommute.nsmul_nsmul
@[to_additive (attr := simp)]
theorem pow_pow (h : Commute a b) (m n : ℕ) : Commute (a ^ m) (b ^ n) 
Arguments: {M : Type u_2} [AddMonoid M] {a b : M} (h : AddCommute a b) (m n : ℕ)
Goal: AddCommute (m • a) (n • b)
-- Commute.pow_pow
@[to_additive (attr := simp)]
theorem pow_pow (h : Commute a b) (m n : ℕ) : Commute (a ^ m) (b ^ n) 
Arguments: {M : Type u_2} [Monoid M] {a b : M} (h : Commute a b) (m n : ℕ)
Goal: Commute (a ^ m) (b ^ n)
-- Commute.self_pow
@[to_additive]
theorem self_pow (a : M) (n : ℕ) : Commute a (a ^ n) 
Arguments: {M : Type u_2} [Monoid M] (a : M) (n : ℕ)
Goal: Commute a (a ^ n)
-- AddCommute.self_nsmul
@[to_additive]
theorem self_pow (a : M) (n : ℕ) : Commute a (a ^ n) 
Arguments: {M : Type u_2} [AddMonoid M] (a : M) (n : ℕ)
Goal: AddCommute a (n • a)
-- AddCommute.nsmul_self
@[to_additive]
theorem pow_self (a : M) (n : ℕ) : Commute (a ^ n) a 
Arguments: {M : Type u_2} [AddMonoid M] (a : M) (n : ℕ)
Goal: AddCommute (n • a) a
-- Commute.pow_self
@[to_additive]
theorem pow_self (a : M) (n : ℕ) : Commute (a ^ n) a 
Arguments: {M : Type u_2} [Monoid M] (a : M) (n : ℕ)
Goal: Commute (a ^ n) a
-- Commute.pow_pow_self
@[to_additive]
theorem pow_pow_self (a : M) (m n : ℕ) : Commute (a ^ m) (a ^ n) 
Arguments: {M : Type u_2} [Monoid M] (a : M) (m n : ℕ)
Goal: Commute (a ^ m) (a ^ n)
-- AddCommute.nsmul_nsmul_self
@[to_additive]
theorem pow_pow_self (a : M) (m n : ℕ) : Commute (a ^ m) (a ^ n) 
Arguments: {M : Type u_2} [AddMonoid M] (a : M) (m n : ℕ)
Goal: AddCommute (m • a) (n • a)
-- AddCommute.add_nsmul
@[to_additive] lemma mul_pow (h : Commute a b) : ∀ n, (a * b) ^ n = a ^ n * b ^ n
  
Arguments: {M : Type u_2} [AddMonoid M] {a b : M} (h : AddCommute a b) (n : ℕ)
Goal: n • (a + b) = n • a + n • b
-- Commute.mul_pow
@[to_additive] lemma mul_pow (h : Commute a b) : ∀ n, (a * b) ^ n = a ^ n * b ^ n
  
Arguments: {M : Type u_2} [Monoid M] {a b : M} (h : Commute a b) (n : ℕ)
Goal: (a * b) ^ n = a ^ n * b ^ n
-- AddCommute.add_neg
@[to_additive]
protected theorem mul_inv (hab : Commute a b) : (a * b)⁻¹ = a⁻¹ * b⁻¹ 
Arguments: {G : Type u_1} [SubtractionMonoid G] {a b : G} (hab : AddCommute a b)
Goal: -(a + b) = -a + -b
-- Commute.mul_inv
@[to_additive]
protected theorem mul_inv (hab : Commute a b) : (a * b)⁻¹ = a⁻¹ * b⁻¹ 
Arguments: {G : Type u_1} [DivisionMonoid G] {a b : G} (hab : Commute a b)
Goal: (a * b)⁻¹ = a⁻¹ * b⁻¹
-- AddCommute.neg
@[to_additive]
protected theorem inv (hab : Commute a b) : (a * b)⁻¹ = a⁻¹ * b⁻¹ 
Arguments: {G : Type u_1} [SubtractionMonoid G] {a b : G} (hab : AddCommute a b)
Goal: -(a + b) = -a + -b
-- Commute.inv
@[to_additive]
protected theorem inv (hab : Commute a b) : (a * b)⁻¹ = a⁻¹ * b⁻¹ 
Arguments: {G : Type u_1} [DivisionMonoid G] {a b : G} (hab : Commute a b)
Goal: (a * b)⁻¹ = a⁻¹ * b⁻¹
-- AddCommute.zsmul_add
@[to_additive AddCommute.zsmul_add]
protected lemma mul_zpow (h : Commute a b) : ∀ n : ℤ, (a * b) ^ n = a ^ n * b ^ n
  
Arguments: {G : Type u_1} [SubtractionMonoid G] {a b : G} (h : AddCommute a b) (n : ℤ)
Goal: n • (a + b) = n • a + n • b
-- Commute.mul_zpow
@[to_additive AddCommute.zsmul_add]
protected lemma mul_zpow (h : Commute a b) : ∀ n : ℤ, (a * b) ^ n = a ^ n * b ^ n
  
Arguments: {G : Type u_1} [DivisionMonoid G] {a b : G} (h : Commute a b) (n : ℤ)
Goal: (a * b) ^ n = a ^ n * b ^ n
-- Commute.mul_inv_cancel
@[to_additive]
protected theorem mul_inv_cancel (h : Commute a b) : a * b * a⁻¹ = b 
Arguments: {G : Type u_1} [Group G] {a b : G} (h : Commute a b)
Goal: a * b * a⁻¹ = b
-- AddCommute.add_neg_cancel
@[to_additive]
protected theorem mul_inv_cancel (h : Commute a b) : a * b * a⁻¹ = b 
Arguments: {G : Type u_1} [AddGroup G] {a b : G} (h : AddCommute a b)
Goal: a + b + -a = b
-- Commute.mul_inv_cancel_assoc
@[to_additive]
theorem mul_inv_cancel_assoc (h : Commute a b) : a * (b * a⁻¹) = b 
Arguments: {G : Type u_1} [Group G] {a b : G} (h : Commute a b)
Goal: a * (b * a⁻¹) = b
-- AddCommute.add_neg_cancel_assoc
@[to_additive]
theorem mul_inv_cancel_assoc (h : Commute a b) : a * (b * a⁻¹) = b 
Arguments: {G : Type u_1} [AddGroup G] {a b : G} (h : AddCommute a b)
Goal: a + (b + -a) = b
-- AddCommute.addUnits_neg_right
@[to_additive]
theorem units_inv_right : Commute a u → Commute a ↑u⁻¹ 
Arguments: {M : Type u_1} [AddMonoid M] {a : M} {u : AddUnits M}
Goal: AddCommute a ↑u → AddCommute a ↑(-u)