ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- AddSubmonoid.zero_mem'
structure AddSubmonoid (M : Type*) [AddZeroClass M] extends AddSubsemigroup M where
    zero_mem' : (0 : M) ∈ carrier
Arguments: {M : Type u_4} [AddZeroClass M] (self : AddSubmonoid M)
Goal: 0 ∈ self.carrier
-- nsmul_mem
@[to_additive (attr := aesop safe apply (rule_sets := [SetLike]))]
theorem pow_mem {M A} [Monoid M] [SetLike A M] [SubmonoidClass A M] {S : A} {x : M}
    (hx : x ∈ S) : ∀ n : ℕ, x ^ n ∈ S
  
Arguments: {M : Type u_4} {A : Type u_5} [AddMonoid M] [SetLike A M] [AddSubmonoidClass A M] {S : A} {x : M} (hx : x ∈ S) (n : ℕ)
Goal: n • x ∈ S
-- pow_mem
@[to_additive (attr := aesop safe apply (rule_sets := [SetLike]))]
theorem pow_mem {M A} [Monoid M] [SetLike A M] [SubmonoidClass A M] {S : A} {x : M}
    (hx : x ∈ S) : ∀ n : ℕ, x ^ n ∈ S
  
Arguments: {M : Type u_4} {A : Type u_5} [Monoid M] [SetLike A M] [SubmonoidClass A M] {S : A} {x : M} (hx : x ∈ S) (n : ℕ)
Goal: x ^ n ∈ S
-- Submonoid.mem_toSubsemigroup
@[to_additive (attr := simp)]
theorem mem_toSubsemigroup {s : Submonoid M} {x : M} : x ∈ s.toSubsemigroup ↔ x ∈ s 
Arguments: {M : Type u_1} [MulOneClass M] {s : Submonoid M} {x : M}
Goal: x ∈ s.toSubsemigroup ↔ x ∈ s
-- AddSubmonoid.mem_toSubsemigroup
@[to_additive (attr := simp)]
theorem mem_toSubsemigroup {s : Submonoid M} {x : M} : x ∈ s.toSubsemigroup ↔ x ∈ s 
Arguments: {M : Type u_1} [AddZeroClass M] {s : AddSubmonoid M} {x : M}
Goal: x ∈ s.toAddSubsemigroup ↔ x ∈ s
-- Submonoid.mem_carrier
@[to_additive]
theorem mem_carrier {s : Submonoid M} {x : M} : x ∈ s.carrier ↔ x ∈ s 
Arguments: {M : Type u_1} [MulOneClass M] {s : Submonoid M} {x : M}
Goal: x ∈ s.carrier ↔ x ∈ s
-- AddSubmonoid.mem_carrier
@[to_additive]
theorem mem_carrier {s : Submonoid M} {x : M} : x ∈ s.carrier ↔ x ∈ s 
Arguments: {M : Type u_1} [AddZeroClass M] {s : AddSubmonoid M} {x : M}
Goal: x ∈ s.carrier ↔ x ∈ s
-- AddSubmonoid.mem_mk
@[to_additive (attr := simp)]
theorem mem_mk {s : Subsemigroup M} {x : M} (h_one) : x ∈ mk s h_one ↔ x ∈ s 
Arguments: {M : Type u_1} [AddZeroClass M] {s : AddSubsemigroup M} {x : M} (h_one : 0 ∈ s.carrier)
Goal: x ∈ { toAddSubsemigroup := s, zero_mem' := h_one } ↔ x ∈ s
-- Submonoid.mem_mk
@[to_additive (attr := simp)]
theorem mem_mk {s : Subsemigroup M} {x : M} (h_one) : x ∈ mk s h_one ↔ x ∈ s 
Arguments: {M : Type u_1} [MulOneClass M] {s : Subsemigroup M} {x : M} (h_one : 1 ∈ s.carrier)
Goal: x ∈ { toSubsemigroup := s, one_mem' := h_one } ↔ x ∈ s
-- Submonoid.coe_set_mk
@[to_additive (attr := simp)]
theorem coe_set_mk {s : Subsemigroup M} (h_one) : (mk s h_one : Set M) = s 
Arguments: {M : Type u_1} [MulOneClass M] {s : Subsemigroup M} (h_one : 1 ∈ s.carrier)
Goal: ↑{ toSubsemigroup := s, one_mem' := h_one } = ↑s
-- AddSubmonoid.coe_set_mk
@[to_additive (attr := simp)]
theorem coe_set_mk {s : Subsemigroup M} (h_one) : (mk s h_one : Set M) = s 
Arguments: {M : Type u_1} [AddZeroClass M] {s : AddSubsemigroup M} (h_one : 0 ∈ s.carrier)
Goal: ↑{ toAddSubsemigroup := s, zero_mem' := h_one } = ↑s
-- Submonoid.mk_le_mk
@[to_additive (attr := simp)]
theorem mk_le_mk {s t : Subsemigroup M} (h_one) (h_one') : mk s h_one ≤ mk t h_one' ↔ s ≤ t 
Arguments: {M : Type u_1} [MulOneClass M] {s t : Subsemigroup M} (h_one : 1 ∈ s.carrier) (h_one' : 1 ∈ t.carrier)
Goal: { toSubsemigroup := s, one_mem' := h_one } ≤ { toSubsemigroup := t, one_mem' := h_one' } ↔ s ≤ t
-- AddSubmonoid.mk_le_mk
@[to_additive (attr := simp)]
theorem mk_le_mk {s t : Subsemigroup M} (h_one) (h_one') : mk s h_one ≤ mk t h_one' ↔ s ≤ t 
Arguments: {M : Type u_1} [AddZeroClass M] {s t : AddSubsemigroup M} (h_one : 0 ∈ s.carrier) (h_one' : 0 ∈ t.carrier)
Goal: { toAddSubsemigroup := s, zero_mem' := h_one } ≤ { toAddSubsemigroup := t, zero_mem' := h_one' } ↔ s ≤ t
-- Submonoid.ext
@[to_additive (attr := ext) "Two `AddSubmonoid`s are equal if they have the same elements."]
theorem ext {S T : Submonoid M} (h : ∀ x, x ∈ S ↔ x ∈ T) : S = T 
Arguments: {M : Type u_1} [MulOneClass M] {S T : Submonoid M} (h : ∀ (x : M), x ∈ S ↔ x ∈ T)
Goal: S = T
-- AddSubmonoid.ext
@[to_additive (attr := ext) "Two `AddSubmonoid`s are equal if they have the same elements."]
theorem ext {S T : Submonoid M} (h : ∀ x, x ∈ S ↔ x ∈ T) : S = T 
Arguments: {M : Type u_1} [AddZeroClass M] {S T : AddSubmonoid M} (h : ∀ (x : M), x ∈ S ↔ x ∈ T)
Goal: S = T
-- AddSubmonoid.coe_copy
@[to_additive (attr := simp)]
theorem coe_copy {s : Set M} (hs : s = S) : (S.copy s hs : Set M) = s 
Arguments: {M : Type u_1} [AddZeroClass M] {S : AddSubmonoid M} {s : Set M} (hs : s = ↑S)
Goal: ↑(S.copy s hs) = s
-- Submonoid.coe_copy
@[to_additive (attr := simp)]
theorem coe_copy {s : Set M} (hs : s = S) : (S.copy s hs : Set M) = s 
Arguments: {M : Type u_1} [MulOneClass M] {S : Submonoid M} {s : Set M} (hs : s = ↑S)
Goal: ↑(S.copy s hs) = s
-- Submonoid.copy_eq
@[to_additive]
theorem copy_eq {s : Set M} (hs : s = S) : S.copy s hs = S 
Arguments: {M : Type u_1} [MulOneClass M] {S : Submonoid M} {s : Set M} (hs : s = ↑S)
Goal: S.copy s hs = S
-- AddSubmonoid.copy_eq
@[to_additive]
theorem copy_eq {s : Set M} (hs : s = S) : S.copy s hs = S 
Arguments: {M : Type u_1} [AddZeroClass M] {S : AddSubmonoid M} {s : Set M} (hs : s = ↑S)
Goal: S.copy s hs = S
-- AddSubmonoid.zero_mem
@[to_additive "An `AddSubmonoid` contains the monoid's 0."]
protected theorem one_mem : (1 : M) ∈ S 
Arguments: {M : Type u_1} [AddZeroClass M] (S : AddSubmonoid M)
Goal: 0 ∈ S
-- Submonoid.one_mem
@[to_additive "An `AddSubmonoid` contains the monoid's 0."]
protected theorem one_mem : (1 : M) ∈ S 
Arguments: {M : Type u_1} [MulOneClass M] (S : Submonoid M)
Goal: 1 ∈ S
-- AddSubmonoid.add_mem
@[to_additive "An `AddSubmonoid` is closed under addition."]
protected theorem mul_mem {x y : M} : x ∈ S → y ∈ S → x * y ∈ S 
Arguments: {M : Type u_1} [AddZeroClass M] (S : AddSubmonoid M) {x y : M}
Goal: x ∈ S → y ∈ S → x + y ∈ S
-- Submonoid.mul_mem
@[to_additive "An `AddSubmonoid` is closed under addition."]
protected theorem mul_mem {x y : M} : x ∈ S → y ∈ S → x * y ∈ S 
Arguments: {M : Type u_1} [MulOneClass M] (S : Submonoid M) {x y : M}
Goal: x ∈ S → y ∈ S → x * y ∈ S
-- Submonoid.mem_bot
@[to_additive (attr := simp)]
theorem mem_bot {x : M} : x ∈ (⊥ : Submonoid M) ↔ x = 1 
Arguments: {M : Type u_1} [MulOneClass M] {x : M}
Goal: x ∈ ⊥ ↔ x = 1
-- AddSubmonoid.mem_bot
@[to_additive (attr := simp)]
theorem mem_bot {x : M} : x ∈ (⊥ : Submonoid M) ↔ x = 1 
Arguments: {M : Type u_1} [AddZeroClass M] {x : M}
Goal: x ∈ ⊥ ↔ x = 0
-- Submonoid.mem_top
@[to_additive (attr := simp)]
theorem mem_top (x : M) : x ∈ (⊤ : Submonoid M) 
Arguments: {M : Type u_1} [MulOneClass M] (x : M)
Goal: x ∈ ⊤
-- AddSubmonoid.mem_top
@[to_additive (attr := simp)]
theorem mem_top (x : M) : x ∈ (⊤ : Submonoid M) 
Arguments: {M : Type u_1} [AddZeroClass M] (x : M)
Goal: x ∈ ⊤
-- AddSubmonoid.coe_top
@[to_additive (attr := simp)]
theorem coe_top : ((⊤ : Submonoid M) : Set M) = Set.univ 
Arguments: {M : Type u_1} [AddZeroClass M]
Goal: ↑⊤ = Set.univ
-- Submonoid.coe_top
@[to_additive (attr := simp)]
theorem coe_top : ((⊤ : Submonoid M) : Set M) = Set.univ 
Arguments: {M : Type u_1} [MulOneClass M]
Goal: ↑⊤ = Set.univ
-- Submonoid.coe_bot
@[to_additive (attr := simp)]
theorem coe_bot : ((⊥ : Submonoid M) : Set M) = {1} 
Arguments: {M : Type u_1} [MulOneClass M]
Goal: ↑⊥ = {1}
-- AddSubmonoid.coe_bot
@[to_additive (attr := simp)]
theorem coe_bot : ((⊥ : Submonoid M) : Set M) = {1} 
Arguments: {M : Type u_1} [AddZeroClass M]
Goal: ↑⊥ = {0}
-- Submonoid.coe_inf
@[to_additive (attr := simp)]
theorem coe_inf (p p' : Submonoid M) : ((p ⊓ p' : Submonoid M) : Set M) = (p : Set M) ∩ p' 
Arguments: {M : Type u_1} [MulOneClass M] (p p' : Submonoid M)
Goal: ↑(p ⊓ p') = ↑p ∩ ↑p'
-- AddSubmonoid.coe_inf
@[to_additive (attr := simp)]
theorem coe_inf (p p' : Submonoid M) : ((p ⊓ p' : Submonoid M) : Set M) = (p : Set M) ∩ p' 
Arguments: {M : Type u_1} [AddZeroClass M] (p p' : AddSubmonoid M)
Goal: ↑(p ⊓ p') = ↑p ∩ ↑p'
-- AddSubmonoid.mem_inf
@[to_additive (attr := simp)]
theorem mem_inf {p p' : Submonoid M} {x : M} : x ∈ p ⊓ p' ↔ x ∈ p ∧ x ∈ p' 
Arguments: {M : Type u_1} [AddZeroClass M] {p p' : AddSubmonoid M} {x : M}
Goal: x ∈ p ⊓ p' ↔ x ∈ p ∧ x ∈ p'
-- Submonoid.mem_inf
@[to_additive (attr := simp)]
theorem mem_inf {p p' : Submonoid M} {x : M} : x ∈ p ⊓ p' ↔ x ∈ p ∧ x ∈ p' 
Arguments: {M : Type u_1} [MulOneClass M] {p p' : Submonoid M} {x : M}
Goal: x ∈ p ⊓ p' ↔ x ∈ p ∧ x ∈ p'
-- Submonoid.coe_sInf
@[to_additive (attr := simp, norm_cast)]
theorem coe_sInf (S : Set (Submonoid M)) : ((sInf S : Submonoid M) : Set M) = ⋂ s ∈ S, ↑s 
Arguments: {M : Type u_1} [MulOneClass M] (S : Set (Submonoid M))
Goal: ↑(sInf S) = ⋂ s ∈ S, ↑s
-- AddSubmonoid.coe_sInf
@[to_additive (attr := simp, norm_cast)]
theorem coe_sInf (S : Set (Submonoid M)) : ((sInf S : Submonoid M) : Set M) = ⋂ s ∈ S, ↑s 
Arguments: {M : Type u_1} [AddZeroClass M] (S : Set (AddSubmonoid M))
Goal: ↑(sInf S) = ⋂ s ∈ S, ↑s
-- AddSubmonoid.mem_sInf
@[to_additive]
theorem mem_sInf {S : Set (Submonoid M)} {x : M} : x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p 
Arguments: {M : Type u_1} [AddZeroClass M] {S : Set (AddSubmonoid M)} {x : M}
Goal: x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p
-- Submonoid.mem_sInf
@[to_additive]
theorem mem_sInf {S : Set (Submonoid M)} {x : M} : x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p 
Arguments: {M : Type u_1} [MulOneClass M] {S : Set (Submonoid M)} {x : M}
Goal: x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p
-- AddSubmonoid.mem_iInf
@[to_additive]
theorem mem_iInf {ι : Sort*} {S : ι → Submonoid M} {x : M} : (x ∈ ⨅ i, S i) ↔ ∀ i, x ∈ S i 
Arguments: {M : Type u_1} [AddZeroClass M] {ι : Sort u_4} {S : ι → AddSubmonoid M} {x : M}
Goal: x ∈ ⨅ i, S i ↔ ∀ (i : ι), x ∈ S i
-- Submonoid.mem_iInf
@[to_additive]
theorem mem_iInf {ι : Sort*} {S : ι → Submonoid M} {x : M} : (x ∈ ⨅ i, S i) ↔ ∀ i, x ∈ S i 
Arguments: {M : Type u_1} [MulOneClass M] {ι : Sort u_4} {S : ι → Submonoid M} {x : M}
Goal: x ∈ ⨅ i, S i ↔ ∀ (i : ι), x ∈ S i
-- AddSubmonoid.coe_iInf
@[to_additive (attr := simp, norm_cast)]
theorem coe_iInf {ι : Sort*} {S : ι → Submonoid M} : (↑(⨅ i, S i) : Set M) = ⋂ i, S i 
Arguments: {M : Type u_1} [AddZeroClass M] {ι : Sort u_4} {S : ι → AddSubmonoid M}
Goal: ↑(⨅ i, S i) = ⋂ i, ↑(S i)
-- Submonoid.coe_iInf
@[to_additive (attr := simp, norm_cast)]
theorem coe_iInf {ι : Sort*} {S : ι → Submonoid M} : (↑(⨅ i, S i) : Set M) = ⋂ i, S i 
Arguments: {M : Type u_1} [MulOneClass M] {ι : Sort u_4} {S : ι → Submonoid M}
Goal: ↑(⨅ i, S i) = ⋂ i, ↑(S i)
-- Submonoid.subsingleton_iff
@[to_additive (attr := simp)]
theorem subsingleton_iff : Subsingleton (Submonoid M) ↔ Subsingleton M 
Arguments: {M : Type u_1} [MulOneClass M]
Goal: Subsingleton (Submonoid M) ↔ Subsingleton M
-- AddSubmonoid.subsingleton_iff
@[to_additive (attr := simp)]
theorem subsingleton_iff : Subsingleton (Submonoid M) ↔ Subsingleton M 
Arguments: {M : Type u_1} [AddZeroClass M]
Goal: Subsingleton (AddSubmonoid M) ↔ Subsingleton M
-- Submonoid.nontrivial_iff
@[to_additive (attr := simp)]
theorem nontrivial_iff : Nontrivial (Submonoid M) ↔ Nontrivial M 
Arguments: {M : Type u_1} [MulOneClass M]
Goal: Nontrivial (Submonoid M) ↔ Nontrivial M
-- AddSubmonoid.nontrivial_iff
@[to_additive (attr := simp)]
theorem nontrivial_iff : Nontrivial (Submonoid M) ↔ Nontrivial M 
Arguments: {M : Type u_1} [AddZeroClass M]
Goal: Nontrivial (AddSubmonoid M) ↔ Nontrivial M
-- AddSubmonoid.mem_closure
@[to_additive]
theorem mem_closure {x : M} : x ∈ closure s ↔ ∀ S : Submonoid M, s ⊆ S → x ∈ S 
Arguments: {M : Type u_1} [AddZeroClass M] {s : Set M} {x : M}
Goal: x ∈ AddSubmonoid.closure s ↔ ∀ (S : AddSubmonoid M), s ⊆ ↑S → x ∈ S
-- Submonoid.mem_closure
@[to_additive]
theorem mem_closure {x : M} : x ∈ closure s ↔ ∀ S : Submonoid M, s ⊆ S → x ∈ S 
Arguments: {M : Type u_1} [MulOneClass M] {s : Set M} {x : M}
Goal: x ∈ Submonoid.closure s ↔ ∀ (S : Submonoid M), s ⊆ ↑S → x ∈ S
-- Submonoid.subset_closure
@[to_additive (attr := simp, aesop safe 20 apply (rule_sets := [SetLike]))
  "The `AddSubmonoid` generated by a set includes the set."]
theorem subset_closure : s ⊆ closure s 
Arguments: {M : Type u_1} [MulOneClass M] {s : Set M}
Goal: s ⊆ ↑(Submonoid.closure s)
-- AddSubmonoid.subset_closure
@[to_additive (attr := simp, aesop safe 20 apply (rule_sets := [SetLike]))
  "The `AddSubmonoid` generated by a set includes the set."]
theorem subset_closure : s ⊆ closure s 
Arguments: {M : Type u_1} [AddZeroClass M] {s : Set M}
Goal: s ⊆ ↑(AddSubmonoid.closure s)
-- AddSubmonoid.not_mem_of_not_mem_closure
@[to_additive]
theorem not_mem_of_not_mem_closure {P : M} (hP : P ∉ closure s) : P ∉ s 
Arguments: {M : Type u_1} [AddZeroClass M] {s : Set M} {P : M} (hP : P ∉ AddSubmonoid.closure s)
Goal: P ∉ s
-- Submonoid.not_mem_of_not_mem_closure
@[to_additive]
theorem not_mem_of_not_mem_closure {P : M} (hP : P ∉ closure s) : P ∉ s 
Arguments: {M : Type u_1} [MulOneClass M] {s : Set M} {P : M} (hP : P ∉ Submonoid.closure s)
Goal: P ∉ s
-- Submonoid.closure_le
@[to_additive (attr := simp)
"An additive submonoid `S` includes `closure s` if and only if it includes `s`"]
theorem closure_le : closure s ≤ S ↔ s ⊆ S 
Arguments: {M : Type u_1} [MulOneClass M] {s : Set M} {S : Submonoid M}
Goal: Submonoid.closure s ≤ S ↔ s ⊆ ↑S
-- AddSubmonoid.closure_le
@[to_additive (attr := simp)
"An additive submonoid `S` includes `closure s` if and only if it includes `s`"]
theorem closure_le : closure s ≤ S ↔ s ⊆ S 
Arguments: {M : Type u_1} [AddZeroClass M] {s : Set M} {S : AddSubmonoid M}
Goal: AddSubmonoid.closure s ≤ S ↔ s ⊆ ↑S
-- AddSubmonoid.closure_mono
@[to_additive
      "Additive submonoid closure of a set is monotone in its argument: if `s ⊆ t`,
      then `closure s ≤ closure t`"]
theorem closure_mono ⦃s t : Set M⦄ (h : s ⊆ t) : closure s ≤ closure t 
Arguments: {M : Type u_1} [AddZeroClass M] ⦃s t : Set M⦄ (h : s ⊆ t)
Goal: AddSubmonoid.closure s ≤ AddSubmonoid.closure t
-- Submonoid.closure_mono
@[to_additive
      "Additive submonoid closure of a set is monotone in its argument: if `s ⊆ t`,
      then `closure s ≤ closure t`"]
theorem closure_mono ⦃s t : Set M⦄ (h : s ⊆ t) : closure s ≤ closure t 
Arguments: {M : Type u_1} [MulOneClass M] ⦃s t : Set M⦄ (h : s ⊆ t)
Goal: Submonoid.closure s ≤ Submonoid.closure t
-- Submonoid.closure_eq_of_le
@[to_additive]
theorem closure_eq_of_le (h₁ : s ⊆ S) (h₂ : S ≤ closure s) : closure s = S 
Arguments: {M : Type u_1} [MulOneClass M] {s : Set M} {S : Submonoid M} (h₁ : s ⊆ ↑S) (h₂ : S ≤ Submonoid.closure s)
Goal: Submonoid.closure s = S
-- AddSubmonoid.closure_eq_of_le
@[to_additive]
theorem closure_eq_of_le (h₁ : s ⊆ S) (h₂ : S ≤ closure s) : closure s = S 
Arguments: {M : Type u_1} [AddZeroClass M] {s : Set M} {S : AddSubmonoid M} (h₁ : s ⊆ ↑S) (h₂ : S ≤ AddSubmonoid.closure s)
Goal: AddSubmonoid.closure s = S
-- AddSubmonoid.closure_induction
@[to_additive (attr := elab_as_elim)
      "An induction principle for additive closure membership. If `p` holds for `0` and all
      elements of `s`, and is preserved under addition, then `p` holds for all elements of the
      additive closure of `s`."]
theorem closure_induction {p : M → Prop} {x} (h : x ∈ closure s) (mem : ∀ x ∈ s, p x) (one : p 1)
    (mul : ∀ x y, p x → p y → p (x * y)) : p x 
Arguments: {M : Type u_1} [AddZeroClass M] {s : Set M} {p : M → Prop} {x : M} (h : x ∈ AddSubmonoid.closure s) (mem : ∀ x ∈ s, p x) (one : p 0) (mul : ∀ (x y : M), p x → p y → p (x + y))
Goal: p x
-- Submonoid.closure_induction
@[to_additive (attr := elab_as_elim)
      "An induction principle for additive closure membership. If `p` holds for `0` and all
      elements of `s`, and is preserved under addition, then `p` holds for all elements of the
      additive closure of `s`."]
theorem closure_induction {p : M → Prop} {x} (h : x ∈ closure s) (mem : ∀ x ∈ s, p x) (one : p 1)
    (mul : ∀ x y, p x → p y → p (x * y)) : p x 
Arguments: {M : Type u_1} [MulOneClass M] {s : Set M} {p : M → Prop} {x : M} (h : x ∈ Submonoid.closure s) (mem : ∀ x ∈ s, p x) (one : p 1) (mul : ∀ (x y : M), p x → p y → p (x * y))
Goal: p x
-- AddSubmonoid.closure_induction'
@[to_additive (attr := elab_as_elim) "A dependent version of `AddSubmonoid.closure_induction`. "]
theorem closure_induction' (s : Set M) {p : ∀ x, x ∈ closure s → Prop}
    (mem : ∀ (x) (h : x ∈ s), p x (subset_closure h)) (one : p 1 (one_mem _))
    (mul : ∀ x hx y hy, p x hx → p y hy → p (x * y) (mul_mem hx hy)) {x} (hx : x ∈ closure s) :
    p x hx 
Arguments: {M : Type u_1} [AddZeroClass M] (s : Set M) {p : (x : M) → x ∈ AddSubmonoid.closure s → Prop} (mem : ∀ (x : M) (h : x ∈ s), p x ⋯) (one : p 0 ⋯) (mul :
  ∀ (x : M) (hx : x ∈ AddSubmonoid.closure s) (y : M) (hy : y ∈ AddSubmonoid.closure s), p x hx → p y hy → p (x + y) ⋯) {x : M} (hx : x ∈ AddSubmonoid.closure s)
Goal: p x hx
-- Submonoid.closure_induction'
@[to_additive (attr := elab_as_elim) "A dependent version of `AddSubmonoid.closure_induction`. "]
theorem closure_induction' (s : Set M) {p : ∀ x, x ∈ closure s → Prop}
    (mem : ∀ (x) (h : x ∈ s), p x (subset_closure h)) (one : p 1 (one_mem _))
    (mul : ∀ x hx y hy, p x hx → p y hy → p (x * y) (mul_mem hx hy)) {x} (hx : x ∈ closure s) :
    p x hx 
Arguments: {M : Type u_1} [MulOneClass M] (s : Set M) {p : (x : M) → x ∈ Submonoid.closure s → Prop} (mem : ∀ (x : M) (h : x ∈ s), p x ⋯) (one : p 1 ⋯) (mul : ∀ (x : M) (hx : x ∈ Submonoid.closure s) (y : M) (hy : y ∈ Submonoid.closure s), p x hx → p y hy → p (x * y) ⋯) {x : M} (hx : x ∈ Submonoid.closure s)
Goal: p x hx
-- Submonoid.closure_induction₂
@[to_additive (attr := elab_as_elim)
      "An induction principle for additive closure membership for predicates with two arguments."]
theorem closure_induction₂ {p : M → M → Prop} {x} {y : M} (hx : x ∈ closure s) (hy : y ∈ closure s)
    (Hs : ∀ x ∈ s, ∀ y ∈ s, p x y) (H1_left : ∀ x, p 1 x) (H1_right : ∀ x, p x 1)
    (Hmul_left : ∀ x y z, p x z → p y z → p (x * y) z)
    (Hmul_right : ∀ x y z, p z x → p z y → p z (x * y)) : p x y 
Arguments: {M : Type u_1} [MulOneClass M] {s : Set M} {p : M → M → Prop} {x y : M} (hx : x ∈ Submonoid.closure s) (hy : y ∈ Submonoid.closure s) (Hs : ∀ x ∈ s, ∀ y ∈ s, p x y) (H1_left : ∀ (x : M), p 1 x) (H1_right : ∀ (x : M), p x 1) (Hmul_left : ∀ (x y z : M), p x z → p y z → p (x * y) z) (Hmul_right : ∀ (x y z : M), p z x → p z y → p z (x * y))
Goal: p x y
-- AddSubmonoid.closure_induction₂
@[to_additive (attr := elab_as_elim)
      "An induction principle for additive closure membership for predicates with two arguments."]
theorem closure_induction₂ {p : M → M → Prop} {x} {y : M} (hx : x ∈ closure s) (hy : y ∈ closure s)
    (Hs : ∀ x ∈ s, ∀ y ∈ s, p x y) (H1_left : ∀ x, p 1 x) (H1_right : ∀ x, p x 1)
    (Hmul_left : ∀ x y z, p x z → p y z → p (x * y) z)
    (Hmul_right : ∀ x y z, p z x → p z y → p z (x * y)) : p x y 
Arguments: {M : Type u_1} [AddZeroClass M] {s : Set M} {p : M → M → Prop} {x y : M} (hx : x ∈ AddSubmonoid.closure s) (hy : y ∈ AddSubmonoid.closure s) (Hs : ∀ x ∈ s, ∀ y ∈ s, p x y) (H1_left : ∀ (x : M), p 0 x) (H1_right : ∀ (x : M), p x 0) (Hmul_left : ∀ (x y z : M), p x z → p y z → p (x + y) z) (Hmul_right : ∀ (x y z : M), p z x → p z y → p z (x + y))
Goal: p x y
-- AddSubmonoid.dense_induction
@[to_additive (attr := elab_as_elim)
      "If `s` is a dense set in an additive monoid `M`, `AddSubmonoid.closure s = ⊤`, then in
      order to prove that some predicate `p` holds for all `x : M` it suffices to verify `p x` for
      `x ∈ s`, verify `p 0`, and verify that `p x` and `p y` imply `p (x + y)`."]
theorem dense_induction {p : M → Prop} (x : M) {s : Set M} (hs : closure s = ⊤)
    (mem : ∀ x ∈ s, p x)
    (one : p 1) (mul : ∀ x y, p x → p y → p (x * y)) : p x 
Arguments: {M : Type u_1} [AddZeroClass M] {p : M → Prop} (x : M) {s : Set M} (hs : AddSubmonoid.closure s = ⊤) (mem : ∀ x ∈ s, p x) (one : p 0) (mul : ∀ (x y : M), p x → p y → p (x + y))
Goal: p x
-- Submonoid.dense_induction
@[to_additive (attr := elab_as_elim)
      "If `s` is a dense set in an additive monoid `M`, `AddSubmonoid.closure s = ⊤`, then in
      order to prove that some predicate `p` holds for all `x : M` it suffices to verify `p x` for
      `x ∈ s`, verify `p 0`, and verify that `p x` and `p y` imply `p (x + y)`."]
theorem dense_induction {p : M → Prop} (x : M) {s : Set M} (hs : closure s = ⊤)
    (mem : ∀ x ∈ s, p x)
    (one : p 1) (mul : ∀ x y, p x → p y → p (x * y)) : p x 
Arguments: {M : Type u_1} [MulOneClass M] {p : M → Prop} (x : M) {s : Set M} (hs : Submonoid.closure s = ⊤) (mem : ∀ x ∈ s, p x) (one : p 1) (mul : ∀ (x y : M), p x → p y → p (x * y))
Goal: p x
-- Submonoid.closure_eq_one_union
lemma closure_eq_one_union (s : Set M) :
    closure s = {(1 : M)} ∪ (Subsemigroup.closure s : Set M) 
Arguments: {M : Type u_1} [MulOneClass M] (s : Set M)
Goal: ↑(Submonoid.closure s) = {1} ∪ ↑(Subsemigroup.closure s)
-- Submonoid.closure_eq
@[to_additive (attr := simp) "Additive closure of an additive submonoid `S` equals `S`"]
theorem closure_eq : closure (S : Set M) = S 
Arguments: {M : Type u_1} [MulOneClass M] (S : Submonoid M)
Goal: Submonoid.closure ↑S = S
-- AddSubmonoid.closure_eq
@[to_additive (attr := simp) "Additive closure of an additive submonoid `S` equals `S`"]
theorem closure_eq : closure (S : Set M) = S 
Arguments: {M : Type u_1} [AddZeroClass M] (S : AddSubmonoid M)
Goal: AddSubmonoid.closure ↑S = S
-- Submonoid.closure_empty
@[to_additive (attr := simp)]
theorem closure_empty : closure (∅ : Set M) = ⊥ 
Arguments: {M : Type u_1} [MulOneClass M]
Goal: Submonoid.closure ∅ = ⊥
-- AddSubmonoid.closure_empty
@[to_additive (attr := simp)]
theorem closure_empty : closure (∅ : Set M) = ⊥ 
Arguments: {M : Type u_1} [AddZeroClass M]
Goal: AddSubmonoid.closure ∅ = ⊥
-- Submonoid.closure_univ
@[to_additive (attr := simp)]
theorem closure_univ : closure (univ : Set M) = ⊤ 
Arguments: {M : Type u_1} [MulOneClass M]
Goal: Submonoid.closure Set.univ = ⊤
-- AddSubmonoid.closure_univ
@[to_additive (attr := simp)]
theorem closure_univ : closure (univ : Set M) = ⊤ 
Arguments: {M : Type u_1} [AddZeroClass M]
Goal: AddSubmonoid.closure Set.univ = ⊤
-- Submonoid.closure_union
@[to_additive]
theorem closure_union (s t : Set M) : closure (s ∪ t) = closure s ⊔ closure t 
Arguments: {M : Type u_1} [MulOneClass M] (s t : Set M)
Goal: Submonoid.closure (s ∪ t) = Submonoid.closure s ⊔ Submonoid.closure t
-- AddSubmonoid.closure_union
@[to_additive]
theorem closure_union (s t : Set M) : closure (s ∪ t) = closure s ⊔ closure t 
Arguments: {M : Type u_1} [AddZeroClass M] (s t : Set M)
Goal: AddSubmonoid.closure (s ∪ t) = AddSubmonoid.closure s ⊔ AddSubmonoid.closure t
-- Submonoid.sup_eq_closure
@[to_additive]
theorem sup_eq_closure (N N' : Submonoid M) : N ⊔ N' = closure ((N : Set M) ∪ (N' : Set M)) 
Arguments: {M : Type u_1} [MulOneClass M] (N N' : Submonoid M)
Goal: N ⊔ N' = Submonoid.closure (↑N ∪ ↑N')
-- AddSubmonoid.sup_eq_closure
@[to_additive]
theorem sup_eq_closure (N N' : Submonoid M) : N ⊔ N' = closure ((N : Set M) ∪ (N' : Set M)) 
Arguments: {M : Type u_1} [AddZeroClass M] (N N' : AddSubmonoid M)
Goal: N ⊔ N' = AddSubmonoid.closure (↑N ∪ ↑N')
-- AddSubmonoid.closure_iUnion
@[to_additive]
theorem closure_iUnion {ι} (s : ι → Set M) : closure (⋃ i, s i) = ⨆ i, closure (s i) 
Arguments: {M : Type u_1} [AddZeroClass M] {ι : Sort u_4} (s : ι → Set M)
Goal: AddSubmonoid.closure (⋃ i, s i) = ⨆ i, AddSubmonoid.closure (s i)
-- Submonoid.closure_iUnion
@[to_additive]
theorem closure_iUnion {ι} (s : ι → Set M) : closure (⋃ i, s i) = ⨆ i, closure (s i) 
Arguments: {M : Type u_1} [MulOneClass M] {ι : Sort u_4} (s : ι → Set M)
Goal: Submonoid.closure (⋃ i, s i) = ⨆ i, Submonoid.closure (s i)
-- AddSubmonoid.closure_singleton_le_iff_mem
@[to_additive]
theorem closure_singleton_le_iff_mem (m : M) (p : Submonoid M) : closure {m} ≤ p ↔ m ∈ p 
Arguments: {M : Type u_1} [AddZeroClass M] (m : M) (p : AddSubmonoid M)
Goal: AddSubmonoid.closure {m} ≤ p ↔ m ∈ p
-- Submonoid.closure_singleton_le_iff_mem
@[to_additive]
theorem closure_singleton_le_iff_mem (m : M) (p : Submonoid M) : closure {m} ≤ p ↔ m ∈ p 
Arguments: {M : Type u_1} [MulOneClass M] (m : M) (p : Submonoid M)
Goal: Submonoid.closure {m} ≤ p ↔ m ∈ p
-- AddSubmonoid.mem_iSup
@[to_additive]
theorem mem_iSup {ι : Sort*} (p : ι → Submonoid M) {m : M} :
    (m ∈ ⨆ i, p i) ↔ ∀ N, (∀ i, p i ≤ N) → m ∈ N 
Arguments: {M : Type u_1} [AddZeroClass M] {ι : Sort u_4} (p : ι → AddSubmonoid M) {m : M}
Goal: m ∈ ⨆ i, p i ↔ ∀ (N : AddSubmonoid M), (∀ (i : ι), p i ≤ N) → m ∈ N