ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Function.support_prod_mk'
@[to_additive support_prod_mk']
theorem mulSupport_prod_mk' (f : α → M × N) :
    mulSupport f = (mulSupport fun x => (f x).1) ∪ mulSupport fun x => (f x).2 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} [Zero M] [Zero N] (f : α → M × N)
Goal: Function.support f = (Function.support fun x => (f x).1) ∪ Function.support fun x => (f x).2
-- Function.mulSupport_prod_mk'
@[to_additive support_prod_mk']
theorem mulSupport_prod_mk' (f : α → M × N) :
    mulSupport f = (mulSupport fun x => (f x).1) ∪ mulSupport fun x => (f x).2 
Arguments: {α : Type u_1} {M : Type u_5} {N : Type u_7} [One M] [One N] (f : α → M × N)
Goal: Function.mulSupport f = (Function.mulSupport fun x => (f x).1) ∪ Function.mulSupport fun x => (f x).2
-- Function.mulSupport_along_fiber_subset
@[to_additive]
theorem mulSupport_along_fiber_subset (f : α × β → M) (a : α) :
    (mulSupport fun b => f (a, b)) ⊆ (mulSupport f).image Prod.snd 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [One M] (f : α × β → M) (a : α)
Goal: (Function.mulSupport fun b => f (a, b)) ⊆ Prod.snd '' Function.mulSupport f
-- Function.support_along_fiber_subset
@[to_additive]
theorem mulSupport_along_fiber_subset (f : α × β → M) (a : α) :
    (mulSupport fun b => f (a, b)) ⊆ (mulSupport f).image Prod.snd 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [Zero M] (f : α × β → M) (a : α)
Goal: (Function.support fun b => f (a, b)) ⊆ Prod.snd '' Function.support f
-- Function.mulSupport_curry
@[to_additive]
theorem mulSupport_curry (f : α × β → M) :
    (mulSupport f.curry) = (mulSupport f).image Prod.fst 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [One M] (f : α × β → M)
Goal: Function.mulSupport (Function.curry f) = Prod.fst '' Function.mulSupport f
-- Function.support_curry
@[to_additive]
theorem mulSupport_curry (f : α × β → M) :
    (mulSupport f.curry) = (mulSupport f).image Prod.fst 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [Zero M] (f : α × β → M)
Goal: Function.support (Function.curry f) = Prod.fst '' Function.support f
-- Function.mulSupport_curry'
@[to_additive]
theorem mulSupport_curry' (f : α × β → M) :
    (mulSupport fun a b ↦ f (a, b)) = (mulSupport f).image Prod.fst 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [One M] (f : α × β → M)
Goal: (Function.mulSupport fun a b => f (a, b)) = Prod.fst '' Function.mulSupport f
-- Function.support_curry'
@[to_additive]
theorem mulSupport_curry' (f : α × β → M) :
    (mulSupport fun a b ↦ f (a, b)) = (mulSupport f).image Prod.fst 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [Zero M] (f : α × β → M)
Goal: (Function.support fun a b => f (a, b)) = Prod.fst '' Function.support f
-- Function.support_add
@[to_additive]
theorem mulSupport_mul [MulOneClass M] (f g : α → M) :
    (mulSupport fun x => f x * g x) ⊆ mulSupport f ∪ mulSupport g 
Arguments: {α : Type u_1} {M : Type u_5} [AddZeroClass M] (f g : α → M)
Goal: (Function.support fun x => f x + g x) ⊆ Function.support f ∪ Function.support g
-- Function.mulSupport_mul
@[to_additive]
theorem mulSupport_mul [MulOneClass M] (f g : α → M) :
    (mulSupport fun x => f x * g x) ⊆ mulSupport f ∪ mulSupport g 
Arguments: {α : Type u_1} {M : Type u_5} [MulOneClass M] (f g : α → M)
Goal: (Function.mulSupport fun x => f x * g x) ⊆ Function.mulSupport f ∪ Function.mulSupport g
-- Function.support_nsmul
@[to_additive]
theorem mulSupport_pow [Monoid M] (f : α → M) (n : ℕ) :
    (mulSupport fun x => f x ^ n) ⊆ mulSupport f 
Arguments: {α : Type u_1} {M : Type u_5} [AddMonoid M] (f : α → M) (n : ℕ)
Goal: (Function.support fun x => n • f x) ⊆ Function.support f
-- Function.mulSupport_pow
@[to_additive]
theorem mulSupport_pow [Monoid M] (f : α → M) (n : ℕ) :
    (mulSupport fun x => f x ^ n) ⊆ mulSupport f 
Arguments: {α : Type u_1} {M : Type u_5} [Monoid M] (f : α → M) (n : ℕ)
Goal: (Function.mulSupport fun x => f x ^ n) ⊆ Function.mulSupport f
-- Function.support_neg
@[to_additive (attr := simp)]
theorem mulSupport_inv : (mulSupport fun x => (f x)⁻¹) = mulSupport f 
Arguments: {α : Type u_1} {G : Type u_9} [SubtractionMonoid G] (f : α → G)
Goal: (Function.support fun x => -f x) = Function.support f
-- Function.mulSupport_inv
@[to_additive (attr := simp)]
theorem mulSupport_inv : (mulSupport fun x => (f x)⁻¹) = mulSupport f 
Arguments: {α : Type u_1} {G : Type u_9} [DivisionMonoid G] (f : α → G)
Goal: (Function.mulSupport fun x => (f x)⁻¹) = Function.mulSupport f
-- Function.mulSupport_inv'
@[to_additive (attr := simp)]
theorem mulSupport_inv' : mulSupport f⁻¹ = mulSupport f 
Arguments: {α : Type u_1} {G : Type u_9} [DivisionMonoid G] (f : α → G)
Goal: Function.mulSupport f⁻¹ = Function.mulSupport f
-- Function.support_neg'
@[to_additive (attr := simp)]
theorem mulSupport_inv' : mulSupport f⁻¹ = mulSupport f 
Arguments: {α : Type u_1} {G : Type u_9} [SubtractionMonoid G] (f : α → G)
Goal: Function.support (-f) = Function.support f
-- Function.mulSupport_mul_inv
@[to_additive]
theorem mulSupport_mul_inv : (mulSupport fun x => f x * (g x)⁻¹) ⊆ mulSupport f ∪ mulSupport g 
Arguments: {α : Type u_1} {G : Type u_9} [DivisionMonoid G] (f g : α → G)
Goal: (Function.mulSupport fun x => f x * (g x)⁻¹) ⊆ Function.mulSupport f ∪ Function.mulSupport g
-- Function.support_add_neg
@[to_additive]
theorem mulSupport_mul_inv : (mulSupport fun x => f x * (g x)⁻¹) ⊆ mulSupport f ∪ mulSupport g 
Arguments: {α : Type u_1} {G : Type u_9} [SubtractionMonoid G] (f g : α → G)
Goal: (Function.support fun x => f x + -g x) ⊆ Function.support f ∪ Function.support g
-- Function.mulSupport_div
@[to_additive]
theorem mulSupport_div : (mulSupport fun x => f x / g x) ⊆ mulSupport f ∪ mulSupport g 
Arguments: {α : Type u_1} {G : Type u_9} [DivisionMonoid G] (f g : α → G)
Goal: (Function.mulSupport fun x => f x / g x) ⊆ Function.mulSupport f ∪ Function.mulSupport g
-- Function.support_sub
@[to_additive]
theorem mulSupport_div : (mulSupport fun x => f x / g x) ⊆ mulSupport f ∪ mulSupport g 
Arguments: {α : Type u_1} {G : Type u_9} [SubtractionMonoid G] (f g : α → G)
Goal: (Function.support fun x => f x - g x) ⊆ Function.support f ∪ Function.support g
-- Set.image_inter_support_eq
@[to_additive]
theorem image_inter_mulSupport_eq {s : Set β} {g : β → α} :
    g '' s ∩ mulSupport f = g '' (s ∩ mulSupport (f ∘ g)) 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_3} [Zero M] {f : α → M} {s : Set β} {g : β → α}
Goal: g '' s ∩ Function.support f = g '' (s ∩ Function.support (f ∘ g))
-- Set.image_inter_mulSupport_eq
@[to_additive]
theorem image_inter_mulSupport_eq {s : Set β} {g : β → α} :
    g '' s ∩ mulSupport f = g '' (s ∩ mulSupport (f ∘ g)) 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_3} [One M] {f : α → M} {s : Set β} {g : β → α}
Goal: g '' s ∩ Function.mulSupport f = g '' (s ∩ Function.mulSupport (f ∘ g))
-- Pi.support_single_subset
@[to_additive]
theorem mulSupport_mulSingle_subset : mulSupport (mulSingle a b) ⊆ {a} 
Arguments: {A : Type u_1} {B : Type u_2} [DecidableEq A] [Zero B] {a : A} {b : B}
Goal: Function.support (Pi.single a b) ⊆ {a}
-- Pi.mulSupport_mulSingle_subset
@[to_additive]
theorem mulSupport_mulSingle_subset : mulSupport (mulSingle a b) ⊆ {a} 
Arguments: {A : Type u_1} {B : Type u_2} [DecidableEq A] [One B] {a : A} {b : B}
Goal: Function.mulSupport (Pi.mulSingle a b) ⊆ {a}
-- Pi.mulSupport_mulSingle_one
@[to_additive]
theorem mulSupport_mulSingle_one : mulSupport (mulSingle a (1 : B)) = ∅ 
Arguments: {A : Type u_1} {B : Type u_2} [DecidableEq A] [One B] {a : A}
Goal: Function.mulSupport (Pi.mulSingle a 1) = ∅
-- Pi.support_single_zero
@[to_additive]
theorem mulSupport_mulSingle_one : mulSupport (mulSingle a (1 : B)) = ∅ 
Arguments: {A : Type u_1} {B : Type u_2} [DecidableEq A] [Zero B] {a : A}
Goal: Function.support (Pi.single a 0) = ∅
-- Pi.mulSupport_mulSingle_of_ne
@[to_additive (attr := simp)]
theorem mulSupport_mulSingle_of_ne (h : b ≠ 1) : mulSupport (mulSingle a b) = {a} 
Arguments: {A : Type u_1} {B : Type u_2} [DecidableEq A] [One B] {a : A} {b : B} (h : b ≠ 1)
Goal: Function.mulSupport (Pi.mulSingle a b) = {a}
-- Pi.support_single_of_ne
@[to_additive (attr := simp)]
theorem mulSupport_mulSingle_of_ne (h : b ≠ 1) : mulSupport (mulSingle a b) = {a} 
Arguments: {A : Type u_1} {B : Type u_2} [DecidableEq A] [Zero B] {a : A} {b : B} (h : b ≠ 0)
Goal: Function.support (Pi.single a b) = {a}
-- Pi.mulSupport_mulSingle
@[to_additive]
theorem mulSupport_mulSingle [DecidableEq B] :
    mulSupport (mulSingle a b) = if b = 1 then ∅ else {a} 
Arguments: {A : Type u_1} {B : Type u_2} [DecidableEq A] [One B] {a : A} {b : B} [DecidableEq B]
Goal: Function.mulSupport (Pi.mulSingle a b) = if b = 1 then ∅ else {a}
-- Pi.support_single
@[to_additive]
theorem mulSupport_mulSingle [DecidableEq B] :
    mulSupport (mulSingle a b) = if b = 1 then ∅ else {a} 
Arguments: {A : Type u_1} {B : Type u_2} [DecidableEq A] [Zero B] {a : A} {b : B} [DecidableEq B]
Goal: Function.support (Pi.single a b) = if b = 0 then ∅ else {a}
-- Pi.support_single_disjoint
@[to_additive]
theorem mulSupport_mulSingle_disjoint {b' : B} (hb : b ≠ 1) (hb' : b' ≠ 1) {i j : A} :
    Disjoint (mulSupport (mulSingle i b)) (mulSupport (mulSingle j b')) ↔ i ≠ j 
Arguments: {A : Type u_1} {B : Type u_2} [DecidableEq A] [Zero B] {b b' : B} (hb : b ≠ 0) (hb' : b' ≠ 0) {i j : A}
Goal: Disjoint (Function.support (Pi.single i b)) (Function.support (Pi.single j b')) ↔ i ≠ j
-- Pi.mulSupport_mulSingle_disjoint
@[to_additive]
theorem mulSupport_mulSingle_disjoint {b' : B} (hb : b ≠ 1) (hb' : b' ≠ 1) {i j : A} :
    Disjoint (mulSupport (mulSingle i b)) (mulSupport (mulSingle j b')) ↔ i ≠ j 
Arguments: {A : Type u_1} {B : Type u_2} [DecidableEq A] [One B] {b b' : B} (hb : b ≠ 1) (hb' : b' ≠ 1) {i j : A}
Goal: Disjoint (Function.mulSupport (Pi.mulSingle i b)) (Function.mulSupport (Pi.mulSingle j b')) ↔ i ≠ j
-- CochainComplex.mapBifunctorHomologicalComplexShift₁Iso_hom_f_f
@[simps! hom_f_f inv_f_f]
def mapBifunctorHomologicalComplexShift₁Iso :
    ((F.mapBifunctorHomologicalComplex _ _).obj (K₁⟦x⟧)).obj K₂ ≅
    (HomologicalComplex₂.shiftFunctor₁ D x).obj
      (((F.mapBifunctorHomologicalComplex _ _).obj K₁).obj K₂) 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {D : Type u_3} [CategoryTheory.Category.{u_4, u_1} C₁] [CategoryTheory.Category.{u_5, u_2} C₂] [CategoryTheory.Category.{u_6, u_3} D] [CategoryTheory.Preadditive C₁] [CategoryTheory.Limits.HasZeroMorphisms C₂] [CategoryTheory.Preadditive D] (K₁ : CochainComplex C₁ ℤ) (K₂ : CochainComplex C₂ ℤ) (F : C₁ ⥤ C₂ ⥤ D) [F.Additive] [∀ (X₁ : C₁), (F.obj X₁).PreservesZeroMorphisms] (x i : ℤ)
Goal: ∀ (x_1 : ℤ),
  ((K₁.mapBifunctorHomologicalComplexShift₁Iso K₂ F x).hom.f i).f x_1 = 𝟙 ((F.obj (K₁.X (i + x))).obj (K₂.X x_1))
-- CochainComplex.mapBifunctorHomologicalComplexShift₁Iso_inv_f_f
@[simps! hom_f_f inv_f_f]
def mapBifunctorHomologicalComplexShift₁Iso :
    ((F.mapBifunctorHomologicalComplex _ _).obj (K₁⟦x⟧)).obj K₂ ≅
    (HomologicalComplex₂.shiftFunctor₁ D x).obj
      (((F.mapBifunctorHomologicalComplex _ _).obj K₁).obj K₂) 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {D : Type u_3} [CategoryTheory.Category.{u_4, u_1} C₁] [CategoryTheory.Category.{u_5, u_2} C₂] [CategoryTheory.Category.{u_6, u_3} D] [CategoryTheory.Preadditive C₁] [CategoryTheory.Limits.HasZeroMorphisms C₂] [CategoryTheory.Preadditive D] (K₁ : CochainComplex C₁ ℤ) (K₂ : CochainComplex C₂ ℤ) (F : C₁ ⥤ C₂ ⥤ D) [F.Additive] [∀ (X₁ : C₁), (F.obj X₁).PreservesZeroMorphisms] (x i : ℤ)
Goal: ∀ (x_1 : ℤ),
  ((K₁.mapBifunctorHomologicalComplexShift₁Iso K₂ F x).inv.f i).f x_1 = 𝟙 ((F.obj (K₁.X (i + x))).obj (K₂.X x_1))
-- CochainComplex.mapBifunctorHomologicalComplexShift₂Iso_inv_f_f
@[simps! hom_f_f inv_f_f]
def mapBifunctorHomologicalComplexShift₂Iso :
    ((F.mapBifunctorHomologicalComplex _ _).obj K₁).obj (K₂⟦y⟧) ≅
    (HomologicalComplex₂.shiftFunctor₂ D y).obj
      (((F.mapBifunctorHomologicalComplex _ _).obj K₁).obj K₂) 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {D : Type u_3} [CategoryTheory.Category.{u_4, u_1} C₁] [CategoryTheory.Category.{u_5, u_2} C₂] [CategoryTheory.Category.{u_6, u_3} D] [CategoryTheory.Limits.HasZeroMorphisms C₁] [CategoryTheory.Preadditive C₂] [CategoryTheory.Preadditive D] (K₁ : CochainComplex C₁ ℤ) (K₂ : CochainComplex C₂ ℤ) (F : C₁ ⥤ C₂ ⥤ D) [F.PreservesZeroMorphisms] [∀ (X₁ : C₁), (F.obj X₁).Additive] (y i : ℤ)
Goal: ∀ (i_1 : ℤ),
  ((K₁.mapBifunctorHomologicalComplexShift₂Iso K₂ F y).inv.f i).f i_1 = 𝟙 ((F.obj (K₁.X i)).obj (K₂.X (i_1 + y)))
-- CochainComplex.mapBifunctorHomologicalComplexShift₂Iso_hom_f_f
@[simps! hom_f_f inv_f_f]
def mapBifunctorHomologicalComplexShift₂Iso :
    ((F.mapBifunctorHomologicalComplex _ _).obj K₁).obj (K₂⟦y⟧) ≅
    (HomologicalComplex₂.shiftFunctor₂ D y).obj
      (((F.mapBifunctorHomologicalComplex _ _).obj K₁).obj K₂) 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {D : Type u_3} [CategoryTheory.Category.{u_4, u_1} C₁] [CategoryTheory.Category.{u_5, u_2} C₂] [CategoryTheory.Category.{u_6, u_3} D] [CategoryTheory.Limits.HasZeroMorphisms C₁] [CategoryTheory.Preadditive C₂] [CategoryTheory.Preadditive D] (K₁ : CochainComplex C₁ ℤ) (K₂ : CochainComplex C₂ ℤ) (F : C₁ ⥤ C₂ ⥤ D) [F.PreservesZeroMorphisms] [∀ (X₁ : C₁), (F.obj X₁).Additive] (y i : ℤ)
Goal: ∀ (i_1 : ℤ),
  ((K₁.mapBifunctorHomologicalComplexShift₂Iso K₂ F y).hom.f i).f i_1 = 𝟙 ((F.obj (K₁.X i)).obj (K₂.X (i_1 + y)))
-- CochainComplex.mapBifunctorShift₁Iso_trans_mapBifunctorShift₂Iso
lemma mapBifunctorShift₁Iso_trans_mapBifunctorShift₂Iso :
    mapBifunctorShift₁Iso K₁ (K₂⟦y⟧) F x ≪≫
      (CategoryTheory.shiftFunctor _ x).mapIso (mapBifunctorShift₂Iso K₁ K₂ F y) =
      (x * y).negOnePow • (mapBifunctorShift₂Iso (K₁⟦x⟧) K₂ F y ≪≫
        (CategoryTheory.shiftFunctor _ y).mapIso (mapBifunctorShift₁Iso K₁ K₂ F x) ≪≫
          (shiftFunctorComm (CochainComplex D ℤ) x y).app _) 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {D : Type u_3} [CategoryTheory.Category.{u_5, u_1} C₁] [CategoryTheory.Category.{u_6, u_2} C₂] [CategoryTheory.Category.{u_4, u_3} D] [CategoryTheory.Preadditive C₁] [CategoryTheory.Preadditive C₂] [CategoryTheory.Preadditive D] (K₁ : CochainComplex C₁ ℤ) (K₂ : CochainComplex C₂ ℤ) (F : C₁ ⥤ C₂ ⥤ D) [F.Additive] [∀ (X₁ : C₁), (F.obj X₁).Additive] (x y : ℤ) [K₁.HasMapBifunctor K₂ F]
Goal: K₁.mapBifunctorShift₁Iso ((CategoryTheory.shiftFunctor (CochainComplex C₂ ℤ) y).obj K₂) F x ≪≫
    (CategoryTheory.shiftFunctor (CochainComplex D ℤ) x).mapIso (K₁.mapBifunctorShift₂Iso K₂ F y) =
  (x * y).negOnePow •
    ((CategoryTheory.shiftFunctor (CochainComplex C₁ ℤ) x).obj K₁).mapBifunctorShift₂Iso K₂ F y ≪≫
      (CategoryTheory.shiftFunctor (CochainComplex D ℤ) y).mapIso (K₁.mapBifunctorShift₁Iso K₂ F x) ≪≫
        (CategoryTheory.shiftFunctorComm (CochainComplex D ℤ) x y).app (K₁.mapBifunctor K₂ F)
-- AddSubmonoid.op_coe
@[to_additive (attr := simps) "Pull an additive submonoid back to an opposite submonoid along
`AddOpposite.unop`"]
protected def op (x : Submonoid M) : Submonoid Mᵐᵒᵖ 
Arguments: {M : Type u_2} [AddZeroClass M] (x : AddSubmonoid M)
Goal: ↑x.op = AddOpposite.unop ⁻¹' ↑x
-- Submonoid.op_coe
@[to_additive (attr := simps) "Pull an additive submonoid back to an opposite submonoid along
`AddOpposite.unop`"]
protected def op (x : Submonoid M) : Submonoid Mᵐᵒᵖ 
Arguments: {M : Type u_2} [MulOneClass M] (x : Submonoid M)
Goal: ↑x.op = MulOpposite.unop ⁻¹' ↑x
-- AddSubmonoid.mem_op
@[to_additive (attr := simp)]
theorem mem_op {x : Mᵐᵒᵖ} {S : Submonoid M} : x ∈ S.op ↔ x.unop ∈ S 
Arguments: {M : Type u_2} [AddZeroClass M] {x : Mᵃᵒᵖ} {S : AddSubmonoid M}
Goal: x ∈ S.op ↔ AddOpposite.unop x ∈ S
-- Submonoid.mem_op
@[to_additive (attr := simp)]
theorem mem_op {x : Mᵐᵒᵖ} {S : Submonoid M} : x ∈ S.op ↔ x.unop ∈ S 
Arguments: {M : Type u_2} [MulOneClass M] {x : Mᵐᵒᵖ} {S : Submonoid M}
Goal: x ∈ S.op ↔ MulOpposite.unop x ∈ S
-- Submonoid.unop_coe
@[to_additive (attr := simps) "Pull an opposite additive submonoid back to a submonoid along
`AddOpposite.op`"]
protected def unop (x : Submonoid Mᵐᵒᵖ) : Submonoid M 
Arguments: {M : Type u_2} [MulOneClass M] (x : Submonoid Mᵐᵒᵖ)
Goal: ↑x.unop = MulOpposite.op ⁻¹' ↑x
-- AddSubmonoid.unop_coe
@[to_additive (attr := simps) "Pull an opposite additive submonoid back to a submonoid along
`AddOpposite.op`"]
protected def unop (x : Submonoid Mᵐᵒᵖ) : Submonoid M 
Arguments: {M : Type u_2} [AddZeroClass M] (x : AddSubmonoid Mᵃᵒᵖ)
Goal: ↑x.unop = AddOpposite.op ⁻¹' ↑x
-- Submonoid.mem_unop
@[to_additive (attr := simp)]
theorem mem_unop {x : M} {S : Submonoid Mᵐᵒᵖ} : x ∈ S.unop ↔ MulOpposite.op x ∈ S 
Arguments: {M : Type u_2} [MulOneClass M] {x : M} {S : Submonoid Mᵐᵒᵖ}
Goal: x ∈ S.unop ↔ MulOpposite.op x ∈ S
-- AddSubmonoid.mem_unop
@[to_additive (attr := simp)]
theorem mem_unop {x : M} {S : Submonoid Mᵐᵒᵖ} : x ∈ S.unop ↔ MulOpposite.op x ∈ S 
Arguments: {M : Type u_2} [AddZeroClass M] {x : M} {S : AddSubmonoid Mᵃᵒᵖ}
Goal: x ∈ S.unop ↔ AddOpposite.op x ∈ S
-- AddSubmonoid.unop_op
@[to_additive (attr := simp)]
theorem unop_op (S : Submonoid M) : S.op.unop = S 
Arguments: {M : Type u_2} [AddZeroClass M] (S : AddSubmonoid M)
Goal: S.op.unop = S
-- Submonoid.unop_op
@[to_additive (attr := simp)]
theorem unop_op (S : Submonoid M) : S.op.unop = S 
Arguments: {M : Type u_2} [MulOneClass M] (S : Submonoid M)
Goal: S.op.unop = S
-- Submonoid.op_unop
@[to_additive (attr := simp)]
theorem op_unop (S : Submonoid Mᵐᵒᵖ) : S.unop.op = S 
Arguments: {M : Type u_2} [MulOneClass M] (S : Submonoid Mᵐᵒᵖ)
Goal: S.unop.op = S
-- AddSubmonoid.op_unop
@[to_additive (attr := simp)]
theorem op_unop (S : Submonoid Mᵐᵒᵖ) : S.unop.op = S 
Arguments: {M : Type u_2} [AddZeroClass M] (S : AddSubmonoid Mᵃᵒᵖ)
Goal: S.unop.op = S
-- Submonoid.op_le_iff
@[to_additive]
theorem op_le_iff {S₁ : Submonoid M} {S₂ : Submonoid Mᵐᵒᵖ} : S₁.op ≤ S₂ ↔ S₁ ≤ S₂.unop 
Arguments: {M : Type u_2} [MulOneClass M] {S₁ : Submonoid M} {S₂ : Submonoid Mᵐᵒᵖ}
Goal: S₁.op ≤ S₂ ↔ S₁ ≤ S₂.unop
-- AddSubmonoid.op_le_iff
@[to_additive]
theorem op_le_iff {S₁ : Submonoid M} {S₂ : Submonoid Mᵐᵒᵖ} : S₁.op ≤ S₂ ↔ S₁ ≤ S₂.unop 
Arguments: {M : Type u_2} [AddZeroClass M] {S₁ : AddSubmonoid M} {S₂ : AddSubmonoid Mᵃᵒᵖ}
Goal: S₁.op ≤ S₂ ↔ S₁ ≤ S₂.unop
-- Submonoid.le_op_iff
@[to_additive]
theorem le_op_iff {S₁ : Submonoid Mᵐᵒᵖ} {S₂ : Submonoid M} : S₁ ≤ S₂.op ↔ S₁.unop ≤ S₂ 
Arguments: {M : Type u_2} [MulOneClass M] {S₁ : Submonoid Mᵐᵒᵖ} {S₂ : Submonoid M}
Goal: S₁ ≤ S₂.op ↔ S₁.unop ≤ S₂
-- AddSubmonoid.le_op_iff
@[to_additive]
theorem le_op_iff {S₁ : Submonoid Mᵐᵒᵖ} {S₂ : Submonoid M} : S₁ ≤ S₂.op ↔ S₁.unop ≤ S₂ 
Arguments: {M : Type u_2} [AddZeroClass M] {S₁ : AddSubmonoid Mᵃᵒᵖ} {S₂ : AddSubmonoid M}
Goal: S₁ ≤ S₂.op ↔ S₁.unop ≤ S₂
-- Submonoid.op_le_op_iff
@[to_additive (attr := simp)]
theorem op_le_op_iff {S₁ S₂ : Submonoid M} : S₁.op ≤ S₂.op ↔ S₁ ≤ S₂ 
Arguments: {M : Type u_2} [MulOneClass M] {S₁ S₂ : Submonoid M}
Goal: S₁.op ≤ S₂.op ↔ S₁ ≤ S₂
-- AddSubmonoid.op_le_op_iff
@[to_additive (attr := simp)]
theorem op_le_op_iff {S₁ S₂ : Submonoid M} : S₁.op ≤ S₂.op ↔ S₁ ≤ S₂ 
Arguments: {M : Type u_2} [AddZeroClass M] {S₁ S₂ : AddSubmonoid M}
Goal: S₁.op ≤ S₂.op ↔ S₁ ≤ S₂
-- Submonoid.unop_le_unop_iff
@[to_additive (attr := simp)]
theorem unop_le_unop_iff {S₁ S₂ : Submonoid Mᵐᵒᵖ} : S₁.unop ≤ S₂.unop ↔ S₁ ≤ S₂ 
Arguments: {M : Type u_2} [MulOneClass M] {S₁ S₂ : Submonoid Mᵐᵒᵖ}
Goal: S₁.unop ≤ S₂.unop ↔ S₁ ≤ S₂
-- AddSubmonoid.unop_le_unop_iff
@[to_additive (attr := simp)]
theorem unop_le_unop_iff {S₁ S₂ : Submonoid Mᵐᵒᵖ} : S₁.unop ≤ S₂.unop ↔ S₁ ≤ S₂ 
Arguments: {M : Type u_2} [AddZeroClass M] {S₁ S₂ : AddSubmonoid Mᵃᵒᵖ}
Goal: S₁.unop ≤ S₂.unop ↔ S₁ ≤ S₂
-- AddSubmonoid.opEquiv_symm_apply
@[to_additive (attr := simps) "A additive submonoid `H` of `G` determines an additive submonoid
`H.op` of the opposite group `Gᵐᵒᵖ`."]
def opEquiv : Submonoid M ≃o Submonoid Mᵐᵒᵖ 
Arguments: {M : Type u_2} [AddZeroClass M] (x : AddSubmonoid Mᵃᵒᵖ)
Goal: (RelIso.symm AddSubmonoid.opEquiv) x = x.unop
-- AddSubmonoid.opEquiv_apply
@[to_additive (attr := simps) "A additive submonoid `H` of `G` determines an additive submonoid
`H.op` of the opposite group `Gᵐᵒᵖ`."]
def opEquiv : Submonoid M ≃o Submonoid Mᵐᵒᵖ 
Arguments: {M : Type u_2} [AddZeroClass M] (x : AddSubmonoid M)
Goal: AddSubmonoid.opEquiv x = x.op
-- Submonoid.opEquiv_apply
@[to_additive (attr := simps) "A additive submonoid `H` of `G` determines an additive submonoid
`H.op` of the opposite group `Gᵐᵒᵖ`."]
def opEquiv : Submonoid M ≃o Submonoid Mᵐᵒᵖ 
Arguments: {M : Type u_2} [MulOneClass M] (x : Submonoid M)
Goal: Submonoid.opEquiv x = x.op
-- Submonoid.opEquiv_symm_apply
@[to_additive (attr := simps) "A additive submonoid `H` of `G` determines an additive submonoid
`H.op` of the opposite group `Gᵐᵒᵖ`."]
def opEquiv : Submonoid M ≃o Submonoid Mᵐᵒᵖ 
Arguments: {M : Type u_2} [MulOneClass M] (x : Submonoid Mᵐᵒᵖ)
Goal: (RelIso.symm Submonoid.opEquiv) x = x.unop
-- AddSubmonoid.op_bot
@[to_additive (attr := simp)]
theorem op_bot : (⊥ : Submonoid M).op = ⊥ 
Arguments: {M : Type u_2} [AddZeroClass M]
Goal: ⊥.op = ⊥
-- Submonoid.op_bot
@[to_additive (attr := simp)]
theorem op_bot : (⊥ : Submonoid M).op = ⊥ 
Arguments: {M : Type u_2} [MulOneClass M]
Goal: ⊥.op = ⊥
-- Submonoid.unop_bot
@[to_additive (attr := simp)]
theorem unop_bot : (⊥ : Submonoid Mᵐᵒᵖ).unop = ⊥ 
Arguments: {M : Type u_2} [MulOneClass M]
Goal: ⊥.unop = ⊥
-- AddSubmonoid.unop_bot
@[to_additive (attr := simp)]
theorem unop_bot : (⊥ : Submonoid Mᵐᵒᵖ).unop = ⊥ 
Arguments: {M : Type u_2} [AddZeroClass M]
Goal: ⊥.unop = ⊥
-- AddSubmonoid.op_top
@[to_additive (attr := simp)]
theorem op_top : (⊤ : Submonoid M).op = ⊤ 
Arguments: {M : Type u_2} [AddZeroClass M]
Goal: ⊤.op = ⊤
-- Submonoid.op_top
@[to_additive (attr := simp)]
theorem op_top : (⊤ : Submonoid M).op = ⊤ 
Arguments: {M : Type u_2} [MulOneClass M]
Goal: ⊤.op = ⊤
-- Submonoid.unop_top
@[to_additive (attr := simp)]
theorem unop_top : (⊤ : Submonoid Mᵐᵒᵖ).unop = ⊤ 
Arguments: {M : Type u_2} [MulOneClass M]
Goal: ⊤.unop = ⊤
-- AddSubmonoid.unop_top
@[to_additive (attr := simp)]
theorem unop_top : (⊤ : Submonoid Mᵐᵒᵖ).unop = ⊤ 
Arguments: {M : Type u_2} [AddZeroClass M]
Goal: ⊤.unop = ⊤
-- Submonoid.op_sup
@[to_additive]
theorem op_sup (S₁ S₂ : Submonoid M) : (S₁ ⊔ S₂).op = S₁.op ⊔ S₂.op 
Arguments: {M : Type u_2} [MulOneClass M] (S₁ S₂ : Submonoid M)
Goal: (S₁ ⊔ S₂).op = S₁.op ⊔ S₂.op
-- AddSubmonoid.op_sup
@[to_additive]
theorem op_sup (S₁ S₂ : Submonoid M) : (S₁ ⊔ S₂).op = S₁.op ⊔ S₂.op 
Arguments: {M : Type u_2} [AddZeroClass M] (S₁ S₂ : AddSubmonoid M)
Goal: (S₁ ⊔ S₂).op = S₁.op ⊔ S₂.op
-- AddSubmonoid.unop_sup
@[to_additive]
theorem unop_sup (S₁ S₂ : Submonoid Mᵐᵒᵖ) : (S₁ ⊔ S₂).unop = S₁.unop ⊔ S₂.unop 
Arguments: {M : Type u_2} [AddZeroClass M] (S₁ S₂ : AddSubmonoid Mᵃᵒᵖ)
Goal: (S₁ ⊔ S₂).unop = S₁.unop ⊔ S₂.unop
-- Submonoid.unop_sup
@[to_additive]
theorem unop_sup (S₁ S₂ : Submonoid Mᵐᵒᵖ) : (S₁ ⊔ S₂).unop = S₁.unop ⊔ S₂.unop 
Arguments: {M : Type u_2} [MulOneClass M] (S₁ S₂ : Submonoid Mᵐᵒᵖ)
Goal: (S₁ ⊔ S₂).unop = S₁.unop ⊔ S₂.unop
-- AddSubmonoid.op_inf
@[to_additive]
theorem op_inf (S₁ S₂ : Submonoid M) : (S₁ ⊓ S₂).op = S₁.op ⊓ S₂.op 
Arguments: {M : Type u_2} [AddZeroClass M] (S₁ S₂ : AddSubmonoid M)
Goal: (S₁ ⊓ S₂).op = S₁.op ⊓ S₂.op
-- Submonoid.op_inf
@[to_additive]
theorem op_inf (S₁ S₂ : Submonoid M) : (S₁ ⊓ S₂).op = S₁.op ⊓ S₂.op 
Arguments: {M : Type u_2} [MulOneClass M] (S₁ S₂ : Submonoid M)
Goal: (S₁ ⊓ S₂).op = S₁.op ⊓ S₂.op
-- Submonoid.unop_inf
@[to_additive]
theorem unop_inf (S₁ S₂ : Submonoid Mᵐᵒᵖ) : (S₁ ⊓ S₂).unop = S₁.unop ⊓ S₂.unop 
Arguments: {M : Type u_2} [MulOneClass M] (S₁ S₂ : Submonoid Mᵐᵒᵖ)
Goal: (S₁ ⊓ S₂).unop = S₁.unop ⊓ S₂.unop
-- AddSubmonoid.unop_inf
@[to_additive]
theorem unop_inf (S₁ S₂ : Submonoid Mᵐᵒᵖ) : (S₁ ⊓ S₂).unop = S₁.unop ⊓ S₂.unop 
Arguments: {M : Type u_2} [AddZeroClass M] (S₁ S₂ : AddSubmonoid Mᵃᵒᵖ)
Goal: (S₁ ⊓ S₂).unop = S₁.unop ⊓ S₂.unop
-- AddSubmonoid.op_sSup
@[to_additive]
theorem op_sSup (S : Set (Submonoid M)) : (sSup S).op = sSup (.unop ⁻¹' S) 
Arguments: {M : Type u_2} [AddZeroClass M] (S : Set (AddSubmonoid M))
Goal: (sSup S).op = sSup (AddSubmonoid.unop ⁻¹' S)
-- Submonoid.op_sSup
@[to_additive]
theorem op_sSup (S : Set (Submonoid M)) : (sSup S).op = sSup (.unop ⁻¹' S) 
Arguments: {M : Type u_2} [MulOneClass M] (S : Set (Submonoid M))
Goal: (sSup S).op = sSup (Submonoid.unop ⁻¹' S)