ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- isAddSubmonoid_iUnion_of_directed
@[to_additive
      "The union of an indexed, directed, nonempty set of `AddSubmonoid`s of an `AddMonoid` `M`
      is an `AddSubmonoid` of `M`. "]
theorem isSubmonoid_iUnion_of_directed {ι : Type*} [hι : Nonempty ι] {s : ι → Set M}
    (hs : ∀ i, IsSubmonoid (s i)) (Directed : ∀ i j, ∃ k, s i ⊆ s k ∧ s j ⊆ s k) :
    IsSubmonoid (⋃ i, s i) 
Arguments: {M : Type u_1} [AddMonoid M] {ι : Type u_3} [hι : Nonempty ι] {s : ι → Set M} (hs : ∀ (i : ι), IsAddSubmonoid (s i)) (Directed : ∀ (i j : ι), ∃ k, s i ⊆ s k ∧ s j ⊆ s k)
Goal: IsAddSubmonoid (⋃ i, s i)
-- multiples.zero_mem
@[to_additive "0 is in the set of natural number multiples of an element of an `AddMonoid`."]
theorem powers.one_mem {x : M} : (1 : M) ∈ powers x 
Arguments: {M : Type u_1} [AddMonoid M] {x : M}
Goal: 0 ∈ multiples x
-- powers.one_mem
@[to_additive "0 is in the set of natural number multiples of an element of an `AddMonoid`."]
theorem powers.one_mem {x : M} : (1 : M) ∈ powers x 
Arguments: {M : Type u_1} [Monoid M] {x : M}
Goal: 1 ∈ powers x
-- multiples.self_mem
@[to_additive
      "An element of an `AddMonoid` is in the set of that element's natural number multiples."]
theorem powers.self_mem {x : M} : x ∈ powers x 
Arguments: {M : Type u_1} [AddMonoid M] {x : M}
Goal: x ∈ multiples x
-- powers.self_mem
@[to_additive
      "An element of an `AddMonoid` is in the set of that element's natural number multiples."]
theorem powers.self_mem {x : M} : x ∈ powers x 
Arguments: {M : Type u_1} [Monoid M] {x : M}
Goal: x ∈ powers x
-- multiples.add_mem
@[to_additive
      "The set of natural number multiples of an element of an `AddMonoid` is closed under
      addition."]
theorem powers.mul_mem {x y z : M} : y ∈ powers x → z ∈ powers x → y * z ∈ powers x 
Arguments: {M : Type u_1} [AddMonoid M] {x y z : M}
Goal: y ∈ multiples x → z ∈ multiples x → y + z ∈ multiples x
-- powers.mul_mem
@[to_additive
      "The set of natural number multiples of an element of an `AddMonoid` is closed under
      addition."]
theorem powers.mul_mem {x y z : M} : y ∈ powers x → z ∈ powers x → y * z ∈ powers x 
Arguments: {M : Type u_1} [Monoid M] {x y z : M}
Goal: y ∈ powers x → z ∈ powers x → y * z ∈ powers x
-- multiples.isAddSubmonoid
@[to_additive
      "The set of natural number multiples of an element of an `AddMonoid` `M` is
      an `AddSubmonoid` of `M`."]
theorem powers.isSubmonoid (x : M) : IsSubmonoid (powers x) 
Arguments: {M : Type u_1} [AddMonoid M] (x : M)
Goal: IsAddSubmonoid (multiples x)
-- powers.isSubmonoid
@[to_additive
      "The set of natural number multiples of an element of an `AddMonoid` `M` is
      an `AddSubmonoid` of `M`."]
theorem powers.isSubmonoid (x : M) : IsSubmonoid (powers x) 
Arguments: {M : Type u_1} [Monoid M] (x : M)
Goal: IsSubmonoid (powers x)
-- Univ.isAddSubmonoid
@[to_additive "An `AddMonoid` is an `AddSubmonoid` of itself."]
theorem Univ.isSubmonoid : IsSubmonoid (@Set.univ M) 
Arguments: {M : Type u_1} [AddMonoid M]
Goal: IsAddSubmonoid Set.univ
-- Univ.isSubmonoid
@[to_additive "An `AddMonoid` is an `AddSubmonoid` of itself."]
theorem Univ.isSubmonoid : IsSubmonoid (@Set.univ M) 
Arguments: {M : Type u_1} [Monoid M]
Goal: IsSubmonoid Set.univ
-- IsAddSubmonoid.preimage
@[to_additive
      "The preimage of an `AddSubmonoid` under an `AddMonoid` hom is
      an `AddSubmonoid` of the domain."]
theorem IsSubmonoid.preimage {N : Type*} [Monoid N] {f : M → N} (hf : IsMonoidHom f) {s : Set N}
    (hs : IsSubmonoid s) : IsSubmonoid (f ⁻¹' s) 
Arguments: {M : Type u_1} [AddMonoid M] {N : Type u_3} [AddMonoid N] {f : M → N} (hf : IsAddMonoidHom f) {s : Set N} (hs : IsAddSubmonoid s)
Goal: IsAddSubmonoid (f ⁻¹' s)
-- IsSubmonoid.preimage
@[to_additive
      "The preimage of an `AddSubmonoid` under an `AddMonoid` hom is
      an `AddSubmonoid` of the domain."]
theorem IsSubmonoid.preimage {N : Type*} [Monoid N] {f : M → N} (hf : IsMonoidHom f) {s : Set N}
    (hs : IsSubmonoid s) : IsSubmonoid (f ⁻¹' s) 
Arguments: {M : Type u_1} [Monoid M] {N : Type u_3} [Monoid N] {f : M → N} (hf : IsMonoidHom f) {s : Set N} (hs : IsSubmonoid s)
Goal: IsSubmonoid (f ⁻¹' s)
-- IsSubmonoid.image
@[to_additive
      "The image of an `AddSubmonoid` under an `AddMonoid` hom is an `AddSubmonoid` of the
      codomain."]
theorem IsSubmonoid.image {γ : Type*} [Monoid γ] {f : M → γ} (hf : IsMonoidHom f) {s : Set M}
    (hs : IsSubmonoid s) : IsSubmonoid (f '' s) 
Arguments: {M : Type u_1} [Monoid M] {γ : Type u_3} [Monoid γ] {f : M → γ} (hf : IsMonoidHom f) {s : Set M} (hs : IsSubmonoid s)
Goal: IsSubmonoid (f '' s)
-- IsAddSubmonoid.image
@[to_additive
      "The image of an `AddSubmonoid` under an `AddMonoid` hom is an `AddSubmonoid` of the
      codomain."]
theorem IsSubmonoid.image {γ : Type*} [Monoid γ] {f : M → γ} (hf : IsMonoidHom f) {s : Set M}
    (hs : IsSubmonoid s) : IsSubmonoid (f '' s) 
Arguments: {M : Type u_1} [AddMonoid M] {γ : Type u_3} [AddMonoid γ] {f : M → γ} (hf : IsAddMonoidHom f) {s : Set M} (hs : IsAddSubmonoid s)
Goal: IsAddSubmonoid (f '' s)
-- Range.isAddSubmonoid
@[to_additive "The image of an `AddMonoid` hom is an `AddSubmonoid` of the codomain."]
theorem Range.isSubmonoid {γ : Type*} [Monoid γ] {f : M → γ} (hf : IsMonoidHom f) :
    IsSubmonoid (Set.range f) 
Arguments: {M : Type u_1} [AddMonoid M] {γ : Type u_3} [AddMonoid γ] {f : M → γ} (hf : IsAddMonoidHom f)
Goal: IsAddSubmonoid (Set.range f)
-- Range.isSubmonoid
@[to_additive "The image of an `AddMonoid` hom is an `AddSubmonoid` of the codomain."]
theorem Range.isSubmonoid {γ : Type*} [Monoid γ] {f : M → γ} (hf : IsMonoidHom f) :
    IsSubmonoid (Set.range f) 
Arguments: {M : Type u_1} [Monoid M] {γ : Type u_3} [Monoid γ] {f : M → γ} (hf : IsMonoidHom f)
Goal: IsSubmonoid (Set.range f)
-- IsAddSubmonoid.nsmul_mem
@[to_additive
      "An `AddSubmonoid` is closed under multiplication by naturals."]
theorem IsSubmonoid.pow_mem {a : M} (hs : IsSubmonoid s) (h : a ∈ s) : ∀ {n : ℕ}, a ^ n ∈ s
  
Arguments: {M : Type u_1} [AddMonoid M] {s : Set M} {a : M} (hs : IsAddSubmonoid s) (h : a ∈ s) {n : ℕ}
Goal: n • a ∈ s
-- IsSubmonoid.pow_mem
@[to_additive
      "An `AddSubmonoid` is closed under multiplication by naturals."]
theorem IsSubmonoid.pow_mem {a : M} (hs : IsSubmonoid s) (h : a ∈ s) : ∀ {n : ℕ}, a ^ n ∈ s
  
Arguments: {M : Type u_1} [Monoid M] {s : Set M} {a : M} (hs : IsSubmonoid s) (h : a ∈ s) {n : ℕ}
Goal: a ^ n ∈ s
-- IsSubmonoid.powers_subset
@[to_additive
      "The set of natural number multiples of an element of an `AddSubmonoid` is a subset of
      the `AddSubmonoid`."]
theorem IsSubmonoid.powers_subset {a : M} (hs : IsSubmonoid s) (h : a ∈ s) : powers a ⊆ s 
Arguments: {M : Type u_1} [Monoid M] {s : Set M} {a : M} (hs : IsSubmonoid s) (h : a ∈ s)
Goal: powers a ⊆ s
-- IsAddSubmonoid.multiples_subset
@[to_additive
      "The set of natural number multiples of an element of an `AddSubmonoid` is a subset of
      the `AddSubmonoid`."]
theorem IsSubmonoid.powers_subset {a : M} (hs : IsSubmonoid s) (h : a ∈ s) : powers a ⊆ s 
Arguments: {M : Type u_1} [AddMonoid M] {s : Set M} {a : M} (hs : IsAddSubmonoid s) (h : a ∈ s)
Goal: multiples a ⊆ s
-- IsAddSubmonoid.list_sum_mem
@[to_additive
      "The sum of a list of elements of an `AddSubmonoid` is an element of the `AddSubmonoid`."]
theorem list_prod_mem (hs : IsSubmonoid s) : ∀ {l : List M}, (∀ x ∈ l, x ∈ s) → l.prod ∈ s
  
Arguments: {M : Type u_1} [AddMonoid M] {s : Set M} (hs : IsAddSubmonoid s) {l : List M}
Goal: (∀ x ∈ l, x ∈ s) → l.sum ∈ s
-- IsSubmonoid.list_prod_mem
@[to_additive
      "The sum of a list of elements of an `AddSubmonoid` is an element of the `AddSubmonoid`."]
theorem list_prod_mem (hs : IsSubmonoid s) : ∀ {l : List M}, (∀ x ∈ l, x ∈ s) → l.prod ∈ s
  
Arguments: {M : Type u_1} [Monoid M] {s : Set M} (hs : IsSubmonoid s) {l : List M}
Goal: (∀ x ∈ l, x ∈ s) → l.prod ∈ s
-- IsSubmonoid.multiset_prod_mem
@[to_additive
      "The sum of a multiset of elements of an `AddSubmonoid` of an `AddCommMonoid`
      is an element of the `AddSubmonoid`. "]
theorem multiset_prod_mem {M} [CommMonoid M] {s : Set M} (hs : IsSubmonoid s) (m : Multiset M) :
    (∀ a ∈ m, a ∈ s) → m.prod ∈ s 
Arguments: {M : Type u_3} [CommMonoid M] {s : Set M} (hs : IsSubmonoid s) (m : Multiset M)
Goal: (∀ a ∈ m, a ∈ s) → m.prod ∈ s
-- IsAddSubmonoid.multiset_sum_mem
@[to_additive
      "The sum of a multiset of elements of an `AddSubmonoid` of an `AddCommMonoid`
      is an element of the `AddSubmonoid`. "]
theorem multiset_prod_mem {M} [CommMonoid M] {s : Set M} (hs : IsSubmonoid s) (m : Multiset M) :
    (∀ a ∈ m, a ∈ s) → m.prod ∈ s 
Arguments: {M : Type u_3} [AddCommMonoid M] {s : Set M} (hs : IsAddSubmonoid s) (m : Multiset M)
Goal: (∀ a ∈ m, a ∈ s) → m.sum ∈ s
-- IsSubmonoid.finset_prod_mem
@[to_additive
      "The sum of elements of an `AddSubmonoid` of an `AddCommMonoid` indexed by
      a `Finset` is an element of the `AddSubmonoid`."]
theorem finset_prod_mem {M A} [CommMonoid M] {s : Set M} (hs : IsSubmonoid s) (f : A → M) :
    ∀ t : Finset A, (∀ b ∈ t, f b ∈ s) → (∏ b ∈ t, f b) ∈ s
  
Arguments: {M : Type u_3} {A : Type u_4} [CommMonoid M] {s : Set M} (hs : IsSubmonoid s) (f : A → M) (t : Finset A)
Goal: (∀ b ∈ t, f b ∈ s) → ∏ b ∈ t, f b ∈ s
-- IsAddSubmonoid.finset_sum_mem
@[to_additive
      "The sum of elements of an `AddSubmonoid` of an `AddCommMonoid` indexed by
      a `Finset` is an element of the `AddSubmonoid`."]
theorem finset_prod_mem {M A} [CommMonoid M] {s : Set M} (hs : IsSubmonoid s) (f : A → M) :
    ∀ t : Finset A, (∀ b ∈ t, f b ∈ s) → (∏ b ∈ t, f b) ∈ s
  
Arguments: {M : Type u_3} {A : Type u_4} [AddCommMonoid M] {s : Set M} (hs : IsAddSubmonoid s) (f : A → M) (t : Finset A)
Goal: (∀ b ∈ t, f b ∈ s) → ∑ b ∈ t, f b ∈ s
-- AddMonoid.closure.isAddSubmonoid
@[to_additive]
theorem closure.isSubmonoid (s : Set M) : IsSubmonoid (Closure s) 
Arguments: {M : Type u_1} [AddMonoid M] (s : Set M)
Goal: IsAddSubmonoid (AddMonoid.Closure s)
-- Monoid.closure.isSubmonoid
@[to_additive]
theorem closure.isSubmonoid (s : Set M) : IsSubmonoid (Closure s) 
Arguments: {M : Type u_1} [Monoid M] (s : Set M)
Goal: IsSubmonoid (Monoid.Closure s)
-- Monoid.subset_closure
@[to_additive
    "A subset of an `AddMonoid` is contained in the `AddSubmonoid` it generates."]
theorem subset_closure {s : Set M} : s ⊆ Closure s 
Arguments: {M : Type u_1} [Monoid M] {s : Set M}
Goal: s ⊆ Monoid.Closure s
-- AddMonoid.subset_closure
@[to_additive
    "A subset of an `AddMonoid` is contained in the `AddSubmonoid` it generates."]
theorem subset_closure {s : Set M} : s ⊆ Closure s 
Arguments: {M : Type u_1} [AddMonoid M] {s : Set M}
Goal: s ⊆ AddMonoid.Closure s
-- AddMonoid.closure_subset
@[to_additive
      "The `AddSubmonoid` generated by a set is contained in any `AddSubmonoid` that
      contains the set."]
theorem closure_subset {s t : Set M} (ht : IsSubmonoid t) (h : s ⊆ t) : Closure s ⊆ t 
Arguments: {M : Type u_1} [AddMonoid M] {s t : Set M} (ht : IsAddSubmonoid t) (h : s ⊆ t)
Goal: AddMonoid.Closure s ⊆ t
-- Monoid.closure_subset
@[to_additive
      "The `AddSubmonoid` generated by a set is contained in any `AddSubmonoid` that
      contains the set."]
theorem closure_subset {s t : Set M} (ht : IsSubmonoid t) (h : s ⊆ t) : Closure s ⊆ t 
Arguments: {M : Type u_1} [Monoid M] {s t : Set M} (ht : IsSubmonoid t) (h : s ⊆ t)
Goal: Monoid.Closure s ⊆ t
-- AddMonoid.closure_mono
@[to_additive
      "Given subsets `t` and `s` of an `AddMonoid M`, if `s ⊆ t`, the `AddSubmonoid`
      of `M` generated by `s` is contained in the `AddSubmonoid` generated by `t`."]
theorem closure_mono {s t : Set M} (h : s ⊆ t) : Closure s ⊆ Closure t 
Arguments: {M : Type u_1} [AddMonoid M] {s t : Set M} (h : s ⊆ t)
Goal: AddMonoid.Closure s ⊆ AddMonoid.Closure t
-- Monoid.closure_mono
@[to_additive
      "Given subsets `t` and `s` of an `AddMonoid M`, if `s ⊆ t`, the `AddSubmonoid`
      of `M` generated by `s` is contained in the `AddSubmonoid` generated by `t`."]
theorem closure_mono {s t : Set M} (h : s ⊆ t) : Closure s ⊆ Closure t 
Arguments: {M : Type u_1} [Monoid M] {s t : Set M} (h : s ⊆ t)
Goal: Monoid.Closure s ⊆ Monoid.Closure t
-- Monoid.closure_singleton
@[to_additive
      "The `AddSubmonoid` generated by an element of an `AddMonoid` equals the set of
      natural number multiples of the element."]
theorem closure_singleton {x : M} : Closure ({x} : Set M) = powers x 
Arguments: {M : Type u_1} [Monoid M] {x : M}
Goal: Monoid.Closure {x} = powers x
-- AddMonoid.closure_singleton
@[to_additive
      "The `AddSubmonoid` generated by an element of an `AddMonoid` equals the set of
      natural number multiples of the element."]
theorem closure_singleton {x : M} : Closure ({x} : Set M) = powers x 
Arguments: {M : Type u_1} [AddMonoid M] {x : M}
Goal: AddMonoid.Closure {x} = multiples x
-- Monoid.image_closure
@[to_additive
      "The image under an `AddMonoid` hom of the `AddSubmonoid` generated by a set equals
      the `AddSubmonoid` generated by the image of the set under the `AddMonoid` hom."]
theorem image_closure {A : Type*} [Monoid A] {f : M → A} (hf : IsMonoidHom f) (s : Set M) :
    f '' Closure s = Closure (f '' s) 
Arguments: {M : Type u_1} [Monoid M] {A : Type u_3} [Monoid A] {f : M → A} (hf : IsMonoidHom f) (s : Set M)
Goal: f '' Monoid.Closure s = Monoid.Closure (f '' s)
-- AddMonoid.image_closure
@[to_additive
      "The image under an `AddMonoid` hom of the `AddSubmonoid` generated by a set equals
      the `AddSubmonoid` generated by the image of the set under the `AddMonoid` hom."]
theorem image_closure {A : Type*} [Monoid A] {f : M → A} (hf : IsMonoidHom f) (s : Set M) :
    f '' Closure s = Closure (f '' s) 
Arguments: {M : Type u_1} [AddMonoid M] {A : Type u_3} [AddMonoid A] {f : M → A} (hf : IsAddMonoidHom f) (s : Set M)
Goal: f '' AddMonoid.Closure s = AddMonoid.Closure (f '' s)
-- AddMonoid.exists_list_of_mem_closure
@[to_additive
      "Given an element `a` of the `AddSubmonoid` of an `AddMonoid M` generated by
      a set `s`, there exists a list of elements of `s` whose sum is `a`."]
theorem exists_list_of_mem_closure {s : Set M} {a : M} (h : a ∈ Closure s) :
    ∃ l : List M, (∀ x ∈ l, x ∈ s) ∧ l.prod = a 
Arguments: {M : Type u_1} [AddMonoid M] {s : Set M} {a : M} (h : a ∈ AddMonoid.Closure s)
Goal: ∃ l, (∀ x ∈ l, x ∈ s) ∧ l.sum = a
-- Monoid.exists_list_of_mem_closure
@[to_additive
      "Given an element `a` of the `AddSubmonoid` of an `AddMonoid M` generated by
      a set `s`, there exists a list of elements of `s` whose sum is `a`."]
theorem exists_list_of_mem_closure {s : Set M} {a : M} (h : a ∈ Closure s) :
    ∃ l : List M, (∀ x ∈ l, x ∈ s) ∧ l.prod = a 
Arguments: {M : Type u_1} [Monoid M] {s : Set M} {a : M} (h : a ∈ Monoid.Closure s)
Goal: ∃ l, (∀ x ∈ l, x ∈ s) ∧ l.prod = a
-- AddMonoid.mem_closure_union_iff
@[to_additive
      "Given sets `s, t` of a commutative `AddMonoid M`, `x ∈ M` is in the `AddSubmonoid`
      of `M` generated by `s ∪ t` iff there exists an element of the `AddSubmonoid` generated by `s`
      and an element of the `AddSubmonoid` generated by `t` whose sum is `x`."]
theorem mem_closure_union_iff {M : Type*} [CommMonoid M] {s t : Set M} {x : M} :
    x ∈ Closure (s ∪ t) ↔ ∃ y ∈ Closure s, ∃ z ∈ Closure t, y * z = x 
Arguments: {M : Type u_3} [AddCommMonoid M] {s t : Set M} {x : M}
Goal: x ∈ AddMonoid.Closure (s ∪ t) ↔ ∃ y ∈ AddMonoid.Closure s, ∃ z ∈ AddMonoid.Closure t, y + z = x
-- Monoid.mem_closure_union_iff
@[to_additive
      "Given sets `s, t` of a commutative `AddMonoid M`, `x ∈ M` is in the `AddSubmonoid`
      of `M` generated by `s ∪ t` iff there exists an element of the `AddSubmonoid` generated by `s`
      and an element of the `AddSubmonoid` generated by `t` whose sum is `x`."]
theorem mem_closure_union_iff {M : Type*} [CommMonoid M] {s t : Set M} {x : M} :
    x ∈ Closure (s ∪ t) ↔ ∃ y ∈ Closure s, ∃ z ∈ Closure t, y * z = x 
Arguments: {M : Type u_3} [CommMonoid M] {s t : Set M} {x : M}
Goal: x ∈ Monoid.Closure (s ∪ t) ↔ ∃ y ∈ Monoid.Closure s, ∃ z ∈ Monoid.Closure t, y * z = x
-- AddSubmonoid.isAddSubmonoid
@[to_additive]
theorem Submonoid.isSubmonoid (S : Submonoid M) : IsSubmonoid (S : Set M) 
Arguments: {M : Type u_1} [AddMonoid M] (S : AddSubmonoid M)
Goal: IsAddSubmonoid ↑S
-- Submonoid.isSubmonoid
@[to_additive]
theorem Submonoid.isSubmonoid (S : Submonoid M) : IsSubmonoid (S : Set M) 
Arguments: {M : Type u_1} [Monoid M] (S : Submonoid M)
Goal: IsSubmonoid ↑S
-- AlgebraicGeometry.Scheme.zariskiPretopology_openCover
lemma zariskiPretopology_openCover {Y : Scheme.{u}} (U : OpenCover.{u} Y) :
    zariskiPretopology Y (Presieve.ofArrows U.obj U.map) 
Arguments: {Y : AlgebraicGeometry.Scheme} (U : Y.OpenCover)
Goal: AlgebraicGeometry.Scheme.zariskiPretopology.coverings Y (CategoryTheory.Presieve.ofArrows U.obj U.map)
-- AlgebraicGeometry.Scheme.zariskiTopology_openCover
lemma zariskiTopology_openCover {Y : Scheme.{u}} (U : OpenCover.{v} Y) :
    zariskiTopology Y (Sieve.generate (Presieve.ofArrows U.obj U.map)) 
Arguments: {Y : AlgebraicGeometry.Scheme} (U : Y.OpenCover)
Goal: AlgebraicGeometry.Scheme.zariskiTopology.sieves Y
  (CategoryTheory.Sieve.generate (CategoryTheory.Presieve.ofArrows U.obj U.map))
-- AlgebraicGeometry.Scheme.subcanonical_zariskiTopology
lemma subcanonical_zariskiTopology : Sheaf.Subcanonical zariskiTopology 
Goal: CategoryTheory.Sheaf.Subcanonical AlgebraicGeometry.Scheme.zariskiTopology
-- finsum_def'
noncomputable irreducible_def finsum (lemma := finsum_def') [AddCommMonoid M] (f : α → M) : M 
Arguments: {M : Type u_7} {α : Sort u_8} [AddCommMonoid M] (f : α → M)
Goal: finsum f = if h : (Function.support (f ∘ PLift.down)).Finite then ∑ i ∈ h.toFinset, f i.down else 0
-- finprod_def'
@[to_additive existing]
noncomputable irreducible_def finprod (lemma := finprod_def') (f : α → M) : M 
Arguments: {M : Type u_7} {α : Sort u_8} [CommMonoid M] (f : α → M)
Goal: finprod f = if h : (Function.mulSupport (f ∘ PLift.down)).Finite then ∏ i ∈ h.toFinset, f i.down else 1
-- finprod_eq_prod_plift_of_mulSupport_toFinset_subset
@[to_additive]
theorem finprod_eq_prod_plift_of_mulSupport_toFinset_subset {f : α → M}
    (hf : (mulSupport (f ∘ PLift.down)).Finite) {s : Finset (PLift α)} (hs : hf.toFinset ⊆ s) :
    ∏ᶠ i, f i = ∏ i ∈ s, f i.down 
Arguments: {M : Type u_2} {α : Sort u_4} [CommMonoid M] {f : α → M} (hf : (Function.mulSupport (f ∘ PLift.down)).Finite) {s : Finset (PLift α)} (hs : hf.toFinset ⊆ s)
Goal: ∏ᶠ (i : α), f i = ∏ i ∈ s, f i.down
-- finsum_eq_sum_plift_of_support_toFinset_subset
@[to_additive]
theorem finprod_eq_prod_plift_of_mulSupport_toFinset_subset {f : α → M}
    (hf : (mulSupport (f ∘ PLift.down)).Finite) {s : Finset (PLift α)} (hs : hf.toFinset ⊆ s) :
    ∏ᶠ i, f i = ∏ i ∈ s, f i.down 
Arguments: {M : Type u_2} {α : Sort u_4} [AddCommMonoid M] {f : α → M} (hf : (Function.support (f ∘ PLift.down)).Finite) {s : Finset (PLift α)} (hs : hf.toFinset ⊆ s)
Goal: ∑ᶠ (i : α), f i = ∑ i ∈ s, f i.down
-- finprod_eq_prod_plift_of_mulSupport_subset
@[to_additive]
theorem finprod_eq_prod_plift_of_mulSupport_subset {f : α → M} {s : Finset (PLift α)}
    (hs : mulSupport (f ∘ PLift.down) ⊆ s) : ∏ᶠ i, f i = ∏ i ∈ s, f i.down 
Arguments: {M : Type u_2} {α : Sort u_4} [CommMonoid M] {f : α → M} {s : Finset (PLift α)} (hs : Function.mulSupport (f ∘ PLift.down) ⊆ ↑s)
Goal: ∏ᶠ (i : α), f i = ∏ i ∈ s, f i.down
-- finsum_eq_sum_plift_of_support_subset
@[to_additive]
theorem finprod_eq_prod_plift_of_mulSupport_subset {f : α → M} {s : Finset (PLift α)}
    (hs : mulSupport (f ∘ PLift.down) ⊆ s) : ∏ᶠ i, f i = ∏ i ∈ s, f i.down 
Arguments: {M : Type u_2} {α : Sort u_4} [AddCommMonoid M] {f : α → M} {s : Finset (PLift α)} (hs : Function.support (f ∘ PLift.down) ⊆ ↑s)
Goal: ∑ᶠ (i : α), f i = ∑ i ∈ s, f i.down
-- finsum_zero
@[to_additive (attr := simp)]
theorem finprod_one : (∏ᶠ _ : α, (1 : M)) = 1 
Arguments: {M : Type u_2} {α : Sort u_4} [AddCommMonoid M]
Goal: ∑ᶠ (x : α), 0 = 0
-- finprod_one
@[to_additive (attr := simp)]
theorem finprod_one : (∏ᶠ _ : α, (1 : M)) = 1 
Arguments: {M : Type u_2} {α : Sort u_4} [CommMonoid M]
Goal: ∏ᶠ (x : α), 1 = 1
-- finsum_of_isEmpty
@[to_additive]
theorem finprod_of_isEmpty [IsEmpty α] (f : α → M) : ∏ᶠ i, f i = 1 
Arguments: {M : Type u_2} {α : Sort u_4} [AddCommMonoid M] [IsEmpty α] (f : α → M)
Goal: ∑ᶠ (i : α), f i = 0
-- finprod_of_isEmpty
@[to_additive]
theorem finprod_of_isEmpty [IsEmpty α] (f : α → M) : ∏ᶠ i, f i = 1 
Arguments: {M : Type u_2} {α : Sort u_4} [CommMonoid M] [IsEmpty α] (f : α → M)
Goal: ∏ᶠ (i : α), f i = 1
-- finsum_false
@[to_additive (attr := simp)]
theorem finprod_false (f : False → M) : ∏ᶠ i, f i = 1 
Arguments: {M : Type u_2} [AddCommMonoid M] (f : False → M)
Goal: ∑ᶠ (i : False), f i = 0
-- finprod_false
@[to_additive (attr := simp)]
theorem finprod_false (f : False → M) : ∏ᶠ i, f i = 1 
Arguments: {M : Type u_2} [CommMonoid M] (f : False → M)
Goal: ∏ᶠ (i : False), f i = 1
-- finsum_eq_single
@[to_additive]
theorem finprod_eq_single (f : α → M) (a : α) (ha : ∀ x, x ≠ a → f x = 1) :
    ∏ᶠ x, f x = f a 
Arguments: {M : Type u_2} {α : Sort u_4} [AddCommMonoid M] (f : α → M) (a : α) (ha : ∀ (x : α), x ≠ a → f x = 0)
Goal: ∑ᶠ (x : α), f x = f a
-- finprod_eq_single
@[to_additive]
theorem finprod_eq_single (f : α → M) (a : α) (ha : ∀ x, x ≠ a → f x = 1) :
    ∏ᶠ x, f x = f a 
Arguments: {M : Type u_2} {α : Sort u_4} [CommMonoid M] (f : α → M) (a : α) (ha : ∀ (x : α), x ≠ a → f x = 1)
Goal: ∏ᶠ (x : α), f x = f a
-- finprod_unique
@[to_additive]
theorem finprod_unique [Unique α] (f : α → M) : ∏ᶠ i, f i = f default 
Arguments: {M : Type u_2} {α : Sort u_4} [CommMonoid M] [Unique α] (f : α → M)
Goal: ∏ᶠ (i : α), f i = f default
-- finsum_unique
@[to_additive]
theorem finprod_unique [Unique α] (f : α → M) : ∏ᶠ i, f i = f default 
Arguments: {M : Type u_2} {α : Sort u_4} [AddCommMonoid M] [Unique α] (f : α → M)
Goal: ∑ᶠ (i : α), f i = f default
-- finsum_true
@[to_additive (attr := simp)]
theorem finprod_true (f : True → M) : ∏ᶠ i, f i = f trivial 
Arguments: {M : Type u_2} [AddCommMonoid M] (f : True → M)
Goal: ∑ᶠ (i : True), f i = f trivial
-- finprod_true
@[to_additive (attr := simp)]
theorem finprod_true (f : True → M) : ∏ᶠ i, f i = f trivial 
Arguments: {M : Type u_2} [CommMonoid M] (f : True → M)
Goal: ∏ᶠ (i : True), f i = f trivial
-- finprod_eq_dif
@[to_additive]
theorem finprod_eq_dif {p : Prop} [Decidable p] (f : p → M) :
    ∏ᶠ i, f i = if h : p then f h else 1 
Arguments: {M : Type u_2} [CommMonoid M] {p : Prop} [Decidable p] (f : p → M)
Goal: ∏ᶠ (i : p), f i = if h : p then f h else 1
-- finsum_eq_dif
@[to_additive]
theorem finprod_eq_dif {p : Prop} [Decidable p] (f : p → M) :
    ∏ᶠ i, f i = if h : p then f h else 1 
Arguments: {M : Type u_2} [AddCommMonoid M] {p : Prop} [Decidable p] (f : p → M)
Goal: ∑ᶠ (i : p), f i = if h : p then f h else 0
-- finprod_eq_if
@[to_additive]
theorem finprod_eq_if {p : Prop} [Decidable p] {x : M} : ∏ᶠ _ : p, x = if p then x else 1 
Arguments: {M : Type u_2} [CommMonoid M] {p : Prop} [Decidable p] {x : M}
Goal: ∏ᶠ (_ : p), x = if p then x else 1
-- finsum_eq_if
@[to_additive]
theorem finprod_eq_if {p : Prop} [Decidable p] {x : M} : ∏ᶠ _ : p, x = if p then x else 1 
Arguments: {M : Type u_2} [AddCommMonoid M] {p : Prop} [Decidable p] {x : M}
Goal: ∑ᶠ (_ : p), x = if p then x else 0
-- finsum_congr
@[to_additive]
theorem finprod_congr {f g : α → M} (h : ∀ x, f x = g x) : finprod f = finprod g 
Arguments: {M : Type u_2} {α : Sort u_4} [AddCommMonoid M] {f g : α → M} (h : ∀ (x : α), f x = g x)
Goal: finsum f = finsum g
-- finprod_congr
@[to_additive]
theorem finprod_congr {f g : α → M} (h : ∀ x, f x = g x) : finprod f = finprod g 
Arguments: {M : Type u_2} {α : Sort u_4} [CommMonoid M] {f g : α → M} (h : ∀ (x : α), f x = g x)
Goal: finprod f = finprod g
-- finprod_congr_Prop
@[to_additive (attr := congr)]
theorem finprod_congr_Prop {p q : Prop} {f : p → M} {g : q → M} (hpq : p = q)
    (hfg : ∀ h : q, f (hpq.mpr h) = g h) : finprod f = finprod g 
Arguments: {M : Type u_2} [CommMonoid M] {p q : Prop} {f : p → M} {g : q → M} (hpq : p = q) (hfg : ∀ (h : q), f ⋯ = g h)
Goal: finprod f = finprod g