ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Equiv.Perm.isThreeCycle_sq_of_three_mem_cycleType_five
theorem isThreeCycle_sq_of_three_mem_cycleType_five {g : Perm (Fin 5)} (h : 3 ∈ cycleType g) :
    IsThreeCycle (g * g) 
Arguments: {g : Equiv.Perm (Fin 5)} (h : 3 ∈ g.cycleType)
Goal: (g * g).IsThreeCycle
-- alternatingGroup.nontrivial_of_three_le_card
theorem nontrivial_of_three_le_card (h3 : 3 ≤ card α) : Nontrivial (alternatingGroup α) 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (h3 : 3 ≤ Fintype.card α)
Goal: Nontrivial ↥(alternatingGroup α)
-- alternatingGroup.normalClosure_finRotate_five
theorem normalClosure_finRotate_five : normalClosure ({⟨finRotate 5,
    finRotate_bit1_mem_alternatingGroup (n := 2)⟩} : Set (alternatingGroup (Fin 5))) = ⊤ 
Goal: Subgroup.normalClosure {⟨finRotate 5, ⋯⟩} = ⊤
-- alternatingGroup.normalClosure_swap_mul_swap_five
theorem normalClosure_swap_mul_swap_five :
    normalClosure
        ({⟨swap 0 4 * swap 1 3, mem_alternatingGroup.2 (by decide)⟩} :
          Set (alternatingGroup (Fin 5))) =
      ⊤ 
Goal: Subgroup.normalClosure {⟨Equiv.swap 0 4 * Equiv.swap 1 3, ⋯⟩} = ⊤
-- alternatingGroup.isConj_swap_mul_swap_of_cycleType_two
theorem isConj_swap_mul_swap_of_cycleType_two {g : Perm (Fin 5)} (ha : g ∈ alternatingGroup (Fin 5))
    (h1 : g ≠ 1) (h2 : ∀ n, n ∈ cycleType (g : Perm (Fin 5)) → n = 2) :
    IsConj (swap 0 4 * swap 1 3) g 
Arguments: {g : Equiv.Perm (Fin 5)} (ha : g ∈ alternatingGroup (Fin 5)) (h1 : g ≠ 1) (h2 : ∀ n ∈ g.cycleType, n = 2)
Goal: IsConj (Equiv.swap 0 4 * Equiv.swap 1 3) g
-- Function.Embedding.vadd_def
@[to_additive]
theorem smul_def [Group G] [MulAction G β] (g : G) (f : α ↪ β) :
    g • f = f.trans (MulAction.toPerm g).toEmbedding 
Arguments: {G : Type u_1} {α : Type u_3} {β : Type u_4} [AddGroup G] [AddAction G β] (g : G) (f : α ↪ β)
Goal: g +ᵥ f = f.trans (Equiv.toEmbedding (AddAction.toPerm g))
-- Function.Embedding.smul_def
@[to_additive]
theorem smul_def [Group G] [MulAction G β] (g : G) (f : α ↪ β) :
    g • f = f.trans (MulAction.toPerm g).toEmbedding 
Arguments: {G : Type u_1} {α : Type u_3} {β : Type u_4} [Group G] [MulAction G β] (g : G) (f : α ↪ β)
Goal: g • f = f.trans (Equiv.toEmbedding (MulAction.toPerm g))
-- Function.Embedding.vadd_apply
@[to_additive (attr := simp)]
theorem smul_apply [Group G] [MulAction G β] (g : G) (f : α ↪ β) (a : α) : (g • f) a = g • f a 
Arguments: {G : Type u_1} {α : Type u_3} {β : Type u_4} [AddGroup G] [AddAction G β] (g : G) (f : α ↪ β) (a : α)
Goal: (g +ᵥ f) a = g +ᵥ f a
-- Function.Embedding.smul_apply
@[to_additive (attr := simp)]
theorem smul_apply [Group G] [MulAction G β] (g : G) (f : α ↪ β) (a : α) : (g • f) a = g • f a 
Arguments: {G : Type u_1} {α : Type u_3} {β : Type u_4} [Group G] [MulAction G β] (g : G) (f : α ↪ β) (a : α)
Goal: (g • f) a = g • f a
-- Function.Embedding.coe_smul
@[to_additive]
theorem coe_smul [Group G] [MulAction G β] (g : G) (f : α ↪ β) : ⇑(g • f) = g • ⇑f 
Arguments: {G : Type u_1} {α : Type u_3} {β : Type u_4} [Group G] [MulAction G β] (g : G) (f : α ↪ β)
Goal: ⇑(g • f) = g • ⇑f
-- Function.Embedding.coe_vadd
@[to_additive]
theorem coe_smul [Group G] [MulAction G β] (g : G) (f : α ↪ β) : ⇑(g • f) = g • ⇑f 
Arguments: {G : Type u_1} {α : Type u_3} {β : Type u_4} [AddGroup G] [AddAction G β] (g : G) (f : α ↪ β)
Goal: ⇑(g +ᵥ f) = g +ᵥ ⇑f
-- AddCon.add'
structure AddCon [Add M] extends Setoid M where
    add' : ∀ {w x y z}, r w x → r y z → r (w + y) (x + z)
Arguments: {M : Type u_1} [Add M] (self : AddCon M) {w x y z : M}
Goal: Setoid.r w x → Setoid.r y z → Setoid.r (w + y) (x + z)
-- Con.mul'
@[to_additive AddCon]
structure Con [Mul M] extends Setoid M where
    mul' : ∀ {w x y z}, r w x → r y z → r (w * y) (x * z)
Arguments: {M : Type u_1} [Mul M] (self : Con M) {w x y z : M}
Goal: Setoid.r w x → Setoid.r y z → Setoid.r (w * y) (x * z)
-- AddCon.rel_eq_coe
@[to_additive (attr := simp)]
theorem rel_eq_coe (c : Con M) : c.r = c 
Arguments: {M : Type u_1} [Add M] (c : AddCon M)
Goal: Setoid.r = ⇑c
-- Con.rel_eq_coe
@[to_additive (attr := simp)]
theorem rel_eq_coe (c : Con M) : c.r = c 
Arguments: {M : Type u_1} [Mul M] (c : Con M)
Goal: Setoid.r = ⇑c
-- Con.refl
@[to_additive "Additive congruence relations are reflexive."]
protected theorem refl (x) : c x x 
Arguments: {M : Type u_1} [Mul M] (c : Con M) (x : M)
Goal: c x x
-- AddCon.refl
@[to_additive "Additive congruence relations are reflexive."]
protected theorem refl (x) : c x x 
Arguments: {M : Type u_1} [Add M] (c : AddCon M) (x : M)
Goal: c x x
-- Con.symm
@[to_additive "Additive congruence relations are symmetric."]
protected theorem symm {x y} : c x y → c y x 
Arguments: {M : Type u_1} [Mul M] (c : Con M) {x y : M}
Goal: c x y → c y x
-- AddCon.symm
@[to_additive "Additive congruence relations are symmetric."]
protected theorem symm {x y} : c x y → c y x 
Arguments: {M : Type u_1} [Add M] (c : AddCon M) {x y : M}
Goal: c x y → c y x
-- AddCon.trans
@[to_additive "Additive congruence relations are transitive."]
protected theorem trans {x y z} : c x y → c y z → c x z 
Arguments: {M : Type u_1} [Add M] (c : AddCon M) {x y z : M}
Goal: c x y → c y z → c x z
-- Con.trans
@[to_additive "Additive congruence relations are transitive."]
protected theorem trans {x y z} : c x y → c y z → c x z 
Arguments: {M : Type u_1} [Mul M] (c : Con M) {x y z : M}
Goal: c x y → c y z → c x z
-- Con.mul
@[to_additive "Additive congruence relations preserve addition."]
protected theorem mul {w x y z} : c w x → c y z → c (w * y) (x * z) 
Arguments: {M : Type u_1} [Mul M] (c : Con M) {w x y z : M}
Goal: c w x → c y z → c (w * y) (x * z)
-- AddCon.add
@[to_additive "Additive congruence relations preserve addition."]
protected theorem mul {w x y z} : c w x → c y z → c (w * y) (x * z) 
Arguments: {M : Type u_1} [Add M] (c : AddCon M) {w x y z : M}
Goal: c w x → c y z → c (w + y) (x + z)
-- AddCon.rel_mk
@[to_additive (attr := simp)]
theorem rel_mk {s : Setoid M} {h a b} : Con.mk s h a b ↔ r a b 
Arguments: {M : Type u_1} [Add M] {s : Setoid M} {h : ∀ {w x y z : M}, Setoid.r w x → Setoid.r y z → Setoid.r (w + y) (x + z)} {a b : M}
Goal: { toSetoid := s, add' := h } a b ↔ Setoid.r a b
-- Con.rel_mk
@[to_additive (attr := simp)]
theorem rel_mk {s : Setoid M} {h a b} : Con.mk s h a b ↔ r a b 
Arguments: {M : Type u_1} [Mul M] {s : Setoid M} {h : ∀ {w x y z : M}, Setoid.r w x → Setoid.r y z → Setoid.r (w * y) (x * z)} {a b : M}
Goal: { toSetoid := s, mul' := h } a b ↔ Setoid.r a b
-- AddCon.ext'
@[to_additive "The map sending an additive congruence relation to its underlying binary relation
is injective."]
theorem ext' {c d : Con M} (H : ⇑c = ⇑d) : c = d 
Arguments: {M : Type u_1} [Add M] {c d : AddCon M} (H : ⇑c = ⇑d)
Goal: c = d
-- Con.ext'
@[to_additive "The map sending an additive congruence relation to its underlying binary relation
is injective."]
theorem ext' {c d : Con M} (H : ⇑c = ⇑d) : c = d 
Arguments: {M : Type u_1} [Mul M] {c d : Con M} (H : ⇑c = ⇑d)
Goal: c = d
-- AddCon.ext
@[to_additive (attr := ext) "Extensionality rule for additive congruence relations."]
theorem ext {c d : Con M} (H : ∀ x y, c x y ↔ d x y) : c = d 
Arguments: {M : Type u_1} [Add M] {c d : AddCon M} (H : ∀ (x y : M), c x y ↔ d x y)
Goal: c = d
-- Con.ext
@[to_additive (attr := ext) "Extensionality rule for additive congruence relations."]
theorem ext {c d : Con M} (H : ∀ x y, c x y ↔ d x y) : c = d 
Arguments: {M : Type u_1} [Mul M] {c d : Con M} (H : ∀ (x y : M), c x y ↔ d x y)
Goal: c = d
-- AddCon.toSetoid_inj
@[to_additive "The map sending an additive congruence relation to its underlying equivalence
relation is injective."]
theorem toSetoid_inj {c d : Con M} (H : c.toSetoid = d.toSetoid) : c = d 
Arguments: {M : Type u_1} [Add M] {c d : AddCon M} (H : c.toSetoid = d.toSetoid)
Goal: c = d
-- Con.toSetoid_inj
@[to_additive "The map sending an additive congruence relation to its underlying equivalence
relation is injective."]
theorem toSetoid_inj {c d : Con M} (H : c.toSetoid = d.toSetoid) : c = d 
Arguments: {M : Type u_1} [Mul M] {c d : Con M} (H : c.toSetoid = d.toSetoid)
Goal: c = d
-- AddCon.ext_iff
@[to_additive "Iff version of extensionality rule for additive congruence relations."]
protected theorem ext_iff {c d : Con M} : c = d ↔ (∀ x y, c x y ↔ d x y) 
Arguments: {M : Type u_1} [Add M] {c d : AddCon M}
Goal: c = d ↔ ∀ (x y : M), c x y ↔ d x y
-- Con.ext_iff
@[to_additive "Iff version of extensionality rule for additive congruence relations."]
protected theorem ext_iff {c d : Con M} : c = d ↔ (∀ x y, c x y ↔ d x y) 
Arguments: {M : Type u_1} [Mul M] {c d : Con M}
Goal: c = d ↔ ∀ (x y : M), c x y ↔ d x y
-- Con.coe_inj
@[to_additive "Two additive congruence relations are equal iff their underlying binary relations
are equal."]
theorem coe_inj {c d : Con M} : ⇑c = ⇑d ↔ c = d 
Arguments: {M : Type u_1} [Mul M] {c d : Con M}
Goal: ⇑c = ⇑d ↔ c = d
-- AddCon.coe_inj
@[to_additive "Two additive congruence relations are equal iff their underlying binary relations
are equal."]
theorem coe_inj {c d : Con M} : ⇑c = ⇑d ↔ c = d 
Arguments: {M : Type u_1} [Add M] {c d : AddCon M}
Goal: ⇑c = ⇑d ↔ c = d
-- AddCon.quot_mk_eq_coe
@[to_additive (attr := simp)]
theorem quot_mk_eq_coe {M : Type*} [Mul M] (c : Con M) (x : M) : Quot.mk c x = (x : c.Quotient) 
Arguments: {M : Type u_4} [Add M] (c : AddCon M) (x : M)
Goal: Quot.mk (⇑c) x = ↑x
-- Con.quot_mk_eq_coe
@[to_additive (attr := simp)]
theorem quot_mk_eq_coe {M : Type*} [Mul M] (c : Con M) (x : M) : Quot.mk c x = (x : c.Quotient) 
Arguments: {M : Type u_4} [Mul M] (c : Con M) (x : M)
Goal: Quot.mk (⇑c) x = ↑x
-- AddCon.hrec_on₂_coe
@[to_additive (attr := simp)]
theorem hrec_on₂_coe {cM : Con M} {cN : Con N} {φ : cM.Quotient → cN.Quotient → Sort*} (a : M)
    (b : N) (f : ∀ (x : M) (y : N), φ x y)
    (h : ∀ x y x' y', cM x x' → cN y y' → HEq (f x y) (f x' y')) :
    Con.hrecOn₂ (↑a) (↑b) f h = f a b 
Arguments: {M : Type u_1} {N : Type u_2} [Add M] [Add N] {cM : AddCon M} {cN : AddCon N} {φ : cM.Quotient → cN.Quotient → Sort u_4} (a : M) (b : N) (f : (x : M) → (y : N) → φ ↑x ↑y) (h : ∀ (x : M) (y : N) (x' : M) (y' : N), cM x x' → cN y y' → HEq (f x y) (f x' y'))
Goal: AddCon.hrecOn₂ (↑a) (↑b) f h = f a b
-- Con.hrec_on₂_coe
@[to_additive (attr := simp)]
theorem hrec_on₂_coe {cM : Con M} {cN : Con N} {φ : cM.Quotient → cN.Quotient → Sort*} (a : M)
    (b : N) (f : ∀ (x : M) (y : N), φ x y)
    (h : ∀ x y x' y', cM x x' → cN y y' → HEq (f x y) (f x' y')) :
    Con.hrecOn₂ (↑a) (↑b) f h = f a b 
Arguments: {M : Type u_1} {N : Type u_2} [Mul M] [Mul N] {cM : Con M} {cN : Con N} {φ : cM.Quotient → cN.Quotient → Sort u_4} (a : M) (b : N) (f : (x : M) → (y : N) → φ ↑x ↑y) (h : ∀ (x : M) (y : N) (x' : M) (y' : N), cM x x' → cN y y' → HEq (f x y) (f x' y'))
Goal: Con.hrecOn₂ (↑a) (↑b) f h = f a b
-- Con.induction_on
@[to_additive (attr := elab_as_elim) "The inductive principle used to prove propositions about
the elements of a quotient by an additive congruence relation."]
protected theorem induction_on {C : c.Quotient → Prop} (q : c.Quotient) (H : ∀ x : M, C x) : C q 
Arguments: {M : Type u_1} [Mul M] {c : Con M} {C : c.Quotient → Prop} (q : c.Quotient) (H : ∀ (x : M), C ↑x)
Goal: C q
-- AddCon.induction_on
@[to_additive (attr := elab_as_elim) "The inductive principle used to prove propositions about
the elements of a quotient by an additive congruence relation."]
protected theorem induction_on {C : c.Quotient → Prop} (q : c.Quotient) (H : ∀ x : M, C x) : C q 
Arguments: {M : Type u_1} [Add M] {c : AddCon M} {C : c.Quotient → Prop} (q : c.Quotient) (H : ∀ (x : M), C ↑x)
Goal: C q
-- Con.induction_on₂
@[to_additive (attr := elab_as_elim) "A version of `AddCon.induction_on` for predicates which take
two arguments."]
protected theorem induction_on₂ {d : Con N} {C : c.Quotient → d.Quotient → Prop} (p : c.Quotient)
    (q : d.Quotient) (H : ∀ (x : M) (y : N), C x y) : C p q 
Arguments: {M : Type u_1} {N : Type u_2} [Mul M] [Mul N] {c : Con M} {d : Con N} {C : c.Quotient → d.Quotient → Prop} (p : c.Quotient) (q : d.Quotient) (H : ∀ (x : M) (y : N), C ↑x ↑y)
Goal: C p q
-- AddCon.induction_on₂
@[to_additive (attr := elab_as_elim) "A version of `AddCon.induction_on` for predicates which take
two arguments."]
protected theorem induction_on₂ {d : Con N} {C : c.Quotient → d.Quotient → Prop} (p : c.Quotient)
    (q : d.Quotient) (H : ∀ (x : M) (y : N), C x y) : C p q 
Arguments: {M : Type u_1} {N : Type u_2} [Add M] [Add N] {c : AddCon M} {d : AddCon N} {C : c.Quotient → d.Quotient → Prop} (p : c.Quotient) (q : d.Quotient) (H : ∀ (x : M) (y : N), C ↑x ↑y)
Goal: C p q
-- Con.eq
@[to_additive (attr := simp) "Two elements are related by an additive congruence relation `c` iff
they are represented by the same element of the quotient by `c`."]
protected theorem eq {a b : M} : (a : c.Quotient) = (b : c.Quotient) ↔ c a b 
Arguments: {M : Type u_1} [Mul M] (c : Con M) {a b : M}
Goal: ↑a = ↑b ↔ c a b
-- AddCon.eq
@[to_additive (attr := simp) "Two elements are related by an additive congruence relation `c` iff
they are represented by the same element of the quotient by `c`."]
protected theorem eq {a b : M} : (a : c.Quotient) = (b : c.Quotient) ↔ c a b 
Arguments: {M : Type u_1} [Add M] (c : AddCon M) {a b : M}
Goal: ↑a = ↑b ↔ c a b
-- AddCon.add_ker_mk_eq
@[to_additive (attr := simp) "The kernel of the quotient map induced by an additive congruence
relation `c` equals `c`."]
theorem mul_ker_mk_eq : (mulKer ((↑) : M → c.Quotient) fun _ _ => rfl) = c 
Arguments: {M : Type u_1} [Add M] (c : AddCon M)
Goal: AddCon.addKer AddCon.toQuotient ⋯ = c
-- Con.mul_ker_mk_eq
@[to_additive (attr := simp) "The kernel of the quotient map induced by an additive congruence
relation `c` equals `c`."]
theorem mul_ker_mk_eq : (mulKer ((↑) : M → c.Quotient) fun _ _ => rfl) = c 
Arguments: {M : Type u_1} [Mul M] (c : Con M)
Goal: Con.mulKer Con.toQuotient ⋯ = c
-- AddCon.coe_add
@[to_additive (attr := simp) "The coercion to the quotient of an additive congruence relation
commutes with addition (by definition)."]
theorem coe_mul (x y : M) : (↑(x * y) : c.Quotient) = ↑x * ↑y 
Arguments: {M : Type u_1} [Add M] {c : AddCon M} (x y : M)
Goal: ↑(x + y) = ↑x + ↑y
-- Con.coe_mul
@[to_additive (attr := simp) "The coercion to the quotient of an additive congruence relation
commutes with addition (by definition)."]
theorem coe_mul (x y : M) : (↑(x * y) : c.Quotient) = ↑x * ↑y 
Arguments: {M : Type u_1} [Mul M] {c : Con M} (x y : M)
Goal: ↑(x * y) = ↑x * ↑y
-- Con.liftOn_coe
@[to_additive (attr := simp) "Definition of the function on the quotient by an additive congruence
relation `c` induced by a function that is constant on `c`'s equivalence classes."]
protected theorem liftOn_coe {β} (c : Con M) (f : M → β) (h : ∀ a b, c a b → f a = f b) (x : M) :
    Con.liftOn (x : c.Quotient) f h = f x 
Arguments: {M : Type u_1} [Mul M] {β : Sort u_4} (c : Con M) (f : M → β) (h : ∀ (a b : M), c a b → f a = f b) (x : M)
Goal: Con.liftOn (↑x) f h = f x
-- AddCon.liftOn_coe
@[to_additive (attr := simp) "Definition of the function on the quotient by an additive congruence
relation `c` induced by a function that is constant on `c`'s equivalence classes."]
protected theorem liftOn_coe {β} (c : Con M) (f : M → β) (h : ∀ a b, c a b → f a = f b) (x : M) :
    Con.liftOn (x : c.Quotient) f h = f x 
Arguments: {M : Type u_1} [Add M] {β : Sort u_4} (c : AddCon M) (f : M → β) (h : ∀ (a b : M), c a b → f a = f b) (x : M)
Goal: AddCon.liftOn (↑x) f h = f x
-- Con.le_def
@[to_additive "Definition of `≤` for additive congruence relations."]
theorem le_def {c d : Con M} : c ≤ d ↔ ∀ {x y}, c x y → d x y 
Arguments: {M : Type u_1} [Mul M] {c d : Con M}
Goal: c ≤ d ↔ ∀ {x y : M}, c x y → d x y
-- AddCon.le_def
@[to_additive "Definition of `≤` for additive congruence relations."]
theorem le_def {c d : Con M} : c ≤ d ↔ ∀ {x y}, c x y → d x y 
Arguments: {M : Type u_1} [Add M] {c d : AddCon M}
Goal: c ≤ d ↔ ∀ {x y : M}, c x y → d x y
-- Con.sInf_toSetoid
@[to_additive "The infimum of a set of additive congruence relations is the same as the infimum of
the set's image under the map to the underlying equivalence relation."]
theorem sInf_toSetoid (S : Set (Con M)) : (sInf S).toSetoid = sInf (toSetoid '' S) 
Arguments: {M : Type u_1} [Mul M] (S : Set (Con M))
Goal: (sInf S).toSetoid = sInf (Con.toSetoid '' S)
-- AddCon.sInf_toSetoid
@[to_additive "The infimum of a set of additive congruence relations is the same as the infimum of
the set's image under the map to the underlying equivalence relation."]
theorem sInf_toSetoid (S : Set (Con M)) : (sInf S).toSetoid = sInf (toSetoid '' S) 
Arguments: {M : Type u_1} [Add M] (S : Set (AddCon M))
Goal: (sInf S).toSetoid = sInf (AddCon.toSetoid '' S)
-- Con.coe_sInf
@[to_additive (attr := simp, norm_cast)
  "The infimum of a set of additive congruence relations is the same as the infimum
  of the set's image under the map to the underlying binary relation."]
theorem coe_sInf (S : Set (Con M)) :
    ⇑(sInf S) = sInf ((⇑) '' S) 
Arguments: {M : Type u_1} [Mul M] (S : Set (Con M))
Goal: ⇑(sInf S) = sInf (DFunLike.coe '' S)
-- AddCon.coe_sInf
@[to_additive (attr := simp, norm_cast)
  "The infimum of a set of additive congruence relations is the same as the infimum
  of the set's image under the map to the underlying binary relation."]
theorem coe_sInf (S : Set (Con M)) :
    ⇑(sInf S) = sInf ((⇑) '' S) 
Arguments: {M : Type u_1} [Add M] (S : Set (AddCon M))
Goal: ⇑(sInf S) = sInf (DFunLike.coe '' S)
-- Con.coe_iInf
@[to_additive (attr := simp, norm_cast)]
theorem coe_iInf {ι : Sort*} (f : ι → Con M) : ⇑(iInf f) = ⨅ i, ⇑(f i) 
Arguments: {M : Type u_1} [Mul M] {ι : Sort u_4} (f : ι → Con M)
Goal: ⇑(iInf f) = ⨅ i, ⇑(f i)
-- AddCon.coe_iInf
@[to_additive (attr := simp, norm_cast)]
theorem coe_iInf {ι : Sort*} (f : ι → Con M) : ⇑(iInf f) = ⨅ i, ⇑(f i) 
Arguments: {M : Type u_1} [Add M] {ι : Sort u_4} (f : ι → AddCon M)
Goal: ⇑(iInf f) = ⨅ i, ⇑(f i)
-- AddCon.coe_inf
@[to_additive (attr := simp, norm_cast)
  "The infimum of two additive congruence relations equals the infimum of the underlying binary
  operations."]
theorem coe_inf {c d : Con M} : ⇑(c ⊓ d) = ⇑c ⊓ ⇑d 
Arguments: {M : Type u_1} [Add M] {c d : AddCon M}
Goal: ⇑(c ⊓ d) = ⇑c ⊓ ⇑d
-- Con.coe_inf
@[to_additive (attr := simp, norm_cast)
  "The infimum of two additive congruence relations equals the infimum of the underlying binary
  operations."]
theorem coe_inf {c d : Con M} : ⇑(c ⊓ d) = ⇑c ⊓ ⇑d 
Arguments: {M : Type u_1} [Mul M] {c d : Con M}
Goal: ⇑(c ⊓ d) = ⇑c ⊓ ⇑d
-- AddCon.inf_iff_and
@[to_additive "Definition of the infimum of two additive congruence relations."]
theorem inf_iff_and {c d : Con M} {x y} : (c ⊓ d) x y ↔ c x y ∧ d x y 
Arguments: {M : Type u_1} [Add M] {c d : AddCon M} {x y : M}
Goal: (c ⊓ d) x y ↔ c x y ∧ d x y
-- Con.inf_iff_and
@[to_additive "Definition of the infimum of two additive congruence relations."]
theorem inf_iff_and {c d : Con M} {x y} : (c ⊓ d) x y ↔ c x y ∧ d x y 
Arguments: {M : Type u_1} [Mul M] {c d : Con M} {x y : M}
Goal: (c ⊓ d) x y ↔ c x y ∧ d x y
-- AddCon.addConGen_eq
@[to_additive addConGen_eq "The inductively defined smallest additive congruence relation
containing a binary relation `r` equals the infimum of the set of additive congruence relations
containing `r`."]
theorem conGen_eq (r : M → M → Prop) : conGen r = sInf { s : Con M | ∀ x y, r x y → s x y } 
Arguments: {M : Type u_1} [Add M] (r : M → M → Prop)
Goal: addConGen r = sInf {s | ∀ (x y : M), r x y → s x y}
-- Con.conGen_eq
@[to_additive addConGen_eq "The inductively defined smallest additive congruence relation
containing a binary relation `r` equals the infimum of the set of additive congruence relations
containing `r`."]
theorem conGen_eq (r : M → M → Prop) : conGen r = sInf { s : Con M | ∀ x y, r x y → s x y } 
Arguments: {M : Type u_1} [Mul M] (r : M → M → Prop)
Goal: conGen r = sInf {s | ∀ (x y : M), r x y → s x y}
-- Con.conGen_le
@[to_additive addConGen_le "The smallest additive congruence relation containing a binary
relation `r` is contained in any additive congruence relation containing `r`."]
theorem conGen_le {r : M → M → Prop} {c : Con M} (h : ∀ x y, r x y → c x y) :
    conGen r ≤ c 
Arguments: {M : Type u_1} [Mul M] {r : M → M → Prop} {c : Con M} (h : ∀ (x y : M), r x y → c x y)
Goal: conGen r ≤ c
-- AddCon.addConGen_le
@[to_additive addConGen_le "The smallest additive congruence relation containing a binary
relation `r` is contained in any additive congruence relation containing `r`."]
theorem conGen_le {r : M → M → Prop} {c : Con M} (h : ∀ x y, r x y → c x y) :
    conGen r ≤ c 
Arguments: {M : Type u_1} [Add M] {r : M → M → Prop} {c : AddCon M} (h : ∀ (x y : M), r x y → c x y)
Goal: addConGen r ≤ c
-- AddCon.addConGen_mono
@[to_additive addConGen_mono "Given binary relations `r, s` with `r` contained in `s`, the
smallest additive congruence relation containing `s` contains the smallest additive congruence
relation containing `r`."]
theorem conGen_mono {r s : M → M → Prop} (h : ∀ x y, r x y → s x y) : conGen r ≤ conGen s 
Arguments: {M : Type u_1} [Add M] {r s : M → M → Prop} (h : ∀ (x y : M), r x y → s x y)
Goal: addConGen r ≤ addConGen s
-- Con.conGen_mono
@[to_additive addConGen_mono "Given binary relations `r, s` with `r` contained in `s`, the
smallest additive congruence relation containing `s` contains the smallest additive congruence
relation containing `r`."]
theorem conGen_mono {r s : M → M → Prop} (h : ∀ x y, r x y → s x y) : conGen r ≤ conGen s 
Arguments: {M : Type u_1} [Mul M] {r s : M → M → Prop} (h : ∀ (x y : M), r x y → s x y)
Goal: conGen r ≤ conGen s
-- Con.conGen_of_con
@[to_additive (attr := simp) addConGen_of_addCon "Additive congruence relations equal the smallest
additive congruence relation in which they are contained."]
theorem conGen_of_con (c : Con M) : conGen c = c 
Arguments: {M : Type u_1} [Mul M] (c : Con M)
Goal: conGen ⇑c = c
-- AddCon.addConGen_of_addCon
@[to_additive (attr := simp) addConGen_of_addCon "Additive congruence relations equal the smallest
additive congruence relation in which they are contained."]
theorem conGen_of_con (c : Con M) : conGen c = c 
Arguments: {M : Type u_1} [Add M] (c : AddCon M)
Goal: addConGen ⇑c = c
-- Con.conGen_idem
@[to_additive addConGen_idem "The map sending a binary relation to the smallest additive
congruence relation in which it is contained is idempotent."]
theorem conGen_idem (r : M → M → Prop) : conGen (conGen r) = conGen r 
Arguments: {M : Type u_1} [Mul M] (r : M → M → Prop)
Goal: conGen ⇑(conGen r) = conGen r
-- AddCon.addConGen_idem
@[to_additive addConGen_idem "The map sending a binary relation to the smallest additive
congruence relation in which it is contained is idempotent."]
theorem conGen_idem (r : M → M → Prop) : conGen (conGen r) = conGen r 
Arguments: {M : Type u_1} [Add M] (r : M → M → Prop)
Goal: addConGen ⇑(addConGen r) = addConGen r
-- AddCon.sup_eq_addConGen
@[to_additive sup_eq_addConGen "The supremum of additive congruence relations `c, d` equals the
smallest additive congruence relation containing the binary relation '`x` is related to `y`
by `c` or `d`'."]
theorem sup_eq_conGen (c d : Con M) : c ⊔ d = conGen fun x y => c x y ∨ d x y 
Arguments: {M : Type u_1} [Add M] (c d : AddCon M)
Goal: c ⊔ d = addConGen fun x y => c x y ∨ d x y
-- Con.sup_eq_conGen
@[to_additive sup_eq_addConGen "The supremum of additive congruence relations `c, d` equals the
smallest additive congruence relation containing the binary relation '`x` is related to `y`
by `c` or `d`'."]
theorem sup_eq_conGen (c d : Con M) : c ⊔ d = conGen fun x y => c x y ∨ d x y 
Arguments: {M : Type u_1} [Mul M] (c d : Con M)
Goal: c ⊔ d = conGen fun x y => c x y ∨ d x y
-- Con.sup_def
@[to_additive "The supremum of two additive congruence relations equals the smallest additive
congruence relation containing the supremum of the underlying binary operations."]
theorem sup_def {c d : Con M} : c ⊔ d = conGen (⇑c ⊔ ⇑d) 
Arguments: {M : Type u_1} [Mul M] {c d : Con M}
Goal: c ⊔ d = conGen (⇑c ⊔ ⇑d)
-- AddCon.sup_def
@[to_additive "The supremum of two additive congruence relations equals the smallest additive
congruence relation containing the supremum of the underlying binary operations."]
theorem sup_def {c d : Con M} : c ⊔ d = conGen (⇑c ⊔ ⇑d) 
Arguments: {M : Type u_1} [Add M] {c d : AddCon M}
Goal: c ⊔ d = addConGen (⇑c ⊔ ⇑d)