ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- AddSubmonoid.mrange_inr
@[to_additive]
theorem mrange_inr : mrange (inr M N) = prod ⊥ ⊤ 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N]
Goal: AddMonoidHom.mrange (AddMonoidHom.inr M N) = ⊥.prod ⊤
-- Submonoid.mrange_inl'
@[to_additive]
theorem mrange_inl' : mrange (inl M N) = comap (snd M N) ⊥ 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N]
Goal: MonoidHom.mrange (MonoidHom.inl M N) = Submonoid.comap (MonoidHom.snd M N) ⊥
-- AddSubmonoid.mrange_inl'
@[to_additive]
theorem mrange_inl' : mrange (inl M N) = comap (snd M N) ⊥ 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N]
Goal: AddMonoidHom.mrange (AddMonoidHom.inl M N) = AddSubmonoid.comap (AddMonoidHom.snd M N) ⊥
-- Submonoid.mrange_inr'
@[to_additive]
theorem mrange_inr' : mrange (inr M N) = comap (fst M N) ⊥ 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N]
Goal: MonoidHom.mrange (MonoidHom.inr M N) = Submonoid.comap (MonoidHom.fst M N) ⊥
-- AddSubmonoid.mrange_inr'
@[to_additive]
theorem mrange_inr' : mrange (inr M N) = comap (fst M N) ⊥ 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N]
Goal: AddMonoidHom.mrange (AddMonoidHom.inr M N) = AddSubmonoid.comap (AddMonoidHom.fst M N) ⊥
-- AddSubmonoid.mrange_fst
@[to_additive (attr := simp)]
theorem mrange_fst : mrange (fst M N) = ⊤ 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N]
Goal: AddMonoidHom.mrange (AddMonoidHom.fst M N) = ⊤
-- Submonoid.mrange_fst
@[to_additive (attr := simp)]
theorem mrange_fst : mrange (fst M N) = ⊤ 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N]
Goal: MonoidHom.mrange (MonoidHom.fst M N) = ⊤
-- Submonoid.mrange_snd
@[to_additive (attr := simp)]
theorem mrange_snd : mrange (snd M N) = ⊤ 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N]
Goal: MonoidHom.mrange (MonoidHom.snd M N) = ⊤
-- AddSubmonoid.mrange_snd
@[to_additive (attr := simp)]
theorem mrange_snd : mrange (snd M N) = ⊤ 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N]
Goal: AddMonoidHom.mrange (AddMonoidHom.snd M N) = ⊤
-- AddSubmonoid.prod_eq_bot_iff
@[to_additive prod_eq_bot_iff]
theorem prod_eq_bot_iff {s : Submonoid M} {t : Submonoid N} : s.prod t = ⊥ ↔ s = ⊥ ∧ t = ⊥ 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {s : AddSubmonoid M} {t : AddSubmonoid N}
Goal: s.prod t = ⊥ ↔ s = ⊥ ∧ t = ⊥
-- Submonoid.prod_eq_bot_iff
@[to_additive prod_eq_bot_iff]
theorem prod_eq_bot_iff {s : Submonoid M} {t : Submonoid N} : s.prod t = ⊥ ↔ s = ⊥ ∧ t = ⊥ 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {s : Submonoid M} {t : Submonoid N}
Goal: s.prod t = ⊥ ↔ s = ⊥ ∧ t = ⊥
-- Submonoid.prod_eq_top_iff
@[to_additive prod_eq_top_iff]
theorem prod_eq_top_iff {s : Submonoid M} {t : Submonoid N} : s.prod t = ⊤ ↔ s = ⊤ ∧ t = ⊤ 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {s : Submonoid M} {t : Submonoid N}
Goal: s.prod t = ⊤ ↔ s = ⊤ ∧ t = ⊤
-- AddSubmonoid.prod_eq_top_iff
@[to_additive prod_eq_top_iff]
theorem prod_eq_top_iff {s : Submonoid M} {t : Submonoid N} : s.prod t = ⊤ ↔ s = ⊤ ∧ t = ⊤ 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {s : AddSubmonoid M} {t : AddSubmonoid N}
Goal: s.prod t = ⊤ ↔ s = ⊤ ∧ t = ⊤
-- AddSubmonoid.mrange_inl_sup_mrange_inr
@[to_additive (attr := simp)]
theorem mrange_inl_sup_mrange_inr : mrange (inl M N) ⊔ mrange (inr M N) = ⊤ 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N]
Goal: AddMonoidHom.mrange (AddMonoidHom.inl M N) ⊔ AddMonoidHom.mrange (AddMonoidHom.inr M N) = ⊤
-- Submonoid.mrange_inl_sup_mrange_inr
@[to_additive (attr := simp)]
theorem mrange_inl_sup_mrange_inr : mrange (inl M N) ⊔ mrange (inr M N) = ⊤ 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N]
Goal: MonoidHom.mrange (MonoidHom.inl M N) ⊔ MonoidHom.mrange (MonoidHom.inr M N) = ⊤
-- Submonoid.range_subtype
@[to_additive (attr := simp)]
theorem range_subtype (s : Submonoid M) : mrange s.subtype = s 
Arguments: {M : Type u_1} [MulOneClass M] (s : Submonoid M)
Goal: MonoidHom.mrange s.subtype = s
-- AddSubmonoid.range_subtype
@[to_additive (attr := simp)]
theorem range_subtype (s : Submonoid M) : mrange s.subtype = s 
Arguments: {M : Type u_1} [AddZeroClass M] (s : AddSubmonoid M)
Goal: AddMonoidHom.mrange s.subtype = s
-- Submonoid.eq_top_iff'
@[to_additive]
theorem eq_top_iff' : S = ⊤ ↔ ∀ x : M, x ∈ S 
Arguments: {M : Type u_1} [MulOneClass M] (S : Submonoid M)
Goal: S = ⊤ ↔ ∀ (x : M), x ∈ S
-- AddSubmonoid.eq_top_iff'
@[to_additive]
theorem eq_top_iff' : S = ⊤ ↔ ∀ x : M, x ∈ S 
Arguments: {M : Type u_1} [AddZeroClass M] (S : AddSubmonoid M)
Goal: S = ⊤ ↔ ∀ (x : M), x ∈ S
-- Submonoid.eq_bot_iff_forall
@[to_additive]
theorem eq_bot_iff_forall : S = ⊥ ↔ ∀ x ∈ S, x = (1 : M) 
Arguments: {M : Type u_1} [MulOneClass M] (S : Submonoid M)
Goal: S = ⊥ ↔ ∀ x ∈ S, x = 1
-- AddSubmonoid.eq_bot_iff_forall
@[to_additive]
theorem eq_bot_iff_forall : S = ⊥ ↔ ∀ x ∈ S, x = (1 : M) 
Arguments: {M : Type u_1} [AddZeroClass M] (S : AddSubmonoid M)
Goal: S = ⊥ ↔ ∀ x ∈ S, x = 0
-- Submonoid.eq_bot_of_subsingleton
@[to_additive]
theorem eq_bot_of_subsingleton [Subsingleton S] : S = ⊥ 
Arguments: {M : Type u_1} [MulOneClass M] (S : Submonoid M) [Subsingleton ↥S]
Goal: S = ⊥
-- AddSubmonoid.eq_bot_of_subsingleton
@[to_additive]
theorem eq_bot_of_subsingleton [Subsingleton S] : S = ⊥ 
Arguments: {M : Type u_1} [AddZeroClass M] (S : AddSubmonoid M) [Subsingleton ↥S]
Goal: S = ⊥
-- Submonoid.nontrivial_iff_exists_ne_one
@[to_additive]
theorem nontrivial_iff_exists_ne_one (S : Submonoid M) : Nontrivial S ↔ ∃ x ∈ S, x ≠ (1 : M) 
Arguments: {M : Type u_1} [MulOneClass M] (S : Submonoid M)
Goal: Nontrivial ↥S ↔ ∃ x ∈ S, x ≠ 1
-- AddSubmonoid.nontrivial_iff_exists_ne_zero
@[to_additive]
theorem nontrivial_iff_exists_ne_one (S : Submonoid M) : Nontrivial S ↔ ∃ x ∈ S, x ≠ (1 : M) 
Arguments: {M : Type u_1} [AddZeroClass M] (S : AddSubmonoid M)
Goal: Nontrivial ↥S ↔ ∃ x ∈ S, x ≠ 0
-- AddSubmonoid.bot_or_nontrivial
@[to_additive "An additive submonoid is either the trivial additive submonoid or nontrivial."]
theorem bot_or_nontrivial (S : Submonoid M) : S = ⊥ ∨ Nontrivial S 
Arguments: {M : Type u_1} [AddZeroClass M] (S : AddSubmonoid M)
Goal: S = ⊥ ∨ Nontrivial ↥S
-- Submonoid.bot_or_nontrivial
@[to_additive "An additive submonoid is either the trivial additive submonoid or nontrivial."]
theorem bot_or_nontrivial (S : Submonoid M) : S = ⊥ ∨ Nontrivial S 
Arguments: {M : Type u_1} [MulOneClass M] (S : Submonoid M)
Goal: S = ⊥ ∨ Nontrivial ↥S
-- Submonoid.bot_or_exists_ne_one
@[to_additive
      "An additive submonoid is either the trivial additive submonoid or contains a nonzero
      element."]
theorem bot_or_exists_ne_one (S : Submonoid M) : S = ⊥ ∨ ∃ x ∈ S, x ≠ (1 : M) 
Arguments: {M : Type u_1} [MulOneClass M] (S : Submonoid M)
Goal: S = ⊥ ∨ ∃ x ∈ S, x ≠ 1
-- AddSubmonoid.bot_or_exists_ne_zero
@[to_additive
      "An additive submonoid is either the trivial additive submonoid or contains a nonzero
      element."]
theorem bot_or_exists_ne_one (S : Submonoid M) : S = ⊥ ∨ ∃ x ∈ S, x ≠ (1 : M) 
Arguments: {M : Type u_1} [AddZeroClass M] (S : AddSubmonoid M)
Goal: S = ⊥ ∨ ∃ x ∈ S, x ≠ 0
-- AddEquiv.ofLeftInverse'_symm_apply
@[to_additive (attr := simps (config := { simpRhs := true }))
      "An additive monoid homomorphism `f : M →+ N` with a left-inverse `g : N → M`
      defines an additive equivalence between `M` and `f.mrange`.
      This is a bidirectional version of `AddMonoidHom.mrange_restrict`. "]
def ofLeftInverse' (f : M →* N) {g : N → M} (h : Function.LeftInverse g f) :
    M ≃* MonoidHom.mrange f 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (f : M →+ N) {g : N → M} (h : Function.LeftInverse g ⇑f)
Goal: ∀ (a : ↥(AddMonoidHom.mrange f)), (AddEquiv.ofLeftInverse' f h).symm a = g ↑a
-- MulEquiv.ofLeftInverse'_symm_apply
@[to_additive (attr := simps (config := { simpRhs := true }))
      "An additive monoid homomorphism `f : M →+ N` with a left-inverse `g : N → M`
      defines an additive equivalence between `M` and `f.mrange`.
      This is a bidirectional version of `AddMonoidHom.mrange_restrict`. "]
def ofLeftInverse' (f : M →* N) {g : N → M} (h : Function.LeftInverse g f) :
    M ≃* MonoidHom.mrange f 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (f : M →* N) {g : N → M} (h : Function.LeftInverse g ⇑f)
Goal: ∀ (a : ↥(MonoidHom.mrange f)), (MulEquiv.ofLeftInverse' f h).symm a = g ↑a
-- AddEquiv.ofLeftInverse'_apply
@[to_additive (attr := simps (config := { simpRhs := true }))
      "An additive monoid homomorphism `f : M →+ N` with a left-inverse `g : N → M`
      defines an additive equivalence between `M` and `f.mrange`.
      This is a bidirectional version of `AddMonoidHom.mrange_restrict`. "]
def ofLeftInverse' (f : M →* N) {g : N → M} (h : Function.LeftInverse g f) :
    M ≃* MonoidHom.mrange f 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (f : M →+ N) {g : N → M} (h : Function.LeftInverse g ⇑f) (a : M)
Goal: (AddEquiv.ofLeftInverse' f h) a = f.mrangeRestrict a
-- MulEquiv.ofLeftInverse'_apply
@[to_additive (attr := simps (config := { simpRhs := true }))
      "An additive monoid homomorphism `f : M →+ N` with a left-inverse `g : N → M`
      defines an additive equivalence between `M` and `f.mrange`.
      This is a bidirectional version of `AddMonoidHom.mrange_restrict`. "]
def ofLeftInverse' (f : M →* N) {g : N → M} (h : Function.LeftInverse g f) :
    M ≃* MonoidHom.mrange f 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (f : M →* N) {g : N → M} (h : Function.LeftInverse g ⇑f) (a : M)
Goal: (MulEquiv.ofLeftInverse' f h) a = f.mrangeRestrict a
-- MulEquiv.coe_submonoidMap_apply
@[to_additive (attr := simp)]
theorem coe_submonoidMap_apply (e : M ≃* N) (S : Submonoid M) (g : S) :
    ((submonoidMap e S g : S.map (e : M →* N)) : N) = e g 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (e : M ≃* N) (S : Submonoid M) (g : ↥S)
Goal: ↑((e.submonoidMap S) g) = e ↑g
-- AddEquiv.coe_addSubmonoidMap_apply
@[to_additive (attr := simp)]
theorem coe_submonoidMap_apply (e : M ≃* N) (S : Submonoid M) (g : S) :
    ((submonoidMap e S g : S.map (e : M →* N)) : N) = e g 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (e : M ≃+ N) (S : AddSubmonoid M) (g : ↥S)
Goal: ↑((e.addSubmonoidMap S) g) = e ↑g
-- AddEquiv.add_submonoid_map_symm_apply
@[to_additive (attr := simp) AddEquiv.add_submonoid_map_symm_apply]
theorem submonoidMap_symm_apply (e : M ≃* N) (S : Submonoid M) (g : S.map (e : M →* N)) :
    (e.submonoidMap S).symm g = ⟨e.symm g, SetLike.mem_coe.1 <| Set.mem_image_equiv.1 g.2⟩ 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (e : M ≃+ N) (S : AddSubmonoid M) (g : ↥(AddSubmonoid.map (↑e) S))
Goal: (e.addSubmonoidMap S).symm g = ⟨e.symm ↑g, ⋯⟩
-- MulEquiv.submonoidMap_symm_apply
@[to_additive (attr := simp) AddEquiv.add_submonoid_map_symm_apply]
theorem submonoidMap_symm_apply (e : M ≃* N) (S : Submonoid M) (g : S.map (e : M →* N)) :
    (e.submonoidMap S).symm g = ⟨e.symm g, SetLike.mem_coe.1 <| Set.mem_image_equiv.1 g.2⟩ 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (e : M ≃* N) (S : Submonoid M) (g : ↥(Submonoid.map (↑e) S))
Goal: (e.submonoidMap S).symm g = ⟨e.symm ↑g, ⋯⟩
-- AddSubmonoid.equivMapOfInjective_coe_addEquiv
@[to_additive (attr := simp)]
theorem Submonoid.equivMapOfInjective_coe_mulEquiv (e : M ≃* N) :
    S.equivMapOfInjective (e : M →* N) (EquivLike.injective e) = e.submonoidMap S 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] (S : AddSubmonoid M) (e : M ≃+ N)
Goal: S.equivMapOfInjective ↑e ⋯ = e.addSubmonoidMap S
-- Submonoid.equivMapOfInjective_coe_mulEquiv
@[to_additive (attr := simp)]
theorem Submonoid.equivMapOfInjective_coe_mulEquiv (e : M ≃* N) :
    S.equivMapOfInjective (e : M →* N) (EquivLike.injective e) = e.submonoidMap S 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] (S : Submonoid M) (e : M ≃* N)
Goal: S.equivMapOfInjective ↑e ⋯ = e.submonoidMap S
-- Submonoid.smul_def
@[to_additive] lemma smul_def (g : S) (a : α) : g • a = (g : M') • a 
Arguments: {M' : Type u_5} {α : Type u_6} [MulOneClass M'] [SMul M' α] {S : Submonoid M'} (g : ↥S) (a : α)
Goal: g • a = ↑g • a
-- AddSubmonoid.vadd_def
@[to_additive] lemma smul_def (g : S) (a : α) : g • a = (g : M') • a 
Arguments: {M' : Type u_5} {α : Type u_6} [AddZeroClass M'] [VAdd M' α] {S : AddSubmonoid M'} (g : ↥S) (a : α)
Goal: g +ᵥ a = ↑g +ᵥ a
-- AddSubmonoid.mk_vadd
@[to_additive (attr := simp)]
lemma mk_smul (g : M') (hg : g ∈ S) (a : α) : (⟨g, hg⟩ : S) • a = g • a 
Arguments: {M' : Type u_5} {α : Type u_6} [AddZeroClass M'] [VAdd M' α] {S : AddSubmonoid M'} (g : M') (hg : g ∈ S) (a : α)
Goal: ⟨g, hg⟩ +ᵥ a = g +ᵥ a
-- Submonoid.mk_smul
@[to_additive (attr := simp)]
lemma mk_smul (g : M') (hg : g ∈ S) (a : α) : (⟨g, hg⟩ : S) • a = g • a 
Arguments: {M' : Type u_5} {α : Type u_6} [MulOneClass M'] [SMul M' α] {S : Submonoid M'} (g : M') (hg : g ∈ S) (a : α)
Goal: ⟨g, hg⟩ • a = g • a
-- Submonoid.val_unitsTypeEquivIsUnitSubmonoid_symm_apply
@[to_additive (attr := simps!) " The additive equivalence between the type of additive units of `M`
  and the additive submonoid whose elements are the additive units of `M`. "]
noncomputable def unitsTypeEquivIsUnitSubmonoid [Monoid M] : Mˣ ≃* IsUnit.submonoid M 
Arguments: {M : Type u_1} [Monoid M] (x : ↥(IsUnit.submonoid M))
Goal: ↑(Submonoid.unitsTypeEquivIsUnitSubmonoid.symm x) = ↑x
-- Submonoid.unitsTypeEquivIsUnitSubmonoid_apply_coe
@[to_additive (attr := simps!) " The additive equivalence between the type of additive units of `M`
  and the additive submonoid whose elements are the additive units of `M`. "]
noncomputable def unitsTypeEquivIsUnitSubmonoid [Monoid M] : Mˣ ≃* IsUnit.submonoid M 
Arguments: {M : Type u_1} [Monoid M] (x : Mˣ)
Goal: ↑(Submonoid.unitsTypeEquivIsUnitSubmonoid x) = ↑x
-- AddSubmonoid.addUnitsTypeEquivIsAddUnitAddSubmonoid_apply_coe
@[to_additive (attr := simps!) " The additive equivalence between the type of additive units of `M`
  and the additive submonoid whose elements are the additive units of `M`. "]
noncomputable def unitsTypeEquivIsUnitSubmonoid [Monoid M] : Mˣ ≃* IsUnit.submonoid M 
Arguments: {M : Type u_1} [AddMonoid M] (x : AddUnits M)
Goal: ↑(AddSubmonoid.addUnitsTypeEquivIsAddUnitAddSubmonoid x) = ↑x
-- AddSubmonoid.val_addUnitsTypeEquivIsAddUnitAddSubmonoid_symm_apply
@[to_additive (attr := simps!) " The additive equivalence between the type of additive units of `M`
  and the additive submonoid whose elements are the additive units of `M`. "]
noncomputable def unitsTypeEquivIsUnitSubmonoid [Monoid M] : Mˣ ≃* IsUnit.submonoid M 
Arguments: {M : Type u_1} [AddMonoid M] (x : ↥(IsAddUnit.addSubmonoid M))
Goal: ↑(AddSubmonoid.addUnitsTypeEquivIsAddUnitAddSubmonoid.symm x) = ↑x
-- Submonoid.val_inv_unitsTypeEquivIsUnitSubmonoid_symm_apply
@[to_additive (attr := simps!) " The additive equivalence between the type of additive units of `M`
  and the additive submonoid whose elements are the additive units of `M`. "]
noncomputable def unitsTypeEquivIsUnitSubmonoid [Monoid M] : Mˣ ≃* IsUnit.submonoid M 
Arguments: {M : Type u_1} [Monoid M] (x : ↥(IsUnit.submonoid M))
Goal: ↑(Submonoid.unitsTypeEquivIsUnitSubmonoid.symm x)⁻¹ = ↑(Classical.choose ⋯)⁻¹
-- AddSubmonoid.val_neg_addUnitsTypeEquivIsAddUnitAddSubmonoid_symm_apply
@[to_additive (attr := simps!) " The additive equivalence between the type of additive units of `M`
  and the additive submonoid whose elements are the additive units of `M`. "]
noncomputable def unitsTypeEquivIsUnitSubmonoid [Monoid M] : Mˣ ≃* IsUnit.submonoid M 
Arguments: {M : Type u_1} [AddMonoid M] (x : ↥(IsAddUnit.addSubmonoid M))
Goal: ↑(-AddSubmonoid.addUnitsTypeEquivIsAddUnitAddSubmonoid.symm x) = ↑(-Classical.choose ⋯)
-- Nat.addSubmonoid_closure_one
@[simp] lemma addSubmonoid_closure_one : closure ({1} : Set ℕ) = ⊤ 
Goal: AddSubmonoid.closure {1} = ⊤
-- Submonoid.map_comap_eq
@[to_additive]
theorem map_comap_eq (f : F) (S : Submonoid N) : (S.comap f).map f = S ⊓ MonoidHom.mrange f 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_5} [FunLike F M N] [mc : MonoidHomClass F M N] (f : F) (S : Submonoid N)
Goal: Submonoid.map f (Submonoid.comap f S) = S ⊓ MonoidHom.mrange f
-- AddSubmonoid.map_comap_eq
@[to_additive]
theorem map_comap_eq (f : F) (S : Submonoid N) : (S.comap f).map f = S ⊓ MonoidHom.mrange f 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_5} [FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F) (S : AddSubmonoid N)
Goal: AddSubmonoid.map f (AddSubmonoid.comap f S) = S ⊓ AddMonoidHom.mrange f
-- Submonoid.map_comap_eq_self
@[to_additive]
theorem map_comap_eq_self {f : F} {S : Submonoid N} (h : S ≤ MonoidHom.mrange f) :
    (S.comap f).map f = S 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_5} [FunLike F M N] [mc : MonoidHomClass F M N] {f : F} {S : Submonoid N} (h : S ≤ MonoidHom.mrange f)
Goal: Submonoid.map f (Submonoid.comap f S) = S
-- AddSubmonoid.map_comap_eq_self
@[to_additive]
theorem map_comap_eq_self {f : F} {S : Submonoid N} (h : S ≤ MonoidHom.mrange f) :
    (S.comap f).map f = S 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_5} [FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F} {S : AddSubmonoid N} (h : S ≤ AddMonoidHom.mrange f)
Goal: AddSubmonoid.map f (AddSubmonoid.comap f S) = S
-- ULift.zero_down
@[to_additive (attr := simp)]
theorem one_down [One α] : (1 : ULift α).down = 1 
Arguments: {α : Type u} [Zero α]
Goal: ULift.down 0 = 0
-- ULift.one_down
@[to_additive (attr := simp)]
theorem one_down [One α] : (1 : ULift α).down = 1 
Arguments: {α : Type u} [One α]
Goal: ULift.down 1 = 1
-- ULift.add_down
@[to_additive (attr := simp)]
theorem mul_down [Mul α] : (x * y).down = x.down * y.down 
Arguments: {α : Type u} {x y : ULift.{v, u} α} [Add α]
Goal: (x + y).down = x.down + y.down
-- ULift.mul_down
@[to_additive (attr := simp)]
theorem mul_down [Mul α] : (x * y).down = x.down * y.down 
Arguments: {α : Type u} {x y : ULift.{v, u} α} [Mul α]
Goal: (x * y).down = x.down * y.down
-- ULift.sub_down
@[to_additive (attr := simp)]
theorem div_down [Div α] : (x / y).down = x.down / y.down 
Arguments: {α : Type u} {x y : ULift.{v, u} α} [Sub α]
Goal: (x - y).down = x.down - y.down
-- ULift.div_down
@[to_additive (attr := simp)]
theorem div_down [Div α] : (x / y).down = x.down / y.down 
Arguments: {α : Type u} {x y : ULift.{v, u} α} [Div α]
Goal: (x / y).down = x.down / y.down
-- ULift.neg_down
@[to_additive (attr := simp)]
theorem inv_down [Inv α] : x⁻¹.down = x.down⁻¹ 
Arguments: {α : Type u} {x : ULift.{v, u} α} [Neg α]
Goal: (-x).down = -x.down
-- ULift.inv_down
@[to_additive (attr := simp)]
theorem inv_down [Inv α] : x⁻¹.down = x.down⁻¹ 
Arguments: {α : Type u} {x : ULift.{v, u} α} [Inv α]
Goal: x⁻¹.down = x.down⁻¹
-- ULift.vadd_down
@[to_additive (attr := simp)]
theorem smul_down [SMul α β] (a : α) (b : ULift.{v} β) : (a • b).down = a • b.down 
Arguments: {α : Type u} {β : Type u_1} [VAdd α β] (a : α) (b : ULift.{v, u_1} β)
Goal: (a +ᵥ b).down = a +ᵥ b.down
-- ULift.smul_down
@[to_additive (attr := simp)]
theorem smul_down [SMul α β] (a : α) (b : ULift.{v} β) : (a • b).down = a • b.down 
Arguments: {α : Type u} {β : Type u_1} [SMul α β] (a : α) (b : ULift.{v, u_1} β)
Goal: (a • b).down = a • b.down
-- ULift.pow_down
@[to_additive existing (attr := simp) (reorder := 1 2) smul_down]
theorem pow_down [Pow α β] (a : ULift.{v} α) (b : β) : (a ^ b).down = a.down ^ b 
Arguments: {α : Type u} {β : Type u_1} [Pow α β] (a : ULift.{v, u} α) (b : β)
Goal: (a ^ b).down = a.down ^ b
-- ULift.up_natCast
@[simp, norm_cast]
theorem up_natCast [NatCast α] (n : ℕ) : up (n : α) = n 
Arguments: {α : Type u} [NatCast α] (n : ℕ)
Goal: { down := ↑n } = ↑n
-- ULift.up_ofNat
@[simp]
theorem up_ofNat [NatCast α] (n : ℕ) [n.AtLeastTwo] :
    up (no_index (OfNat.ofNat n : α)) = OfNat.ofNat n 
Arguments: {α : Type u} [NatCast α] (n : ℕ) [n.AtLeastTwo]
Goal: { down := OfNat.ofNat n } = OfNat.ofNat n
-- ULift.up_intCast
@[simp, norm_cast]
theorem up_intCast [IntCast α] (n : ℤ) : up (n : α) = n 
Arguments: {α : Type u} [IntCast α] (n : ℤ)
Goal: { down := ↑n } = ↑n
-- ULift.down_natCast
@[simp, norm_cast]
theorem down_natCast [NatCast α] (n : ℕ) : down (n : ULift α) = n 
Arguments: {α : Type u} [NatCast α] (n : ℕ)
Goal: (↑n).down = ↑n
-- ULift.down_ofNat
@[simp]
theorem down_ofNat [NatCast α] (n : ℕ) [n.AtLeastTwo] :
    down (no_index (OfNat.ofNat n : ULift α)) = OfNat.ofNat n 
Arguments: {α : Type u} [NatCast α] (n : ℕ) [n.AtLeastTwo]
Goal: (OfNat.ofNat n).down = OfNat.ofNat n
-- ULift.down_intCast
@[simp, norm_cast]
theorem down_intCast [IntCast α] (n : ℤ) : down (n : ULift α) = n 
Arguments: {α : Type u} [IntCast α] (n : ℤ)
Goal: (↑n).down = ↑n
-- Fin.coe_sub_one
lemma coe_sub_one (a : Fin (n + 1)) : ↑(a - 1) = if a = 0 then n else a - 1 
Arguments: {n : ℕ} (a : Fin (n + 1))
Goal: ↑(a - 1) = if a = 0 then n else ↑a - 1
-- Fin.lt_sub_one_iff
@[simp]
lemma lt_sub_one_iff {k : Fin (n + 2)} : k < k - 1 ↔ k = 0 
Arguments: {n : ℕ} {k : Fin (n + 2)}
Goal: k < k - 1 ↔ k = 0
-- Fin.le_sub_one_iff
@[simp] lemma le_sub_one_iff {k : Fin (n + 1)} : k ≤ k - 1 ↔ k = 0 
Arguments: {n : ℕ} {k : Fin (n + 1)}
Goal: k ≤ k - 1 ↔ k = 0
-- Fin.sub_one_lt_iff
lemma sub_one_lt_iff {k : Fin (n + 1)} : k - 1 < k ↔ 0 < k 
Arguments: {n : ℕ} {k : Fin (n + 1)}
Goal: k - 1 < k ↔ 0 < k
-- Fin.neg_last
@[simp] lemma neg_last (n : ℕ) : -Fin.last n = 1 
Arguments: (n : ℕ)
Goal: -Fin.last n = 1
-- Fin.neg_natCast_eq_one
lemma neg_natCast_eq_one (n : ℕ) : -(n : Fin (n + 1)) = 1 
Arguments: (n : ℕ)
Goal: -↑n = 1
-- Nat.nsmul_eq_mul
@[simp, nolint simpNF] protected lemma nsmul_eq_mul (m n : ℕ) : m • n = m * n 
Arguments: (m n : ℕ)
Goal: m • n = m * n
-- Nat.toAdd_pow
lemma toAdd_pow (a : Multiplicative ℕ) (b : ℕ) : toAdd (a ^ b) = toAdd a * b 
Arguments: (a : Multiplicative ℕ) (b : ℕ)
Goal: Multiplicative.toAdd (a ^ b) = Multiplicative.toAdd a * b
-- Nat.ofAdd_mul
@[simp] lemma ofAdd_mul (a b : ℕ) : ofAdd (a * b) = ofAdd a ^ b 
Arguments: (a b : ℕ)
Goal: Multiplicative.ofAdd (a * b) = Multiplicative.ofAdd a ^ b
-- Nat.even_iff
lemma even_iff : Even n ↔ n % 2 = 0 
Arguments: {n : ℕ}
Goal: Even n ↔ n % 2 = 0
-- Nat.not_even_iff
lemma not_even_iff : ¬ Even n ↔ n % 2 = 1 
Arguments: {n : ℕ}
Goal: ¬Even n ↔ n % 2 = 1
-- Nat.two_dvd_ne_zero
@[simp] lemma two_dvd_ne_zero : ¬2 ∣ n ↔ n % 2 = 1 
Arguments: {n : ℕ}
Goal: ¬2 ∣ n ↔ n % 2 = 1
-- Nat.not_even_one
@[simp] lemma not_even_one : ¬Even 1 
Goal: ¬Even 1
-- Nat.even_add
@[parity_simps] lemma even_add : Even (m + n) ↔ (Even m ↔ Even n) 
Arguments: {m n : ℕ}
Goal: Even (m + n) ↔ (Even m ↔ Even n)
-- Nat.even_add_one
@[parity_simps] lemma even_add_one : Even (n + 1) ↔ ¬Even n 
Arguments: {n : ℕ}
Goal: Even (n + 1) ↔ ¬Even n
-- Nat.succ_mod_two_eq_zero_iff
lemma succ_mod_two_eq_zero_iff {m : ℕ} : (m + 1) % 2 = 0 ↔ m % 2 = 1 
Arguments: {m : ℕ}
Goal: (m + 1) % 2 = 0 ↔ m % 2 = 1
-- Nat.succ_mod_two_eq_one_iff
lemma succ_mod_two_eq_one_iff {m : ℕ} : (m + 1) % 2 = 1 ↔ m % 2 = 0 
Arguments: {m : ℕ}
Goal: (m + 1) % 2 = 1 ↔ m % 2 = 0
-- Nat.two_not_dvd_two_mul_add_one
lemma two_not_dvd_two_mul_add_one (n : ℕ) : ¬2 ∣ 2 * n + 1 
Arguments: (n : ℕ)
Goal: ¬2 ∣ 2 * n + 1
-- Nat.two_not_dvd_two_mul_sub_one
lemma two_not_dvd_two_mul_sub_one : ∀ {n}, 0 < n → ¬2 ∣ 2 * n - 1
  
Arguments: {n : ℕ}
Goal: 0 < n → ¬2 ∣ 2 * n - 1
-- Nat.even_sub
@[parity_simps] lemma even_sub (h : n ≤ m) : Even (m - n) ↔ (Even m ↔ Even n) 
Arguments: {m n : ℕ} (h : n ≤ m)
Goal: Even (m - n) ↔ (Even m ↔ Even n)
-- Nat.even_mul
@[parity_simps] lemma even_mul : Even (m * n) ↔ Even m ∨ Even n 
Arguments: {m n : ℕ}
Goal: Even (m * n) ↔ Even m ∨ Even n
-- Nat.even_pow
@[parity_simps] lemma even_pow : Even (m ^ n) ↔ Even m ∧ n ≠ 0 
Arguments: {m n : ℕ}
Goal: Even (m ^ n) ↔ Even m ∧ n ≠ 0
-- Nat.even_pow'
lemma even_pow' (h : n ≠ 0) : Even (m ^ n) ↔ Even m 
Arguments: {m n : ℕ} (h : n ≠ 0)
Goal: Even (m ^ n) ↔ Even m