ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- AddCon.sSup_eq_addConGen
@[to_additive sSup_eq_addConGen "The supremum of a set of additive congruence relations `S` equals
the smallest additive congruence relation containing the binary relation 'there exists `c ∈ S`
such that `x` is related to `y` by `c`'."]
theorem sSup_eq_conGen (S : Set (Con M)) :
    sSup S = conGen fun x y => ∃ c : Con M, c ∈ S ∧ c x y 
Arguments: {M : Type u_1} [Add M] (S : Set (AddCon M))
Goal: sSup S = addConGen fun x y => ∃ c ∈ S, c x y
-- Con.sSup_eq_conGen
@[to_additive sSup_eq_addConGen "The supremum of a set of additive congruence relations `S` equals
the smallest additive congruence relation containing the binary relation 'there exists `c ∈ S`
such that `x` is related to `y` by `c`'."]
theorem sSup_eq_conGen (S : Set (Con M)) :
    sSup S = conGen fun x y => ∃ c : Con M, c ∈ S ∧ c x y 
Arguments: {M : Type u_1} [Mul M] (S : Set (Con M))
Goal: sSup S = conGen fun x y => ∃ c ∈ S, c x y
-- Con.sSup_def
@[to_additive "The supremum of a set of additive congruence relations is the same as the smallest
additive congruence relation containing the supremum of the set's image under the map to the
underlying binary relation."]
theorem sSup_def {S : Set (Con M)} :
    sSup S = conGen (sSup ((⇑) '' S)) 
Arguments: {M : Type u_1} [Mul M] {S : Set (Con M)}
Goal: sSup S = conGen (sSup (DFunLike.coe '' S))
-- AddCon.sSup_def
@[to_additive "The supremum of a set of additive congruence relations is the same as the smallest
additive congruence relation containing the supremum of the set's image under the map to the
underlying binary relation."]
theorem sSup_def {S : Set (Con M)} :
    sSup S = conGen (sSup ((⇑) '' S)) 
Arguments: {M : Type u_1} [Add M] {S : Set (AddCon M)}
Goal: sSup S = addConGen (sSup (DFunLike.coe '' S))
-- Con.mapOfSurjective_eq_mapGen
@[to_additive "A specialization of 'the smallest additive congruence relation containing
an additive congruence relation `c` equals `c`'."]
theorem mapOfSurjective_eq_mapGen {c : Con M} {f : M → N} (H : ∀ x y, f (x * y) = f x * f y)
    (h : mulKer f H ≤ c) (hf : Surjective f) : c.mapGen f = c.mapOfSurjective f H h hf 
Arguments: {M : Type u_1} {N : Type u_2} [Mul M] [Mul N] {c : Con M} {f : M → N} (H : ∀ (x y : M), f (x * y) = f x * f y) (h : Con.mulKer f H ≤ c) (hf : Function.Surjective f)
Goal: c.mapGen f = c.mapOfSurjective f H h hf
-- AddCon.mapOfSurjective_eq_mapGen
@[to_additive "A specialization of 'the smallest additive congruence relation containing
an additive congruence relation `c` equals `c`'."]
theorem mapOfSurjective_eq_mapGen {c : Con M} {f : M → N} (H : ∀ x y, f (x * y) = f x * f y)
    (h : mulKer f H ≤ c) (hf : Surjective f) : c.mapGen f = c.mapOfSurjective f H h hf 
Arguments: {M : Type u_1} {N : Type u_2} [Add M] [Add N] {c : AddCon M} {f : M → N} (H : ∀ (x y : M), f (x + y) = f x + f y) (h : AddCon.addKer f H ≤ c) (hf : Function.Surjective f)
Goal: c.mapGen f = c.mapOfSurjective f H h hf
-- AddCon.comap_rel
@[to_additive (attr := simp)]
theorem comap_rel {f : M → N} (H : ∀ x y, f (x * y) = f x * f y) {c : Con N} {x y : M} :
    comap f H c x y ↔ c (f x) (f y) 
Arguments: {M : Type u_1} {N : Type u_2} [Add M] [Add N] {f : M → N} (H : ∀ (x y : M), f (x + y) = f x + f y) {c : AddCon N} {x y : M}
Goal: (AddCon.comap f H c) x y ↔ c (f x) (f y)
-- Con.comap_rel
@[to_additive (attr := simp)]
theorem comap_rel {f : M → N} (H : ∀ x y, f (x * y) = f x * f y) {c : Con N} {x y : M} :
    comap f H c x y ↔ c (f x) (f y) 
Arguments: {M : Type u_1} {N : Type u_2} [Mul M] [Mul N] {f : M → N} (H : ∀ (x y : M), f (x * y) = f x * f y) {c : Con N} {x y : M}
Goal: (Con.comap f H c) x y ↔ c (f x) (f y)
-- Con.coe_one
@[to_additive (attr := simp) "The 0 of the quotient of an `AddMonoid` by an additive congruence
relation is the equivalence class of the `AddMonoid`'s 0."]
theorem coe_one : ((1 : M) : c.Quotient) = 1 
Arguments: {M : Type u_1} [MulOneClass M] {c : Con M}
Goal: ↑1 = 1
-- AddCon.coe_zero
@[to_additive (attr := simp) "The 0 of the quotient of an `AddMonoid` by an additive congruence
relation is the equivalence class of the `AddMonoid`'s 0."]
theorem coe_one : ((1 : M) : c.Quotient) = 1 
Arguments: {M : Type u_1} [AddZeroClass M] {c : AddCon M}
Goal: ↑0 = 0
-- Con.mem_coe
@[to_additive]
theorem mem_coe {c : Con M} {x y} : (x, y) ∈ (↑c : Submonoid (M × M)) ↔ (x, y) ∈ c 
Arguments: {M : Type u_1} [MulOneClass M] {c : Con M} {x y : M}
Goal: (x, y) ∈ ↑c ↔ (x, y) ∈ c
-- AddCon.mem_coe
@[to_additive]
theorem mem_coe {c : Con M} {x y} : (x, y) ∈ (↑c : Submonoid (M × M)) ↔ (x, y) ∈ c 
Arguments: {M : Type u_1} [AddZeroClass M] {c : AddCon M} {x y : M}
Goal: (x, y) ∈ ↑c ↔ (x, y) ∈ c
-- Con.to_submonoid_inj
@[to_additive]
theorem to_submonoid_inj (c d : Con M) (H : (c : Submonoid (M × M)) = d) : c = d 
Arguments: {M : Type u_1} [MulOneClass M] (c d : Con M) (H : ↑c = ↑d)
Goal: c = d
-- AddCon.to_addSubmonoid_inj
@[to_additive]
theorem to_submonoid_inj (c d : Con M) (H : (c : Submonoid (M × M)) = d) : c = d 
Arguments: {M : Type u_1} [AddZeroClass M] (c d : AddCon M) (H : ↑c = ↑d)
Goal: c = d
-- Con.le_iff
@[to_additive]
theorem le_iff {c d : Con M} : c ≤ d ↔ (c : Submonoid (M × M)) ≤ d 
Arguments: {M : Type u_1} [MulOneClass M] {c d : Con M}
Goal: c ≤ d ↔ ↑c ≤ ↑d
-- AddCon.le_iff
@[to_additive]
theorem le_iff {c d : Con M} : c ≤ d ↔ (c : Submonoid (M × M)) ≤ d 
Arguments: {M : Type u_1} [AddZeroClass M] {c d : AddCon M}
Goal: c ≤ d ↔ ↑c ≤ ↑d
-- Con.ker_rel
@[to_additive (attr := simp) "The definition of the additive congruence relation defined by an
`AddMonoid` homomorphism's kernel."]
theorem ker_rel (f : M →* P) {x y} : ker f x y ↔ f x = f y 
Arguments: {M : Type u_1} {P : Type u_3} [MulOneClass M] [MulOneClass P] (f : M →* P) {x y : M}
Goal: (Con.ker f) x y ↔ f x = f y
-- AddCon.ker_rel
@[to_additive (attr := simp) "The definition of the additive congruence relation defined by an
`AddMonoid` homomorphism's kernel."]
theorem ker_rel (f : M →* P) {x y} : ker f x y ↔ f x = f y 
Arguments: {M : Type u_1} {P : Type u_3} [AddZeroClass M] [AddZeroClass P] (f : M →+ P) {x y : M}
Goal: (AddCon.ker f) x y ↔ f x = f y
-- Con.mk'_ker
@[to_additive (attr := simp) "The kernel of the natural homomorphism from an `AddMonoid` to its
quotient by an additive congruence relation `c` equals `c`."]
theorem mk'_ker : ker c.mk' = c 
Arguments: {M : Type u_1} [MulOneClass M] (c : Con M)
Goal: Con.ker c.mk' = c
-- AddCon.mk'_ker
@[to_additive (attr := simp) "The kernel of the natural homomorphism from an `AddMonoid` to its
quotient by an additive congruence relation `c` equals `c`."]
theorem mk'_ker : ker c.mk' = c 
Arguments: {M : Type u_1} [AddZeroClass M] (c : AddCon M)
Goal: AddCon.ker c.mk' = c
-- Con.mk'_surjective
@[to_additive "The natural homomorphism from an `AddMonoid` to its quotient by a congruence
relation is surjective."]
theorem mk'_surjective : Surjective c.mk' 
Arguments: {M : Type u_1} [MulOneClass M] {c : Con M}
Goal: Function.Surjective ⇑c.mk'
-- AddCon.mk'_surjective
@[to_additive "The natural homomorphism from an `AddMonoid` to its quotient by a congruence
relation is surjective."]
theorem mk'_surjective : Surjective c.mk' 
Arguments: {M : Type u_1} [AddZeroClass M] {c : AddCon M}
Goal: Function.Surjective ⇑c.mk'
-- AddCon.coe_mk'
@[to_additive (attr := simp)]
theorem coe_mk' : (c.mk' : M → c.Quotient) = ((↑) : M → c.Quotient) 
Arguments: {M : Type u_1} [AddZeroClass M] {c : AddCon M}
Goal: ⇑c.mk' = AddCon.toQuotient
-- Con.coe_mk'
@[to_additive (attr := simp)]
theorem coe_mk' : (c.mk' : M → c.Quotient) = ((↑) : M → c.Quotient) 
Arguments: {M : Type u_1} [MulOneClass M] {c : Con M}
Goal: ⇑c.mk' = Con.toQuotient
-- Con.mrange_mk'
@[to_additive (attr := simp)]
-- Porting note: removed dot notation
theorem mrange_mk' : MonoidHom.mrange c.mk' = ⊤ 
Arguments: {M : Type u_1} [MulOneClass M] {c : Con M}
Goal: MonoidHom.mrange c.mk' = ⊤
-- AddCon.mrange_mk'
@[to_additive (attr := simp)]
-- Porting note: removed dot notation
theorem mrange_mk' : MonoidHom.mrange c.mk' = ⊤ 
Arguments: {M : Type u_1} [AddZeroClass M] {c : AddCon M}
Goal: AddMonoidHom.mrange c.mk' = ⊤
-- AddCon.ker_apply
@[to_additive]
theorem ker_apply {f : M →* P} {x y} : ker f x y ↔ f x = f y 
Arguments: {M : Type u_1} {P : Type u_3} [AddZeroClass M] [AddZeroClass P] {f : M →+ P} {x y : M}
Goal: (AddCon.ker f) x y ↔ f x = f y
-- Con.ker_apply
@[to_additive]
theorem ker_apply {f : M →* P} {x y} : ker f x y ↔ f x = f y 
Arguments: {M : Type u_1} {P : Type u_3} [MulOneClass M] [MulOneClass P] {f : M →* P} {x y : M}
Goal: (Con.ker f) x y ↔ f x = f y
-- AddCon.comap_eq
@[to_additive "Given an `AddMonoid` homomorphism `f : N → M` and an additive congruence relation
`c` on `M`, the additive congruence relation induced on `N` by `f` equals the kernel of `c`'s
quotient homomorphism composed with `f`."]
theorem comap_eq {f : N →* M} : comap f f.map_mul c = ker (c.mk'.comp f) 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {c : AddCon M} {f : N →+ M}
Goal: AddCon.comap ⇑f ⋯ c = AddCon.ker (c.mk'.comp f)
-- Con.comap_eq
@[to_additive "Given an `AddMonoid` homomorphism `f : N → M` and an additive congruence relation
`c` on `M`, the additive congruence relation induced on `N` by `f` equals the kernel of `c`'s
quotient homomorphism composed with `f`."]
theorem comap_eq {f : N →* M} : comap f f.map_mul c = ker (c.mk'.comp f) 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {c : Con M} {f : N →* M}
Goal: Con.comap ⇑f ⋯ c = Con.ker (c.mk'.comp f)
-- Con.lift_mk'
@[to_additive "The diagram describing the universal property for quotients of `AddMonoid`s
commutes."]
theorem lift_mk' (H : c ≤ ker f) (x) : c.lift f H (c.mk' x) = f x 
Arguments: {M : Type u_1} {P : Type u_3} [MulOneClass M] [MulOneClass P] {c : Con M} {f : M →* P} (H : c ≤ Con.ker f) (x : M)
Goal: (c.lift f H) (c.mk' x) = f x
-- AddCon.lift_mk'
@[to_additive "The diagram describing the universal property for quotients of `AddMonoid`s
commutes."]
theorem lift_mk' (H : c ≤ ker f) (x) : c.lift f H (c.mk' x) = f x 
Arguments: {M : Type u_1} {P : Type u_3} [AddZeroClass M] [AddZeroClass P] {c : AddCon M} {f : M →+ P} (H : c ≤ AddCon.ker f) (x : M)
Goal: (c.lift f H) (c.mk' x) = f x
-- AddCon.lift_coe
@[to_additive (attr := simp) "The diagram describing the universal property for quotients of
`AddMonoid`s commutes."]
theorem lift_coe (H : c ≤ ker f) (x : M) : c.lift f H x = f x 
Arguments: {M : Type u_1} {P : Type u_3} [AddZeroClass M] [AddZeroClass P] {c : AddCon M} {f : M →+ P} (H : c ≤ AddCon.ker f) (x : M)
Goal: (c.lift f H) ↑x = f x
-- Con.lift_coe
@[to_additive (attr := simp) "The diagram describing the universal property for quotients of
`AddMonoid`s commutes."]
theorem lift_coe (H : c ≤ ker f) (x : M) : c.lift f H x = f x 
Arguments: {M : Type u_1} {P : Type u_3} [MulOneClass M] [MulOneClass P] {c : Con M} {f : M →* P} (H : c ≤ Con.ker f) (x : M)
Goal: (c.lift f H) ↑x = f x
-- AddCon.lift_comp_mk'
@[to_additive (attr := simp) "The diagram describing the universal property for quotients of
`AddMonoid`s commutes."]
theorem lift_comp_mk' (H : c ≤ ker f) : (c.lift f H).comp c.mk' = f 
Arguments: {M : Type u_1} {P : Type u_3} [AddZeroClass M] [AddZeroClass P] {c : AddCon M} {f : M →+ P} (H : c ≤ AddCon.ker f)
Goal: (c.lift f H).comp c.mk' = f
-- Con.lift_comp_mk'
@[to_additive (attr := simp) "The diagram describing the universal property for quotients of
`AddMonoid`s commutes."]
theorem lift_comp_mk' (H : c ≤ ker f) : (c.lift f H).comp c.mk' = f 
Arguments: {M : Type u_1} {P : Type u_3} [MulOneClass M] [MulOneClass P] {c : Con M} {f : M →* P} (H : c ≤ Con.ker f)
Goal: (c.lift f H).comp c.mk' = f
-- AddCon.lift_apply_mk'
@[to_additive (attr := simp) "Given a homomorphism `f` from the quotient of an `AddMonoid` by an
additive congruence relation, `f` equals the homomorphism on the quotient induced by `f` composed
with the natural map from the `AddMonoid` to the quotient."]
theorem lift_apply_mk' (f : c.Quotient →* P) :
    (c.lift (f.comp c.mk') fun x y h => show f ↑x = f ↑y by rw [c.eq.2 h]) = f 
Arguments: {M : Type u_1} {P : Type u_3} [AddZeroClass M] [AddZeroClass P] {c : AddCon M} (f : c.Quotient →+ P)
Goal: c.lift (f.comp c.mk') ⋯ = f
-- Con.lift_apply_mk'
@[to_additive (attr := simp) "Given a homomorphism `f` from the quotient of an `AddMonoid` by an
additive congruence relation, `f` equals the homomorphism on the quotient induced by `f` composed
with the natural map from the `AddMonoid` to the quotient."]
theorem lift_apply_mk' (f : c.Quotient →* P) :
    (c.lift (f.comp c.mk') fun x y h => show f ↑x = f ↑y by rw [c.eq.2 h]) = f 
Arguments: {M : Type u_1} {P : Type u_3} [MulOneClass M] [MulOneClass P] {c : Con M} (f : c.Quotient →* P)
Goal: c.lift (f.comp c.mk') ⋯ = f
-- Con.lift_funext
@[to_additive "Homomorphisms on the quotient of an `AddMonoid` by an additive congruence relation
are equal if they are equal on elements that are coercions from the `AddMonoid`."]
theorem lift_funext (f g : c.Quotient →* P) (h : ∀ a : M, f a = g a) : f = g 
Arguments: {M : Type u_1} {P : Type u_3} [MulOneClass M] [MulOneClass P] {c : Con M} (f g : c.Quotient →* P) (h : ∀ (a : M), f ↑a = g ↑a)
Goal: f = g
-- AddCon.lift_funext
@[to_additive "Homomorphisms on the quotient of an `AddMonoid` by an additive congruence relation
are equal if they are equal on elements that are coercions from the `AddMonoid`."]
theorem lift_funext (f g : c.Quotient →* P) (h : ∀ a : M, f a = g a) : f = g 
Arguments: {M : Type u_1} {P : Type u_3} [AddZeroClass M] [AddZeroClass P] {c : AddCon M} (f g : c.Quotient →+ P) (h : ∀ (a : M), f ↑a = g ↑a)
Goal: f = g
-- Con.lift_unique
@[to_additive "The uniqueness part of the universal property for quotients of `AddMonoid`s."]
theorem lift_unique (H : c ≤ ker f) (g : c.Quotient →* P) (Hg : g.comp c.mk' = f) :
    g = c.lift f H 
Arguments: {M : Type u_1} {P : Type u_3} [MulOneClass M] [MulOneClass P] {c : Con M} {f : M →* P} (H : c ≤ Con.ker f) (g : c.Quotient →* P) (Hg : g.comp c.mk' = f)
Goal: g = c.lift f H
-- AddCon.lift_unique
@[to_additive "The uniqueness part of the universal property for quotients of `AddMonoid`s."]
theorem lift_unique (H : c ≤ ker f) (g : c.Quotient →* P) (Hg : g.comp c.mk' = f) :
    g = c.lift f H 
Arguments: {M : Type u_1} {P : Type u_3} [AddZeroClass M] [AddZeroClass P] {c : AddCon M} {f : M →+ P} (H : c ≤ AddCon.ker f) (g : c.Quotient →+ P) (Hg : g.comp c.mk' = f)
Goal: g = c.lift f H
-- AddCon.lift_range
@[to_additive "Given an additive congruence relation `c` on an `AddMonoid` and a homomorphism `f`
constant on `c`'s equivalence classes, `f` has the same image as the homomorphism that `f` induces
on the quotient."]
theorem lift_range (H : c ≤ ker f) : MonoidHom.mrange (c.lift f H) = MonoidHom.mrange f 
Arguments: {M : Type u_1} {P : Type u_3} [AddZeroClass M] [AddZeroClass P] {c : AddCon M} {f : M →+ P} (H : c ≤ AddCon.ker f)
Goal: AddMonoidHom.mrange (c.lift f H) = AddMonoidHom.mrange f
-- Con.lift_range
@[to_additive "Given an additive congruence relation `c` on an `AddMonoid` and a homomorphism `f`
constant on `c`'s equivalence classes, `f` has the same image as the homomorphism that `f` induces
on the quotient."]
theorem lift_range (H : c ≤ ker f) : MonoidHom.mrange (c.lift f H) = MonoidHom.mrange f 
Arguments: {M : Type u_1} {P : Type u_3} [MulOneClass M] [MulOneClass P] {c : Con M} {f : M →* P} (H : c ≤ Con.ker f)
Goal: MonoidHom.mrange (c.lift f H) = MonoidHom.mrange f
-- AddCon.lift_surjective_of_surjective
@[to_additive "Surjective `AddMonoid` homomorphisms constant on an additive congruence
relation `c`'s equivalence classes induce a surjective homomorphism on `c`'s quotient."]
theorem lift_surjective_of_surjective (h : c ≤ ker f) (hf : Surjective f) :
    Surjective (c.lift f h) 
Arguments: {M : Type u_1} {P : Type u_3} [AddZeroClass M] [AddZeroClass P] {c : AddCon M} {f : M →+ P} (h : c ≤ AddCon.ker f) (hf : Function.Surjective ⇑f)
Goal: Function.Surjective ⇑(c.lift f h)
-- Con.lift_surjective_of_surjective
@[to_additive "Surjective `AddMonoid` homomorphisms constant on an additive congruence
relation `c`'s equivalence classes induce a surjective homomorphism on `c`'s quotient."]
theorem lift_surjective_of_surjective (h : c ≤ ker f) (hf : Surjective f) :
    Surjective (c.lift f h) 
Arguments: {M : Type u_1} {P : Type u_3} [MulOneClass M] [MulOneClass P] {c : Con M} {f : M →* P} (h : c ≤ Con.ker f) (hf : Function.Surjective ⇑f)
Goal: Function.Surjective ⇑(c.lift f h)
-- Con.ker_eq_lift_of_injective
@[to_additive "Given an `AddMonoid` homomorphism `f` from `M` to `P`, the kernel of `f`
is the unique additive congruence relation on `M` whose induced map from the quotient of `M`
to `P` is injective."]
theorem ker_eq_lift_of_injective (H : c ≤ ker f) (h : Injective (c.lift f H)) : ker f = c 
Arguments: {M : Type u_1} {P : Type u_3} [MulOneClass M] [MulOneClass P] (c : Con M) (f : M →* P) (H : c ≤ Con.ker f) (h : Function.Injective ⇑(c.lift f H))
Goal: Con.ker f = c
-- AddCon.ker_eq_lift_of_injective
@[to_additive "Given an `AddMonoid` homomorphism `f` from `M` to `P`, the kernel of `f`
is the unique additive congruence relation on `M` whose induced map from the quotient of `M`
to `P` is injective."]
theorem ker_eq_lift_of_injective (H : c ≤ ker f) (h : Injective (c.lift f H)) : ker f = c 
Arguments: {M : Type u_1} {P : Type u_3} [AddZeroClass M] [AddZeroClass P] (c : AddCon M) (f : M →+ P) (H : c ≤ AddCon.ker f) (h : Function.Injective ⇑(c.lift f H))
Goal: AddCon.ker f = c
-- Con.kerLift_mk
@[to_additive (attr := simp) "The diagram described by the universal property for quotients
of `AddMonoid`s, when the additive congruence relation is the kernel of the homomorphism,
commutes."]
theorem kerLift_mk (x : M) : kerLift f x = f x 
Arguments: {M : Type u_1} {P : Type u_3} [MulOneClass M] [MulOneClass P] {f : M →* P} (x : M)
Goal: (Con.kerLift f) ↑x = f x
-- AddCon.kerLift_mk
@[to_additive (attr := simp) "The diagram described by the universal property for quotients
of `AddMonoid`s, when the additive congruence relation is the kernel of the homomorphism,
commutes."]
theorem kerLift_mk (x : M) : kerLift f x = f x 
Arguments: {M : Type u_1} {P : Type u_3} [AddZeroClass M] [AddZeroClass P] {f : M →+ P} (x : M)
Goal: (AddCon.kerLift f) ↑x = f x
-- AddCon.kerLift_range_eq
@[to_additive (attr := simp) "Given an `AddMonoid` homomorphism `f`, the induced homomorphism
on the quotient by `f`'s kernel has the same image as `f`."]
theorem kerLift_range_eq : MonoidHom.mrange (kerLift f) = MonoidHom.mrange f 
Arguments: {M : Type u_1} {P : Type u_3} [AddZeroClass M] [AddZeroClass P] {f : M →+ P}
Goal: AddMonoidHom.mrange (AddCon.kerLift f) = AddMonoidHom.mrange f
-- Con.kerLift_range_eq
@[to_additive (attr := simp) "Given an `AddMonoid` homomorphism `f`, the induced homomorphism
on the quotient by `f`'s kernel has the same image as `f`."]
theorem kerLift_range_eq : MonoidHom.mrange (kerLift f) = MonoidHom.mrange f 
Arguments: {M : Type u_1} {P : Type u_3} [MulOneClass M] [MulOneClass P] {f : M →* P}
Goal: MonoidHom.mrange (Con.kerLift f) = MonoidHom.mrange f
-- Con.kerLift_injective
@[to_additive "An `AddMonoid` homomorphism `f` induces an injective homomorphism on the quotient
by `f`'s kernel."]
theorem kerLift_injective (f : M →* P) : Injective (kerLift f) 
Arguments: {M : Type u_1} {P : Type u_3} [MulOneClass M] [MulOneClass P] (f : M →* P)
Goal: Function.Injective ⇑(Con.kerLift f)
-- AddCon.kerLift_injective
@[to_additive "An `AddMonoid` homomorphism `f` induces an injective homomorphism on the quotient
by `f`'s kernel."]
theorem kerLift_injective (f : M →* P) : Injective (kerLift f) 
Arguments: {M : Type u_1} {P : Type u_3} [AddZeroClass M] [AddZeroClass P] (f : M →+ P)
Goal: Function.Injective ⇑(AddCon.kerLift f)
-- AddCon.map_apply
@[to_additive "Given additive congruence relations `c, d` on an `AddMonoid` such that `d`
contains `c`, the definition of the homomorphism from the quotient by `c` to the quotient by `d`
induced by `d`'s quotient map."]
theorem map_apply {c d : Con M} (h : c ≤ d) (x) :
    c.map d h x = c.lift d.mk' (fun _ _ hc => d.eq.2 <| h hc) x 
Arguments: {M : Type u_1} [AddZeroClass M] {c d : AddCon M} (h : c ≤ d) (x : c.Quotient)
Goal: (c.map d h) x = (c.lift d.mk' ⋯) x
-- Con.map_apply
@[to_additive "Given additive congruence relations `c, d` on an `AddMonoid` such that `d`
contains `c`, the definition of the homomorphism from the quotient by `c` to the quotient by `d`
induced by `d`'s quotient map."]
theorem map_apply {c d : Con M} (h : c ≤ d) (x) :
    c.map d h x = c.lift d.mk' (fun _ _ hc => d.eq.2 <| h hc) x 
Arguments: {M : Type u_1} [MulOneClass M] {c d : Con M} (h : c ≤ d) (x : c.Quotient)
Goal: (c.map d h) x = (c.lift d.mk' ⋯) x
-- AddCon.quotientKerEquivOfRightInverse_symm_apply
@[to_additive (attr := simps)
  "The first isomorphism theorem for `AddMonoid`s in the case of a homomorphism
  with right inverse."]
def quotientKerEquivOfRightInverse (f : M →* P) (g : P → M) (hf : Function.RightInverse g f) :
    (ker f).Quotient ≃* P 
Arguments: {M : Type u_1} {P : Type u_3} [AddZeroClass M] [AddZeroClass P] (f : M →+ P) (g : P → M) (hf : Function.RightInverse g ⇑f)
Goal: ∀ (a : P), (AddCon.quotientKerEquivOfRightInverse f g hf).symm a = (AddCon.toQuotient ∘ g) a
-- Con.quotientKerEquivOfRightInverse_apply
@[to_additive (attr := simps)
  "The first isomorphism theorem for `AddMonoid`s in the case of a homomorphism
  with right inverse."]
def quotientKerEquivOfRightInverse (f : M →* P) (g : P → M) (hf : Function.RightInverse g f) :
    (ker f).Quotient ≃* P 
Arguments: {M : Type u_1} {P : Type u_3} [MulOneClass M] [MulOneClass P] (f : M →* P) (g : P → M) (hf : Function.RightInverse g ⇑f) (a : (Con.ker f).Quotient)
Goal: (Con.quotientKerEquivOfRightInverse f g hf) a = (Con.kerLift f) a
-- Con.quotientKerEquivOfRightInverse_symm_apply
@[to_additive (attr := simps)
  "The first isomorphism theorem for `AddMonoid`s in the case of a homomorphism
  with right inverse."]
def quotientKerEquivOfRightInverse (f : M →* P) (g : P → M) (hf : Function.RightInverse g f) :
    (ker f).Quotient ≃* P 
Arguments: {M : Type u_1} {P : Type u_3} [MulOneClass M] [MulOneClass P] (f : M →* P) (g : P → M) (hf : Function.RightInverse g ⇑f)
Goal: ∀ (a : P), (Con.quotientKerEquivOfRightInverse f g hf).symm a = (Con.toQuotient ∘ g) a
-- AddCon.quotientKerEquivOfRightInverse_apply
@[to_additive (attr := simps)
  "The first isomorphism theorem for `AddMonoid`s in the case of a homomorphism
  with right inverse."]
def quotientKerEquivOfRightInverse (f : M →* P) (g : P → M) (hf : Function.RightInverse g f) :
    (ker f).Quotient ≃* P 
Arguments: {M : Type u_1} {P : Type u_3} [AddZeroClass M] [AddZeroClass P] (f : M →+ P) (g : P → M) (hf : Function.RightInverse g ⇑f) (a : (AddCon.ker f).Quotient)
Goal: (AddCon.quotientKerEquivOfRightInverse f g hf) a = (AddCon.kerLift f) a
-- AddCon.nsmul
@[to_additive "Additive congruence relations preserve natural scaling."]
protected theorem pow {M : Type*} [Monoid M] (c : Con M) :
    ∀ (n : ℕ) {w x}, c w x → c (w ^ n) (x ^ n)
  
Arguments: {M : Type u_4} [AddMonoid M] (c : AddCon M) (n : ℕ) {w x : M}
Goal: c w x → c (n • w) (n • x)
-- Con.pow
@[to_additive "Additive congruence relations preserve natural scaling."]
protected theorem pow {M : Type*} [Monoid M] (c : Con M) :
    ∀ (n : ℕ) {w x}, c w x → c (w ^ n) (x ^ n)
  
Arguments: {M : Type u_4} [Monoid M] (c : Con M) (n : ℕ) {w x : M}
Goal: c w x → c (w ^ n) (x ^ n)
-- AddCon.vadd
@[to_additive]
theorem smul {α M : Type*} [MulOneClass M] [SMul α M] [IsScalarTower α M M] (c : Con M) (a : α)
    {w x : M} (h : c w x) : c (a • w) (a • x) 
Arguments: {α : Type u_4} {M : Type u_5} [AddZeroClass M] [VAdd α M] [VAddAssocClass α M M] (c : AddCon M) (a : α) {w x : M} (h : c w x)
Goal: c (a +ᵥ w) (a +ᵥ x)
-- Con.smul
@[to_additive]
theorem smul {α M : Type*} [MulOneClass M] [SMul α M] [IsScalarTower α M M] (c : Con M) (a : α)
    {w x : M} (h : c w x) : c (a • w) (a • x) 
Arguments: {α : Type u_4} {M : Type u_5} [MulOneClass M] [SMul α M] [IsScalarTower α M M] (c : Con M) (a : α) {w x : M} (h : c w x)
Goal: c (a • w) (a • x)