File: Mathlib/Data/Finset/Pointwise.lean

full_name: Finset.one
code: /-- The finset `1 : Finset α` is defined as `{1}` in locale `Pointwise`. -/
@[to_additive "The finset `0 : Finset α` is defined as `{0}` in locale `Pointwise`."]
protected def one : One (Finset α) 
goal: One (Finset α)

full_name: Finset.zero
code: /-- The finset `1 : Finset α` is defined as `{1}` in locale `Pointwise`. -/
@[to_additive "The finset `0 : Finset α` is defined as `{0}` in locale `Pointwise`."]
protected def one : One (Finset α) 
goal: Zero (Finset α)

full_name: Finset.mem_zero
code: @[to_additive (attr := simp)]
theorem mem_one : a ∈ (1 : Finset α) ↔ a = 1 
goal: a ∈ 0 ↔ a = 0

full_name: Finset.mem_one
code: @[to_additive (attr := simp)]
theorem mem_one : a ∈ (1 : Finset α) ↔ a = 1 
goal: a ∈ 1 ↔ a = 1

full_name: Finset.coe_one
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_one : ↑(1 : Finset α) = (1 : Set α) 
goal: ↑1 = 1

full_name: Finset.coe_zero
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_one : ↑(1 : Finset α) = (1 : Set α) 
goal: ↑0 = 0

full_name: Finset.coe_eq_one
code: @[to_additive (attr := simp, norm_cast)]
lemma coe_eq_one : (s : Set α) = 1 ↔ s = 1 
goal: ↑s = 1 ↔ s = 1

full_name: Finset.coe_eq_zero
code: @[to_additive (attr := simp, norm_cast)]
lemma coe_eq_one : (s : Set α) = 1 ↔ s = 1 
goal: ↑s = 0 ↔ s = 0

full_name: Finset.one_subset
code: @[to_additive (attr := simp)]
theorem one_subset : (1 : Finset α) ⊆ s ↔ (1 : α) ∈ s 
goal: 1 ⊆ s ↔ 1 ∈ s

full_name: Finset.zero_subset
code: @[to_additive (attr := simp)]
theorem one_subset : (1 : Finset α) ⊆ s ↔ (1 : α) ∈ s 
goal: 0 ⊆ s ↔ 0 ∈ s

full_name: Finset.singleton_one
code: @[to_additive]
theorem singleton_one : ({1} : Finset α) = 1 
goal: {1} = 1

full_name: Finset.singleton_zero
code: @[to_additive]
theorem singleton_one : ({1} : Finset α) = 1 
goal: {0} = 0

full_name: Finset.one_mem_one
code: @[to_additive]
theorem one_mem_one : (1 : α) ∈ (1 : Finset α) 
goal: 1 ∈ 1

full_name: Finset.zero_mem_zero
code: @[to_additive]
theorem one_mem_one : (1 : α) ∈ (1 : Finset α) 
goal: 0 ∈ 0

full_name: Finset.one_nonempty
code: @[to_additive (attr := simp, aesop safe apply (rule_sets := [finsetNonempty]))]
theorem one_nonempty : (1 : Finset α).Nonempty 
goal: Finset.Nonempty 1

full_name: Finset.zero_nonempty
code: @[to_additive (attr := simp, aesop safe apply (rule_sets := [finsetNonempty]))]
theorem one_nonempty : (1 : Finset α).Nonempty 
goal: Finset.Nonempty 0

full_name: Finset.map_zero
code: @[to_additive (attr := simp)]
protected theorem map_one {f : α ↪ β} : map f 1 = {f 1} 
goal: Finset.map f 0 = {f 0}

full_name: Finset.map_one
code: @[to_additive (attr := simp)]
protected theorem map_one {f : α ↪ β} : map f 1 = {f 1} 
goal: Finset.map f 1 = {f 1}

full_name: Finset.image_zero
code: @[to_additive (attr := simp)]
theorem image_one [DecidableEq β] {f : α → β} : image f 1 = {f 1} 
goal: Finset.image f 0 = {f 0}

full_name: Finset.image_one
code: @[to_additive (attr := simp)]
theorem image_one [DecidableEq β] {f : α → β} : image f 1 = {f 1} 
goal: Finset.image f 1 = {f 1}

full_name: Finset.subset_zero_iff_eq
code: @[to_additive]
theorem subset_one_iff_eq : s ⊆ 1 ↔ s = ∅ ∨ s = 1 
goal: s ⊆ 0 ↔ s = ∅ ∨ s = 0

full_name: Finset.subset_one_iff_eq
code: @[to_additive]
theorem subset_one_iff_eq : s ⊆ 1 ↔ s = ∅ ∨ s = 1 
goal: s ⊆ 1 ↔ s = ∅ ∨ s = 1

full_name: Finset.Nonempty.subset_one_iff
code: @[to_additive]
theorem Nonempty.subset_one_iff (h : s.Nonempty) : s ⊆ 1 ↔ s = 1 
goal: s ⊆ 1 ↔ s = 1

full_name: Finset.Nonempty.subset_zero_iff
code: @[to_additive]
theorem Nonempty.subset_one_iff (h : s.Nonempty) : s ⊆ 1 ↔ s = 1 
goal: s ⊆ 0 ↔ s = 0

full_name: Finset.card_one
code: @[to_additive (attr := simp)]
theorem card_one : (1 : Finset α).card = 1 
goal: Finset.card 1 = 1

full_name: Finset.card_zero
code: @[to_additive (attr := simp)]
theorem card_one : (1 : Finset α).card = 1 
goal: Finset.card 0 = 1

full_name: Finset.singletonZeroHom
code: /-- The singleton operation as a `OneHom`. -/
@[to_additive "The singleton operation as a `ZeroHom`."]
def singletonOneHom : OneHom α (Finset α) 
goal: ZeroHom α (Finset α)

full_name: Finset.singletonOneHom
code: /-- The singleton operation as a `OneHom`. -/
@[to_additive "The singleton operation as a `ZeroHom`."]
def singletonOneHom : OneHom α (Finset α) 
goal: OneHom α (Finset α)

full_name: Finset.coe_singletonZeroHom
code: @[to_additive (attr := simp)]
theorem coe_singletonOneHom : (singletonOneHom : α → Finset α) = singleton 
goal: ⇑Finset.singletonZeroHom = singleton

full_name: Finset.coe_singletonOneHom
code: @[to_additive (attr := simp)]
theorem coe_singletonOneHom : (singletonOneHom : α → Finset α) = singleton 
goal: ⇑Finset.singletonOneHom = singleton

full_name: Finset.singletonOneHom_apply
code: @[to_additive (attr := simp)]
theorem singletonOneHom_apply (a : α) : singletonOneHom a = {a} 
goal: Finset.singletonOneHom a = {a}

full_name: Finset.singletonZeroHom_apply
code: @[to_additive (attr := simp)]
theorem singletonOneHom_apply (a : α) : singletonOneHom a = {a} 
goal: Finset.singletonZeroHom a = {a}

full_name: Finset.imageZeroHom
code: /-- Lift a `OneHom` to `Finset` via `image`. -/
@[to_additive (attr := simps) "Lift a `ZeroHom` to `Finset` via `image`"]
def imageOneHom [DecidableEq β] [One β] [FunLike F α β] [OneHomClass F α β] (f : F) :
    OneHom (Finset α) (Finset β) 
goal: ZeroHom (Finset α) (Finset β)

full_name: Finset.imageOneHom
code: /-- Lift a `OneHom` to `Finset` via `image`. -/
@[to_additive (attr := simps) "Lift a `ZeroHom` to `Finset` via `image`"]
def imageOneHom [DecidableEq β] [One β] [FunLike F α β] [OneHomClass F α β] (f : F) :
    OneHom (Finset α) (Finset β) 
goal: OneHom (Finset α) (Finset β)

full_name: Finset.imageZeroHom_apply
code: /-- Lift a `OneHom` to `Finset` via `image`. -/
@[to_additive (attr := simps) "Lift a `ZeroHom` to `Finset` via `image`"]
def imageOneHom [DecidableEq β] [One β] [FunLike F α β] [OneHomClass F α β] (f : F) :
    OneHom (Finset α) (Finset β) 
goal: (Finset.imageZeroHom f) s = Finset.image (⇑f) s

full_name: Finset.imageOneHom_apply
code: /-- Lift a `OneHom` to `Finset` via `image`. -/
@[to_additive (attr := simps) "Lift a `ZeroHom` to `Finset` via `image`"]
def imageOneHom [DecidableEq β] [One β] [FunLike F α β] [OneHomClass F α β] (f : F) :
    OneHom (Finset α) (Finset β) 
goal: (Finset.imageOneHom f) s = Finset.image (⇑f) s

full_name: Finset.sup_one
code: @[to_additive (attr := simp)]
lemma sup_one [SemilatticeSup β] [OrderBot β] (f : α → β) : sup 1 f = f 1 
goal: Finset.sup 1 f = f 1

full_name: Finset.sup_zero
code: @[to_additive (attr := simp)]
lemma sup_one [SemilatticeSup β] [OrderBot β] (f : α → β) : sup 1 f = f 1 
goal: Finset.sup 0 f = f 0

full_name: Finset.sup'_one
code: @[to_additive (attr := simp)]
lemma sup'_one [SemilatticeSup β] (f : α → β) : sup' 1 one_nonempty f = f 1 
goal: Finset.sup' 1 ⋯ f = f 1

full_name: Finset.sup'_zero
code: @[to_additive (attr := simp)]
lemma sup'_one [SemilatticeSup β] (f : α → β) : sup' 1 one_nonempty f = f 1 
goal: Finset.sup' 0 ⋯ f = f 0

full_name: Finset.inf_zero
code: @[to_additive (attr := simp)]
lemma inf_one [SemilatticeInf β] [OrderTop β] (f : α → β) : inf 1 f = f 1 
goal: Finset.inf 0 f = f 0

full_name: Finset.inf_one
code: @[to_additive (attr := simp)]
lemma inf_one [SemilatticeInf β] [OrderTop β] (f : α → β) : inf 1 f = f 1 
goal: Finset.inf 1 f = f 1

full_name: Finset.inf'_one
code: @[to_additive (attr := simp)]
lemma inf'_one [SemilatticeInf β] (f : α → β) : inf' 1 one_nonempty f = f 1 
goal: Finset.inf' 1 ⋯ f = f 1

full_name: Finset.inf'_zero
code: @[to_additive (attr := simp)]
lemma inf'_one [SemilatticeInf β] (f : α → β) : inf' 1 one_nonempty f = f 1 
goal: Finset.inf' 0 ⋯ f = f 0

full_name: Finset.max_zero
code: @[to_additive (attr := simp)]
lemma max_one [LinearOrder α] : (1 : Finset α).max = 1 
goal: Finset.max 0 = 0

full_name: Finset.max_one
code: @[to_additive (attr := simp)]
lemma max_one [LinearOrder α] : (1 : Finset α).max = 1 
goal: Finset.max 1 = 1

full_name: Finset.min_zero
code: @[to_additive (attr := simp)]
lemma min_one [LinearOrder α] : (1 : Finset α).min = 1 
goal: Finset.min 0 = 0

full_name: Finset.min_one
code: @[to_additive (attr := simp)]
lemma min_one [LinearOrder α] : (1 : Finset α).min = 1 
goal: Finset.min 1 = 1

full_name: Finset.max'_zero
code: @[to_additive (attr := simp)]
lemma max'_one [LinearOrder α] : (1 : Finset α).max' one_nonempty = 1 
goal: Finset.max' 0 ⋯ = 0

full_name: Finset.max'_one
code: @[to_additive (attr := simp)]
lemma max'_one [LinearOrder α] : (1 : Finset α).max' one_nonempty = 1 
goal: Finset.max' 1 ⋯ = 1

full_name: Finset.min'_one
code: @[to_additive (attr := simp)]
lemma min'_one [LinearOrder α] : (1 : Finset α).min' one_nonempty = 1 
goal: Finset.min' 1 ⋯ = 1

full_name: Finset.min'_zero
code: @[to_additive (attr := simp)]
lemma min'_one [LinearOrder α] : (1 : Finset α).min' one_nonempty = 1 
goal: Finset.min' 0 ⋯ = 0

full_name: Finset.inv
code: /-- The pointwise inversion of finset `s⁻¹` is defined as `{x⁻¹ | x ∈ s}` in locale `Pointwise`. -/
@[to_additive
      "The pointwise negation of finset `-s` is defined as `{-x | x ∈ s}` in locale `Pointwise`."]
protected def inv : Inv (Finset α) 
goal: Inv (Finset α)

full_name: Finset.neg
code: /-- The pointwise inversion of finset `s⁻¹` is defined as `{x⁻¹ | x ∈ s}` in locale `Pointwise`. -/
@[to_additive
      "The pointwise negation of finset `-s` is defined as `{-x | x ∈ s}` in locale `Pointwise`."]
protected def inv : Inv (Finset α) 
goal: Neg (Finset α)

full_name: Finset.inv_def
code: @[to_additive]
theorem inv_def : s⁻¹ = s.image fun x => x⁻¹ 
goal: s⁻¹ = Finset.image (fun x => x⁻¹) s

full_name: Finset.neg_def
code: @[to_additive]
theorem inv_def : s⁻¹ = s.image fun x => x⁻¹ 
goal: -s = Finset.image (fun x => -x) s

full_name: Finset.image_neg
code: @[to_additive]
theorem image_inv : (s.image fun x => x⁻¹) = s⁻¹ 
goal: Finset.image (fun x => -x) s = -s

full_name: Finset.image_inv
code: @[to_additive]
theorem image_inv : (s.image fun x => x⁻¹) = s⁻¹ 
goal: Finset.image (fun x => x⁻¹) s = s⁻¹

full_name: Finset.mem_neg
code: @[to_additive]
theorem mem_inv {x : α} : x ∈ s⁻¹ ↔ ∃ y ∈ s, y⁻¹ = x 
goal: x ∈ -s ↔ ∃ y ∈ s, -y = x

full_name: Finset.mem_inv
code: @[to_additive]
theorem mem_inv {x : α} : x ∈ s⁻¹ ↔ ∃ y ∈ s, y⁻¹ = x 
goal: x ∈ s⁻¹ ↔ ∃ y ∈ s, y⁻¹ = x

full_name: Finset.neg_mem_neg
code: @[to_additive]
theorem inv_mem_inv (ha : a ∈ s) : a⁻¹ ∈ s⁻¹ 
goal: -a ∈ -s

full_name: Finset.inv_mem_inv
code: @[to_additive]
theorem inv_mem_inv (ha : a ∈ s) : a⁻¹ ∈ s⁻¹ 
goal: a⁻¹ ∈ s⁻¹

full_name: Finset.card_inv_le
code: @[to_additive]
theorem card_inv_le : s⁻¹.card ≤ s.card 
goal: s⁻¹.card ≤ s.card

full_name: Finset.card_neg_le
code: @[to_additive]
theorem card_inv_le : s⁻¹.card ≤ s.card 
goal: (-s).card ≤ s.card

full_name: Finset.inv_empty
code: @[to_additive (attr := simp)]
theorem inv_empty : (∅ : Finset α)⁻¹ = ∅ 
goal: ∅⁻¹ = ∅

full_name: Finset.neg_empty
code: @[to_additive (attr := simp)]
theorem inv_empty : (∅ : Finset α)⁻¹ = ∅ 
goal: -∅ = ∅

full_name: Finset.neg_nonempty_iff
code: @[to_additive (attr := simp, aesop safe apply (rule_sets := [finsetNonempty]))]
theorem inv_nonempty_iff : s⁻¹.Nonempty ↔ s.Nonempty 
goal: (-s).Nonempty ↔ s.Nonempty

full_name: Finset.inv_nonempty_iff
code: @[to_additive (attr := simp, aesop safe apply (rule_sets := [finsetNonempty]))]
theorem inv_nonempty_iff : s⁻¹.Nonempty ↔ s.Nonempty 
goal: s⁻¹.Nonempty ↔ s.Nonempty

full_name: Finset.neg_eq_empty
code: @[to_additive (attr := simp)]
theorem inv_eq_empty : s⁻¹ = ∅ ↔ s = ∅ 
goal: -s = ∅ ↔ s = ∅

full_name: Finset.inv_eq_empty
code: @[to_additive (attr := simp)]
theorem inv_eq_empty : s⁻¹ = ∅ ↔ s = ∅ 
goal: s⁻¹ = ∅ ↔ s = ∅

full_name: Finset.inv_subset_inv
code: @[to_additive (attr := mono)]
theorem inv_subset_inv (h : s ⊆ t) : s⁻¹ ⊆ t⁻¹ 
goal: s⁻¹ ⊆ t⁻¹

full_name: Finset.neg_subset_neg
code: @[to_additive (attr := mono)]
theorem inv_subset_inv (h : s ⊆ t) : s⁻¹ ⊆ t⁻¹ 
goal: -s ⊆ -t

full_name: Finset.inv_singleton
code: @[to_additive (attr := simp)]
theorem inv_singleton (a : α) : ({a} : Finset α)⁻¹ = {a⁻¹} 
goal: {a}⁻¹ = {a⁻¹}

full_name: Finset.neg_singleton
code: @[to_additive (attr := simp)]
theorem inv_singleton (a : α) : ({a} : Finset α)⁻¹ = {a⁻¹} 
goal: -{a} = {-a}

full_name: Finset.neg_insert
code: @[to_additive (attr := simp)]
theorem inv_insert (a : α) (s : Finset α) : (insert a s)⁻¹ = insert a⁻¹ s⁻¹ 
goal: -insert a s = insert (-a) (-s)

full_name: Finset.inv_insert
code: @[to_additive (attr := simp)]
theorem inv_insert (a : α) (s : Finset α) : (insert a s)⁻¹ = insert a⁻¹ s⁻¹ 
goal: (insert a s)⁻¹ = insert a⁻¹ s⁻¹

full_name: Finset.sup_inv
code: @[to_additive (attr := simp)]
lemma sup_inv [SemilatticeSup β] [OrderBot β] (s : Finset α) (f : α → β) :
    sup s⁻¹ f = sup s (f ·⁻¹) 
goal: s⁻¹.sup f = s.sup fun x => f x⁻¹

full_name: Finset.sup_neg
code: @[to_additive (attr := simp)]
lemma sup_inv [SemilatticeSup β] [OrderBot β] (s : Finset α) (f : α → β) :
    sup s⁻¹ f = sup s (f ·⁻¹) 
goal: (-s).sup f = s.sup fun x => f (-x)

full_name: Finset.sup'_inv
code: @[to_additive (attr := simp)]
lemma sup'_inv [SemilatticeSup β] {s : Finset α} (hs : s⁻¹.Nonempty) (f : α → β) :
    sup' s⁻¹ hs f = sup' s hs.of_inv (f ·⁻¹) 
goal: s⁻¹.sup' hs f = s.sup' ⋯ fun x => f x⁻¹

full_name: Finset.sup'_neg
code: @[to_additive (attr := simp)]
lemma sup'_inv [SemilatticeSup β] {s : Finset α} (hs : s⁻¹.Nonempty) (f : α → β) :
    sup' s⁻¹ hs f = sup' s hs.of_inv (f ·⁻¹) 
goal: (-s).sup' hs f = s.sup' ⋯ fun x => f (-x)

full_name: Finset.inf_inv
code: @[to_additive (attr := simp)]
lemma inf_inv [SemilatticeInf β] [OrderTop β] (s : Finset α) (f : α → β) :
    inf s⁻¹ f = inf s (f ·⁻¹) 
goal: s⁻¹.inf f = s.inf fun x => f x⁻¹

full_name: Finset.inf_neg
code: @[to_additive (attr := simp)]
lemma inf_inv [SemilatticeInf β] [OrderTop β] (s : Finset α) (f : α → β) :
    inf s⁻¹ f = inf s (f ·⁻¹) 
goal: (-s).inf f = s.inf fun x => f (-x)

full_name: Finset.inf'_inv
code: @[to_additive (attr := simp)]
lemma inf'_inv [SemilatticeInf β] {s : Finset α} (hs : s⁻¹.Nonempty) (f : α → β) :
    inf' s⁻¹ hs f = inf' s hs.of_inv (f ·⁻¹) 
goal: s⁻¹.inf' hs f = s.inf' ⋯ fun x => f x⁻¹

full_name: Finset.inf'_neg
code: @[to_additive (attr := simp)]
lemma inf'_inv [SemilatticeInf β] {s : Finset α} (hs : s⁻¹.Nonempty) (f : α → β) :
    inf' s⁻¹ hs f = inf' s hs.of_inv (f ·⁻¹) 
goal: (-s).inf' hs f = s.inf' ⋯ fun x => f (-x)

full_name: Finset.image_op_inv
code: @[to_additive] lemma image_op_inv (s : Finset α) : s⁻¹.image op = (s.image op)⁻¹ 
goal: Finset.image MulOpposite.op s⁻¹ = (Finset.image MulOpposite.op s)⁻¹

full_name: Finset.image_op_neg
code: @[to_additive] lemma image_op_inv (s : Finset α) : s⁻¹.image op = (s.image op)⁻¹ 
goal: Finset.image AddOpposite.op (-s) = -Finset.image AddOpposite.op s

full_name: Finset.mem_inv'
code: @[to_additive (attr := simp)]
lemma mem_inv' : a ∈ s⁻¹ ↔ a⁻¹ ∈ s 
goal: a ∈ s⁻¹ ↔ a⁻¹ ∈ s

full_name: Finset.mem_neg'
code: @[to_additive (attr := simp)]
lemma mem_inv' : a ∈ s⁻¹ ↔ a⁻¹ ∈ s 
goal: a ∈ -s ↔ -a ∈ s

full_name: Finset.coe_neg
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_inv (s : Finset α) : ↑s⁻¹ = (s : Set α)⁻¹ 
goal: ↑(-s) = -↑s

full_name: Finset.coe_inv
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_inv (s : Finset α) : ↑s⁻¹ = (s : Set α)⁻¹ 
goal: ↑s⁻¹ = (↑s)⁻¹

full_name: Finset.card_neg
code: @[to_additive (attr := simp)]
theorem card_inv (s : Finset α) : s⁻¹.card = s.card 
goal: (-s).card = s.card

full_name: Finset.card_inv
code: @[to_additive (attr := simp)]
theorem card_inv (s : Finset α) : s⁻¹.card = s.card 
goal: s⁻¹.card = s.card

full_name: Finset.preimage_inv
code: @[to_additive (attr := simp)]
theorem preimage_inv (s : Finset α) : s.preimage (·⁻¹) inv_injective.injOn = s⁻¹ 
goal: s.preimage (fun x => x⁻¹) ⋯ = s⁻¹

full_name: Finset.preimage_neg
code: @[to_additive (attr := simp)]
theorem preimage_inv (s : Finset α) : s.preimage (·⁻¹) inv_injective.injOn = s⁻¹ 
goal: s.preimage (fun x => -x) ⋯ = -s

full_name: Finset.inv_univ
code: @[to_additive (attr := simp)]
lemma inv_univ [Fintype α] : (univ : Finset α)⁻¹ = univ 
goal: Finset.univ⁻¹ = Finset.univ

full_name: Finset.neg_univ
code: @[to_additive (attr := simp)]
lemma inv_univ [Fintype α] : (univ : Finset α)⁻¹ = univ 
goal: -Finset.univ = Finset.univ

full_name: Finset.neg_inter
code: @[to_additive (attr := simp)]
lemma inv_inter (s t : Finset α) : (s ∩ t)⁻¹ = s⁻¹ ∩ t⁻¹ 
goal: -(s ∩ t) = -s ∩ -t

full_name: Finset.inv_inter
code: @[to_additive (attr := simp)]
lemma inv_inter (s t : Finset α) : (s ∩ t)⁻¹ = s⁻¹ ∩ t⁻¹ 
goal: (s ∩ t)⁻¹ = s⁻¹ ∩ t⁻¹

full_name: Finset.mul
code: /-- The pointwise multiplication of finsets `s * t` and `t` is defined as `{x * y | x ∈ s, y ∈ t}`
in locale `Pointwise`. -/
@[to_additive
      "The pointwise addition of finsets `s + t` is defined as `{x + y | x ∈ s, y ∈ t}` in
      locale `Pointwise`."]
protected def mul : Mul (Finset α) 
goal: Mul (Finset α)

full_name: Finset.add
code: /-- The pointwise multiplication of finsets `s * t` and `t` is defined as `{x * y | x ∈ s, y ∈ t}`
in locale `Pointwise`. -/
@[to_additive
      "The pointwise addition of finsets `s + t` is defined as `{x + y | x ∈ s, y ∈ t}` in
      locale `Pointwise`."]
protected def mul : Mul (Finset α) 
goal: Add (Finset α)

full_name: Finset.add_def
code: @[to_additive]
theorem mul_def : s * t = (s ×ˢ t).image fun p : α × α => p.1 * p.2 
goal: s + t = Finset.image (fun p => p.1 + p.2) (s ×ˢ t)

full_name: Finset.mul_def
code: @[to_additive]
theorem mul_def : s * t = (s ×ˢ t).image fun p : α × α => p.1 * p.2 
goal: s * t = Finset.image (fun p => p.1 * p.2) (s ×ˢ t)

full_name: Finset.image_add_product
code: @[to_additive]
theorem image_mul_product : ((s ×ˢ t).image fun x : α × α => x.fst * x.snd) = s * t 
goal: Finset.image (fun x => x.1 + x.2) (s ×ˢ t) = s + t

full_name: Finset.image_mul_product
code: @[to_additive]
theorem image_mul_product : ((s ×ˢ t).image fun x : α × α => x.fst * x.snd) = s * t 
goal: Finset.image (fun x => x.1 * x.2) (s ×ˢ t) = s * t

full_name: Finset.mem_mul
code: @[to_additive]
theorem mem_mul {x : α} : x ∈ s * t ↔ ∃ y ∈ s, ∃ z ∈ t, y * z = x 
goal: x ∈ s * t ↔ ∃ y ∈ s, ∃ z ∈ t, y * z = x

full_name: Finset.mem_add
code: @[to_additive]
theorem mem_mul {x : α} : x ∈ s * t ↔ ∃ y ∈ s, ∃ z ∈ t, y * z = x 
goal: x ∈ s + t ↔ ∃ y ∈ s, ∃ z ∈ t, y + z = x

full_name: Finset.coe_add
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_mul (s t : Finset α) : (↑(s * t) : Set α) = ↑s * ↑t 
goal: ↑(s + t) = ↑s + ↑t

full_name: Finset.coe_mul
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_mul (s t : Finset α) : (↑(s * t) : Set α) = ↑s * ↑t 
goal: ↑(s * t) = ↑s * ↑t

full_name: Finset.mul_mem_mul
code: @[to_additive]
theorem mul_mem_mul : a ∈ s → b ∈ t → a * b ∈ s * t 
goal: a ∈ s → b ∈ t → a * b ∈ s * t

full_name: Finset.add_mem_add
code: @[to_additive]
theorem mul_mem_mul : a ∈ s → b ∈ t → a * b ∈ s * t 
goal: a ∈ s → b ∈ t → a + b ∈ s + t

full_name: Finset.card_mul_le
code: @[to_additive]
theorem card_mul_le : (s * t).card ≤ s.card * t.card 
goal: (s * t).card ≤ s.card * t.card

full_name: Finset.card_add_le
code: @[to_additive]
theorem card_mul_le : (s * t).card ≤ s.card * t.card 
goal: (s + t).card ≤ s.card * t.card

full_name: Finset.card_add_iff
code: @[to_additive]
theorem card_mul_iff :
    (s * t).card = s.card * t.card ↔ (s ×ˢ t : Set (α × α)).InjOn fun p => p.1 * p.2 
goal: (s + t).card = s.card * t.card ↔ Set.InjOn (fun p => p.1 + p.2) (↑s ×ˢ ↑t)

full_name: Finset.card_mul_iff
code: @[to_additive]
theorem card_mul_iff :
    (s * t).card = s.card * t.card ↔ (s ×ˢ t : Set (α × α)).InjOn fun p => p.1 * p.2 
goal: (s * t).card = s.card * t.card ↔ Set.InjOn (fun p => p.1 * p.2) (↑s ×ˢ ↑t)

full_name: Finset.empty_add
code: @[to_additive (attr := simp)]
theorem empty_mul (s : Finset α) : ∅ * s = ∅ 
goal: ∅ + s = ∅

full_name: Finset.empty_mul
code: @[to_additive (attr := simp)]
theorem empty_mul (s : Finset α) : ∅ * s = ∅ 
goal: ∅ * s = ∅

full_name: Finset.add_empty
code: @[to_additive (attr := simp)]
theorem mul_empty (s : Finset α) : s * ∅ = ∅ 
goal: s + ∅ = ∅

full_name: Finset.mul_empty
code: @[to_additive (attr := simp)]
theorem mul_empty (s : Finset α) : s * ∅ = ∅ 
goal: s * ∅ = ∅

full_name: Finset.mul_eq_empty
code: @[to_additive (attr := simp)]
theorem mul_eq_empty : s * t = ∅ ↔ s = ∅ ∨ t = ∅ 
goal: s * t = ∅ ↔ s = ∅ ∨ t = ∅

full_name: Finset.add_eq_empty
code: @[to_additive (attr := simp)]
theorem mul_eq_empty : s * t = ∅ ↔ s = ∅ ∨ t = ∅ 
goal: s + t = ∅ ↔ s = ∅ ∨ t = ∅

full_name: Finset.add_nonempty
code: @[to_additive (attr := simp, aesop safe apply (rule_sets := [finsetNonempty]))]
theorem mul_nonempty : (s * t).Nonempty ↔ s.Nonempty ∧ t.Nonempty 
goal: (s + t).Nonempty ↔ s.Nonempty ∧ t.Nonempty

full_name: Finset.mul_nonempty
code: @[to_additive (attr := simp, aesop safe apply (rule_sets := [finsetNonempty]))]
theorem mul_nonempty : (s * t).Nonempty ↔ s.Nonempty ∧ t.Nonempty 
goal: (s * t).Nonempty ↔ s.Nonempty ∧ t.Nonempty

full_name: Finset.Nonempty.mul
code: @[to_additive]
theorem Nonempty.mul : s.Nonempty → t.Nonempty → (s * t).Nonempty 
goal: s.Nonempty → t.Nonempty → (s * t).Nonempty

full_name: Finset.Nonempty.add
code: @[to_additive]
theorem Nonempty.mul : s.Nonempty → t.Nonempty → (s * t).Nonempty 
goal: s.Nonempty → t.Nonempty → (s + t).Nonempty

full_name: Finset.Nonempty.of_mul_left
code: @[to_additive]
theorem Nonempty.of_mul_left : (s * t).Nonempty → s.Nonempty 
goal: (s * t).Nonempty → s.Nonempty

full_name: Finset.Nonempty.of_add_left
code: @[to_additive]
theorem Nonempty.of_mul_left : (s * t).Nonempty → s.Nonempty 
goal: (s + t).Nonempty → s.Nonempty

full_name: Finset.Nonempty.of_mul_right
code: @[to_additive]
theorem Nonempty.of_mul_right : (s * t).Nonempty → t.Nonempty 
goal: (s * t).Nonempty → t.Nonempty

full_name: Finset.Nonempty.of_add_right
code: @[to_additive]
theorem Nonempty.of_mul_right : (s * t).Nonempty → t.Nonempty 
goal: (s + t).Nonempty → t.Nonempty

full_name: Finset.add_singleton
code: @[to_additive]
theorem mul_singleton (a : α) : s * {a} = s.image (· * a) 
goal: s + {a} = Finset.image (fun x => x + a) s

full_name: Finset.mul_singleton
code: @[to_additive]
theorem mul_singleton (a : α) : s * {a} = s.image (· * a) 
goal: s * {a} = Finset.image (fun x => x * a) s

full_name: Finset.singleton_add
code: @[to_additive]
theorem singleton_mul (a : α) : {a} * s = s.image (a * ·) 
goal: {a} + s = Finset.image (fun x => a + x) s

full_name: Finset.singleton_mul
code: @[to_additive]
theorem singleton_mul (a : α) : {a} * s = s.image (a * ·) 
goal: {a} * s = Finset.image (fun x => a * x) s

full_name: Finset.singleton_mul_singleton
code: @[to_additive (attr := simp)]
theorem singleton_mul_singleton (a b : α) : ({a} : Finset α) * {b} = {a * b} 
goal: {a} * {b} = {a * b}

full_name: Finset.singleton_add_singleton
code: @[to_additive (attr := simp)]
theorem singleton_mul_singleton (a b : α) : ({a} : Finset α) * {b} = {a * b} 
goal: {a} + {b} = {a + b}

full_name: Finset.mul_subset_mul
code: @[to_additive (attr := mono)]
theorem mul_subset_mul : s₁ ⊆ s₂ → t₁ ⊆ t₂ → s₁ * t₁ ⊆ s₂ * t₂ 
goal: s₁ ⊆ s₂ → t₁ ⊆ t₂ → s₁ * t₁ ⊆ s₂ * t₂

full_name: Finset.add_subset_add
code: @[to_additive (attr := mono)]
theorem mul_subset_mul : s₁ ⊆ s₂ → t₁ ⊆ t₂ → s₁ * t₁ ⊆ s₂ * t₂ 
goal: s₁ ⊆ s₂ → t₁ ⊆ t₂ → s₁ + t₁ ⊆ s₂ + t₂

full_name: Finset.mul_subset_mul_left
code: @[to_additive]
theorem mul_subset_mul_left : t₁ ⊆ t₂ → s * t₁ ⊆ s * t₂ 
goal: t₁ ⊆ t₂ → s * t₁ ⊆ s * t₂

full_name: Finset.add_subset_add_left
code: @[to_additive]
theorem mul_subset_mul_left : t₁ ⊆ t₂ → s * t₁ ⊆ s * t₂ 
goal: t₁ ⊆ t₂ → s + t₁ ⊆ s + t₂

full_name: Finset.mul_subset_mul_right
code: @[to_additive]
theorem mul_subset_mul_right : s₁ ⊆ s₂ → s₁ * t ⊆ s₂ * t 
goal: s₁ ⊆ s₂ → s₁ * t ⊆ s₂ * t

full_name: Finset.add_subset_add_right
code: @[to_additive]
theorem mul_subset_mul_right : s₁ ⊆ s₂ → s₁ * t ⊆ s₂ * t 
goal: s₁ ⊆ s₂ → s₁ + t ⊆ s₂ + t

full_name: Finset.mul_subset_iff
code: @[to_additive]
theorem mul_subset_iff : s * t ⊆ u ↔ ∀ x ∈ s, ∀ y ∈ t, x * y ∈ u 
goal: s * t ⊆ u ↔ ∀ x ∈ s, ∀ y ∈ t, x * y ∈ u

full_name: Finset.add_subset_iff
code: @[to_additive]
theorem mul_subset_iff : s * t ⊆ u ↔ ∀ x ∈ s, ∀ y ∈ t, x * y ∈ u 
goal: s + t ⊆ u ↔ ∀ x ∈ s, ∀ y ∈ t, x + y ∈ u

full_name: Finset.union_mul
code: @[to_additive]
theorem union_mul : (s₁ ∪ s₂) * t = s₁ * t ∪ s₂ * t 
goal: (s₁ ∪ s₂) * t = s₁ * t ∪ s₂ * t

full_name: Finset.union_add
code: @[to_additive]
theorem union_mul : (s₁ ∪ s₂) * t = s₁ * t ∪ s₂ * t 
goal: s₁ ∪ s₂ + t = s₁ + t ∪ (s₂ + t)

full_name: Finset.add_union
code: @[to_additive]
theorem mul_union : s * (t₁ ∪ t₂) = s * t₁ ∪ s * t₂ 
goal: s + (t₁ ∪ t₂) = s + t₁ ∪ (s + t₂)

full_name: Finset.mul_union
code: @[to_additive]
theorem mul_union : s * (t₁ ∪ t₂) = s * t₁ ∪ s * t₂ 
goal: s * (t₁ ∪ t₂) = s * t₁ ∪ s * t₂

full_name: Finset.inter_add_subset
code: @[to_additive]
theorem inter_mul_subset : s₁ ∩ s₂ * t ⊆ s₁ * t ∩ (s₂ * t) 
goal: s₁ ∩ s₂ + t ⊆ (s₁ + t) ∩ (s₂ + t)

full_name: Finset.inter_mul_subset
code: @[to_additive]
theorem inter_mul_subset : s₁ ∩ s₂ * t ⊆ s₁ * t ∩ (s₂ * t) 
goal: s₁ ∩ s₂ * t ⊆ s₁ * t ∩ (s₂ * t)

full_name: Finset.add_inter_subset
code: @[to_additive]
theorem mul_inter_subset : s * (t₁ ∩ t₂) ⊆ s * t₁ ∩ (s * t₂) 
goal: s + t₁ ∩ t₂ ⊆ (s + t₁) ∩ (s + t₂)

full_name: Finset.mul_inter_subset
code: @[to_additive]
theorem mul_inter_subset : s * (t₁ ∩ t₂) ⊆ s * t₁ ∩ (s * t₂) 
goal: s * (t₁ ∩ t₂) ⊆ s * t₁ ∩ (s * t₂)

full_name: Finset.inter_mul_union_subset_union
code: @[to_additive]
theorem inter_mul_union_subset_union : s₁ ∩ s₂ * (t₁ ∪ t₂) ⊆ s₁ * t₁ ∪ s₂ * t₂ 
goal: s₁ ∩ s₂ * (t₁ ∪ t₂) ⊆ s₁ * t₁ ∪ s₂ * t₂

full_name: Finset.inter_add_union_subset_union
code: @[to_additive]
theorem inter_mul_union_subset_union : s₁ ∩ s₂ * (t₁ ∪ t₂) ⊆ s₁ * t₁ ∪ s₂ * t₂ 
goal: s₁ ∩ s₂ + (t₁ ∪ t₂) ⊆ s₁ + t₁ ∪ (s₂ + t₂)

full_name: Finset.union_add_inter_subset_union
code: @[to_additive]
theorem union_mul_inter_subset_union : (s₁ ∪ s₂) * (t₁ ∩ t₂) ⊆ s₁ * t₁ ∪ s₂ * t₂ 
goal: s₁ ∪ s₂ + t₁ ∩ t₂ ⊆ s₁ + t₁ ∪ (s₂ + t₂)

full_name: Finset.union_mul_inter_subset_union
code: @[to_additive]
theorem union_mul_inter_subset_union : (s₁ ∪ s₂) * (t₁ ∩ t₂) ⊆ s₁ * t₁ ∪ s₂ * t₂ 
goal: (s₁ ∪ s₂) * (t₁ ∩ t₂) ⊆ s₁ * t₁ ∪ s₂ * t₂

full_name: Finset.subset_add
code: /-- If a finset `u` is contained in the product of two sets `s * t`, we can find two finsets `s'`,
`t'` such that `s' ⊆ s`, `t' ⊆ t` and `u ⊆ s' * t'`. -/
@[to_additive
      "If a finset `u` is contained in the sum of two sets `s + t`, we can find two finsets
      `s'`, `t'` such that `s' ⊆ s`, `t' ⊆ t` and `u ⊆ s' + t'`."]
theorem subset_mul {s t : Set α} :
    ↑u ⊆ s * t → ∃ s' t' : Finset α, ↑s' ⊆ s ∧ ↑t' ⊆ t ∧ u ⊆ s' * t' 
goal: ↑u ⊆ s + t → ∃ s' t', ↑s' ⊆ s ∧ ↑t' ⊆ t ∧ u ⊆ s' + t'

full_name: Finset.subset_mul
code: /-- If a finset `u` is contained in the product of two sets `s * t`, we can find two finsets `s'`,
`t'` such that `s' ⊆ s`, `t' ⊆ t` and `u ⊆ s' * t'`. -/
@[to_additive
      "If a finset `u` is contained in the sum of two sets `s + t`, we can find two finsets
      `s'`, `t'` such that `s' ⊆ s`, `t' ⊆ t` and `u ⊆ s' + t'`."]
theorem subset_mul {s t : Set α} :
    ↑u ⊆ s * t → ∃ s' t' : Finset α, ↑s' ⊆ s ∧ ↑t' ⊆ t ∧ u ⊆ s' * t' 
goal: ↑u ⊆ s * t → ∃ s' t', ↑s' ⊆ s ∧ ↑t' ⊆ t ∧ u ⊆ s' * t'

full_name: Finset.image_mul
code: @[to_additive]
theorem image_mul : (s * t).image (f : α → β) = s.image f * t.image f 
goal: Finset.image (⇑f) (s * t) = Finset.image (⇑f) s * Finset.image (⇑f) t

full_name: Finset.image_add
code: @[to_additive]
theorem image_mul : (s * t).image (f : α → β) = s.image f * t.image f 
goal: Finset.image (⇑f) (s + t) = Finset.image (⇑f) s + Finset.image (⇑f) t

full_name: Finset.singletonMulHom
code: /-- The singleton operation as a `MulHom`. -/
@[to_additive "The singleton operation as an `AddHom`."]
def singletonMulHom : α →ₙ* Finset α 
goal: α →ₙ* Finset α

full_name: Finset.singletonAddHom
code: /-- The singleton operation as a `MulHom`. -/
@[to_additive "The singleton operation as an `AddHom`."]
def singletonMulHom : α →ₙ* Finset α 
goal: AddHom α (Finset α)

full_name: Finset.coe_singletonMulHom
code: @[to_additive (attr := simp)]
theorem coe_singletonMulHom : (singletonMulHom : α → Finset α) = singleton 
goal: ⇑Finset.singletonMulHom = singleton

full_name: Finset.coe_singletonAddHom
code: @[to_additive (attr := simp)]
theorem coe_singletonMulHom : (singletonMulHom : α → Finset α) = singleton 
goal: ⇑Finset.singletonAddHom = singleton

full_name: Finset.singletonMulHom_apply
code: @[to_additive (attr := simp)]
theorem singletonMulHom_apply (a : α) : singletonMulHom a = {a} 
goal: Finset.singletonMulHom a = {a}

full_name: Finset.singletonAddHom_apply
code: @[to_additive (attr := simp)]
theorem singletonMulHom_apply (a : α) : singletonMulHom a = {a} 
goal: Finset.singletonAddHom a = {a}

full_name: Finset.imageMulHom_apply
code: /-- Lift a `MulHom` to `Finset` via `image`. -/
@[to_additive (attr := simps) "Lift an `AddHom` to `Finset` via `image`"]
def imageMulHom : Finset α →ₙ* Finset β 
goal: (Finset.imageMulHom f) s = Finset.image (⇑f) s

full_name: Finset.imageAddHom_apply
code: /-- Lift a `MulHom` to `Finset` via `image`. -/
@[to_additive (attr := simps) "Lift an `AddHom` to `Finset` via `image`"]
def imageMulHom : Finset α →ₙ* Finset β 
goal: (Finset.imageAddHom f) s = Finset.image (⇑f) s

full_name: Finset.imageMulHom
code: /-- Lift a `MulHom` to `Finset` via `image`. -/
@[to_additive (attr := simps) "Lift an `AddHom` to `Finset` via `image`"]
def imageMulHom : Finset α →ₙ* Finset β 
goal: Finset α →ₙ* Finset β

full_name: Finset.imageAddHom
code: /-- Lift a `MulHom` to `Finset` via `image`. -/
@[to_additive (attr := simps) "Lift an `AddHom` to `Finset` via `image`"]
def imageMulHom : Finset α →ₙ* Finset β 
goal: AddHom (Finset α) (Finset β)

full_name: Finset.sup_mul_le
code: @[to_additive (attr := simp (default + 1))]
lemma sup_mul_le [SemilatticeSup β] [OrderBot β] {s t : Finset α} {f : α → β} {a : β} :
    sup (s * t) f ≤ a ↔ ∀ x ∈ s, ∀ y ∈ t, f (x * y) ≤ a 
goal: (s * t).sup f ≤ a ↔ ∀ x ∈ s, ∀ y ∈ t, f (x * y) ≤ a

full_name: Finset.sup_add_le
code: @[to_additive (attr := simp (default + 1))]
lemma sup_mul_le [SemilatticeSup β] [OrderBot β] {s t : Finset α} {f : α → β} {a : β} :
    sup (s * t) f ≤ a ↔ ∀ x ∈ s, ∀ y ∈ t, f (x * y) ≤ a 
goal: (s + t).sup f ≤ a ↔ ∀ x ∈ s, ∀ y ∈ t, f (x + y) ≤ a

full_name: Finset.sup_add_left
code: @[to_additive]
lemma sup_mul_left [SemilatticeSup β] [OrderBot β] (s t : Finset α) (f : α → β) :
    sup (s * t) f = sup s fun x ↦ sup t (f <| x * ·) 
goal: (s + t).sup f = s.sup fun x => t.sup fun x_1 => f (x + x_1)

full_name: Finset.sup_mul_left
code: @[to_additive]
lemma sup_mul_left [SemilatticeSup β] [OrderBot β] (s t : Finset α) (f : α → β) :
    sup (s * t) f = sup s fun x ↦ sup t (f <| x * ·) 
goal: (s * t).sup f = s.sup fun x => t.sup fun x_1 => f (x * x_1)

full_name: Finset.sup_mul_right
code: @[to_additive]
lemma sup_mul_right [SemilatticeSup β] [OrderBot β] (s t : Finset α) (f : α → β) :
    sup (s * t) f = sup t fun y ↦ sup s (f <| · * y) 
goal: (s * t).sup f = t.sup fun y => s.sup fun x => f (x * y)

full_name: Finset.sup_add_right
code: @[to_additive]
lemma sup_mul_right [SemilatticeSup β] [OrderBot β] (s t : Finset α) (f : α → β) :
    sup (s * t) f = sup t fun y ↦ sup s (f <| · * y) 
goal: (s + t).sup f = t.sup fun y => s.sup fun x => f (x + y)

full_name: Finset.le_inf_add
code: @[to_additive (attr := simp (default + 1))]
lemma le_inf_mul [SemilatticeInf β] [OrderTop β] {s t : Finset α} {f : α → β} {a : β} :
    a ≤ inf (s * t) f ↔ ∀ x ∈ s, ∀ y ∈ t, a ≤ f (x * y) 
goal: a ≤ (s + t).inf f ↔ ∀ x ∈ s, ∀ y ∈ t, a ≤ f (x + y)

full_name: Finset.le_inf_mul
code: @[to_additive (attr := simp (default + 1))]
lemma le_inf_mul [SemilatticeInf β] [OrderTop β] {s t : Finset α} {f : α → β} {a : β} :
    a ≤ inf (s * t) f ↔ ∀ x ∈ s, ∀ y ∈ t, a ≤ f (x * y) 
goal: a ≤ (s * t).inf f ↔ ∀ x ∈ s, ∀ y ∈ t, a ≤ f (x * y)

full_name: Finset.inf_add_left
code: @[to_additive]
lemma inf_mul_left [SemilatticeInf β] [OrderTop β] (s t : Finset α) (f : α → β) :
    inf (s * t) f = inf s fun x ↦ inf t (f <| x * ·) 
goal: (s + t).inf f = s.inf fun x => t.inf fun x_1 => f (x + x_1)

full_name: Finset.inf_mul_left
code: @[to_additive]
lemma inf_mul_left [SemilatticeInf β] [OrderTop β] (s t : Finset α) (f : α → β) :
    inf (s * t) f = inf s fun x ↦ inf t (f <| x * ·) 
goal: (s * t).inf f = s.inf fun x => t.inf fun x_1 => f (x * x_1)

full_name: Finset.inf_add_right
code: @[to_additive]
lemma inf_mul_right [SemilatticeInf β] [OrderTop β] (s t : Finset α) (f : α → β) :
    inf (s * t) f = inf t fun y ↦ inf s (f <| · * y) 
goal: (s + t).inf f = t.inf fun y => s.inf fun x => f (x + y)

full_name: Finset.inf_mul_right
code: @[to_additive]
lemma inf_mul_right [SemilatticeInf β] [OrderTop β] (s t : Finset α) (f : α → β) :
    inf (s * t) f = inf t fun y ↦ inf s (f <| · * y) 
goal: (s * t).inf f = t.inf fun y => s.inf fun x => f (x * y)

full_name: Finset.div
code: /-- The pointwise division of finsets `s / t` is defined as `{x / y | x ∈ s, y ∈ t}` in locale
`Pointwise`. -/
@[to_additive
      "The pointwise subtraction of finsets `s - t` is defined as `{x - y | x ∈ s, y ∈ t}`
      in locale `Pointwise`."]
protected def div : Div (Finset α) 
goal: Div (Finset α)

full_name: Finset.sub
code: /-- The pointwise division of finsets `s / t` is defined as `{x / y | x ∈ s, y ∈ t}` in locale
`Pointwise`. -/
@[to_additive
      "The pointwise subtraction of finsets `s - t` is defined as `{x - y | x ∈ s, y ∈ t}`
      in locale `Pointwise`."]
protected def div : Div (Finset α) 
goal: Sub (Finset α)

full_name: Finset.div_def
code: @[to_additive]
theorem div_def : s / t = (s ×ˢ t).image fun p : α × α => p.1 / p.2 
goal: s / t = Finset.image (fun p => p.1 / p.2) (s ×ˢ t)

full_name: Finset.sub_def
code: @[to_additive]
theorem div_def : s / t = (s ×ˢ t).image fun p : α × α => p.1 / p.2 
goal: s - t = Finset.image (fun p => p.1 - p.2) (s ×ˢ t)

full_name: Finset.image_sub_product
code: @[to_additive]
theorem image_div_product : ((s ×ˢ t).image fun x : α × α => x.fst / x.snd) = s / t 
goal: Finset.image (fun x => x.1 - x.2) (s ×ˢ t) = s - t

full_name: Finset.image_div_product
code: @[to_additive]
theorem image_div_product : ((s ×ˢ t).image fun x : α × α => x.fst / x.snd) = s / t 
goal: Finset.image (fun x => x.1 / x.2) (s ×ˢ t) = s / t

full_name: Finset.mem_div
code: @[to_additive]
theorem mem_div : a ∈ s / t ↔ ∃ b ∈ s, ∃ c ∈ t, b / c = a 
goal: a ∈ s / t ↔ ∃ b ∈ s, ∃ c ∈ t, b / c = a

full_name: Finset.mem_sub
code: @[to_additive]
theorem mem_div : a ∈ s / t ↔ ∃ b ∈ s, ∃ c ∈ t, b / c = a 
goal: a ∈ s - t ↔ ∃ b ∈ s, ∃ c ∈ t, b - c = a

full_name: Finset.coe_sub
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_div (s t : Finset α) : (↑(s / t) : Set α) = ↑s / ↑t 
goal: ↑(s - t) = ↑s - ↑t

full_name: Finset.coe_div
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_div (s t : Finset α) : (↑(s / t) : Set α) = ↑s / ↑t 
goal: ↑(s / t) = ↑s / ↑t

full_name: Finset.sub_mem_sub
code: @[to_additive]
theorem div_mem_div : a ∈ s → b ∈ t → a / b ∈ s / t 
goal: a ∈ s → b ∈ t → a - b ∈ s - t

full_name: Finset.div_mem_div
code: @[to_additive]
theorem div_mem_div : a ∈ s → b ∈ t → a / b ∈ s / t 
goal: a ∈ s → b ∈ t → a / b ∈ s / t

full_name: Finset.sub_card_le
code: @[to_additive]
theorem div_card_le : (s / t).card ≤ s.card * t.card 
goal: (s - t).card ≤ s.card * t.card

full_name: Finset.div_card_le
code: @[to_additive]
theorem div_card_le : (s / t).card ≤ s.card * t.card 
goal: (s / t).card ≤ s.card * t.card

full_name: Finset.empty_sub
code: @[to_additive (attr := simp)]
theorem empty_div (s : Finset α) : ∅ / s = ∅ 
goal: ∅ - s = ∅

full_name: Finset.empty_div
code: @[to_additive (attr := simp)]
theorem empty_div (s : Finset α) : ∅ / s = ∅ 
goal: ∅ / s = ∅

full_name: Finset.div_empty
code: @[to_additive (attr := simp)]
theorem div_empty (s : Finset α) : s / ∅ = ∅ 
goal: s / ∅ = ∅

full_name: Finset.sub_empty
code: @[to_additive (attr := simp)]
theorem div_empty (s : Finset α) : s / ∅ = ∅ 
goal: s - ∅ = ∅

full_name: Finset.sub_eq_empty
code: @[to_additive (attr := simp)]
theorem div_eq_empty : s / t = ∅ ↔ s = ∅ ∨ t = ∅ 
goal: s - t = ∅ ↔ s = ∅ ∨ t = ∅

full_name: Finset.div_eq_empty
code: @[to_additive (attr := simp)]
theorem div_eq_empty : s / t = ∅ ↔ s = ∅ ∨ t = ∅ 
goal: s / t = ∅ ↔ s = ∅ ∨ t = ∅

full_name: Finset.div_nonempty
code: @[to_additive (attr := simp, aesop safe apply (rule_sets := [finsetNonempty]))]
theorem div_nonempty : (s / t).Nonempty ↔ s.Nonempty ∧ t.Nonempty 
goal: (s / t).Nonempty ↔ s.Nonempty ∧ t.Nonempty

full_name: Finset.sub_nonempty
code: @[to_additive (attr := simp, aesop safe apply (rule_sets := [finsetNonempty]))]
theorem div_nonempty : (s / t).Nonempty ↔ s.Nonempty ∧ t.Nonempty 
goal: (s - t).Nonempty ↔ s.Nonempty ∧ t.Nonempty

full_name: Finset.Nonempty.div
code: @[to_additive]
theorem Nonempty.div : s.Nonempty → t.Nonempty → (s / t).Nonempty 
goal: s.Nonempty → t.Nonempty → (s / t).Nonempty

full_name: Finset.Nonempty.sub
code: @[to_additive]
theorem Nonempty.div : s.Nonempty → t.Nonempty → (s / t).Nonempty 
goal: s.Nonempty → t.Nonempty → (s - t).Nonempty

full_name: Finset.Nonempty.of_div_left
code: @[to_additive]
theorem Nonempty.of_div_left : (s / t).Nonempty → s.Nonempty 
goal: (s / t).Nonempty → s.Nonempty

full_name: Finset.Nonempty.of_sub_left
code: @[to_additive]
theorem Nonempty.of_div_left : (s / t).Nonempty → s.Nonempty 
goal: (s - t).Nonempty → s.Nonempty

full_name: Finset.Nonempty.of_sub_right
code: @[to_additive]
theorem Nonempty.of_div_right : (s / t).Nonempty → t.Nonempty 
goal: (s - t).Nonempty → t.Nonempty

full_name: Finset.Nonempty.of_div_right
code: @[to_additive]
theorem Nonempty.of_div_right : (s / t).Nonempty → t.Nonempty 
goal: (s / t).Nonempty → t.Nonempty

full_name: Finset.div_singleton
code: @[to_additive (attr := simp)]
theorem div_singleton (a : α) : s / {a} = s.image (· / a) 
goal: s / {a} = Finset.image (fun x => x / a) s

full_name: Finset.sub_singleton
code: @[to_additive (attr := simp)]
theorem div_singleton (a : α) : s / {a} = s.image (· / a) 
goal: s - {a} = Finset.image (fun x => x - a) s

full_name: Finset.singleton_div
code: @[to_additive (attr := simp)]
theorem singleton_div (a : α) : {a} / s = s.image (a / ·) 
goal: {a} / s = Finset.image (fun x => a / x) s

full_name: Finset.singleton_sub
code: @[to_additive (attr := simp)]
theorem singleton_div (a : α) : {a} / s = s.image (a / ·) 
goal: {a} - s = Finset.image (fun x => a - x) s

full_name: Finset.singleton_sub_singleton
code: @[to_additive]
theorem singleton_div_singleton (a b : α) : ({a} : Finset α) / {b} = {a / b} 
goal: {a} - {b} = {a - b}

full_name: Finset.singleton_div_singleton
code: @[to_additive]
theorem singleton_div_singleton (a b : α) : ({a} : Finset α) / {b} = {a / b} 
goal: {a} / {b} = {a / b}

full_name: Finset.div_subset_div
code: @[to_additive (attr := mono)]
theorem div_subset_div : s₁ ⊆ s₂ → t₁ ⊆ t₂ → s₁ / t₁ ⊆ s₂ / t₂ 
goal: s₁ ⊆ s₂ → t₁ ⊆ t₂ → s₁ / t₁ ⊆ s₂ / t₂

full_name: Finset.sub_subset_sub
code: @[to_additive (attr := mono)]
theorem div_subset_div : s₁ ⊆ s₂ → t₁ ⊆ t₂ → s₁ / t₁ ⊆ s₂ / t₂ 
goal: s₁ ⊆ s₂ → t₁ ⊆ t₂ → s₁ - t₁ ⊆ s₂ - t₂

full_name: Finset.div_subset_div_left
code: @[to_additive]
theorem div_subset_div_left : t₁ ⊆ t₂ → s / t₁ ⊆ s / t₂ 
goal: t₁ ⊆ t₂ → s / t₁ ⊆ s / t₂

full_name: Finset.sub_subset_sub_left
code: @[to_additive]
theorem div_subset_div_left : t₁ ⊆ t₂ → s / t₁ ⊆ s / t₂ 
goal: t₁ ⊆ t₂ → s - t₁ ⊆ s - t₂

full_name: Finset.div_subset_div_right
code: @[to_additive]
theorem div_subset_div_right : s₁ ⊆ s₂ → s₁ / t ⊆ s₂ / t 
goal: s₁ ⊆ s₂ → s₁ / t ⊆ s₂ / t

full_name: Finset.sub_subset_sub_right
code: @[to_additive]
theorem div_subset_div_right : s₁ ⊆ s₂ → s₁ / t ⊆ s₂ / t 
goal: s₁ ⊆ s₂ → s₁ - t ⊆ s₂ - t

full_name: Finset.sub_subset_iff
code: @[to_additive]
theorem div_subset_iff : s / t ⊆ u ↔ ∀ x ∈ s, ∀ y ∈ t, x / y ∈ u 
goal: s - t ⊆ u ↔ ∀ x ∈ s, ∀ y ∈ t, x - y ∈ u

full_name: Finset.div_subset_iff
code: @[to_additive]
theorem div_subset_iff : s / t ⊆ u ↔ ∀ x ∈ s, ∀ y ∈ t, x / y ∈ u 
goal: s / t ⊆ u ↔ ∀ x ∈ s, ∀ y ∈ t, x / y ∈ u

full_name: Finset.union_sub
code: @[to_additive]
theorem union_div : (s₁ ∪ s₂) / t = s₁ / t ∪ s₂ / t 
goal: s₁ ∪ s₂ - t = s₁ - t ∪ (s₂ - t)

full_name: Finset.union_div
code: @[to_additive]
theorem union_div : (s₁ ∪ s₂) / t = s₁ / t ∪ s₂ / t 
goal: (s₁ ∪ s₂) / t = s₁ / t ∪ s₂ / t

full_name: Finset.sub_union
code: @[to_additive]
theorem div_union : s / (t₁ ∪ t₂) = s / t₁ ∪ s / t₂ 
goal: s - (t₁ ∪ t₂) = s - t₁ ∪ (s - t₂)

full_name: Finset.div_union
code: @[to_additive]
theorem div_union : s / (t₁ ∪ t₂) = s / t₁ ∪ s / t₂ 
goal: s / (t₁ ∪ t₂) = s / t₁ ∪ s / t₂

full_name: Finset.inter_sub_subset
code: @[to_additive]
theorem inter_div_subset : s₁ ∩ s₂ / t ⊆ s₁ / t ∩ (s₂ / t) 
goal: s₁ ∩ s₂ - t ⊆ (s₁ - t) ∩ (s₂ - t)

full_name: Finset.inter_div_subset
code: @[to_additive]
theorem inter_div_subset : s₁ ∩ s₂ / t ⊆ s₁ / t ∩ (s₂ / t) 
goal: s₁ ∩ s₂ / t ⊆ s₁ / t ∩ (s₂ / t)

full_name: Finset.sub_inter_subset
code: @[to_additive]
theorem div_inter_subset : s / (t₁ ∩ t₂) ⊆ s / t₁ ∩ (s / t₂) 
goal: s - t₁ ∩ t₂ ⊆ (s - t₁) ∩ (s - t₂)

full_name: Finset.div_inter_subset
code: @[to_additive]
theorem div_inter_subset : s / (t₁ ∩ t₂) ⊆ s / t₁ ∩ (s / t₂) 
goal: s / (t₁ ∩ t₂) ⊆ s / t₁ ∩ (s / t₂)

full_name: Finset.inter_div_union_subset_union
code: @[to_additive]
theorem inter_div_union_subset_union : s₁ ∩ s₂ / (t₁ ∪ t₂) ⊆ s₁ / t₁ ∪ s₂ / t₂ 
goal: s₁ ∩ s₂ / (t₁ ∪ t₂) ⊆ s₁ / t₁ ∪ s₂ / t₂

full_name: Finset.inter_sub_union_subset_union
code: @[to_additive]
theorem inter_div_union_subset_union : s₁ ∩ s₂ / (t₁ ∪ t₂) ⊆ s₁ / t₁ ∪ s₂ / t₂ 
goal: s₁ ∩ s₂ - (t₁ ∪ t₂) ⊆ s₁ - t₁ ∪ (s₂ - t₂)

full_name: Finset.union_sub_inter_subset_union
code: @[to_additive]
theorem union_div_inter_subset_union : (s₁ ∪ s₂) / (t₁ ∩ t₂) ⊆ s₁ / t₁ ∪ s₂ / t₂ 
goal: s₁ ∪ s₂ - t₁ ∩ t₂ ⊆ s₁ - t₁ ∪ (s₂ - t₂)

full_name: Finset.union_div_inter_subset_union
code: @[to_additive]
theorem union_div_inter_subset_union : (s₁ ∪ s₂) / (t₁ ∩ t₂) ⊆ s₁ / t₁ ∪ s₂ / t₂ 
goal: (s₁ ∪ s₂) / (t₁ ∩ t₂) ⊆ s₁ / t₁ ∪ s₂ / t₂

full_name: Finset.subset_sub
code: /-- If a finset `u` is contained in the product of two sets `s / t`, we can find two finsets `s'`,
`t'` such that `s' ⊆ s`, `t' ⊆ t` and `u ⊆ s' / t'`. -/
@[to_additive
      "If a finset `u` is contained in the sum of two sets `s - t`, we can find two finsets
      `s'`, `t'` such that `s' ⊆ s`, `t' ⊆ t` and `u ⊆ s' - t'`."]
theorem subset_div {s t : Set α} :
    ↑u ⊆ s / t → ∃ s' t' : Finset α, ↑s' ⊆ s ∧ ↑t' ⊆ t ∧ u ⊆ s' / t' 
goal: ↑u ⊆ s - t → ∃ s' t', ↑s' ⊆ s ∧ ↑t' ⊆ t ∧ u ⊆ s' - t'

full_name: Finset.subset_div
code: /-- If a finset `u` is contained in the product of two sets `s / t`, we can find two finsets `s'`,
`t'` such that `s' ⊆ s`, `t' ⊆ t` and `u ⊆ s' / t'`. -/
@[to_additive
      "If a finset `u` is contained in the sum of two sets `s - t`, we can find two finsets
      `s'`, `t'` such that `s' ⊆ s`, `t' ⊆ t` and `u ⊆ s' - t'`."]
theorem subset_div {s t : Set α} :
    ↑u ⊆ s / t → ∃ s' t' : Finset α, ↑s' ⊆ s ∧ ↑t' ⊆ t ∧ u ⊆ s' / t' 
goal: ↑u ⊆ s / t → ∃ s' t', ↑s' ⊆ s ∧ ↑t' ⊆ t ∧ u ⊆ s' / t'

full_name: Finset.sup_sub_le
code: @[to_additive (attr := simp (default + 1))]
lemma sup_div_le [SemilatticeSup β] [OrderBot β] {s t : Finset α} {f : α → β} {a : β} :
    sup (s / t) f ≤ a ↔ ∀ x ∈ s, ∀ y ∈ t, f (x /  y) ≤ a 
goal: (s - t).sup f ≤ a ↔ ∀ x ∈ s, ∀ y ∈ t, f (x - y) ≤ a

full_name: Finset.sup_div_le
code: @[to_additive (attr := simp (default + 1))]
lemma sup_div_le [SemilatticeSup β] [OrderBot β] {s t : Finset α} {f : α → β} {a : β} :
    sup (s / t) f ≤ a ↔ ∀ x ∈ s, ∀ y ∈ t, f (x /  y) ≤ a 
goal: (s / t).sup f ≤ a ↔ ∀ x ∈ s, ∀ y ∈ t, f (x / y) ≤ a

full_name: Finset.sup_sub_left
code: @[to_additive]
lemma sup_div_left [SemilatticeSup β] [OrderBot β] (s t : Finset α) (f : α → β) :
    sup (s / t) f = sup s fun x ↦ sup t (f <| x / ·) 
goal: (s - t).sup f = s.sup fun x => t.sup fun x_1 => f (x - x_1)

full_name: Finset.sup_div_left
code: @[to_additive]
lemma sup_div_left [SemilatticeSup β] [OrderBot β] (s t : Finset α) (f : α → β) :
    sup (s / t) f = sup s fun x ↦ sup t (f <| x / ·) 
goal: (s / t).sup f = s.sup fun x => t.sup fun x_1 => f (x / x_1)

full_name: Finset.sup_div_right
code: @[to_additive]
lemma sup_div_right [SemilatticeSup β] [OrderBot β] (s t : Finset α) (f : α → β) :
    sup (s / t) f = sup t fun y ↦ sup s (f <| · / y) 
goal: (s / t).sup f = t.sup fun y => s.sup fun x => f (x / y)

full_name: Finset.sup_sub_right
code: @[to_additive]
lemma sup_div_right [SemilatticeSup β] [OrderBot β] (s t : Finset α) (f : α → β) :
    sup (s / t) f = sup t fun y ↦ sup s (f <| · / y) 
goal: (s - t).sup f = t.sup fun y => s.sup fun x => f (x - y)

full_name: Finset.le_inf_div
code: @[to_additive (attr := simp (default + 1))]
lemma le_inf_div [SemilatticeInf β] [OrderTop β] {s t : Finset α} {f : α → β} {a : β} :
    a ≤ inf (s / t) f ↔ ∀ x ∈ s, ∀ y ∈ t, a ≤ f (x / y) 
goal: a ≤ (s / t).inf f ↔ ∀ x ∈ s, ∀ y ∈ t, a ≤ f (x / y)

full_name: Finset.le_inf_sub
code: @[to_additive (attr := simp (default + 1))]
lemma le_inf_div [SemilatticeInf β] [OrderTop β] {s t : Finset α} {f : α → β} {a : β} :
    a ≤ inf (s / t) f ↔ ∀ x ∈ s, ∀ y ∈ t, a ≤ f (x / y) 
goal: a ≤ (s - t).inf f ↔ ∀ x ∈ s, ∀ y ∈ t, a ≤ f (x - y)

full_name: Finset.inf_div_left
code: @[to_additive]
lemma inf_div_left [SemilatticeInf β] [OrderTop β] (s t : Finset α) (f : α → β) :
    inf (s / t) f = inf s fun x ↦ inf t (f <| x / ·) 
goal: (s / t).inf f = s.inf fun x => t.inf fun x_1 => f (x / x_1)

full_name: Finset.inf_sub_left
code: @[to_additive]
lemma inf_div_left [SemilatticeInf β] [OrderTop β] (s t : Finset α) (f : α → β) :
    inf (s / t) f = inf s fun x ↦ inf t (f <| x / ·) 
goal: (s - t).inf f = s.inf fun x => t.inf fun x_1 => f (x - x_1)

full_name: Finset.inf_sub_right
code: @[to_additive]
lemma inf_div_right [SemilatticeInf β] [OrderTop β] (s t : Finset α) (f : α → β) :
    inf (s / t) f = inf t fun y ↦ inf s (f <| · / y) 
goal: (s - t).inf f = t.inf fun y => s.inf fun x => f (x - y)

full_name: Finset.inf_div_right
code: @[to_additive]
lemma inf_div_right [SemilatticeInf β] [OrderTop β] (s t : Finset α) (f : α → β) :
    inf (s / t) f = inf t fun y ↦ inf s (f <| · / y) 
goal: (s / t).inf f = t.inf fun y => s.inf fun x => f (x / y)

full_name: Finset.nsmul
code: /-- Repeated pointwise addition (not the same as pointwise repeated addition!) of a `Finset`. See
note [pointwise nat action]. -/
protected def nsmul [Zero α] [Add α] : SMul ℕ (Finset α) 
goal: SMul ℕ (Finset α)

full_name: Finset.npow
code: /-- Repeated pointwise multiplication (not the same as pointwise repeated multiplication!) of a
`Finset`. See note [pointwise nat action]. -/
protected def npow [One α] [Mul α] : Pow (Finset α) ℕ 
goal: Pow (Finset α) ℕ

full_name: Finset.zsmul
code: /-- Repeated pointwise addition/subtraction (not the same as pointwise repeated
addition/subtraction!) of a `Finset`. See note [pointwise nat action]. -/
protected def zsmul [Zero α] [Add α] [Neg α] : SMul ℤ (Finset α) 
goal: SMul ℤ (Finset α)

full_name: Finset.zpow
code: /-- Repeated pointwise multiplication/division (not the same as pointwise repeated
multiplication/division!) of a `Finset`. See note [pointwise nat action]. -/
@[to_additive existing]
protected def zpow [One α] [Mul α] [Inv α] : Pow (Finset α) ℤ 
goal: Pow (Finset α) ℤ

full_name: Finset.addSemigroup
code: /-- `Finset α` is a `Semigroup` under pointwise operations if `α` is. -/
@[to_additive "`Finset α` is an `AddSemigroup` under pointwise operations if `α` is. "]
protected def semigroup [Semigroup α] : Semigroup (Finset α) 
goal: AddSemigroup (Finset α)

full_name: Finset.semigroup
code: /-- `Finset α` is a `Semigroup` under pointwise operations if `α` is. -/
@[to_additive "`Finset α` is an `AddSemigroup` under pointwise operations if `α` is. "]
protected def semigroup [Semigroup α] : Semigroup (Finset α) 
goal: Semigroup (Finset α)

full_name: Finset.commSemigroup
code: /-- `Finset α` is a `CommSemigroup` under pointwise operations if `α` is. -/
@[to_additive "`Finset α` is an `AddCommSemigroup` under pointwise operations if `α` is. "]
protected def commSemigroup : CommSemigroup (Finset α) 
goal: CommSemigroup (Finset α)

full_name: Finset.addCommSemigroup
code: /-- `Finset α` is a `CommSemigroup` under pointwise operations if `α` is. -/
@[to_additive "`Finset α` is an `AddCommSemigroup` under pointwise operations if `α` is. "]
protected def commSemigroup : CommSemigroup (Finset α) 
goal: AddCommSemigroup (Finset α)

full_name: Finset.inter_mul_union_subset
code: @[to_additive]
theorem inter_mul_union_subset : s ∩ t * (s ∪ t) ⊆ s * t 
goal: s ∩ t * (s ∪ t) ⊆ s * t

full_name: Finset.inter_add_union_subset
code: @[to_additive]
theorem inter_mul_union_subset : s ∩ t * (s ∪ t) ⊆ s * t 
goal: s ∩ t + (s ∪ t) ⊆ s + t

full_name: Finset.union_add_inter_subset
code: @[to_additive]
theorem union_mul_inter_subset : (s ∪ t) * (s ∩ t) ⊆ s * t 
goal: s ∪ t + s ∩ t ⊆ s + t

full_name: Finset.union_mul_inter_subset
code: @[to_additive]
theorem union_mul_inter_subset : (s ∪ t) * (s ∩ t) ⊆ s * t 
goal: (s ∪ t) * (s ∩ t) ⊆ s * t

full_name: Finset.mulOneClass
code: /-- `Finset α` is a `MulOneClass` under pointwise operations if `α` is. -/
@[to_additive "`Finset α` is an `AddZeroClass` under pointwise operations if `α` is."]
protected def mulOneClass : MulOneClass (Finset α) 
goal: MulOneClass (Finset α)

full_name: Finset.addZeroClass
code: /-- `Finset α` is a `MulOneClass` under pointwise operations if `α` is. -/
@[to_additive "`Finset α` is an `AddZeroClass` under pointwise operations if `α` is."]
protected def mulOneClass : MulOneClass (Finset α) 
goal: AddZeroClass (Finset α)

full_name: Finset.subset_mul_left
code: @[to_additive]
theorem subset_mul_left (s : Finset α) {t : Finset α} (ht : (1 : α) ∈ t) : s ⊆ s * t 
goal: s ⊆ s * t

full_name: Finset.subset_add_left
code: @[to_additive]
theorem subset_mul_left (s : Finset α) {t : Finset α} (ht : (1 : α) ∈ t) : s ⊆ s * t 
goal: s ⊆ s + t

full_name: Finset.subset_mul_right
code: @[to_additive]
theorem subset_mul_right {s : Finset α} (t : Finset α) (hs : (1 : α) ∈ s) : t ⊆ s * t 
goal: t ⊆ s * t

full_name: Finset.subset_add_right
code: @[to_additive]
theorem subset_mul_right {s : Finset α} (t : Finset α) (hs : (1 : α) ∈ s) : t ⊆ s * t 
goal: t ⊆ s + t

full_name: Finset.singletonAddMonoidHom
code: /-- The singleton operation as a `MonoidHom`. -/
@[to_additive "The singleton operation as an `AddMonoidHom`."]
def singletonMonoidHom : α →* Finset α 
goal: α →+ Finset α

full_name: Finset.singletonMonoidHom
code: /-- The singleton operation as a `MonoidHom`. -/
@[to_additive "The singleton operation as an `AddMonoidHom`."]
def singletonMonoidHom : α →* Finset α 
goal: α →* Finset α

full_name: Finset.coe_singletonAddMonoidHom
code: @[to_additive (attr := simp)]
theorem coe_singletonMonoidHom : (singletonMonoidHom : α → Finset α) = singleton 
goal: ⇑Finset.singletonAddMonoidHom = singleton

full_name: Finset.coe_singletonMonoidHom
code: @[to_additive (attr := simp)]
theorem coe_singletonMonoidHom : (singletonMonoidHom : α → Finset α) = singleton 
goal: ⇑Finset.singletonMonoidHom = singleton

full_name: Finset.singletonMonoidHom_apply
code: @[to_additive (attr := simp)]
theorem singletonMonoidHom_apply (a : α) : singletonMonoidHom a = {a} 
goal: Finset.singletonMonoidHom a = {a}

full_name: Finset.singletonAddMonoidHom_apply
code: @[to_additive (attr := simp)]
theorem singletonMonoidHom_apply (a : α) : singletonMonoidHom a = {a} 
goal: Finset.singletonAddMonoidHom a = {a}

full_name: Finset.coeMonoidHom
code: /-- The coercion from `Finset` to `Set` as a `MonoidHom`. -/
@[to_additive "The coercion from `Finset` to `set` as an `AddMonoidHom`."]
noncomputable def coeMonoidHom : Finset α →* Set α 
goal: Finset α →* Set α

full_name: Finset.coeAddMonoidHom
code: /-- The coercion from `Finset` to `Set` as a `MonoidHom`. -/
@[to_additive "The coercion from `Finset` to `set` as an `AddMonoidHom`."]
noncomputable def coeMonoidHom : Finset α →* Set α 
goal: Finset α →+ Set α

full_name: Finset.coe_coeAddMonoidHom
code: @[to_additive (attr := simp)]
theorem coe_coeMonoidHom : (coeMonoidHom : Finset α → Set α) = CoeTC.coe 
goal: ⇑Finset.coeAddMonoidHom = CoeTC.coe

full_name: Finset.coe_coeMonoidHom
code: @[to_additive (attr := simp)]
theorem coe_coeMonoidHom : (coeMonoidHom : Finset α → Set α) = CoeTC.coe 
goal: ⇑Finset.coeMonoidHom = CoeTC.coe

full_name: Finset.coeMonoidHom_apply
code: @[to_additive (attr := simp)]
theorem coeMonoidHom_apply (s : Finset α) : coeMonoidHom s = s 
goal: Finset.coeMonoidHom s = ↑s

full_name: Finset.coeAddMonoidHom_apply
code: @[to_additive (attr := simp)]
theorem coeMonoidHom_apply (s : Finset α) : coeMonoidHom s = s 
goal: Finset.coeAddMonoidHom s = ↑s

full_name: Finset.imageMonoidHom
code: /-- Lift a `MonoidHom` to `Finset` via `image`. -/
@[to_additive (attr := simps) "Lift an `add_monoid_hom` to `Finset` via `image`"]
def imageMonoidHom [MulOneClass β] [FunLike F α β] [MonoidHomClass F α β] (f : F) :
    Finset α →* Finset β 
goal: Finset α →* Finset β

full_name: Finset.imageAddMonoidHom
code: /-- Lift a `MonoidHom` to `Finset` via `image`. -/
@[to_additive (attr := simps) "Lift an `add_monoid_hom` to `Finset` via `image`"]
def imageMonoidHom [MulOneClass β] [FunLike F α β] [MonoidHomClass F α β] (f : F) :
    Finset α →* Finset β 
goal: Finset α →+ Finset β

full_name: Finset.imageMonoidHom_apply
code: /-- Lift a `MonoidHom` to `Finset` via `image`. -/
@[to_additive (attr := simps) "Lift an `add_monoid_hom` to `Finset` via `image`"]
def imageMonoidHom [MulOneClass β] [FunLike F α β] [MonoidHomClass F α β] (f : F) :
    Finset α →* Finset β 
goal: ∀ (a : Finset α), (Finset.imageMonoidHom f) a = (Finset.imageMulHom f).toFun a

full_name: Finset.imageAddMonoidHom_apply
code: /-- Lift a `MonoidHom` to `Finset` via `image`. -/
@[to_additive (attr := simps) "Lift an `add_monoid_hom` to `Finset` via `image`"]
def imageMonoidHom [MulOneClass β] [FunLike F α β] [MonoidHomClass F α β] (f : F) :
    Finset α →* Finset β 
goal: ∀ (a : Finset α), (Finset.imageAddMonoidHom f) a = (Finset.imageAddHom f).toFun a

full_name: Finset.coe_nsmul
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_pow (s : Finset α) (n : ℕ) : ↑(s ^ n) = (s : Set α) ^ n 
goal: ↑(n • s) = n • ↑s

full_name: Finset.coe_pow
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_pow (s : Finset α) (n : ℕ) : ↑(s ^ n) = (s : Set α) ^ n 
goal: ↑(s ^ n) = ↑s ^ n

full_name: Finset.addMonoid
code: /-- `Finset α` is a `Monoid` under pointwise operations if `α` is. -/
@[to_additive "`Finset α` is an `AddMonoid` under pointwise operations if `α` is. "]
protected def monoid : Monoid (Finset α) 
goal: AddMonoid (Finset α)

full_name: Finset.monoid
code: /-- `Finset α` is a `Monoid` under pointwise operations if `α` is. -/
@[to_additive "`Finset α` is an `AddMonoid` under pointwise operations if `α` is. "]
protected def monoid : Monoid (Finset α) 
goal: Monoid (Finset α)

full_name: Finset.pow_mem_pow
code: @[to_additive]
theorem pow_mem_pow (ha : a ∈ s) : ∀ n : ℕ, a ^ n ∈ s ^ n
  
goal: a ^ n ∈ s ^ n

full_name: Finset.nsmul_mem_nsmul
code: @[to_additive]
theorem pow_mem_pow (ha : a ∈ s) : ∀ n : ℕ, a ^ n ∈ s ^ n
  
goal: n • a ∈ n • s

full_name: Finset.pow_subset_pow
code: @[to_additive]
theorem pow_subset_pow (hst : s ⊆ t) : ∀ n : ℕ, s ^ n ⊆ t ^ n
  
goal: s ^ n ⊆ t ^ n

full_name: Finset.nsmul_subset_nsmul
code: @[to_additive]
theorem pow_subset_pow (hst : s ⊆ t) : ∀ n : ℕ, s ^ n ⊆ t ^ n
  
goal: n • s ⊆ n • t

full_name: Finset.nsmul_subset_nsmul_of_zero_mem
code: @[to_additive]
theorem pow_subset_pow_of_one_mem (hs : (1 : α) ∈ s) : m ≤ n → s ^ m ⊆ s ^ n 
goal: m ≤ n → m • s ⊆ n • s

full_name: Finset.pow_subset_pow_of_one_mem
code: @[to_additive]
theorem pow_subset_pow_of_one_mem (hs : (1 : α) ∈ s) : m ≤ n → s ^ m ⊆ s ^ n 
goal: m ≤ n → s ^ m ⊆ s ^ n

full_name: Finset.coe_list_prod
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_list_prod (s : List (Finset α)) : (↑s.prod : Set α) = (s.map (↑)).prod 
goal: ↑s.prod = (List.map Finset.toSet s).prod

full_name: Finset.coe_list_sum
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_list_prod (s : List (Finset α)) : (↑s.prod : Set α) = (s.map (↑)).prod 
goal: ↑s.sum = (List.map Finset.toSet s).sum

full_name: Finset.mem_prod_list_ofFn
code: @[to_additive]
theorem mem_prod_list_ofFn {a : α} {s : Fin n → Finset α} :
    a ∈ (List.ofFn s).prod ↔ ∃ f : ∀ i : Fin n, s i, (List.ofFn fun i => (f i : α)).prod = a 
goal: a ∈ (List.ofFn s).prod ↔ ∃ f, (List.ofFn fun i => ↑(f i)).prod = a

full_name: Finset.mem_sum_list_ofFn
code: @[to_additive]
theorem mem_prod_list_ofFn {a : α} {s : Fin n → Finset α} :
    a ∈ (List.ofFn s).prod ↔ ∃ f : ∀ i : Fin n, s i, (List.ofFn fun i => (f i : α)).prod = a 
goal: a ∈ (List.ofFn s).sum ↔ ∃ f, (List.ofFn fun i => ↑(f i)).sum = a

full_name: Finset.mem_pow
code: @[to_additive]
theorem mem_pow {a : α} {n : ℕ} :
    a ∈ s ^ n ↔ ∃ f : Fin n → s, (List.ofFn fun i => ↑(f i)).prod = a 
goal: a ∈ s ^ n ↔ ∃ f, (List.ofFn fun i => ↑(f i)).prod = a

full_name: Finset.mem_nsmul
code: @[to_additive]
theorem mem_pow {a : α} {n : ℕ} :
    a ∈ s ^ n ↔ ∃ f : Fin n → s, (List.ofFn fun i => ↑(f i)).prod = a 
goal: a ∈ n • s ↔ ∃ f, (List.ofFn fun i => ↑(f i)).sum = a

full_name: Finset.empty_nsmul
code: @[to_additive (attr := simp)]
theorem empty_pow (hn : n ≠ 0) : (∅ : Finset α) ^ n = ∅ 
goal: n • ∅ = ∅

full_name: Finset.empty_pow
code: @[to_additive (attr := simp)]
theorem empty_pow (hn : n ≠ 0) : (∅ : Finset α) ^ n = ∅ 
goal: ∅ ^ n = ∅

full_name: Finset.add_univ_of_zero_mem
code: @[to_additive]
theorem mul_univ_of_one_mem [Fintype α] (hs : (1 : α) ∈ s) : s * univ = univ 
goal: s + Finset.univ = Finset.univ

full_name: Finset.mul_univ_of_one_mem
code: @[to_additive]
theorem mul_univ_of_one_mem [Fintype α] (hs : (1 : α) ∈ s) : s * univ = univ 
goal: s * Finset.univ = Finset.univ

full_name: Finset.univ_mul_of_one_mem
code: @[to_additive]
theorem univ_mul_of_one_mem [Fintype α] (ht : (1 : α) ∈ t) : univ * t = univ 
goal: Finset.univ * t = Finset.univ

full_name: Finset.univ_add_of_zero_mem
code: @[to_additive]
theorem univ_mul_of_one_mem [Fintype α] (ht : (1 : α) ∈ t) : univ * t = univ 
goal: Finset.univ + t = Finset.univ

full_name: Finset.univ_add_univ
code: @[to_additive (attr := simp)]
theorem univ_mul_univ [Fintype α] : (univ : Finset α) * univ = univ 
goal: Finset.univ + Finset.univ = Finset.univ

full_name: Finset.univ_mul_univ
code: @[to_additive (attr := simp)]
theorem univ_mul_univ [Fintype α] : (univ : Finset α) * univ = univ 
goal: Finset.univ * Finset.univ = Finset.univ

full_name: Finset.univ_pow
code: @[to_additive (attr := simp) nsmul_univ]
theorem univ_pow [Fintype α] (hn : n ≠ 0) : (univ : Finset α) ^ n = univ 
goal: Finset.univ ^ n = Finset.univ

full_name: Finset.nsmul_univ
code: @[to_additive (attr := simp) nsmul_univ]
theorem univ_pow [Fintype α] (hn : n ≠ 0) : (univ : Finset α) ^ n = univ 
goal: n • Finset.univ = Finset.univ

full_name: IsUnit.finset
code: @[to_additive]
protected theorem _root_.IsUnit.finset : IsUnit a → IsUnit ({a} : Finset α) 
goal: IsUnit a → IsUnit {a}

full_name: IsAddUnit.finset
code: @[to_additive]
protected theorem _root_.IsUnit.finset : IsUnit a → IsUnit ({a} : Finset α) 
goal: IsAddUnit a → IsAddUnit {a}

full_name: Finset.addCommMonoid
code: /-- `Finset α` is a `CommMonoid` under pointwise operations if `α` is. -/
@[to_additive "`Finset α` is an `AddCommMonoid` under pointwise operations if `α` is. "]
protected def commMonoid : CommMonoid (Finset α) 
goal: AddCommMonoid (Finset α)

full_name: Finset.commMonoid
code: /-- `Finset α` is a `CommMonoid` under pointwise operations if `α` is. -/
@[to_additive "`Finset α` is an `AddCommMonoid` under pointwise operations if `α` is. "]
protected def commMonoid : CommMonoid (Finset α) 
goal: CommMonoid (Finset α)

full_name: Finset.coe_sum
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_prod {ι : Type*} (s : Finset ι) (f : ι → Finset α) :
    ↑(∏ i ∈ s, f i) = ∏ i ∈ s, (f i : Set α) 
goal: ↑(∑ i ∈ s, f i) = ∑ i ∈ s, ↑(f i)

full_name: Finset.coe_prod
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_prod {ι : Type*} (s : Finset ι) (f : ι → Finset α) :
    ↑(∏ i ∈ s, f i) = ∏ i ∈ s, (f i : Set α) 
goal: ↑(∏ i ∈ s, f i) = ∏ i ∈ s, ↑(f i)

full_name: Finset.coe_zpow
code: @[to_additive (attr := simp)]
theorem coe_zpow (s : Finset α) : ∀ n : ℤ, ↑(s ^ n) = (s : Set α) ^ n
  
goal: ↑(s ^ n) = ↑s ^ n

full_name: Finset.coe_zsmul
code: @[to_additive (attr := simp)]
theorem coe_zpow (s : Finset α) : ∀ n : ℤ, ↑(s ^ n) = (s : Set α) ^ n
  
goal: ↑(n • s) = n • ↑s

full_name: Finset.mul_eq_one_iff
code: @[to_additive]
protected theorem mul_eq_one_iff : s * t = 1 ↔ ∃ a b, s = {a} ∧ t = {b} ∧ a * b = 1 
goal: s * t = 1 ↔ ∃ a b, s = {a} ∧ t = {b} ∧ a * b = 1

full_name: Finset.add_eq_zero_iff
code: @[to_additive]
protected theorem mul_eq_one_iff : s * t = 1 ↔ ∃ a b, s = {a} ∧ t = {b} ∧ a * b = 1 
goal: s + t = 0 ↔ ∃ a b, s = {a} ∧ t = {b} ∧ a + b = 0

full_name: Finset.divisionMonoid
code: /-- `Finset α` is a division monoid under pointwise operations if `α` is. -/
@[to_additive subtractionMonoid
  "`Finset α` is a subtraction monoid under pointwise operations if `α` is."]
protected def divisionMonoid : DivisionMonoid (Finset α) 
goal: DivisionMonoid (Finset α)

full_name: Finset.subtractionMonoid
code: /-- `Finset α` is a division monoid under pointwise operations if `α` is. -/
@[to_additive subtractionMonoid
  "`Finset α` is a subtraction monoid under pointwise operations if `α` is."]
protected def divisionMonoid : DivisionMonoid (Finset α) 
goal: SubtractionMonoid (Finset α)

full_name: Finset.isUnit_iff
code: @[to_additive (attr := simp)]
theorem isUnit_iff : IsUnit s ↔ ∃ a, s = {a} ∧ IsUnit a 
goal: IsUnit s ↔ ∃ a, s = {a} ∧ IsUnit a

full_name: Finset.isAddUnit_iff
code: @[to_additive (attr := simp)]
theorem isUnit_iff : IsUnit s ↔ ∃ a, s = {a} ∧ IsUnit a 
goal: IsAddUnit s ↔ ∃ a, s = {a} ∧ IsAddUnit a

full_name: Finset.isUnit_coe
code: @[to_additive (attr := simp)]
theorem isUnit_coe : IsUnit (s : Set α) ↔ IsUnit s 
goal: IsUnit ↑s ↔ IsUnit s

full_name: Finset.isAddUnit_coe
code: @[to_additive (attr := simp)]
theorem isUnit_coe : IsUnit (s : Set α) ↔ IsUnit s 
goal: IsAddUnit ↑s ↔ IsAddUnit s

full_name: Finset.univ_sub_univ
code: @[to_additive (attr := simp)]
lemma univ_div_univ [Fintype α] : (univ / univ : Finset α) = univ 
goal: Finset.univ - Finset.univ = Finset.univ

full_name: Finset.univ_div_univ
code: @[to_additive (attr := simp)]
lemma univ_div_univ [Fintype α] : (univ / univ : Finset α) = univ 
goal: Finset.univ / Finset.univ = Finset.univ

full_name: Finset.divisionCommMonoid
code: /-- `Finset α` is a commutative division monoid under pointwise operations if `α` is. -/
@[to_additive subtractionCommMonoid
      "`Finset α` is a commutative subtraction monoid under pointwise operations if `α` is."]
protected def divisionCommMonoid [DivisionCommMonoid α] : DivisionCommMonoid (Finset α) 
goal: DivisionCommMonoid (Finset α)

full_name: Finset.subtractionCommMonoid
code: /-- `Finset α` is a commutative division monoid under pointwise operations if `α` is. -/
@[to_additive subtractionCommMonoid
      "`Finset α` is a commutative subtraction monoid under pointwise operations if `α` is."]
protected def divisionCommMonoid [DivisionCommMonoid α] : DivisionCommMonoid (Finset α) 
goal: SubtractionCommMonoid (Finset α)

full_name: Finset.distribNeg
code: /-- `Finset α` has distributive negation if `α` has. -/
protected def distribNeg [Mul α] [HasDistribNeg α] : HasDistribNeg (Finset α) 
goal: HasDistribNeg (Finset α)

full_name: Finset.mul_add_subset
code: theorem mul_add_subset : s * (t + u) ⊆ s * t + s * u 
goal: s * (t + u) ⊆ s * t + s * u

full_name: Finset.add_mul_subset
code: theorem add_mul_subset : (s + t) * u ⊆ s * u + t * u 
goal: (s + t) * u ⊆ s * u + t * u

full_name: Finset.mul_zero_subset
code: theorem mul_zero_subset (s : Finset α) : s * 0 ⊆ 0 
goal: s * 0 ⊆ 0

full_name: Finset.zero_mul_subset
code: theorem zero_mul_subset (s : Finset α) : 0 * s ⊆ 0 
goal: 0 * s ⊆ 0

full_name: Finset.Nonempty.mul_zero
code: theorem Nonempty.mul_zero (hs : s.Nonempty) : s * 0 = 0 
goal: s * 0 = 0

full_name: Finset.Nonempty.zero_mul
code: theorem Nonempty.zero_mul (hs : s.Nonempty) : 0 * s = 0 
goal: 0 * s = 0

full_name: Finset.zero_mem_sub_iff
code: @[to_additive (attr := simp)]
theorem one_mem_div_iff : (1 : α) ∈ s / t ↔ ¬Disjoint s t 
goal: 0 ∈ s - t ↔ ¬Disjoint s t

full_name: Finset.one_mem_div_iff
code: @[to_additive (attr := simp)]
theorem one_mem_div_iff : (1 : α) ∈ s / t ↔ ¬Disjoint s t 
goal: 1 ∈ s / t ↔ ¬Disjoint s t

full_name: Finset.not_zero_mem_sub_iff
code: @[to_additive]
theorem not_one_mem_div_iff : (1 : α) ∉ s / t ↔ Disjoint s t 
goal: 0 ∉ s - t ↔ Disjoint s t

full_name: Finset.not_one_mem_div_iff
code: @[to_additive]
theorem not_one_mem_div_iff : (1 : α) ∉ s / t ↔ Disjoint s t 
goal: 1 ∉ s / t ↔ Disjoint s t

full_name: Finset.Nonempty.one_mem_div
code: @[to_additive]
theorem Nonempty.one_mem_div (h : s.Nonempty) : (1 : α) ∈ s / s 
goal: 1 ∈ s / s

full_name: Finset.Nonempty.zero_mem_sub
code: @[to_additive]
theorem Nonempty.one_mem_div (h : s.Nonempty) : (1 : α) ∈ s / s 
goal: 0 ∈ s - s

full_name: Finset.isUnit_singleton
code: @[to_additive]
theorem isUnit_singleton (a : α) : IsUnit ({a} : Finset α) 
goal: IsUnit {a}

full_name: Finset.isAddUnit_singleton
code: @[to_additive]
theorem isUnit_singleton (a : α) : IsUnit ({a} : Finset α) 
goal: IsAddUnit {a}

full_name: Finset.isUnit_iff_singleton
code: theorem isUnit_iff_singleton : IsUnit s ↔ ∃ a, s = {a} 
goal: IsUnit s ↔ ∃ a, s = {a}

full_name: Finset.isUnit_iff_singleton_aux
code: @[simp]
theorem isUnit_iff_singleton_aux : (∃ a, s = {a} ∧ IsUnit a) ↔ ∃ a, s = {a} 
goal: (∃ a, s = {a} ∧ IsUnit a) ↔ ∃ a, s = {a}

full_name: Finset.image_mul_left
code: @[to_additive (attr := simp)]
theorem image_mul_left :
    image (fun b => a * b) t = preimage t (fun b => a⁻¹ * b) (mul_right_injective _).injOn 
goal: Finset.image (fun b => a * b) t = t.preimage (fun b => a⁻¹ * b) ⋯

full_name: Finset.image_add_left
code: @[to_additive (attr := simp)]
theorem image_mul_left :
    image (fun b => a * b) t = preimage t (fun b => a⁻¹ * b) (mul_right_injective _).injOn 
goal: Finset.image (fun b => a + b) t = t.preimage (fun b => -a + b) ⋯

full_name: Finset.image_add_right
code: @[to_additive (attr := simp)]
theorem image_mul_right : image (· * b) t = preimage t (· * b⁻¹) (mul_left_injective _).injOn 
goal: Finset.image (fun x => x + b) t = t.preimage (fun x => x + -b) ⋯

full_name: Finset.image_mul_right
code: @[to_additive (attr := simp)]
theorem image_mul_right : image (· * b) t = preimage t (· * b⁻¹) (mul_left_injective _).injOn 
goal: Finset.image (fun x => x * b) t = t.preimage (fun x => x * b⁻¹) ⋯

full_name: Finset.image_mul_left'
code: @[to_additive]
theorem image_mul_left' :
    image (fun b => a⁻¹ * b) t = preimage t (fun b => a * b) (mul_right_injective _).injOn 
goal: Finset.image (fun b => a⁻¹ * b) t = t.preimage (fun b => a * b) ⋯

full_name: Finset.image_add_left'
code: @[to_additive]
theorem image_mul_left' :
    image (fun b => a⁻¹ * b) t = preimage t (fun b => a * b) (mul_right_injective _).injOn 
goal: Finset.image (fun b => -a + b) t = t.preimage (fun b => a + b) ⋯

full_name: Finset.image_mul_right'
code: @[to_additive]
theorem image_mul_right' :
    image (· * b⁻¹) t = preimage t (· * b) (mul_left_injective _).injOn 
goal: Finset.image (fun x => x * b⁻¹) t = t.preimage (fun x => x * b) ⋯

full_name: Finset.image_add_right'
code: @[to_additive]
theorem image_mul_right' :
    image (· * b⁻¹) t = preimage t (· * b) (mul_left_injective _).injOn 
goal: Finset.image (fun x => x + -b) t = t.preimage (fun x => x + b) ⋯

full_name: Finset.image_div
code: theorem image_div : (s / t).image (f : α → β) = s.image f / t.image f 
goal: Finset.image (⇑f) (s / t) = Finset.image (⇑f) s / Finset.image (⇑f) t

full_name: Finset.div_zero_subset
code: theorem div_zero_subset (s : Finset α) : s / 0 ⊆ 0 
goal: s / 0 ⊆ 0

full_name: Finset.zero_div_subset
code: theorem zero_div_subset (s : Finset α) : 0 / s ⊆ 0 
goal: 0 / s ⊆ 0

full_name: Finset.Nonempty.div_zero
code: theorem Nonempty.div_zero (hs : s.Nonempty) : s / 0 = 0 
goal: s / 0 = 0

full_name: Finset.Nonempty.zero_div
code: theorem Nonempty.zero_div (hs : s.Nonempty) : 0 / s = 0 
goal: 0 / s = 0

full_name: Finset.preimage_add_left_singleton
code: @[to_additive (attr := simp)]
theorem preimage_mul_left_singleton :
    preimage {b} (a * ·) (mul_right_injective _).injOn = {a⁻¹ * b} 
goal: {b}.preimage (fun x => a + x) ⋯ = {-a + b}

full_name: Finset.preimage_mul_left_singleton
code: @[to_additive (attr := simp)]
theorem preimage_mul_left_singleton :
    preimage {b} (a * ·) (mul_right_injective _).injOn = {a⁻¹ * b} 
goal: {b}.preimage (fun x => a * x) ⋯ = {a⁻¹ * b}

full_name: Finset.preimage_mul_right_singleton
code: @[to_additive (attr := simp)]
theorem preimage_mul_right_singleton :
    preimage {b} (· * a) (mul_left_injective _).injOn = {b * a⁻¹} 
goal: {b}.preimage (fun x => x * a) ⋯ = {b * a⁻¹}

full_name: Finset.preimage_add_right_singleton
code: @[to_additive (attr := simp)]
theorem preimage_mul_right_singleton :
    preimage {b} (· * a) (mul_left_injective _).injOn = {b * a⁻¹} 
goal: {b}.preimage (fun x => x + a) ⋯ = {b + -a}

full_name: Finset.preimage_mul_left_one
code: @[to_additive (attr := simp)]
theorem preimage_mul_left_one : preimage 1 (a * ·) (mul_right_injective _).injOn = {a⁻¹} 
goal: Finset.preimage 1 (fun x => a * x) ⋯ = {a⁻¹}

full_name: Finset.preimage_add_left_zero
code: @[to_additive (attr := simp)]
theorem preimage_mul_left_one : preimage 1 (a * ·) (mul_right_injective _).injOn = {a⁻¹} 
goal: Finset.preimage 0 (fun x => a + x) ⋯ = {-a}

full_name: Finset.preimage_mul_right_one
code: @[to_additive (attr := simp)]
theorem preimage_mul_right_one : preimage 1 (· * b) (mul_left_injective _).injOn = {b⁻¹} 
goal: Finset.preimage 1 (fun x => x * b) ⋯ = {b⁻¹}

full_name: Finset.preimage_add_right_zero
code: @[to_additive (attr := simp)]
theorem preimage_mul_right_one : preimage 1 (· * b) (mul_left_injective _).injOn = {b⁻¹} 
goal: Finset.preimage 0 (fun x => x + b) ⋯ = {-b}

full_name: Finset.preimage_mul_left_one'
code: @[to_additive]
theorem preimage_mul_left_one' : preimage 1 (a⁻¹ * ·) (mul_right_injective _).injOn = {a} 
goal: Finset.preimage 1 (fun x => a⁻¹ * x) ⋯ = {a}

full_name: Finset.preimage_add_left_zero'
code: @[to_additive]
theorem preimage_mul_left_one' : preimage 1 (a⁻¹ * ·) (mul_right_injective _).injOn = {a} 
goal: Finset.preimage 0 (fun x => -a + x) ⋯ = {a}

full_name: Finset.preimage_mul_right_one'
code: @[to_additive]
theorem preimage_mul_right_one' : preimage 1 (· * b⁻¹) (mul_left_injective _).injOn = {b} 
goal: Finset.preimage 1 (fun x => x * b⁻¹) ⋯ = {b}

full_name: Finset.preimage_add_right_zero'
code: @[to_additive]
theorem preimage_mul_right_one' : preimage 1 (· * b⁻¹) (mul_left_injective _).injOn = {b} 
goal: Finset.preimage 0 (fun x => x + -b) ⋯ = {b}

full_name: Finset.smul
code: /-- The pointwise product of two finsets `s` and `t`: `s • t = {x • y | x ∈ s, y ∈ t}`. -/
@[to_additive "The pointwise sum of two finsets `s` and `t`: `s +ᵥ t = {x +ᵥ y | x ∈ s, y ∈ t}`."]
protected def smul : SMul (Finset α) (Finset β) 
goal: SMul (Finset α) (Finset β)

full_name: Finset.vadd
code: /-- The pointwise product of two finsets `s` and `t`: `s • t = {x • y | x ∈ s, y ∈ t}`. -/
@[to_additive "The pointwise sum of two finsets `s` and `t`: `s +ᵥ t = {x +ᵥ y | x ∈ s, y ∈ t}`."]
protected def smul : SMul (Finset α) (Finset β) 
goal: VAdd (Finset α) (Finset β)

full_name: Finset.vadd_def
code: @[to_additive]
theorem smul_def : s • t = (s ×ˢ t).image fun p : α × β => p.1 • p.2 
goal: s +ᵥ t = Finset.image (fun p => p.1 +ᵥ p.2) (s ×ˢ t)

full_name: Finset.smul_def
code: @[to_additive]
theorem smul_def : s • t = (s ×ˢ t).image fun p : α × β => p.1 • p.2 
goal: s • t = Finset.image (fun p => p.1 • p.2) (s ×ˢ t)

full_name: Finset.image_vadd_product
code: @[to_additive]
theorem image_smul_product : ((s ×ˢ t).image fun x : α × β => x.fst • x.snd) = s • t 
goal: Finset.image (fun x => x.1 +ᵥ x.2) (s ×ˢ t) = s +ᵥ t

full_name: Finset.image_smul_product
code: @[to_additive]
theorem image_smul_product : ((s ×ˢ t).image fun x : α × β => x.fst • x.snd) = s • t 
goal: Finset.image (fun x => x.1 • x.2) (s ×ˢ t) = s • t

full_name: Finset.mem_vadd
code: @[to_additive]
theorem mem_smul {x : β} : x ∈ s • t ↔ ∃ y ∈ s, ∃ z ∈ t, y • z = x 
goal: x ∈ s +ᵥ t ↔ ∃ y ∈ s, ∃ z ∈ t, y +ᵥ z = x

full_name: Finset.mem_smul
code: @[to_additive]
theorem mem_smul {x : β} : x ∈ s • t ↔ ∃ y ∈ s, ∃ z ∈ t, y • z = x 
goal: x ∈ s • t ↔ ∃ y ∈ s, ∃ z ∈ t, y • z = x

full_name: Finset.coe_smul
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_smul (s : Finset α) (t : Finset β) : ↑(s • t) = (s : Set α) • (t : Set β) 
goal: ↑(s • t) = ↑s • ↑t

full_name: Finset.coe_vadd
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_smul (s : Finset α) (t : Finset β) : ↑(s • t) = (s : Set α) • (t : Set β) 
goal: ↑(s +ᵥ t) = ↑s +ᵥ ↑t

full_name: Finset.smul_mem_smul
code: @[to_additive]
theorem smul_mem_smul : a ∈ s → b ∈ t → a • b ∈ s • t 
goal: a ∈ s → b ∈ t → a • b ∈ s • t

full_name: Finset.vadd_mem_vadd
code: @[to_additive]
theorem smul_mem_smul : a ∈ s → b ∈ t → a • b ∈ s • t 
goal: a ∈ s → b ∈ t → a +ᵥ b ∈ s +ᵥ t

full_name: Finset.vadd_card_le
code: @[to_additive]
theorem smul_card_le : (s • t).card ≤ s.card • t.card 
goal: (s +ᵥ t).card ≤ s.card • t.card

full_name: Finset.smul_card_le
code: @[to_additive]
theorem smul_card_le : (s • t).card ≤ s.card • t.card 
goal: (s • t).card ≤ s.card • t.card

full_name: Finset.empty_smul
code: @[to_additive (attr := simp)]
theorem empty_smul (t : Finset β) : (∅ : Finset α) • t = ∅ 
goal: ∅ • t = ∅

full_name: Finset.empty_vadd
code: @[to_additive (attr := simp)]
theorem empty_smul (t : Finset β) : (∅ : Finset α) • t = ∅ 
goal: ∅ +ᵥ t = ∅

full_name: Finset.vadd_empty
code: @[to_additive (attr := simp)]
theorem smul_empty (s : Finset α) : s • (∅ : Finset β) = ∅ 
goal: s +ᵥ ∅ = ∅

full_name: Finset.smul_empty
code: @[to_additive (attr := simp)]
theorem smul_empty (s : Finset α) : s • (∅ : Finset β) = ∅ 
goal: s • ∅ = ∅

full_name: Finset.vadd_eq_empty
code: @[to_additive (attr := simp)]
theorem smul_eq_empty : s • t = ∅ ↔ s = ∅ ∨ t = ∅ 
goal: s +ᵥ t = ∅ ↔ s = ∅ ∨ t = ∅

full_name: Finset.smul_eq_empty
code: @[to_additive (attr := simp)]
theorem smul_eq_empty : s • t = ∅ ↔ s = ∅ ∨ t = ∅ 
goal: s • t = ∅ ↔ s = ∅ ∨ t = ∅

full_name: Finset.vadd_nonempty_iff
code: @[to_additive (attr := simp, aesop safe apply (rule_sets := [finsetNonempty]))]
theorem smul_nonempty_iff : (s • t).Nonempty ↔ s.Nonempty ∧ t.Nonempty 
goal: (s +ᵥ t).Nonempty ↔ s.Nonempty ∧ t.Nonempty

full_name: Finset.smul_nonempty_iff
code: @[to_additive (attr := simp, aesop safe apply (rule_sets := [finsetNonempty]))]
theorem smul_nonempty_iff : (s • t).Nonempty ↔ s.Nonempty ∧ t.Nonempty 
goal: (s • t).Nonempty ↔ s.Nonempty ∧ t.Nonempty

full_name: Finset.Nonempty.vadd
code: @[to_additive]
theorem Nonempty.smul : s.Nonempty → t.Nonempty → (s • t).Nonempty 
goal: s.Nonempty → t.Nonempty → (s +ᵥ t).Nonempty

full_name: Finset.Nonempty.smul
code: @[to_additive]
theorem Nonempty.smul : s.Nonempty → t.Nonempty → (s • t).Nonempty 
goal: s.Nonempty → t.Nonempty → (s • t).Nonempty

full_name: Finset.Nonempty.of_vadd_left
code: @[to_additive]
theorem Nonempty.of_smul_left : (s • t).Nonempty → s.Nonempty 
goal: (s +ᵥ t).Nonempty → s.Nonempty

full_name: Finset.Nonempty.of_smul_left
code: @[to_additive]
theorem Nonempty.of_smul_left : (s • t).Nonempty → s.Nonempty 
goal: (s • t).Nonempty → s.Nonempty

full_name: Finset.Nonempty.of_smul_right
code: @[to_additive]
theorem Nonempty.of_smul_right : (s • t).Nonempty → t.Nonempty 
goal: (s • t).Nonempty → t.Nonempty

full_name: Finset.Nonempty.of_vadd_right
code: @[to_additive]
theorem Nonempty.of_smul_right : (s • t).Nonempty → t.Nonempty 
goal: (s +ᵥ t).Nonempty → t.Nonempty

full_name: Finset.vadd_singleton
code: @[to_additive]
theorem smul_singleton (b : β) : s • ({b} : Finset β) = s.image (· • b) 
goal: s +ᵥ {b} = Finset.image (fun x => x +ᵥ b) s

full_name: Finset.smul_singleton
code: @[to_additive]
theorem smul_singleton (b : β) : s • ({b} : Finset β) = s.image (· • b) 
goal: s • {b} = Finset.image (fun x => x • b) s

full_name: Finset.singleton_smul_singleton
code: @[to_additive]
theorem singleton_smul_singleton (a : α) (b : β) : ({a} : Finset α) • ({b} : Finset β) = {a • b} 
goal: {a} • {b} = {a • b}

full_name: Finset.singleton_vadd_singleton
code: @[to_additive]
theorem singleton_smul_singleton (a : α) (b : β) : ({a} : Finset α) • ({b} : Finset β) = {a • b} 
goal: {a} +ᵥ {b} = {a +ᵥ b}

full_name: Finset.vadd_subset_vadd
code: @[to_additive (attr := mono)]
theorem smul_subset_smul : s₁ ⊆ s₂ → t₁ ⊆ t₂ → s₁ • t₁ ⊆ s₂ • t₂ 
goal: s₁ ⊆ s₂ → t₁ ⊆ t₂ → s₁ +ᵥ t₁ ⊆ s₂ +ᵥ t₂

full_name: Finset.smul_subset_smul
code: @[to_additive (attr := mono)]
theorem smul_subset_smul : s₁ ⊆ s₂ → t₁ ⊆ t₂ → s₁ • t₁ ⊆ s₂ • t₂ 
goal: s₁ ⊆ s₂ → t₁ ⊆ t₂ → s₁ • t₁ ⊆ s₂ • t₂

full_name: Finset.smul_subset_smul_left
code: @[to_additive]
theorem smul_subset_smul_left : t₁ ⊆ t₂ → s • t₁ ⊆ s • t₂ 
goal: t₁ ⊆ t₂ → s • t₁ ⊆ s • t₂

full_name: Finset.vadd_subset_vadd_left
code: @[to_additive]
theorem smul_subset_smul_left : t₁ ⊆ t₂ → s • t₁ ⊆ s • t₂ 
goal: t₁ ⊆ t₂ → s +ᵥ t₁ ⊆ s +ᵥ t₂

full_name: Finset.vadd_subset_vadd_right
code: @[to_additive]
theorem smul_subset_smul_right : s₁ ⊆ s₂ → s₁ • t ⊆ s₂ • t 
goal: s₁ ⊆ s₂ → s₁ +ᵥ t ⊆ s₂ +ᵥ t

full_name: Finset.smul_subset_smul_right
code: @[to_additive]
theorem smul_subset_smul_right : s₁ ⊆ s₂ → s₁ • t ⊆ s₂ • t 
goal: s₁ ⊆ s₂ → s₁ • t ⊆ s₂ • t

full_name: Finset.smul_subset_iff
code: @[to_additive]
theorem smul_subset_iff : s • t ⊆ u ↔ ∀ a ∈ s, ∀ b ∈ t, a • b ∈ u 
goal: s • t ⊆ u ↔ ∀ a ∈ s, ∀ b ∈ t, a • b ∈ u

full_name: Finset.vadd_subset_iff
code: @[to_additive]
theorem smul_subset_iff : s • t ⊆ u ↔ ∀ a ∈ s, ∀ b ∈ t, a • b ∈ u 
goal: s +ᵥ t ⊆ u ↔ ∀ a ∈ s, ∀ b ∈ t, a +ᵥ b ∈ u

full_name: Finset.union_smul
code: @[to_additive]
theorem union_smul [DecidableEq α] : (s₁ ∪ s₂) • t = s₁ • t ∪ s₂ • t 
goal: (s₁ ∪ s₂) • t = s₁ • t ∪ s₂ • t

full_name: Finset.union_vadd
code: @[to_additive]
theorem union_smul [DecidableEq α] : (s₁ ∪ s₂) • t = s₁ • t ∪ s₂ • t 
goal: s₁ ∪ s₂ +ᵥ t = s₁ +ᵥ t ∪ (s₂ +ᵥ t)

full_name: Finset.vadd_union
code: @[to_additive]
theorem smul_union : s • (t₁ ∪ t₂) = s • t₁ ∪ s • t₂ 
goal: s +ᵥ (t₁ ∪ t₂) = s +ᵥ t₁ ∪ (s +ᵥ t₂)

full_name: Finset.smul_union
code: @[to_additive]
theorem smul_union : s • (t₁ ∪ t₂) = s • t₁ ∪ s • t₂ 
goal: s • (t₁ ∪ t₂) = s • t₁ ∪ s • t₂

full_name: Finset.inter_vadd_subset
code: @[to_additive]
theorem inter_smul_subset [DecidableEq α] : (s₁ ∩ s₂) • t ⊆ s₁ • t ∩ s₂ • t 
goal: s₁ ∩ s₂ +ᵥ t ⊆ (s₁ +ᵥ t) ∩ (s₂ +ᵥ t)

full_name: Finset.inter_smul_subset
code: @[to_additive]
theorem inter_smul_subset [DecidableEq α] : (s₁ ∩ s₂) • t ⊆ s₁ • t ∩ s₂ • t 
goal: (s₁ ∩ s₂) • t ⊆ s₁ • t ∩ s₂ • t

full_name: Finset.vadd_inter_subset
code: @[to_additive]
theorem smul_inter_subset : s • (t₁ ∩ t₂) ⊆ s • t₁ ∩ s • t₂ 
goal: s +ᵥ t₁ ∩ t₂ ⊆ (s +ᵥ t₁) ∩ (s +ᵥ t₂)

full_name: Finset.smul_inter_subset
code: @[to_additive]
theorem smul_inter_subset : s • (t₁ ∩ t₂) ⊆ s • t₁ ∩ s • t₂ 
goal: s • (t₁ ∩ t₂) ⊆ s • t₁ ∩ s • t₂

full_name: Finset.inter_vadd_union_subset_union
code: @[to_additive]
theorem inter_smul_union_subset_union [DecidableEq α] : (s₁ ∩ s₂) • (t₁ ∪ t₂) ⊆ s₁ • t₁ ∪ s₂ • t₂ 
goal: s₁ ∩ s₂ +ᵥ (t₁ ∪ t₂) ⊆ s₁ +ᵥ t₁ ∪ (s₂ +ᵥ t₂)

full_name: Finset.inter_smul_union_subset_union
code: @[to_additive]
theorem inter_smul_union_subset_union [DecidableEq α] : (s₁ ∩ s₂) • (t₁ ∪ t₂) ⊆ s₁ • t₁ ∪ s₂ • t₂ 
goal: (s₁ ∩ s₂) • (t₁ ∪ t₂) ⊆ s₁ • t₁ ∪ s₂ • t₂

full_name: Finset.union_vadd_inter_subset_union
code: @[to_additive]
theorem union_smul_inter_subset_union [DecidableEq α] : (s₁ ∪ s₂) • (t₁ ∩ t₂) ⊆ s₁ • t₁ ∪ s₂ • t₂ 
goal: s₁ ∪ s₂ +ᵥ t₁ ∩ t₂ ⊆ s₁ +ᵥ t₁ ∪ (s₂ +ᵥ t₂)

full_name: Finset.union_smul_inter_subset_union
code: @[to_additive]
theorem union_smul_inter_subset_union [DecidableEq α] : (s₁ ∪ s₂) • (t₁ ∩ t₂) ⊆ s₁ • t₁ ∪ s₂ • t₂ 
goal: (s₁ ∪ s₂) • (t₁ ∩ t₂) ⊆ s₁ • t₁ ∪ s₂ • t₂

full_name: Finset.subset_vadd
code: /-- If a finset `u` is contained in the scalar product of two sets `s • t`, we can find two finsets
`s'`, `t'` such that `s' ⊆ s`, `t' ⊆ t` and `u ⊆ s' • t'`. -/
@[to_additive
      "If a finset `u` is contained in the scalar sum of two sets `s +ᵥ t`, we can find two
      finsets `s'`, `t'` such that `s' ⊆ s`, `t' ⊆ t` and `u ⊆ s' +ᵥ t'`."]
theorem subset_smul {s : Set α} {t : Set β} :
    ↑u ⊆ s • t → ∃ (s' : Finset α) (t' : Finset β), ↑s' ⊆ s ∧ ↑t' ⊆ t ∧ u ⊆ s' • t' 
goal: ↑u ⊆ s +ᵥ t → ∃ s' t', ↑s' ⊆ s ∧ ↑t' ⊆ t ∧ u ⊆ s' +ᵥ t'

full_name: Finset.subset_smul
code: /-- If a finset `u` is contained in the scalar product of two sets `s • t`, we can find two finsets
`s'`, `t'` such that `s' ⊆ s`, `t' ⊆ t` and `u ⊆ s' • t'`. -/
@[to_additive
      "If a finset `u` is contained in the scalar sum of two sets `s +ᵥ t`, we can find two
      finsets `s'`, `t'` such that `s' ⊆ s`, `t' ⊆ t` and `u ⊆ s' +ᵥ t'`."]
theorem subset_smul {s : Set α} {t : Set β} :
    ↑u ⊆ s • t → ∃ (s' : Finset α) (t' : Finset β), ↑s' ⊆ s ∧ ↑t' ⊆ t ∧ u ⊆ s' • t' 
goal: ↑u ⊆ s • t → ∃ s' t', ↑s' ⊆ s ∧ ↑t' ⊆ t ∧ u ⊆ s' • t'

full_name: Finset.vsub
code: /-- The pointwise subtraction of two finsets `s` and `t`: `s -ᵥ t = {x -ᵥ y | x ∈ s, y ∈ t}`. -/
protected def vsub : VSub (Finset α) (Finset β) 
goal: VSub (Finset α) (Finset β)

full_name: Finset.vsub_def
code: theorem vsub_def : s -ᵥ t = image₂ (· -ᵥ ·) s t 
goal: s -ᵥ t = Finset.image₂ (fun x x_1 => x -ᵥ x_1) s t

full_name: Finset.image_vsub_product
code: @[simp]
theorem image_vsub_product : image₂ (· -ᵥ ·) s t = s -ᵥ t 
goal: Finset.image₂ (fun x x_1 => x -ᵥ x_1) s t = s -ᵥ t

full_name: Finset.mem_vsub
code: theorem mem_vsub : a ∈ s -ᵥ t ↔ ∃ b ∈ s, ∃ c ∈ t, b -ᵥ c = a 
goal: a ∈ s -ᵥ t ↔ ∃ b ∈ s, ∃ c ∈ t, b -ᵥ c = a

full_name: Finset.coe_vsub
code: @[simp, norm_cast]
theorem coe_vsub (s t : Finset β) : (↑(s -ᵥ t) : Set α) = (s : Set β) -ᵥ t 
goal: ↑(s -ᵥ t) = ↑s -ᵥ ↑t

full_name: Finset.vsub_mem_vsub
code: theorem vsub_mem_vsub : b ∈ s → c ∈ t → b -ᵥ c ∈ s -ᵥ t 
goal: b ∈ s → c ∈ t → b -ᵥ c ∈ s -ᵥ t

full_name: Finset.vsub_card_le
code: theorem vsub_card_le : (s -ᵥ t : Finset α).card ≤ s.card * t.card 
goal: (s -ᵥ t).card ≤ s.card * t.card

full_name: Finset.empty_vsub
code: @[simp]
theorem empty_vsub (t : Finset β) : (∅ : Finset β) -ᵥ t = ∅ 
goal: ∅ -ᵥ t = ∅

full_name: Finset.vsub_empty
code: @[simp]
theorem vsub_empty (s : Finset β) : s -ᵥ (∅ : Finset β) = ∅ 
goal: s -ᵥ ∅ = ∅

full_name: Finset.vsub_eq_empty
code: @[simp]
theorem vsub_eq_empty : s -ᵥ t = ∅ ↔ s = ∅ ∨ t = ∅ 
goal: s -ᵥ t = ∅ ↔ s = ∅ ∨ t = ∅

full_name: Finset.vsub_nonempty
code: @[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem vsub_nonempty : (s -ᵥ t : Finset α).Nonempty ↔ s.Nonempty ∧ t.Nonempty 
goal: (s -ᵥ t).Nonempty ↔ s.Nonempty ∧ t.Nonempty

full_name: Finset.Nonempty.vsub
code: theorem Nonempty.vsub : s.Nonempty → t.Nonempty → (s -ᵥ t : Finset α).Nonempty 
goal: s.Nonempty → t.Nonempty → (s -ᵥ t).Nonempty

full_name: Finset.Nonempty.of_vsub_left
code: theorem Nonempty.of_vsub_left : (s -ᵥ t : Finset α).Nonempty → s.Nonempty 
goal: (s -ᵥ t).Nonempty → s.Nonempty

full_name: Finset.Nonempty.of_vsub_right
code: theorem Nonempty.of_vsub_right : (s -ᵥ t : Finset α).Nonempty → t.Nonempty 
goal: (s -ᵥ t).Nonempty → t.Nonempty

full_name: Finset.vsub_singleton
code: @[simp]
theorem vsub_singleton (b : β) : s -ᵥ ({b} : Finset β) = s.image (· -ᵥ b) 
goal: s -ᵥ {b} = Finset.image (fun x => x -ᵥ b) s

full_name: Finset.singleton_vsub
code: theorem singleton_vsub (a : β) : ({a} : Finset β) -ᵥ t = t.image (a -ᵥ ·) 
goal: {a} -ᵥ t = Finset.image (fun x => a -ᵥ x) t

full_name: Finset.singleton_vsub_singleton
code: theorem singleton_vsub_singleton (a b : β) : ({a} : Finset β) -ᵥ {b} = {a -ᵥ b} 
goal: {a} -ᵥ {b} = {a -ᵥ b}

full_name: Finset.vsub_subset_vsub
code: @[mono]
theorem vsub_subset_vsub : s₁ ⊆ s₂ → t₁ ⊆ t₂ → s₁ -ᵥ t₁ ⊆ s₂ -ᵥ t₂ 
goal: s₁ ⊆ s₂ → t₁ ⊆ t₂ → s₁ -ᵥ t₁ ⊆ s₂ -ᵥ t₂

full_name: Finset.vsub_subset_vsub_left
code: theorem vsub_subset_vsub_left : t₁ ⊆ t₂ → s -ᵥ t₁ ⊆ s -ᵥ t₂ 
goal: t₁ ⊆ t₂ → s -ᵥ t₁ ⊆ s -ᵥ t₂

full_name: Finset.vsub_subset_vsub_right
code: theorem vsub_subset_vsub_right : s₁ ⊆ s₂ → s₁ -ᵥ t ⊆ s₂ -ᵥ t 
goal: s₁ ⊆ s₂ → s₁ -ᵥ t ⊆ s₂ -ᵥ t

full_name: Finset.vsub_subset_iff
code: theorem vsub_subset_iff : s -ᵥ t ⊆ u ↔ ∀ x ∈ s, ∀ y ∈ t, x -ᵥ y ∈ u 
goal: s -ᵥ t ⊆ u ↔ ∀ x ∈ s, ∀ y ∈ t, x -ᵥ y ∈ u

full_name: Finset.union_vsub
code: theorem union_vsub : s₁ ∪ s₂ -ᵥ t = s₁ -ᵥ t ∪ (s₂ -ᵥ t) 
goal: s₁ ∪ s₂ -ᵥ t = s₁ -ᵥ t ∪ (s₂ -ᵥ t)

full_name: Finset.vsub_union
code: theorem vsub_union : s -ᵥ (t₁ ∪ t₂) = s -ᵥ t₁ ∪ (s -ᵥ t₂) 
goal: s -ᵥ (t₁ ∪ t₂) = s -ᵥ t₁ ∪ (s -ᵥ t₂)

full_name: Finset.inter_vsub_subset
code: theorem inter_vsub_subset : s₁ ∩ s₂ -ᵥ t ⊆ (s₁ -ᵥ t) ∩ (s₂ -ᵥ t) 
goal: s₁ ∩ s₂ -ᵥ t ⊆ (s₁ -ᵥ t) ∩ (s₂ -ᵥ t)

full_name: Finset.vsub_inter_subset
code: theorem vsub_inter_subset : s -ᵥ t₁ ∩ t₂ ⊆ (s -ᵥ t₁) ∩ (s -ᵥ t₂) 
goal: s -ᵥ t₁ ∩ t₂ ⊆ (s -ᵥ t₁) ∩ (s -ᵥ t₂)

full_name: Finset.subset_vsub
code: /-- If a finset `u` is contained in the pointwise subtraction of two sets `s -ᵥ t`, we can find two
finsets `s'`, `t'` such that `s' ⊆ s`, `t' ⊆ t` and `u ⊆ s' -ᵥ t'`. -/
theorem subset_vsub {s t : Set β} :
    ↑u ⊆ s -ᵥ t → ∃ s' t' : Finset β, ↑s' ⊆ s ∧ ↑t' ⊆ t ∧ u ⊆ s' -ᵥ t' 
goal: ↑u ⊆ s -ᵥ t → ∃ s' t', ↑s' ⊆ s ∧ ↑t' ⊆ t ∧ u ⊆ s' -ᵥ t'

full_name: Finset.vaddFinset
code: /-- The scaling of a finset `s` by a scalar `a`: `a • s = {a • x | x ∈ s}`. -/
@[to_additive "The translation of a finset `s` by a vector `a`: `a +ᵥ s = {a +ᵥ x | x ∈ s}`."]
protected def smulFinset : SMul α (Finset β) 
goal: VAdd α (Finset β)

full_name: Finset.smulFinset
code: /-- The scaling of a finset `s` by a scalar `a`: `a • s = {a • x | x ∈ s}`. -/
@[to_additive "The translation of a finset `s` by a vector `a`: `a +ᵥ s = {a +ᵥ x | x ∈ s}`."]
protected def smulFinset : SMul α (Finset β) 
goal: SMul α (Finset β)

full_name: Finset.smul_finset_def
code: @[to_additive]
theorem smul_finset_def : a • s = s.image (a • ·) 
goal: a • s = Finset.image (fun x => a • x) s

full_name: Finset.vadd_finset_def
code: @[to_additive]
theorem smul_finset_def : a • s = s.image (a • ·) 
goal: a +ᵥ s = Finset.image (fun x => a +ᵥ x) s

full_name: Finset.image_vadd
code: @[to_additive]
theorem image_smul : (s.image fun x => a • x) = a • s 
goal: Finset.image (fun x => a +ᵥ x) s = a +ᵥ s

full_name: Finset.image_smul
code: @[to_additive]
theorem image_smul : (s.image fun x => a • x) = a • s 
goal: Finset.image (fun x => a • x) s = a • s

full_name: Finset.mem_vadd_finset
code: @[to_additive]
theorem mem_smul_finset {x : β} : x ∈ a • s ↔ ∃ y, y ∈ s ∧ a • y = x 
goal: x ∈ a +ᵥ s ↔ ∃ y ∈ s, a +ᵥ y = x

full_name: Finset.mem_smul_finset
code: @[to_additive]
theorem mem_smul_finset {x : β} : x ∈ a • s ↔ ∃ y, y ∈ s ∧ a • y = x 
goal: x ∈ a • s ↔ ∃ y ∈ s, a • y = x

full_name: Finset.coe_smul_finset
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_smul_finset (a : α) (s : Finset β) : ↑(a • s) = a • (↑s : Set β) 
goal: ↑(a • s) = a • ↑s

full_name: Finset.coe_vadd_finset
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_smul_finset (a : α) (s : Finset β) : ↑(a • s) = a • (↑s : Set β) 
goal: ↑(a +ᵥ s) = a +ᵥ ↑s

full_name: Finset.smul_mem_smul_finset
code: @[to_additive]
theorem smul_mem_smul_finset : b ∈ s → a • b ∈ a • s 
goal: b ∈ s → a • b ∈ a • s

full_name: Finset.vadd_mem_vadd_finset
code: @[to_additive]
theorem smul_mem_smul_finset : b ∈ s → a • b ∈ a • s 
goal: b ∈ s → a +ᵥ b ∈ a +ᵥ s

full_name: Finset.smul_finset_card_le
code: @[to_additive]
theorem smul_finset_card_le : (a • s).card ≤ s.card 
goal: (a • s).card ≤ s.card

full_name: Finset.vadd_finset_card_le
code: @[to_additive]
theorem smul_finset_card_le : (a • s).card ≤ s.card 
goal: (a +ᵥ s).card ≤ s.card

full_name: Finset.smul_finset_empty
code: @[to_additive (attr := simp)]
theorem smul_finset_empty (a : α) : a • (∅ : Finset β) = ∅ 
goal: a • ∅ = ∅

full_name: Finset.vadd_finset_empty
code: @[to_additive (attr := simp)]
theorem smul_finset_empty (a : α) : a • (∅ : Finset β) = ∅ 
goal: a +ᵥ ∅ = ∅

full_name: Finset.vadd_finset_eq_empty
code: @[to_additive (attr := simp)]
theorem smul_finset_eq_empty : a • s = ∅ ↔ s = ∅ 
goal: a +ᵥ s = ∅ ↔ s = ∅

full_name: Finset.smul_finset_eq_empty
code: @[to_additive (attr := simp)]
theorem smul_finset_eq_empty : a • s = ∅ ↔ s = ∅ 
goal: a • s = ∅ ↔ s = ∅

full_name: Finset.smul_finset_nonempty
code: @[to_additive (attr := simp, aesop safe apply (rule_sets := [finsetNonempty]))]
theorem smul_finset_nonempty : (a • s).Nonempty ↔ s.Nonempty 
goal: (a • s).Nonempty ↔ s.Nonempty

full_name: Finset.vadd_finset_nonempty
code: @[to_additive (attr := simp, aesop safe apply (rule_sets := [finsetNonempty]))]
theorem smul_finset_nonempty : (a • s).Nonempty ↔ s.Nonempty 
goal: (a +ᵥ s).Nonempty ↔ s.Nonempty

full_name: Finset.Nonempty.vadd_finset
code: @[to_additive]
theorem Nonempty.smul_finset (hs : s.Nonempty) : (a • s).Nonempty 
goal: (a +ᵥ s).Nonempty

full_name: Finset.Nonempty.smul_finset
code: @[to_additive]
theorem Nonempty.smul_finset (hs : s.Nonempty) : (a • s).Nonempty 
goal: (a • s).Nonempty

full_name: Finset.singleton_smul
code: @[to_additive (attr := simp)]
theorem singleton_smul (a : α) : ({a} : Finset α) • t = a • t 
goal: {a} • t = a • t

full_name: Finset.singleton_vadd
code: @[to_additive (attr := simp)]
theorem singleton_smul (a : α) : ({a} : Finset α) • t = a • t 
goal: {a} +ᵥ t = a +ᵥ t

full_name: Finset.vadd_finset_subset_vadd_finset
code: @[to_additive (attr := mono)]
theorem smul_finset_subset_smul_finset : s ⊆ t → a • s ⊆ a • t 
goal: s ⊆ t → a +ᵥ s ⊆ a +ᵥ t

full_name: Finset.smul_finset_subset_smul_finset
code: @[to_additive (attr := mono)]
theorem smul_finset_subset_smul_finset : s ⊆ t → a • s ⊆ a • t 
goal: s ⊆ t → a • s ⊆ a • t

full_name: Finset.smul_finset_singleton
code: @[to_additive (attr := simp)]
theorem smul_finset_singleton (b : β) : a • ({b} : Finset β) = {a • b} 
goal: a • {b} = {a • b}

full_name: Finset.vadd_finset_singleton
code: @[to_additive (attr := simp)]
theorem smul_finset_singleton (b : β) : a • ({b} : Finset β) = {a • b} 
goal: a +ᵥ {b} = {a +ᵥ b}

full_name: Finset.vadd_finset_union
code: @[to_additive]
theorem smul_finset_union : a • (s₁ ∪ s₂) = a • s₁ ∪ a • s₂ 
goal: a +ᵥ (s₁ ∪ s₂) = a +ᵥ s₁ ∪ (a +ᵥ s₂)

full_name: Finset.smul_finset_union
code: @[to_additive]
theorem smul_finset_union : a • (s₁ ∪ s₂) = a • s₁ ∪ a • s₂ 
goal: a • (s₁ ∪ s₂) = a • s₁ ∪ a • s₂

full_name: Finset.vadd_finset_inter_subset
code: @[to_additive]
theorem smul_finset_inter_subset : a • (s₁ ∩ s₂) ⊆ a • s₁ ∩ a • s₂ 
goal: a +ᵥ s₁ ∩ s₂ ⊆ (a +ᵥ s₁) ∩ (a +ᵥ s₂)

full_name: Finset.smul_finset_inter_subset
code: @[to_additive]
theorem smul_finset_inter_subset : a • (s₁ ∩ s₂) ⊆ a • s₁ ∩ a • s₂ 
goal: a • (s₁ ∩ s₂) ⊆ a • s₁ ∩ a • s₂

full_name: Finset.vadd_finset_subset_vadd
code: @[to_additive]
theorem smul_finset_subset_smul {s : Finset α} : a ∈ s → a • t ⊆ s • t 
goal: a ∈ s → a +ᵥ t ⊆ s +ᵥ t

full_name: Finset.smul_finset_subset_smul
code: @[to_additive]
theorem smul_finset_subset_smul {s : Finset α} : a ∈ s → a • t ⊆ s • t 
goal: a ∈ s → a • t ⊆ s • t

full_name: Finset.biUnion_vadd_finset
code: @[to_additive (attr := simp)]
theorem biUnion_smul_finset (s : Finset α) (t : Finset β) : s.biUnion (· • t) = s • t 
goal: (s.biUnion fun x => x +ᵥ t) = s +ᵥ t

full_name: Finset.biUnion_smul_finset
code: @[to_additive (attr := simp)]
theorem biUnion_smul_finset (s : Finset α) (t : Finset β) : s.biUnion (· • t) = s • t 
goal: (s.biUnion fun x => x • t) = s • t

full_name: Finset.smulCommClass_finset
code: @[to_additive]
instance smulCommClass_finset [SMul α γ] [SMul β γ] [SMulCommClass α β γ] :
    SMulCommClass α β (Finset γ) 
goal: SMulCommClass α β (Finset γ)

full_name: Finset.vaddCommClass_finset
code: @[to_additive]
instance smulCommClass_finset [SMul α γ] [SMul β γ] [SMulCommClass α β γ] :
    SMulCommClass α β (Finset γ) 
goal: VAddCommClass α β (Finset γ)

full_name: Finset.vaddCommClass_finset'
code: @[to_additive]
instance smulCommClass_finset' [SMul α γ] [SMul β γ] [SMulCommClass α β γ] :
    SMulCommClass α (Finset β) (Finset γ) 
goal: VAddCommClass α (Finset β) (Finset γ)

full_name: Finset.smulCommClass_finset'
code: @[to_additive]
instance smulCommClass_finset' [SMul α γ] [SMul β γ] [SMulCommClass α β γ] :
    SMulCommClass α (Finset β) (Finset γ) 
goal: SMulCommClass α (Finset β) (Finset γ)

full_name: Finset.smulCommClass_finset''
code: @[to_additive]
instance smulCommClass_finset'' [SMul α γ] [SMul β γ] [SMulCommClass α β γ] :
    SMulCommClass (Finset α) β (Finset γ) 
goal: SMulCommClass (Finset α) β (Finset γ)

full_name: Finset.vaddCommClass_finset''
code: @[to_additive]
instance smulCommClass_finset'' [SMul α γ] [SMul β γ] [SMulCommClass α β γ] :
    SMulCommClass (Finset α) β (Finset γ) 
goal: VAddCommClass (Finset α) β (Finset γ)

full_name: Finset.smulCommClass
code: @[to_additive]
instance smulCommClass [SMul α γ] [SMul β γ] [SMulCommClass α β γ] :
    SMulCommClass (Finset α) (Finset β) (Finset γ) 
goal: SMulCommClass (Finset α) (Finset β) (Finset γ)

full_name: Finset.vaddCommClass
code: @[to_additive]
instance smulCommClass [SMul α γ] [SMul β γ] [SMulCommClass α β γ] :
    SMulCommClass (Finset α) (Finset β) (Finset γ) 
goal: VAddCommClass (Finset α) (Finset β) (Finset γ)

full_name: Finset.vaddAssocClass
code: @[to_additive vaddAssocClass]
instance isScalarTower [SMul α β] [SMul α γ] [SMul β γ] [IsScalarTower α β γ] :
    IsScalarTower α β (Finset γ) 
goal: VAddAssocClass α β (Finset γ)

full_name: Finset.isScalarTower
code: @[to_additive vaddAssocClass]
instance isScalarTower [SMul α β] [SMul α γ] [SMul β γ] [IsScalarTower α β γ] :
    IsScalarTower α β (Finset γ) 
goal: IsScalarTower α β (Finset γ)

full_name: Finset.vaddAssocClass'
code: @[to_additive vaddAssocClass']
instance isScalarTower' [SMul α β] [SMul α γ] [SMul β γ] [IsScalarTower α β γ] :
    IsScalarTower α (Finset β) (Finset γ) 
goal: VAddAssocClass α (Finset β) (Finset γ)

full_name: Finset.isScalarTower'
code: @[to_additive vaddAssocClass']
instance isScalarTower' [SMul α β] [SMul α γ] [SMul β γ] [IsScalarTower α β γ] :
    IsScalarTower α (Finset β) (Finset γ) 
goal: IsScalarTower α (Finset β) (Finset γ)

full_name: Finset.vaddAssocClass''
code: @[to_additive vaddAssocClass'']
instance isScalarTower'' [SMul α β] [SMul α γ] [SMul β γ] [IsScalarTower α β γ] :
    IsScalarTower (Finset α) (Finset β) (Finset γ) 
goal: VAddAssocClass (Finset α) (Finset β) (Finset γ)

full_name: Finset.isScalarTower''
code: @[to_additive vaddAssocClass'']
instance isScalarTower'' [SMul α β] [SMul α γ] [SMul β γ] [IsScalarTower α β γ] :
    IsScalarTower (Finset α) (Finset β) (Finset γ) 
goal: IsScalarTower (Finset α) (Finset β) (Finset γ)

full_name: Finset.isCentralVAdd
code: @[to_additive]
instance isCentralScalar [SMul α β] [SMul αᵐᵒᵖ β] [IsCentralScalar α β] :
    IsCentralScalar α (Finset β) 
goal: IsCentralVAdd α (Finset β)

full_name: Finset.isCentralScalar
code: @[to_additive]
instance isCentralScalar [SMul α β] [SMul αᵐᵒᵖ β] [IsCentralScalar α β] :
    IsCentralScalar α (Finset β) 
goal: IsCentralScalar α (Finset β)

full_name: Finset.mulAction
code: /-- A multiplicative action of a monoid `α` on a type `β` gives a multiplicative action of
`Finset α` on `Finset β`. -/
@[to_additive
      "An additive action of an additive monoid `α` on a type `β` gives an additive action
      of `Finset α` on `Finset β`"]
protected def mulAction [DecidableEq α] [Monoid α] [MulAction α β] :
    MulAction (Finset α) (Finset β) 
goal: MulAction (Finset α) (Finset β)

full_name: Finset.addAction
code: /-- A multiplicative action of a monoid `α` on a type `β` gives a multiplicative action of
`Finset α` on `Finset β`. -/
@[to_additive
      "An additive action of an additive monoid `α` on a type `β` gives an additive action
      of `Finset α` on `Finset β`"]
protected def mulAction [DecidableEq α] [Monoid α] [MulAction α β] :
    MulAction (Finset α) (Finset β) 
goal: AddAction (Finset α) (Finset β)

full_name: Finset.addActionFinset
code: /-- A multiplicative action of a monoid on a type `β` gives a multiplicative action on `Finset β`.
-/
@[to_additive
      "An additive action of an additive monoid on a type `β` gives an additive action
      on `Finset β`."]
protected def mulActionFinset [Monoid α] [MulAction α β] : MulAction α (Finset β) 
goal: AddAction α (Finset β)

full_name: Finset.mulActionFinset
code: /-- A multiplicative action of a monoid on a type `β` gives a multiplicative action on `Finset β`.
-/
@[to_additive
      "An additive action of an additive monoid on a type `β` gives an additive action
      on `Finset β`."]
protected def mulActionFinset [Monoid α] [MulAction α β] : MulAction α (Finset β) 
goal: MulAction α (Finset β)

full_name: Finset.smulZeroClassFinset
code: /-- If scalar multiplication by elements of `α` sends `(0 : β)` to zero,
then the same is true for `(0 : Finset β)`. -/
protected def smulZeroClassFinset [Zero β] [SMulZeroClass α β] :
    SMulZeroClass α (Finset β) 
goal: SMulZeroClass α (Finset β)

full_name: Finset.distribSMulFinset
code: /-- If the scalar multiplication `(· • ·) : α → β → β` is distributive,
then so is `(· • ·) : α → Finset β → Finset β`. -/
protected def distribSMulFinset [AddZeroClass β] [DistribSMul α β] :
    DistribSMul α (Finset β) 
goal: DistribSMul α (Finset β)

full_name: Finset.distribMulActionFinset
code: /-- A distributive multiplicative action of a monoid on an additive monoid `β` gives a distributive
multiplicative action on `Finset β`. -/
protected def distribMulActionFinset [Monoid α] [AddMonoid β] [DistribMulAction α β] :
    DistribMulAction α (Finset β) 
goal: DistribMulAction α (Finset β)

full_name: Finset.mulDistribMulActionFinset
code: /-- A multiplicative action of a monoid on a monoid `β` gives a multiplicative action on `Set β`. -/
protected def mulDistribMulActionFinset [Monoid α] [Monoid β] [MulDistribMulAction α β] :
    MulDistribMulAction α (Finset β) 
goal: MulDistribMulAction α (Finset β)

full_name: Finset.instNoZeroDivisors
code: instance [DecidableEq α] [Zero α] [Mul α] [NoZeroDivisors α] : NoZeroDivisors (Finset α) 
goal: NoZeroDivisors (Finset α)

full_name: Finset.noZeroSMulDivisors
code: instance noZeroSMulDivisors [Zero α] [Zero β] [SMul α β] [NoZeroSMulDivisors α β] :
    NoZeroSMulDivisors (Finset α) (Finset β) 
goal: NoZeroSMulDivisors (Finset α) (Finset β)

full_name: Finset.noZeroSMulDivisors_finset
code: instance noZeroSMulDivisors_finset [Zero α] [Zero β] [SMul α β] [NoZeroSMulDivisors α β] :
    NoZeroSMulDivisors α (Finset β) 
goal: NoZeroSMulDivisors α (Finset β)

full_name: Finset.op_vadd_finset_vadd_eq_vadd_vadd_finset
code: @[to_additive]
theorem op_smul_finset_smul_eq_smul_smul_finset (a : α) (s : Finset β) (t : Finset γ)
    (h : ∀ (a : α) (b : β) (c : γ), (op a • b) • c = b • a • c) : (op a • s) • t = s • a • t 
goal: AddOpposite.op a +ᵥ s +ᵥ t = s +ᵥ (a +ᵥ t)

full_name: Finset.op_smul_finset_smul_eq_smul_smul_finset
code: @[to_additive]
theorem op_smul_finset_smul_eq_smul_smul_finset (a : α) (s : Finset β) (t : Finset γ)
    (h : ∀ (a : α) (b : β) (c : γ), (op a • b) • c = b • a • c) : (op a • s) • t = s • a • t 
goal: (MulOpposite.op a • s) • t = s • a • t

full_name: Finset.op_vadd_finset_subset_add
code: @[to_additive]
theorem op_smul_finset_subset_mul : a ∈ t → op a • s ⊆ s * t 
goal: a ∈ t → AddOpposite.op a +ᵥ s ⊆ s + t

full_name: Finset.op_smul_finset_subset_mul
code: @[to_additive]
theorem op_smul_finset_subset_mul : a ∈ t → op a • s ⊆ s * t 
goal: a ∈ t → MulOpposite.op a • s ⊆ s * t

full_name: Finset.biUnion_op_smul_finset
code: @[to_additive (attr := simp)]
theorem biUnion_op_smul_finset (s t : Finset α) : (t.biUnion fun a => op a • s) = s * t 
goal: (t.biUnion fun a => MulOpposite.op a • s) = s * t

full_name: Finset.biUnion_op_vadd_finset
code: @[to_additive (attr := simp)]
theorem biUnion_op_smul_finset (s t : Finset α) : (t.biUnion fun a => op a • s) = s * t 
goal: (t.biUnion fun a => AddOpposite.op a +ᵥ s) = s + t

full_name: Finset.add_subset_iff_left
code: @[to_additive]
theorem mul_subset_iff_left : s * t ⊆ u ↔ ∀ a ∈ s, a • t ⊆ u 
goal: s + t ⊆ u ↔ ∀ a ∈ s, a +ᵥ t ⊆ u

full_name: Finset.mul_subset_iff_left
code: @[to_additive]
theorem mul_subset_iff_left : s * t ⊆ u ↔ ∀ a ∈ s, a • t ⊆ u 
goal: s * t ⊆ u ↔ ∀ a ∈ s, a • t ⊆ u

full_name: Finset.mul_subset_iff_right
code: @[to_additive]
theorem mul_subset_iff_right : s * t ⊆ u ↔ ∀ b ∈ t, op b • s ⊆ u 
goal: s * t ⊆ u ↔ ∀ b ∈ t, MulOpposite.op b • s ⊆ u

full_name: Finset.add_subset_iff_right
code: @[to_additive]
theorem mul_subset_iff_right : s * t ⊆ u ↔ ∀ b ∈ t, op b • s ⊆ u 
goal: s + t ⊆ u ↔ ∀ b ∈ t, AddOpposite.op b +ᵥ s ⊆ u

full_name: Finset.op_smul_finset_mul_eq_mul_smul_finset
code: @[to_additive]
theorem op_smul_finset_mul_eq_mul_smul_finset (a : α) (s : Finset α) (t : Finset α) :
    op a • s * t = s * a • t 
goal: MulOpposite.op a • s * t = s * a • t

full_name: Finset.op_vadd_finset_add_eq_add_vadd_finset
code: @[to_additive]
theorem op_smul_finset_mul_eq_mul_smul_finset (a : α) (s : Finset α) (t : Finset α) :
    op a • s * t = s * a • t 
goal: AddOpposite.op a +ᵥ s + t = s + (a +ᵥ t)

full_name: Finset.pairwiseDisjoint_vadd_iff
code: @[to_additive]
theorem pairwiseDisjoint_smul_iff {s : Set α} {t : Finset α} :
    s.PairwiseDisjoint (· • t) ↔ (s ×ˢ t : Set (α × α)).InjOn fun p => p.1 * p.2 
goal: (s.PairwiseDisjoint fun x => x +ᵥ t) ↔ Set.InjOn (fun p => p.1 + p.2) (s ×ˢ ↑t)

full_name: Finset.pairwiseDisjoint_smul_iff
code: @[to_additive]
theorem pairwiseDisjoint_smul_iff {s : Set α} {t : Finset α} :
    s.PairwiseDisjoint (· • t) ↔ (s ×ˢ t : Set (α × α)).InjOn fun p => p.1 * p.2 
goal: (s.PairwiseDisjoint fun x => x • t) ↔ Set.InjOn (fun p => p.1 * p.2) (s ×ˢ ↑t)

full_name: Finset.card_singleton_mul
code: @[to_additive (attr := simp)]
theorem card_singleton_mul : ({a} * t).card = t.card 
goal: ({a} * t).card = t.card

full_name: Finset.card_singleton_add
code: @[to_additive (attr := simp)]
theorem card_singleton_mul : ({a} * t).card = t.card 
goal: ({a} + t).card = t.card

full_name: Finset.singleton_add_inter
code: @[to_additive]
theorem singleton_mul_inter : {a} * (s ∩ t) = {a} * s ∩ ({a} * t) 
goal: {a} + s ∩ t = ({a} + s) ∩ ({a} + t)

full_name: Finset.singleton_mul_inter
code: @[to_additive]
theorem singleton_mul_inter : {a} * (s ∩ t) = {a} * s ∩ ({a} * t) 
goal: {a} * (s ∩ t) = {a} * s ∩ ({a} * t)

full_name: Finset.card_le_card_add_left
code: @[to_additive]
theorem card_le_card_mul_left {s : Finset α} (hs : s.Nonempty) : t.card ≤ (s * t).card 
goal: t.card ≤ (s + t).card

full_name: Finset.card_le_card_mul_left
code: @[to_additive]
theorem card_le_card_mul_left {s : Finset α} (hs : s.Nonempty) : t.card ≤ (s * t).card 
goal: t.card ≤ (s * t).card

full_name: Finset.card_add_singleton
code: @[to_additive (attr := simp)]
theorem card_mul_singleton : (s * {a}).card = s.card 
goal: (s + {a}).card = s.card

full_name: Finset.card_mul_singleton
code: @[to_additive (attr := simp)]
theorem card_mul_singleton : (s * {a}).card = s.card 
goal: (s * {a}).card = s.card

full_name: Finset.inter_mul_singleton
code: @[to_additive]
theorem inter_mul_singleton : s ∩ t * {a} = s * {a} ∩ (t * {a}) 
goal: s ∩ t * {a} = s * {a} ∩ (t * {a})

full_name: Finset.inter_add_singleton
code: @[to_additive]
theorem inter_mul_singleton : s ∩ t * {a} = s * {a} ∩ (t * {a}) 
goal: s ∩ t + {a} = (s + {a}) ∩ (t + {a})

full_name: Finset.card_le_card_mul_right
code: @[to_additive]
theorem card_le_card_mul_right {t : Finset α} (ht : t.Nonempty) : s.card ≤ (s * t).card 
goal: s.card ≤ (s * t).card

full_name: Finset.card_le_card_add_right
code: @[to_additive]
theorem card_le_card_mul_right {t : Finset α} (ht : t.Nonempty) : s.card ≤ (s * t).card 
goal: s.card ≤ (s + t).card

full_name: Finset.card_le_card_div_left
code: @[to_additive] lemma card_le_card_div_left (hs : s.Nonempty) : t.card ≤ (s / t).card 
goal: t.card ≤ (s / t).card

full_name: Finset.card_le_card_sub_left
code: @[to_additive] lemma card_le_card_div_left (hs : s.Nonempty) : t.card ≤ (s / t).card 
goal: t.card ≤ (s - t).card

full_name: Finset.card_le_card_div_right
code: @[to_additive] lemma card_le_card_div_right (ht : t.Nonempty) : s.card ≤ (s / t).card 
goal: s.card ≤ (s / t).card

full_name: Finset.card_le_card_sub_right
code: @[to_additive] lemma card_le_card_div_right (ht : t.Nonempty) : s.card ≤ (s / t).card 
goal: s.card ≤ (s - t).card

full_name: Finset.image_smul_comm
code: @[to_additive]
theorem image_smul_comm [DecidableEq β] [DecidableEq γ] [SMul α β] [SMul α γ] (f : β → γ) (a : α)
    (s : Finset β) : (∀ b, f (a • b) = a • f b) → (a • s).image f = a • s.image f 
goal: (∀ (b : β), f (a • b) = a • f b) → Finset.image f (a • s) = a • Finset.image f s

full_name: Finset.image_vadd_comm
code: @[to_additive]
theorem image_smul_comm [DecidableEq β] [DecidableEq γ] [SMul α β] [SMul α γ] (f : β → γ) (a : α)
    (s : Finset β) : (∀ b, f (a • b) = a • f b) → (a • s).image f = a • s.image f 
goal: (∀ (b : β), f (a +ᵥ b) = a +ᵥ f b) → Finset.image f (a +ᵥ s) = a +ᵥ Finset.image f s

full_name: Finset.image_vadd_distrib
code: @[to_additive]
theorem image_smul_distrib [DecidableEq α] [DecidableEq β] [Monoid α] [Monoid β] [FunLike F α β]
    [MonoidHomClass F α β] (f : F) (a : α) (s : Finset α) : (a • s).image f = f a • s.image f 
goal: Finset.image (⇑f) (a +ᵥ s) = f a +ᵥ Finset.image (⇑f) s

full_name: Finset.image_smul_distrib
code: @[to_additive]
theorem image_smul_distrib [DecidableEq α] [DecidableEq β] [Monoid α] [Monoid β] [FunLike F α β]
    [MonoidHomClass F α β] (f : F) (a : α) (s : Finset α) : (a • s).image f = f a • s.image f 
goal: Finset.image (⇑f) (a • s) = f a • Finset.image (⇑f) s

full_name: Finset.smul_mem_smul_finset_iff
code: @[to_additive (attr := simp)]
theorem smul_mem_smul_finset_iff (a : α) : a • b ∈ a • s ↔ b ∈ s 
goal: a • b ∈ a • s ↔ b ∈ s

full_name: Finset.vadd_mem_vadd_finset_iff
code: @[to_additive (attr := simp)]
theorem smul_mem_smul_finset_iff (a : α) : a • b ∈ a • s ↔ b ∈ s 
goal: a +ᵥ b ∈ a +ᵥ s ↔ b ∈ s

full_name: Finset.inv_smul_mem_iff
code: @[to_additive]
theorem inv_smul_mem_iff : a⁻¹ • b ∈ s ↔ b ∈ a • s 
goal: a⁻¹ • b ∈ s ↔ b ∈ a • s

full_name: Finset.neg_vadd_mem_iff
code: @[to_additive]
theorem inv_smul_mem_iff : a⁻¹ • b ∈ s ↔ b ∈ a • s 
goal: -a +ᵥ b ∈ s ↔ b ∈ a +ᵥ s

full_name: Finset.mem_neg_vadd_finset_iff
code: @[to_additive]
theorem mem_inv_smul_finset_iff : b ∈ a⁻¹ • s ↔ a • b ∈ s 
goal: b ∈ -a +ᵥ s ↔ a +ᵥ b ∈ s

full_name: Finset.mem_inv_smul_finset_iff
code: @[to_additive]
theorem mem_inv_smul_finset_iff : b ∈ a⁻¹ • s ↔ a • b ∈ s 
goal: b ∈ a⁻¹ • s ↔ a • b ∈ s

full_name: Finset.vadd_finset_subset_vadd_finset_iff
code: @[to_additive (attr := simp)]
theorem smul_finset_subset_smul_finset_iff : a • s ⊆ a • t ↔ s ⊆ t 
goal: a +ᵥ s ⊆ a +ᵥ t ↔ s ⊆ t

full_name: Finset.smul_finset_subset_smul_finset_iff
code: @[to_additive (attr := simp)]
theorem smul_finset_subset_smul_finset_iff : a • s ⊆ a • t ↔ s ⊆ t 
goal: a • s ⊆ a • t ↔ s ⊆ t

full_name: Finset.vadd_finset_subset_iff
code: @[to_additive]
theorem smul_finset_subset_iff : a • s ⊆ t ↔ s ⊆ a⁻¹ • t 
goal: a +ᵥ s ⊆ t ↔ s ⊆ -a +ᵥ t

full_name: Finset.smul_finset_subset_iff
code: @[to_additive]
theorem smul_finset_subset_iff : a • s ⊆ t ↔ s ⊆ a⁻¹ • t 
goal: a • s ⊆ t ↔ s ⊆ a⁻¹ • t

full_name: Finset.subset_vadd_finset_iff
code: @[to_additive]
theorem subset_smul_finset_iff : s ⊆ a • t ↔ a⁻¹ • s ⊆ t 
goal: s ⊆ a +ᵥ t ↔ -a +ᵥ s ⊆ t

full_name: Finset.subset_smul_finset_iff
code: @[to_additive]
theorem subset_smul_finset_iff : s ⊆ a • t ↔ a⁻¹ • s ⊆ t 
goal: s ⊆ a • t ↔ a⁻¹ • s ⊆ t

full_name: Finset.vadd_finset_inter
code: @[to_additive]
theorem smul_finset_inter : a • (s ∩ t) = a • s ∩ a • t 
goal: a +ᵥ s ∩ t = (a +ᵥ s) ∩ (a +ᵥ t)

full_name: Finset.smul_finset_inter
code: @[to_additive]
theorem smul_finset_inter : a • (s ∩ t) = a • s ∩ a • t 
goal: a • (s ∩ t) = a • s ∩ a • t

full_name: Finset.vadd_finset_sdiff
code: @[to_additive]
theorem smul_finset_sdiff : a • (s \ t) = a • s \ a • t 
goal: a +ᵥ s \ t = (a +ᵥ s) \ (a +ᵥ t)

full_name: Finset.smul_finset_sdiff
code: @[to_additive]
theorem smul_finset_sdiff : a • (s \ t) = a • s \ a • t 
goal: a • (s \ t) = a • s \ a • t

full_name: Finset.smul_finset_symmDiff
code: @[to_additive]
theorem smul_finset_symmDiff : a • s ∆ t = (a • s) ∆ (a • t) 
goal: a • symmDiff s t = symmDiff (a • s) (a • t)

full_name: Finset.vadd_finset_symmDiff
code: @[to_additive]
theorem smul_finset_symmDiff : a • s ∆ t = (a • s) ∆ (a • t) 
goal: a +ᵥ symmDiff s t = symmDiff (a +ᵥ s) (a +ᵥ t)

full_name: Finset.smul_finset_univ
code: @[to_additive (attr := simp)]
theorem smul_finset_univ [Fintype β] : a • (univ : Finset β) = univ 
goal: a • Finset.univ = Finset.univ

full_name: Finset.vadd_finset_univ
code: @[to_additive (attr := simp)]
theorem smul_finset_univ [Fintype β] : a • (univ : Finset β) = univ 
goal: a +ᵥ Finset.univ = Finset.univ

full_name: Finset.vadd_univ
code: @[to_additive (attr := simp)]
theorem smul_univ [Fintype β] {s : Finset α} (hs : s.Nonempty) : s • (univ : Finset β) = univ 
goal: s +ᵥ Finset.univ = Finset.univ

full_name: Finset.smul_univ
code: @[to_additive (attr := simp)]
theorem smul_univ [Fintype β] {s : Finset α} (hs : s.Nonempty) : s • (univ : Finset β) = univ 
goal: s • Finset.univ = Finset.univ

full_name: Finset.card_smul_finset
code: @[to_additive (attr := simp)]
theorem card_smul_finset (a : α) (s : Finset β) : (a • s).card = s.card 
goal: (a • s).card = s.card

full_name: Finset.card_vadd_finset
code: @[to_additive (attr := simp)]
theorem card_smul_finset (a : α) (s : Finset β) : (a • s).card = s.card 
goal: (a +ᵥ s).card = s.card

full_name: Finset.card_dvd_card_smul_right
code: /-- If the left cosets of `t` by elements of `s` are disjoint (but not necessarily distinct!), then
the size of `t` divides the size of `s • t`. -/
@[to_additive "If the left cosets of `t` by elements of `s` are disjoint (but not necessarily
distinct!), then the size of `t` divides the size of `s +ᵥ t`."]
theorem card_dvd_card_smul_right {s : Finset α} :
    ((· • t) '' (s : Set α)).PairwiseDisjoint id → t.card ∣ (s • t).card 
goal: ((fun x => x • t) '' ↑s).PairwiseDisjoint id → t.card ∣ (s • t).card

full_name: Finset.card_dvd_card_vadd_right
code: /-- If the left cosets of `t` by elements of `s` are disjoint (but not necessarily distinct!), then
the size of `t` divides the size of `s • t`. -/
@[to_additive "If the left cosets of `t` by elements of `s` are disjoint (but not necessarily
distinct!), then the size of `t` divides the size of `s +ᵥ t`."]
theorem card_dvd_card_smul_right {s : Finset α} :
    ((· • t) '' (s : Set α)).PairwiseDisjoint id → t.card ∣ (s • t).card 
goal: ((fun x => x +ᵥ t) '' ↑s).PairwiseDisjoint id → t.card ∣ (s +ᵥ t).card

full_name: Finset.card_dvd_card_add_left
code: /-- If the right cosets of `s` by elements of `t` are disjoint (but not necessarily distinct!), then
the size of `s` divides the size of `s * t`. -/
@[to_additive "If the right cosets of `s` by elements of `t` are disjoint (but not necessarily
distinct!), then the size of `s` divides the size of `s + t`."]
theorem card_dvd_card_mul_left {s t : Finset α} :
    ((fun b => s.image fun a => a * b) '' (t : Set α)).PairwiseDisjoint id →
      s.card ∣ (s * t).card 
goal: ((fun b => Finset.image (fun a => a + b) s) '' ↑t).PairwiseDisjoint id → s.card ∣ (s + t).card

full_name: Finset.card_dvd_card_mul_left
code: /-- If the right cosets of `s` by elements of `t` are disjoint (but not necessarily distinct!), then
the size of `s` divides the size of `s * t`. -/
@[to_additive "If the right cosets of `s` by elements of `t` are disjoint (but not necessarily
distinct!), then the size of `s` divides the size of `s + t`."]
theorem card_dvd_card_mul_left {s t : Finset α} :
    ((fun b => s.image fun a => a * b) '' (t : Set α)).PairwiseDisjoint id →
      s.card ∣ (s * t).card 
goal: ((fun b => Finset.image (fun a => a * b) s) '' ↑t).PairwiseDisjoint id → s.card ∣ (s * t).card

full_name: Finset.card_dvd_card_mul_right
code: /-- If the left cosets of `t` by elements of `s` are disjoint (but not necessarily distinct!), then
the size of `t` divides the size of `s * t`. -/
@[to_additive "If the left cosets of `t` by elements of `s` are disjoint (but not necessarily
distinct!), then the size of `t` divides the size of `s + t`."]
theorem card_dvd_card_mul_right {s t : Finset α} :
    ((· • t) '' (s : Set α)).PairwiseDisjoint id → t.card ∣ (s * t).card 
goal: ((fun x => x • t) '' ↑s).PairwiseDisjoint id → t.card ∣ (s * t).card

full_name: Finset.card_dvd_card_add_right
code: /-- If the left cosets of `t` by elements of `s` are disjoint (but not necessarily distinct!), then
the size of `t` divides the size of `s * t`. -/
@[to_additive "If the left cosets of `t` by elements of `s` are disjoint (but not necessarily
distinct!), then the size of `t` divides the size of `s + t`."]
theorem card_dvd_card_mul_right {s t : Finset α} :
    ((· • t) '' (s : Set α)).PairwiseDisjoint id → t.card ∣ (s * t).card 
goal: ((fun x => x +ᵥ t) '' ↑s).PairwiseDisjoint id → t.card ∣ (s + t).card

full_name: Finset.inv_smul_finset_distrib
code: @[to_additive (attr := simp)]
lemma inv_smul_finset_distrib (a : α) (s : Finset α) : (a • s)⁻¹ = op a⁻¹ • s⁻¹ 
goal: (a • s)⁻¹ = MulOpposite.op a⁻¹ • s⁻¹

full_name: Finset.neg_vadd_finset_distrib
code: @[to_additive (attr := simp)]
lemma inv_smul_finset_distrib (a : α) (s : Finset α) : (a • s)⁻¹ = op a⁻¹ • s⁻¹ 
goal: -(a +ᵥ s) = AddOpposite.op (-a) +ᵥ -s

full_name: Finset.inv_op_smul_finset_distrib
code: @[to_additive (attr := simp)]
lemma inv_op_smul_finset_distrib (a : α) (s : Finset α) : (op a • s)⁻¹ = a⁻¹ • s⁻¹ 
goal: (MulOpposite.op a • s)⁻¹ = a⁻¹ • s⁻¹

full_name: Finset.neg_op_vadd_finset_distrib
code: @[to_additive (attr := simp)]
lemma inv_op_smul_finset_distrib (a : α) (s : Finset α) : (op a • s)⁻¹ = a⁻¹ • s⁻¹ 
goal: -(AddOpposite.op a +ᵥ s) = -a +ᵥ -s

full_name: Finset.smul_zero_subset
code: theorem smul_zero_subset (s : Finset α) : s • (0 : Finset β) ⊆ 0 
goal: s • 0 ⊆ 0

full_name: Finset.Nonempty.smul_zero
code: theorem Nonempty.smul_zero (hs : s.Nonempty) : s • (0 : Finset β) = 0 
goal: s • 0 = 0

full_name: Finset.zero_mem_smul_finset
code: theorem zero_mem_smul_finset (h : (0 : β) ∈ t) : (0 : β) ∈ a • t 
goal: 0 ∈ a • t

full_name: Finset.zero_mem_smul_finset_iff
code: theorem zero_mem_smul_finset_iff (ha : a ≠ 0) : (0 : β) ∈ a • t ↔ (0 : β) ∈ t 
goal: 0 ∈ a • t ↔ 0 ∈ t

full_name: Finset.zero_smul_subset
code: lemma zero_smul_subset (t : Finset β) : (0 : Finset α) • t ⊆ 0 
goal: 0 • t ⊆ 0

full_name: Finset.Nonempty.zero_smul
code: lemma Nonempty.zero_smul (ht : t.Nonempty) : (0 : Finset α) • t = 0 
goal: 0 • t = 0

full_name: Finset.zero_smul_finset
code: /-- A nonempty set is scaled by zero to the singleton set containing zero. -/
@[simp] lemma zero_smul_finset {s : Finset β} (h : s.Nonempty) : (0 : α) • s = (0 : Finset β) 
goal: 0 • s = 0

full_name: Finset.zero_smul_finset_subset
code: lemma zero_smul_finset_subset (s : Finset β) : (0 : α) • s ⊆ 0 
goal: 0 • s ⊆ 0

full_name: Finset.zero_mem_smul_iff
code: lemma zero_mem_smul_iff :
    (0 : β) ∈ s • t ↔ (0 : α) ∈ s ∧ t.Nonempty ∨ (0 : β) ∈ t ∧ s.Nonempty 
goal: 0 ∈ s • t ↔ 0 ∈ s ∧ t.Nonempty ∨ 0 ∈ t ∧ s.Nonempty

full_name: Finset.smul_mem_smul_finset_iff₀
code: @[simp]
theorem smul_mem_smul_finset_iff₀ (ha : a ≠ 0) : a • b ∈ a • s ↔ b ∈ s 
goal: a • b ∈ a • s ↔ b ∈ s

full_name: Finset.inv_smul_mem_iff₀
code: theorem inv_smul_mem_iff₀ (ha : a ≠ 0) : a⁻¹ • b ∈ s ↔ b ∈ a • s 
goal: a⁻¹ • b ∈ s ↔ b ∈ a • s

full_name: Finset.mem_inv_smul_finset_iff₀
code: theorem mem_inv_smul_finset_iff₀ (ha : a ≠ 0) : b ∈ a⁻¹ • s ↔ a • b ∈ s 
goal: b ∈ a⁻¹ • s ↔ a • b ∈ s

full_name: Finset.smul_finset_subset_smul_finset_iff₀
code: @[simp]
theorem smul_finset_subset_smul_finset_iff₀ (ha : a ≠ 0) : a • s ⊆ a • t ↔ s ⊆ t 
goal: a • s ⊆ a • t ↔ s ⊆ t

full_name: Finset.smul_finset_subset_iff₀
code: theorem smul_finset_subset_iff₀ (ha : a ≠ 0) : a • s ⊆ t ↔ s ⊆ a⁻¹ • t 
goal: a • s ⊆ t ↔ s ⊆ a⁻¹ • t

full_name: Finset.subset_smul_finset_iff₀
code: theorem subset_smul_finset_iff₀ (ha : a ≠ 0) : s ⊆ a • t ↔ a⁻¹ • s ⊆ t 
goal: s ⊆ a • t ↔ a⁻¹ • s ⊆ t

full_name: Finset.smul_finset_inter₀
code: theorem smul_finset_inter₀ (ha : a ≠ 0) : a • (s ∩ t) = a • s ∩ a • t 
goal: a • (s ∩ t) = a • s ∩ a • t

full_name: Finset.smul_finset_sdiff₀
code: theorem smul_finset_sdiff₀ (ha : a ≠ 0) : a • (s \ t) = a • s \ a • t 
goal: a • (s \ t) = a • s \ a • t

full_name: Finset.smul_finset_symmDiff₀
code: theorem smul_finset_symmDiff₀ (ha : a ≠ 0) : a • s ∆ t = (a • s) ∆ (a • t) 
goal: a • symmDiff s t = symmDiff (a • s) (a • t)

full_name: Finset.smul_finset_univ₀
code: lemma smul_finset_univ₀ [Fintype β] (ha : a ≠ 0) : a • (univ : Finset β) = univ 
goal: a • Finset.univ = Finset.univ

full_name: Finset.smul_univ₀
code: theorem smul_univ₀ [Fintype β] {s : Finset α} (hs : ¬s ⊆ 0) : s • (univ : Finset β) = univ 
goal: s • Finset.univ = Finset.univ

full_name: Finset.smul_univ₀'
code: lemma smul_univ₀' [Fintype β] {s : Finset α} (hs : s.Nontrivial) : s • (univ : Finset β) = univ 
goal: s • Finset.univ = Finset.univ

full_name: Finset.inv_zero
code: @[simp] protected lemma inv_zero : (0 : Finset α)⁻¹ = 0 
goal: 0⁻¹ = 0

full_name: Finset.inv_smul_finset_distrib₀
code: @[simp] lemma inv_smul_finset_distrib₀ (a : α) (s : Finset α) : (a • s)⁻¹ = op a⁻¹ • s⁻¹ 
goal: (a • s)⁻¹ = MulOpposite.op a⁻¹ • s⁻¹

full_name: Finset.inv_op_smul_finset_distrib₀
code: @[simp] lemma inv_op_smul_finset_distrib₀ (a : α) (s : Finset α) : (op a • s)⁻¹ = a⁻¹ • s⁻¹ 
goal: (MulOpposite.op a • s)⁻¹ = a⁻¹ • s⁻¹

full_name: Finset.smul_finset_neg
code: @[simp]
theorem smul_finset_neg : a • -t = -(a • t) 
goal: a • -t = -(a • t)

full_name: Finset.smul_neg
code: @[simp]
protected theorem smul_neg : s • -t = -(s • t) 
goal: s • -t = -(s • t)

full_name: Finset.neg_smul_finset
code: @[simp]
theorem neg_smul_finset : -a • t = -(a • t) 
goal: -a • t = -(a • t)

full_name: Finset.neg_smul
code: @[simp]
protected theorem neg_smul [DecidableEq α] : -s • t = -(s • t) 
goal: -s • t = -(s • t)

full_name: Finset.sum_neg_index
code: @[to_additive (attr := simp)] lemma prod_inv_index [InvolutiveInv ι] (s : Finset ι) (f : ι → α) :
    ∏ i ∈ s⁻¹, f i = ∏ i ∈ s, f i⁻¹ 
goal: ∑ i ∈ -s, f i = ∑ i ∈ s, f (-i)

full_name: Finset.prod_inv_index
code: @[to_additive (attr := simp)] lemma prod_inv_index [InvolutiveInv ι] (s : Finset ι) (f : ι → α) :
    ∏ i ∈ s⁻¹, f i = ∏ i ∈ s, f i⁻¹ 
goal: ∏ i ∈ s⁻¹, f i = ∏ i ∈ s, f i⁻¹

full_name: Finset.prod_neg_index
code: @[to_additive existing, simp] lemma prod_neg_index [InvolutiveNeg ι] (s : Finset ι) (f : ι → α) :
    ∏ i ∈ -s, f i = ∏ i ∈ s, f (-i) 
goal: ∏ i ∈ -s, f i = ∏ i ∈ s, f (-i)

full_name: Finset.sum_inv_index
code: @[to_additive existing, simp] lemma sum_inv_index [InvolutiveInv ι] (s : Finset ι) (f : ι → α) :
    ∑ i ∈ s⁻¹, f i = ∑ i ∈ s, f i⁻¹ 
goal: ∑ i ∈ s⁻¹, f i = ∑ i ∈ s, f i⁻¹

full_name: Fintype.piFinset_mul
code: @[to_additive]
lemma piFinset_mul [∀ i, Mul (α i)] (s t : ∀ i, Finset (α i)) :
    piFinset (fun i ↦ s i * t i) = piFinset s * piFinset t 
goal: (Fintype.piFinset fun i => s i * t i) = Fintype.piFinset s * Fintype.piFinset t

full_name: Fintype.piFinset_add
code: @[to_additive]
lemma piFinset_mul [∀ i, Mul (α i)] (s t : ∀ i, Finset (α i)) :
    piFinset (fun i ↦ s i * t i) = piFinset s * piFinset t 
goal: (Fintype.piFinset fun i => s i + t i) = Fintype.piFinset s + Fintype.piFinset t

full_name: Fintype.piFinset_sub
code: @[to_additive]
lemma piFinset_div [∀ i, Div (α i)] (s t : ∀ i, Finset (α i)) :
    piFinset (fun i ↦ s i / t i) = piFinset s / piFinset t 
goal: (Fintype.piFinset fun i => s i - t i) = Fintype.piFinset s - Fintype.piFinset t

full_name: Fintype.piFinset_div
code: @[to_additive]
lemma piFinset_div [∀ i, Div (α i)] (s t : ∀ i, Finset (α i)) :
    piFinset (fun i ↦ s i / t i) = piFinset s / piFinset t 
goal: (Fintype.piFinset fun i => s i / t i) = Fintype.piFinset s / Fintype.piFinset t

full_name: Fintype.piFinset_neg
code: @[to_additive (attr := simp)]
lemma piFinset_inv [∀ i, Inv (α i)] (s : ∀ i, Finset (α i)) :
    piFinset (fun i ↦ (s i)⁻¹) = (piFinset s)⁻¹ 
goal: (Fintype.piFinset fun i => -s i) = -Fintype.piFinset s

full_name: Fintype.piFinset_inv
code: @[to_additive (attr := simp)]
lemma piFinset_inv [∀ i, Inv (α i)] (s : ∀ i, Finset (α i)) :
    piFinset (fun i ↦ (s i)⁻¹) = (piFinset s)⁻¹ 
goal: (Fintype.piFinset fun i => (s i)⁻¹) = (Fintype.piFinset s)⁻¹

full_name: Fintype.piFinset_vadd
code: @[to_additive]
lemma piFinset_smul [∀ i, SMul (α i) (β i)] (s : ∀ i, Finset (α i)) (t : ∀ i, Finset (β i)) :
    piFinset (fun i ↦ s i • t i) = piFinset s • piFinset t 
goal: (Fintype.piFinset fun i => s i +ᵥ t i) = Fintype.piFinset s +ᵥ Fintype.piFinset t

full_name: Fintype.piFinset_smul
code: @[to_additive]
lemma piFinset_smul [∀ i, SMul (α i) (β i)] (s : ∀ i, Finset (α i)) (t : ∀ i, Finset (β i)) :
    piFinset (fun i ↦ s i • t i) = piFinset s • piFinset t 
goal: (Fintype.piFinset fun i => s i • t i) = Fintype.piFinset s • Fintype.piFinset t

full_name: Fintype.piFinset_vadd_finset
code: @[to_additive]
lemma piFinset_smul_finset [∀ i, SMul (α i) (β i)] (a : ∀ i, α i) (s : ∀ i, Finset (β i)) :
    piFinset (fun i ↦ a i • s i) = a • piFinset s 
goal: (Fintype.piFinset fun i => a i +ᵥ s i) = a +ᵥ Fintype.piFinset s

full_name: Fintype.piFinset_smul_finset
code: @[to_additive]
lemma piFinset_smul_finset [∀ i, SMul (α i) (β i)] (a : ∀ i, α i) (s : ∀ i, Finset (β i)) :
    piFinset (fun i ↦ a i • s i) = a • piFinset s 
goal: (Fintype.piFinset fun i => a i • s i) = a • Fintype.piFinset s

full_name: Set.toFinset_one
code: @[to_additive (attr := simp)]
theorem toFinset_one : (1 : Set α).toFinset = 1 
goal: Set.toFinset 1 = 1

full_name: Set.toFinset_zero
code: @[to_additive (attr := simp)]
theorem toFinset_one : (1 : Set α).toFinset = 1 
goal: Set.toFinset 0 = 0

full_name: Set.Finite.toFinset_one
code: @[to_additive (attr := simp high)]
theorem Finite.toFinset_one (h : (1 : Set α).Finite := finite_one) : h.toFinset = 1 
goal: Set.Finite.toFinset h = 1

full_name: Set.Finite.toFinset_zero
code: @[to_additive (attr := simp high)]
theorem Finite.toFinset_one (h : (1 : Set α).Finite := finite_one) : h.toFinset = 1 
goal: Set.Finite.toFinset h = 0

full_name: Set.toFinset_mul
code: @[to_additive (attr := simp)]
theorem toFinset_mul (s t : Set α) [Fintype s] [Fintype t] [Fintype ↑(s * t)] :
    (s * t).toFinset = s.toFinset * t.toFinset 
goal: (s * t).toFinset = s.toFinset * t.toFinset

full_name: Set.toFinset_add
code: @[to_additive (attr := simp)]
theorem toFinset_mul (s t : Set α) [Fintype s] [Fintype t] [Fintype ↑(s * t)] :
    (s * t).toFinset = s.toFinset * t.toFinset 
goal: (s + t).toFinset = s.toFinset + t.toFinset

full_name: Set.Finite.toFinset_add
code: @[to_additive]
theorem Finite.toFinset_mul (hs : s.Finite) (ht : t.Finite) (hf := hs.mul ht) :
    hf.toFinset = hs.toFinset * ht.toFinset 
goal: Set.Finite.toFinset hf = hs.toFinset + ht.toFinset

full_name: Set.Finite.toFinset_mul
code: @[to_additive]
theorem Finite.toFinset_mul (hs : s.Finite) (ht : t.Finite) (hf := hs.mul ht) :
    hf.toFinset = hs.toFinset * ht.toFinset 
goal: Set.Finite.toFinset hf = hs.toFinset * ht.toFinset

full_name: Set.toFinset_vadd
code: @[to_additive (attr := simp)]
theorem toFinset_smul (s : Set α) (t : Set β) [Fintype s] [Fintype t] [Fintype ↑(s • t)] :
    (s • t).toFinset = s.toFinset • t.toFinset 
goal: (s +ᵥ t).toFinset = s.toFinset +ᵥ t.toFinset

full_name: Set.toFinset_smul
code: @[to_additive (attr := simp)]
theorem toFinset_smul (s : Set α) (t : Set β) [Fintype s] [Fintype t] [Fintype ↑(s • t)] :
    (s • t).toFinset = s.toFinset • t.toFinset 
goal: (s • t).toFinset = s.toFinset • t.toFinset

full_name: Set.Finite.toFinset_vadd
code: @[to_additive]
theorem Finite.toFinset_smul (hs : s.Finite) (ht : t.Finite) (hf := hs.smul ht) :
    hf.toFinset = hs.toFinset • ht.toFinset 
goal: Set.Finite.toFinset hf = hs.toFinset +ᵥ ht.toFinset

full_name: Set.Finite.toFinset_smul
code: @[to_additive]
theorem Finite.toFinset_smul (hs : s.Finite) (ht : t.Finite) (hf := hs.smul ht) :
    hf.toFinset = hs.toFinset • ht.toFinset 
goal: Set.Finite.toFinset hf = hs.toFinset • ht.toFinset

full_name: Set.toFinset_vadd_set
code: @[to_additive (attr := simp)]
theorem toFinset_smul_set (a : α) (s : Set β) [Fintype s] [Fintype ↑(a • s)] :
    (a • s).toFinset = a • s.toFinset 
goal: (a +ᵥ s).toFinset = a +ᵥ s.toFinset

full_name: Set.toFinset_smul_set
code: @[to_additive (attr := simp)]
theorem toFinset_smul_set (a : α) (s : Set β) [Fintype s] [Fintype ↑(a • s)] :
    (a • s).toFinset = a • s.toFinset 
goal: (a • s).toFinset = a • s.toFinset

full_name: Set.Finite.toFinset_vadd_set
code: @[to_additive]
theorem Finite.toFinset_smul_set (hs : s.Finite) (hf : (a • s).Finite := hs.smul_set) :
    hf.toFinset = a • hs.toFinset 
goal: Set.Finite.toFinset hf = a +ᵥ hs.toFinset

full_name: Set.Finite.toFinset_smul_set
code: @[to_additive]
theorem Finite.toFinset_smul_set (hs : s.Finite) (hf : (a • s).Finite := hs.smul_set) :
    hf.toFinset = a • hs.toFinset 
goal: Set.Finite.toFinset hf = a • hs.toFinset

full_name: Set.toFinset_vsub
code: @[simp]
theorem toFinset_vsub (s t : Set β) [Fintype s] [Fintype t] [Fintype ↑(s -ᵥ t)] :
    (s -ᵥ t : Set α).toFinset = s.toFinset -ᵥ t.toFinset 
goal: (s -ᵥ t).toFinset = s.toFinset -ᵥ t.toFinset

full_name: Set.Finite.toFinset_vsub
code: theorem Finite.toFinset_vsub (hs : s.Finite) (ht : t.Finite) (hf := hs.vsub ht) :
    hf.toFinset = hs.toFinset -ᵥ ht.toFinset 
goal: Set.Finite.toFinset hf = hs.toFinset -ᵥ ht.toFinset

full_name: Set.card_vadd_set
code: @[to_additive (attr := simp)]
lemma card_smul_set (a : α) (s : Set β) : Nat.card ↥(a • s) = Nat.card s 
goal: Nat.card ↑(a +ᵥ s) = Nat.card ↑s

full_name: Set.card_smul_set
code: @[to_additive (attr := simp)]
lemma card_smul_set (a : α) (s : Set β) : Nat.card ↥(a • s) = Nat.card s 
goal: Nat.card ↑(a • s) = Nat.card ↑s

full_name: Set.card_add_le
code: @[to_additive]
lemma card_mul_le : Nat.card (s * t) ≤ Nat.card s * Nat.card t 
goal: Nat.card ↑(s + t) ≤ Nat.card ↑s * Nat.card ↑t

full_name: Set.card_mul_le
code: @[to_additive]
lemma card_mul_le : Nat.card (s * t) ≤ Nat.card s * Nat.card t 
goal: Nat.card ↑(s * t) ≤ Nat.card ↑s * Nat.card ↑t

full_name: Set.card_inv
code: @[to_additive (attr := simp)]
lemma card_inv (s : Set α) : Nat.card ↥(s⁻¹) = Nat.card s 
goal: Nat.card ↑s⁻¹ = Nat.card ↑s

full_name: Set.card_neg
code: @[to_additive (attr := simp)]
lemma card_inv (s : Set α) : Nat.card ↥(s⁻¹) = Nat.card s 
goal: Nat.card ↑(-s) = Nat.card ↑s

full_name: Set.card_sub_le
code: @[to_additive]
lemma card_div_le : Nat.card (s / t) ≤ Nat.card s * Nat.card t 
goal: Nat.card ↑(s - t) ≤ Nat.card ↑s * Nat.card ↑t

full_name: Set.card_div_le
code: @[to_additive]
lemma card_div_le : Nat.card (s / t) ≤ Nat.card s * Nat.card t 
goal: Nat.card ↑(s / t) ≤ Nat.card ↑s * Nat.card ↑t

full_name: Nat.decidablePred_mem_vadd_set
code: instance Nat.decidablePred_mem_vadd_set {s : Set ℕ} [DecidablePred (· ∈ s)] (a : ℕ) :
    DecidablePred (· ∈ a +ᵥ s) 
goal: DecidablePred fun x => x ∈ a +ᵥ s