File: Mathlib/Data/Set/Pointwise/Basic.lean

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

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

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

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

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

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

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

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

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

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

full_name: Set.one_nonempty
code: @[to_additive]
theorem one_nonempty : (1 : Set α).Nonempty 
goal: Set.Nonempty 1

full_name: Set.zero_nonempty
code: @[to_additive]
theorem one_nonempty : (1 : Set α).Nonempty 
goal: Set.Nonempty 0

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

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

full_name: Set.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: Set.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: Set.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: Set.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: Set.singletonOneHom
code: /-- The singleton operation as a `OneHom`. -/
@[to_additive "The singleton operation as a `ZeroHom`."]
noncomputable def singletonOneHom : OneHom α (Set α) 
goal: OneHom α (Set α)

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

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

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

full_name: Set.inv
code: /-- The pointwise inversion of set `s⁻¹` is defined as `{x | x⁻¹ ∈ s}` in locale `Pointwise`. It is
equal to `{x⁻¹ | x ∈ s}`, see `Set.image_inv`. -/
@[to_additive
      "The pointwise negation of set `-s` is defined as `{x | -x ∈ s}` in locale `Pointwise`.
      It is equal to `{-x | x ∈ s}`, see `Set.image_neg`."]
protected def inv [Inv α] : Inv (Set α) 
goal: Inv (Set α)

full_name: Set.neg
code: /-- The pointwise inversion of set `s⁻¹` is defined as `{x | x⁻¹ ∈ s}` in locale `Pointwise`. It is
equal to `{x⁻¹ | x ∈ s}`, see `Set.image_inv`. -/
@[to_additive
      "The pointwise negation of set `-s` is defined as `{x | -x ∈ s}` in locale `Pointwise`.
      It is equal to `{-x | x ∈ s}`, see `Set.image_neg`."]
protected def inv [Inv α] : Inv (Set α) 
goal: Neg (Set α)

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

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

full_name: Set.inv_preimage
code: @[to_additive (attr := simp)]
theorem inv_preimage : Inv.inv ⁻¹' s = s⁻¹ 
goal: Inv.inv ⁻¹' s = s⁻¹

full_name: Set.neg_preimage
code: @[to_additive (attr := simp)]
theorem inv_preimage : Inv.inv ⁻¹' s = s⁻¹ 
goal: Neg.neg ⁻¹' s = -s

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

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

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

full_name: Set.inv_univ
code: @[to_additive (attr := simp)]
theorem inv_univ : (univ : Set α)⁻¹ = univ 
goal: Set.univ⁻¹ = Set.univ

full_name: Set.inter_neg
code: @[to_additive (attr := simp)]
theorem inter_inv : (s ∩ t)⁻¹ = s⁻¹ ∩ t⁻¹ 
goal: -(s ∩ t) = -s ∩ -t

full_name: Set.inter_inv
code: @[to_additive (attr := simp)]
theorem inter_inv : (s ∩ t)⁻¹ = s⁻¹ ∩ t⁻¹ 
goal: (s ∩ t)⁻¹ = s⁻¹ ∩ t⁻¹

full_name: Set.union_inv
code: @[to_additive (attr := simp)]
theorem union_inv : (s ∪ t)⁻¹ = s⁻¹ ∪ t⁻¹ 
goal: (s ∪ t)⁻¹ = s⁻¹ ∪ t⁻¹

full_name: Set.union_neg
code: @[to_additive (attr := simp)]
theorem union_inv : (s ∪ t)⁻¹ = s⁻¹ ∪ t⁻¹ 
goal: -(s ∪ t) = -s ∪ -t

full_name: Set.iInter_neg
code: @[to_additive (attr := simp)]
theorem iInter_inv (s : ι → Set α) : (⋂ i, s i)⁻¹ = ⋂ i, (s i)⁻¹ 
goal: -⋂ i, s i = ⋂ i, -s i

full_name: Set.iInter_inv
code: @[to_additive (attr := simp)]
theorem iInter_inv (s : ι → Set α) : (⋂ i, s i)⁻¹ = ⋂ i, (s i)⁻¹ 
goal: (⋂ i, s i)⁻¹ = ⋂ i, (s i)⁻¹

full_name: Set.iUnion_neg
code: @[to_additive (attr := simp)]
theorem iUnion_inv (s : ι → Set α) : (⋃ i, s i)⁻¹ = ⋃ i, (s i)⁻¹ 
goal: -⋃ i, s i = ⋃ i, -s i

full_name: Set.iUnion_inv
code: @[to_additive (attr := simp)]
theorem iUnion_inv (s : ι → Set α) : (⋃ i, s i)⁻¹ = ⋃ i, (s i)⁻¹ 
goal: (⋃ i, s i)⁻¹ = ⋃ i, (s i)⁻¹

full_name: Set.compl_neg
code: @[to_additive (attr := simp)]
theorem compl_inv : sᶜ⁻¹ = s⁻¹ᶜ 
goal: -sᶜ = (-s)ᶜ

full_name: Set.compl_inv
code: @[to_additive (attr := simp)]
theorem compl_inv : sᶜ⁻¹ = s⁻¹ᶜ 
goal: sᶜ⁻¹ = s⁻¹ᶜ

full_name: Set.inv_mem_inv
code: @[to_additive]
theorem inv_mem_inv : a⁻¹ ∈ s⁻¹ ↔ a ∈ s 
goal: a⁻¹ ∈ s⁻¹ ↔ a ∈ s

full_name: Set.neg_mem_neg
code: @[to_additive]
theorem inv_mem_inv : a⁻¹ ∈ s⁻¹ ↔ a ∈ s 
goal: -a ∈ -s ↔ a ∈ s

full_name: Set.nonempty_neg
code: @[to_additive (attr := simp)]
theorem nonempty_inv : s⁻¹.Nonempty ↔ s.Nonempty 
goal: (-s).Nonempty ↔ s.Nonempty

full_name: Set.nonempty_inv
code: @[to_additive (attr := simp)]
theorem nonempty_inv : s⁻¹.Nonempty ↔ s.Nonempty 
goal: s⁻¹.Nonempty ↔ s.Nonempty

full_name: Set.Nonempty.neg
code: @[to_additive]
theorem Nonempty.inv (h : s.Nonempty) : s⁻¹.Nonempty 
goal: (-s).Nonempty

full_name: Set.Nonempty.inv
code: @[to_additive]
theorem Nonempty.inv (h : s.Nonempty) : s⁻¹.Nonempty 
goal: s⁻¹.Nonempty

full_name: Set.image_neg
code: @[to_additive (attr := simp)]
theorem image_inv : Inv.inv '' s = s⁻¹ 
goal: Neg.neg '' s = -s

full_name: Set.image_inv
code: @[to_additive (attr := simp)]
theorem image_inv : Inv.inv '' s = s⁻¹ 
goal: Inv.inv '' s = s⁻¹

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

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

full_name: Set.involutiveInv
code: @[to_additive (attr := simp)]
noncomputable instance involutiveInv : InvolutiveInv (Set α) 
goal: InvolutiveInv (Set α)

full_name: Set.involutiveNeg
code: @[to_additive (attr := simp)]
noncomputable instance involutiveInv : InvolutiveInv (Set α) 
goal: InvolutiveNeg (Set α)

full_name: Set.neg_subset_neg
code: @[to_additive (attr := simp)]
theorem inv_subset_inv : s⁻¹ ⊆ t⁻¹ ↔ s ⊆ t 
goal: -s ⊆ -t ↔ s ⊆ t

full_name: Set.inv_subset_inv
code: @[to_additive (attr := simp)]
theorem inv_subset_inv : s⁻¹ ⊆ t⁻¹ ↔ s ⊆ t 
goal: s⁻¹ ⊆ t⁻¹ ↔ s ⊆ t

full_name: Set.neg_subset
code: @[to_additive]
theorem inv_subset : s⁻¹ ⊆ t ↔ s ⊆ t⁻¹ 
goal: -s ⊆ t ↔ s ⊆ -t

full_name: Set.inv_subset
code: @[to_additive]
theorem inv_subset : s⁻¹ ⊆ t ↔ s ⊆ t⁻¹ 
goal: s⁻¹ ⊆ t ↔ s ⊆ t⁻¹

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

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

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

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

full_name: Set.neg_range
code: @[to_additive]
theorem inv_range {ι : Sort*} {f : ι → α} : (range f)⁻¹ = range fun i => (f i)⁻¹ 
goal: -Set.range f = Set.range fun i => -f i

full_name: Set.inv_range
code: @[to_additive]
theorem inv_range {ι : Sort*} {f : ι → α} : (range f)⁻¹ = range fun i => (f i)⁻¹ 
goal: (Set.range f)⁻¹ = Set.range fun i => (f i)⁻¹

full_name: Set.image_op_neg
code: @[to_additive]
theorem image_op_inv : op '' s⁻¹ = (op '' s)⁻¹ 
goal: AddOpposite.op '' (-s) = -AddOpposite.op '' s

full_name: Set.image_op_inv
code: @[to_additive]
theorem image_op_inv : op '' s⁻¹ = (op '' s)⁻¹ 
goal: MulOpposite.op '' s⁻¹ = (MulOpposite.op '' s)⁻¹

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

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

full_name: Set.image2_add
code: @[to_additive (attr := simp)]
theorem image2_mul : image2 (· * ·) s t = s * t 
goal: Set.image2 (fun x x_1 => x + x_1) s t = s + t

full_name: Set.image2_mul
code: @[to_additive (attr := simp)]
theorem image2_mul : image2 (· * ·) s t = s * t 
goal: Set.image2 (fun x x_1 => x * x_1) s t = s * t

full_name: Set.mem_mul
code: @[to_additive]
theorem mem_mul : a ∈ s * t ↔ ∃ x ∈ s, ∃ y ∈ t, x * y = a 
goal: a ∈ s * t ↔ ∃ x ∈ s, ∃ y ∈ t, x * y = a

full_name: Set.mem_add
code: @[to_additive]
theorem mem_mul : a ∈ s * t ↔ ∃ x ∈ s, ∃ y ∈ t, x * y = a 
goal: a ∈ s + t ↔ ∃ x ∈ s, ∃ y ∈ t, x + y = a

full_name: Set.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: Set.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: Set.add_image_prod
code: @[to_additive add_image_prod]
theorem image_mul_prod : (fun x : α × α => x.fst * x.snd) '' s ×ˢ t = s * t 
goal: (fun x => x.1 + x.2) '' s ×ˢ t = s + t

full_name: Set.image_mul_prod
code: @[to_additive add_image_prod]
theorem image_mul_prod : (fun x : α × α => x.fst * x.snd) '' s ×ˢ t = s * t 
goal: (fun x => x.1 * x.2) '' s ×ˢ t = s * t

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

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

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

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

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

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

full_name: Set.mul_nonempty
code: @[to_additive (attr := simp)]
theorem mul_nonempty : (s * t).Nonempty ↔ s.Nonempty ∧ t.Nonempty 
goal: (s * t).Nonempty ↔ s.Nonempty ∧ t.Nonempty

full_name: Set.add_nonempty
code: @[to_additive (attr := simp)]
theorem mul_nonempty : (s * t).Nonempty ↔ s.Nonempty ∧ t.Nonempty 
goal: (s + t).Nonempty ↔ s.Nonempty ∧ t.Nonempty

full_name: Set.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: Set.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: Set.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: Set.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: Set.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: Set.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: Set.add_singleton
code: @[to_additive (attr := simp)]
theorem mul_singleton : s * {b} = (· * b) '' s 
goal: s + {b} = (fun x => x + b) '' s

full_name: Set.mul_singleton
code: @[to_additive (attr := simp)]
theorem mul_singleton : s * {b} = (· * b) '' s 
goal: s * {b} = (fun x => x * b) '' s

full_name: Set.singleton_mul
code: @[to_additive (attr := simp)]
theorem singleton_mul : {a} * t = (a * ·) '' t 
goal: {a} * t = (fun x => a * x) '' t

full_name: Set.singleton_add
code: @[to_additive (attr := simp)]
theorem singleton_mul : {a} * t = (a * ·) '' t 
goal: {a} + t = (fun x => a + x) '' t

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

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

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

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

full_name: Set.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: Set.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: Set.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: Set.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: Set.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: Set.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: Set.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: Set.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: Set.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: Set.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: Set.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: Set.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: Set.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: Set.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: Set.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: Set.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: Set.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: Set.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: Set.iUnion_add_left_image
code: @[to_additive]
theorem iUnion_mul_left_image : ⋃ a ∈ s, (a * ·) '' t = s * t 
goal: ⋃ a ∈ s, (fun x => a + x) '' t = s + t

full_name: Set.iUnion_mul_left_image
code: @[to_additive]
theorem iUnion_mul_left_image : ⋃ a ∈ s, (a * ·) '' t = s * t 
goal: ⋃ a ∈ s, (fun x => a * x) '' t = s * t

full_name: Set.iUnion_mul_right_image
code: @[to_additive]
theorem iUnion_mul_right_image : ⋃ a ∈ t, (· * a) '' s = s * t 
goal: ⋃ a ∈ t, (fun x => x * a) '' s = s * t

full_name: Set.iUnion_add_right_image
code: @[to_additive]
theorem iUnion_mul_right_image : ⋃ a ∈ t, (· * a) '' s = s * t 
goal: ⋃ a ∈ t, (fun x => x + a) '' s = s + t

full_name: Set.iUnion_mul
code: @[to_additive]
theorem iUnion_mul (s : ι → Set α) (t : Set α) : (⋃ i, s i) * t = ⋃ i, s i * t 
goal: (⋃ i, s i) * t = ⋃ i, s i * t

full_name: Set.iUnion_add
code: @[to_additive]
theorem iUnion_mul (s : ι → Set α) (t : Set α) : (⋃ i, s i) * t = ⋃ i, s i * t 
goal: (⋃ i, s i) + t = ⋃ i, s i + t

full_name: Set.add_iUnion
code: @[to_additive]
theorem mul_iUnion (s : Set α) (t : ι → Set α) : (s * ⋃ i, t i) = ⋃ i, s * t i 
goal: s + ⋃ i, t i = ⋃ i, s + t i

full_name: Set.mul_iUnion
code: @[to_additive]
theorem mul_iUnion (s : Set α) (t : ι → Set α) : (s * ⋃ i, t i) = ⋃ i, s * t i 
goal: s * ⋃ i, t i = ⋃ i, s * t i

full_name: Set.iUnion₂_mul
code: @[to_additive]
theorem iUnion₂_mul (s : ∀ i, κ i → Set α) (t : Set α) :
    (⋃ (i) (j), s i j) * t = ⋃ (i) (j), s i j * t 
goal: (⋃ i, ⋃ j, s i j) * t = ⋃ i, ⋃ j, s i j * t

full_name: Set.iUnion₂_add
code: @[to_additive]
theorem iUnion₂_mul (s : ∀ i, κ i → Set α) (t : Set α) :
    (⋃ (i) (j), s i j) * t = ⋃ (i) (j), s i j * t 
goal: (⋃ i, ⋃ j, s i j) + t = ⋃ i, ⋃ j, s i j + t

full_name: Set.mul_iUnion₂
code: @[to_additive]
theorem mul_iUnion₂ (s : Set α) (t : ∀ i, κ i → Set α) :
    (s * ⋃ (i) (j), t i j) = ⋃ (i) (j), s * t i j 
goal: s * ⋃ i, ⋃ j, t i j = ⋃ i, ⋃ j, s * t i j

full_name: Set.add_iUnion₂
code: @[to_additive]
theorem mul_iUnion₂ (s : Set α) (t : ∀ i, κ i → Set α) :
    (s * ⋃ (i) (j), t i j) = ⋃ (i) (j), s * t i j 
goal: s + ⋃ i, ⋃ j, t i j = ⋃ i, ⋃ j, s + t i j

full_name: Set.iInter_add_subset
code: @[to_additive]
theorem iInter_mul_subset (s : ι → Set α) (t : Set α) : (⋂ i, s i) * t ⊆ ⋂ i, s i * t 
goal: (⋂ i, s i) + t ⊆ ⋂ i, s i + t

full_name: Set.iInter_mul_subset
code: @[to_additive]
theorem iInter_mul_subset (s : ι → Set α) (t : Set α) : (⋂ i, s i) * t ⊆ ⋂ i, s i * t 
goal: (⋂ i, s i) * t ⊆ ⋂ i, s i * t

full_name: Set.add_iInter_subset
code: @[to_additive]
theorem mul_iInter_subset (s : Set α) (t : ι → Set α) : (s * ⋂ i, t i) ⊆ ⋂ i, s * t i 
goal: s + ⋂ i, t i ⊆ ⋂ i, s + t i

full_name: Set.mul_iInter_subset
code: @[to_additive]
theorem mul_iInter_subset (s : Set α) (t : ι → Set α) : (s * ⋂ i, t i) ⊆ ⋂ i, s * t i 
goal: s * ⋂ i, t i ⊆ ⋂ i, s * t i

full_name: Set.iInter₂_mul_subset
code: @[to_additive]
theorem iInter₂_mul_subset (s : ∀ i, κ i → Set α) (t : Set α) :
    (⋂ (i) (j), s i j) * t ⊆ ⋂ (i) (j), s i j * t 
goal: (⋂ i, ⋂ j, s i j) * t ⊆ ⋂ i, ⋂ j, s i j * t

full_name: Set.iInter₂_add_subset
code: @[to_additive]
theorem iInter₂_mul_subset (s : ∀ i, κ i → Set α) (t : Set α) :
    (⋂ (i) (j), s i j) * t ⊆ ⋂ (i) (j), s i j * t 
goal: (⋂ i, ⋂ j, s i j) + t ⊆ ⋂ i, ⋂ j, s i j + t

full_name: Set.add_iInter₂_subset
code: @[to_additive]
theorem mul_iInter₂_subset (s : Set α) (t : ∀ i, κ i → Set α) :
    (s * ⋂ (i) (j), t i j) ⊆ ⋂ (i) (j), s * t i j 
goal: s + ⋂ i, ⋂ j, t i j ⊆ ⋂ i, ⋂ j, s + t i j

full_name: Set.mul_iInter₂_subset
code: @[to_additive]
theorem mul_iInter₂_subset (s : Set α) (t : ∀ i, κ i → Set α) :
    (s * ⋂ (i) (j), t i j) ⊆ ⋂ (i) (j), s * t i j 
goal: s * ⋂ i, ⋂ j, t i j ⊆ ⋂ i, ⋂ j, s * t i j

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

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

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

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

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

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

full_name: Set.image_op_mul
code: @[to_additive (attr := simp)]
theorem image_op_mul : op '' (s * t) = op '' t * op '' s 
goal: MulOpposite.op '' (s * t) = MulOpposite.op '' t * MulOpposite.op '' s

full_name: Set.image_op_add
code: @[to_additive (attr := simp)]
theorem image_op_mul : op '' (s * t) = op '' t * op '' s 
goal: AddOpposite.op '' (s + t) = AddOpposite.op '' t + AddOpposite.op '' s

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

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

full_name: Set.image2_div
code: @[to_additive (attr := simp)]
theorem image2_div : image2 Div.div s t = s / t 
goal: Set.image2 Div.div s t = s / t

full_name: Set.image2_sub
code: @[to_additive (attr := simp)]
theorem image2_div : image2 Div.div s t = s / t 
goal: Set.image2 Sub.sub s t = s - t

full_name: Set.mem_sub
code: @[to_additive]
theorem mem_div : a ∈ s / t ↔ ∃ x ∈ s, ∃ y ∈ t, x / y = a 
goal: a ∈ s - t ↔ ∃ x ∈ s, ∃ y ∈ t, x - y = a

full_name: Set.mem_div
code: @[to_additive]
theorem mem_div : a ∈ s / t ↔ ∃ x ∈ s, ∃ y ∈ t, x / y = a 
goal: a ∈ s / t ↔ ∃ x ∈ s, ∃ y ∈ t, x / y = a

full_name: Set.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: Set.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: Set.image_div_prod
code: @[to_additive sub_image_prod]
theorem image_div_prod : (fun x : α × α => x.fst / x.snd) '' s ×ˢ t = s / t 
goal: (fun x => x.1 / x.2) '' s ×ˢ t = s / t

full_name: Set.sub_image_prod
code: @[to_additive sub_image_prod]
theorem image_div_prod : (fun x : α × α => x.fst / x.snd) '' s ×ˢ t = s / t 
goal: (fun x => x.1 - x.2) '' s ×ˢ t = s - t

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

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

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

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

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

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

full_name: Set.div_nonempty
code: @[to_additive (attr := simp)]
theorem div_nonempty : (s / t).Nonempty ↔ s.Nonempty ∧ t.Nonempty 
goal: (s / t).Nonempty ↔ s.Nonempty ∧ t.Nonempty

full_name: Set.sub_nonempty
code: @[to_additive (attr := simp)]
theorem div_nonempty : (s / t).Nonempty ↔ s.Nonempty ∧ t.Nonempty 
goal: (s - t).Nonempty ↔ s.Nonempty ∧ t.Nonempty

full_name: Set.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: Set.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: Set.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: Set.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: Set.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: Set.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: Set.sub_singleton
code: @[to_additive (attr := simp)]
theorem div_singleton : s / {b} = (· / b) '' s 
goal: s - {b} = (fun x => x - b) '' s

full_name: Set.div_singleton
code: @[to_additive (attr := simp)]
theorem div_singleton : s / {b} = (· / b) '' s 
goal: s / {b} = (fun x => x / b) '' s

full_name: Set.singleton_div
code: @[to_additive (attr := simp)]
theorem singleton_div : {a} / t = (· / ·) a '' t 
goal: {a} / t = (fun x x_1 => x / x_1) a '' t

full_name: Set.singleton_sub
code: @[to_additive (attr := simp)]
theorem singleton_div : {a} / t = (· / ·) a '' t 
goal: {a} - t = (fun x x_1 => x - x_1) a '' t

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

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

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

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

full_name: Set.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: Set.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: Set.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: Set.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: Set.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: Set.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: Set.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: Set.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: Set.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: Set.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: Set.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: Set.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: Set.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: Set.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: Set.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: Set.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: Set.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: Set.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: Set.iUnion_sub_left_image
code: @[to_additive]
theorem iUnion_div_left_image : ⋃ a ∈ s, (a / ·) '' t = s / t 
goal: ⋃ a ∈ s, (fun x => a - x) '' t = s - t

full_name: Set.iUnion_div_left_image
code: @[to_additive]
theorem iUnion_div_left_image : ⋃ a ∈ s, (a / ·) '' t = s / t 
goal: ⋃ a ∈ s, (fun x => a / x) '' t = s / t

full_name: Set.iUnion_sub_right_image
code: @[to_additive]
theorem iUnion_div_right_image : ⋃ a ∈ t, (· / a) '' s = s / t 
goal: ⋃ a ∈ t, (fun x => x - a) '' s = s - t

full_name: Set.iUnion_div_right_image
code: @[to_additive]
theorem iUnion_div_right_image : ⋃ a ∈ t, (· / a) '' s = s / t 
goal: ⋃ a ∈ t, (fun x => x / a) '' s = s / t

full_name: Set.iUnion_div
code: @[to_additive]
theorem iUnion_div (s : ι → Set α) (t : Set α) : (⋃ i, s i) / t = ⋃ i, s i / t 
goal: (⋃ i, s i) / t = ⋃ i, s i / t

full_name: Set.iUnion_sub
code: @[to_additive]
theorem iUnion_div (s : ι → Set α) (t : Set α) : (⋃ i, s i) / t = ⋃ i, s i / t 
goal: (⋃ i, s i) - t = ⋃ i, s i - t

full_name: Set.sub_iUnion
code: @[to_additive]
theorem div_iUnion (s : Set α) (t : ι → Set α) : (s / ⋃ i, t i) = ⋃ i, s / t i 
goal: s - ⋃ i, t i = ⋃ i, s - t i

full_name: Set.div_iUnion
code: @[to_additive]
theorem div_iUnion (s : Set α) (t : ι → Set α) : (s / ⋃ i, t i) = ⋃ i, s / t i 
goal: s / ⋃ i, t i = ⋃ i, s / t i

full_name: Set.iUnion₂_div
code: @[to_additive]
theorem iUnion₂_div (s : ∀ i, κ i → Set α) (t : Set α) :
    (⋃ (i) (j), s i j) / t = ⋃ (i) (j), s i j / t 
goal: (⋃ i, ⋃ j, s i j) / t = ⋃ i, ⋃ j, s i j / t

full_name: Set.iUnion₂_sub
code: @[to_additive]
theorem iUnion₂_div (s : ∀ i, κ i → Set α) (t : Set α) :
    (⋃ (i) (j), s i j) / t = ⋃ (i) (j), s i j / t 
goal: (⋃ i, ⋃ j, s i j) - t = ⋃ i, ⋃ j, s i j - t

full_name: Set.div_iUnion₂
code: @[to_additive]
theorem div_iUnion₂ (s : Set α) (t : ∀ i, κ i → Set α) :
    (s / ⋃ (i) (j), t i j) = ⋃ (i) (j), s / t i j 
goal: s / ⋃ i, ⋃ j, t i j = ⋃ i, ⋃ j, s / t i j

full_name: Set.sub_iUnion₂
code: @[to_additive]
theorem div_iUnion₂ (s : Set α) (t : ∀ i, κ i → Set α) :
    (s / ⋃ (i) (j), t i j) = ⋃ (i) (j), s / t i j 
goal: s - ⋃ i, ⋃ j, t i j = ⋃ i, ⋃ j, s - t i j

full_name: Set.iInter_div_subset
code: @[to_additive]
theorem iInter_div_subset (s : ι → Set α) (t : Set α) : (⋂ i, s i) / t ⊆ ⋂ i, s i / t 
goal: (⋂ i, s i) / t ⊆ ⋂ i, s i / t

full_name: Set.iInter_sub_subset
code: @[to_additive]
theorem iInter_div_subset (s : ι → Set α) (t : Set α) : (⋂ i, s i) / t ⊆ ⋂ i, s i / t 
goal: (⋂ i, s i) - t ⊆ ⋂ i, s i - t

full_name: Set.sub_iInter_subset
code: @[to_additive]
theorem div_iInter_subset (s : Set α) (t : ι → Set α) : (s / ⋂ i, t i) ⊆ ⋂ i, s / t i 
goal: s - ⋂ i, t i ⊆ ⋂ i, s - t i

full_name: Set.div_iInter_subset
code: @[to_additive]
theorem div_iInter_subset (s : Set α) (t : ι → Set α) : (s / ⋂ i, t i) ⊆ ⋂ i, s / t i 
goal: s / ⋂ i, t i ⊆ ⋂ i, s / t i

full_name: Set.iInter₂_sub_subset
code: @[to_additive]
theorem iInter₂_div_subset (s : ∀ i, κ i → Set α) (t : Set α) :
    (⋂ (i) (j), s i j) / t ⊆ ⋂ (i) (j), s i j / t 
goal: (⋂ i, ⋂ j, s i j) - t ⊆ ⋂ i, ⋂ j, s i j - t

full_name: Set.iInter₂_div_subset
code: @[to_additive]
theorem iInter₂_div_subset (s : ∀ i, κ i → Set α) (t : Set α) :
    (⋂ (i) (j), s i j) / t ⊆ ⋂ (i) (j), s i j / t 
goal: (⋂ i, ⋂ j, s i j) / t ⊆ ⋂ i, ⋂ j, s i j / t

full_name: Set.div_iInter₂_subset
code: @[to_additive]
theorem div_iInter₂_subset (s : Set α) (t : ∀ i, κ i → Set α) :
    (s / ⋂ (i) (j), t i j) ⊆ ⋂ (i) (j), s / t i j 
goal: s / ⋂ i, ⋂ j, t i j ⊆ ⋂ i, ⋂ j, s / t i j

full_name: Set.sub_iInter₂_subset
code: @[to_additive]
theorem div_iInter₂_subset (s : Set α) (t : ∀ i, κ i → Set α) :
    (s / ⋂ (i) (j), t i j) ⊆ ⋂ (i) (j), s / t i j 
goal: s - ⋂ i, ⋂ j, t i j ⊆ ⋂ i, ⋂ j, s - t i j

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

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

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

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

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

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

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

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

full_name: Set.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: Set.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: Set.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: Set.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: Set.mulOneClass
code: /-- `Set α` is a `MulOneClass` under pointwise operations if `α` is. -/
@[to_additive "`Set α` is an `AddZeroClass` under pointwise operations if `α` is."]
protected noncomputable def mulOneClass : MulOneClass (Set α) 
goal: MulOneClass (Set α)

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

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

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

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

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

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

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

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

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

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

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

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

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

full_name: Set.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: Set.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: Set.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: Set.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: Set.nsmul_subset_nsmul_of_zero_mem
code: @[to_additive]
theorem pow_subset_pow_of_one_mem (hs : (1 : α) ∈ s) (hn : m ≤ n) : s ^ m ⊆ s ^ n 
goal: m • s ⊆ n • s

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

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

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

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

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

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

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

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

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

full_name: Set.nsmul_univ
code: @[simp]
theorem nsmul_univ {α : Type*} [AddMonoid α] : ∀ {n : ℕ}, n ≠ 0 → n • (univ : Set α) = univ
  
goal: n ≠ 0 → n • Set.univ = Set.univ

full_name: Set.univ_pow
code: @[to_additive existing (attr := simp) nsmul_univ]
theorem univ_pow : ∀ {n : ℕ}, n ≠ 0 → (univ : Set α) ^ n = univ
  
goal: n ≠ 0 → Set.univ ^ n = Set.univ

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

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

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

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

full_name: Set.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: Set.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: Set.divisionMonoid
code: /-- `Set α` is a division monoid under pointwise operations if `α` is. -/
@[to_additive subtractionMonoid
    "`Set α` is a subtraction monoid under pointwise operations if `α` is."]
protected noncomputable def divisionMonoid : DivisionMonoid (Set α) 
goal: DivisionMonoid (Set α)

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

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

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

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

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

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

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

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

full_name: Set.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: Set.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: Set.mul_zero_subset
code: theorem mul_zero_subset (s : Set α) : s * 0 ⊆ 0 
goal: s * 0 ⊆ 0

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

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

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

full_name: Set.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: Set.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: Set.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: Set.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: Set.Nonempty.one_mem_div
code: @[to_additive]
theorem Nonempty.one_mem_div (h : s.Nonempty) : (1 : α) ∈ s / s 
goal: 1 ∈ s / s

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

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

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

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

full_name: Set.isAddUnit_iff_singleton
code: @[to_additive (attr := simp)]
theorem isUnit_iff_singleton : IsUnit s ↔ ∃ a, s = {a} 
goal: IsAddUnit s ↔ ∃ a, s = {a}

full_name: Set.image_add_left
code: @[to_additive (attr := simp)]
theorem image_mul_left : (a * ·) '' t = (a⁻¹ * ·) ⁻¹' t 
goal: (fun x => a + x) '' t = (fun x => -a + x) ⁻¹' t

full_name: Set.image_mul_left
code: @[to_additive (attr := simp)]
theorem image_mul_left : (a * ·) '' t = (a⁻¹ * ·) ⁻¹' t 
goal: (fun x => a * x) '' t = (fun x => a⁻¹ * x) ⁻¹' t

full_name: Set.image_add_right
code: @[to_additive (attr := simp)]
theorem image_mul_right : (· * b) '' t = (· * b⁻¹) ⁻¹' t 
goal: (fun x => x + b) '' t = (fun x => x + -b) ⁻¹' t

full_name: Set.image_mul_right
code: @[to_additive (attr := simp)]
theorem image_mul_right : (· * b) '' t = (· * b⁻¹) ⁻¹' t 
goal: (fun x => x * b) '' t = (fun x => x * b⁻¹) ⁻¹' t

full_name: Set.image_mul_left'
code: @[to_additive]
theorem image_mul_left' : (a⁻¹ * ·) '' t = (a * ·) ⁻¹' t 
goal: (fun x => a⁻¹ * x) '' t = (fun x => a * x) ⁻¹' t

full_name: Set.image_add_left'
code: @[to_additive]
theorem image_mul_left' : (a⁻¹ * ·) '' t = (a * ·) ⁻¹' t 
goal: (fun x => -a + x) '' t = (fun x => a + x) ⁻¹' t

full_name: Set.image_add_right'
code: @[to_additive]
theorem image_mul_right' : (· * b⁻¹) '' t = (· * b) ⁻¹' t 
goal: (fun x => x + -b) '' t = (fun x => x + b) ⁻¹' t

full_name: Set.image_mul_right'
code: @[to_additive]
theorem image_mul_right' : (· * b⁻¹) '' t = (· * b) ⁻¹' t 
goal: (fun x => x * b⁻¹) '' t = (fun x => x * b) ⁻¹' t

full_name: Set.preimage_add_left_singleton
code: @[to_additive (attr := simp)]
theorem preimage_mul_left_singleton : (a * ·) ⁻¹' {b} = {a⁻¹ * b} 
goal: (fun x => a + x) ⁻¹' {b} = {-a + b}

full_name: Set.preimage_mul_left_singleton
code: @[to_additive (attr := simp)]
theorem preimage_mul_left_singleton : (a * ·) ⁻¹' {b} = {a⁻¹ * b} 
goal: (fun x => a * x) ⁻¹' {b} = {a⁻¹ * b}

full_name: Set.preimage_mul_right_singleton
code: @[to_additive (attr := simp)]
theorem preimage_mul_right_singleton : (· * a) ⁻¹' {b} = {b * a⁻¹} 
goal: (fun x => x * a) ⁻¹' {b} = {b * a⁻¹}

full_name: Set.preimage_add_right_singleton
code: @[to_additive (attr := simp)]
theorem preimage_mul_right_singleton : (· * a) ⁻¹' {b} = {b * a⁻¹} 
goal: (fun x => x + a) ⁻¹' {b} = {b + -a}

full_name: Set.preimage_mul_left_one
code: @[to_additive (attr := simp)]
theorem preimage_mul_left_one : (a * ·) ⁻¹' 1 = {a⁻¹} 
goal: (fun x => a * x) ⁻¹' 1 = {a⁻¹}

full_name: Set.preimage_add_left_zero
code: @[to_additive (attr := simp)]
theorem preimage_mul_left_one : (a * ·) ⁻¹' 1 = {a⁻¹} 
goal: (fun x => a + x) ⁻¹' 0 = {-a}

full_name: Set.preimage_mul_right_one
code: @[to_additive (attr := simp)]
theorem preimage_mul_right_one : (· * b) ⁻¹' 1 = {b⁻¹} 
goal: (fun x => x * b) ⁻¹' 1 = {b⁻¹}

full_name: Set.preimage_add_right_zero
code: @[to_additive (attr := simp)]
theorem preimage_mul_right_one : (· * b) ⁻¹' 1 = {b⁻¹} 
goal: (fun x => x + b) ⁻¹' 0 = {-b}

full_name: Set.preimage_mul_left_one'
code: @[to_additive]
theorem preimage_mul_left_one' : (a⁻¹ * ·) ⁻¹' 1 = {a} 
goal: (fun x => a⁻¹ * x) ⁻¹' 1 = {a}

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

full_name: Set.preimage_mul_right_one'
code: @[to_additive]
theorem preimage_mul_right_one' : (· * b⁻¹) ⁻¹' 1 = {b} 
goal: (fun x => x * b⁻¹) ⁻¹' 1 = {b}

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

full_name: Set.add_univ
code: @[to_additive (attr := simp)]
theorem mul_univ (hs : s.Nonempty) : s * (univ : Set α) = univ 
goal: s + Set.univ = Set.univ

full_name: Set.mul_univ
code: @[to_additive (attr := simp)]
theorem mul_univ (hs : s.Nonempty) : s * (univ : Set α) = univ 
goal: s * Set.univ = Set.univ

full_name: Set.univ_mul
code: @[to_additive (attr := simp)]
theorem univ_mul (ht : t.Nonempty) : (univ : Set α) * t = univ 
goal: Set.univ * t = Set.univ

full_name: Set.univ_add
code: @[to_additive (attr := simp)]
theorem univ_mul (ht : t.Nonempty) : (univ : Set α) * t = univ 
goal: Set.univ + t = Set.univ

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

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

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

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

full_name: Set.image_mul
code: @[to_additive]
theorem image_mul : m '' (s * t) = m '' s * m '' t 
goal: ⇑m '' (s * t) = ⇑m '' s * ⇑m '' t

full_name: Set.image_add
code: @[to_additive]
theorem image_mul : m '' (s * t) = m '' s * m '' t 
goal: ⇑m '' (s + t) = ⇑m '' s + ⇑m '' t

full_name: Set.mul_subset_range
code: @[to_additive]
lemma mul_subset_range {s t : Set β} (hs : s ⊆ range m) (ht : t ⊆ range m) : s * t ⊆ range m 
goal: s * t ⊆ Set.range ⇑m

full_name: Set.add_subset_range
code: @[to_additive]
lemma mul_subset_range {s t : Set β} (hs : s ⊆ range m) (ht : t ⊆ range m) : s * t ⊆ range m 
goal: s + t ⊆ Set.range ⇑m

full_name: Set.preimage_mul_preimage_subset
code: @[to_additive]
theorem preimage_mul_preimage_subset {s t : Set β} : m ⁻¹' s * m ⁻¹' t ⊆ m ⁻¹' (s * t) 
goal: ⇑m ⁻¹' s * ⇑m ⁻¹' t ⊆ ⇑m ⁻¹' (s * t)

full_name: Set.preimage_add_preimage_subset
code: @[to_additive]
theorem preimage_mul_preimage_subset {s t : Set β} : m ⁻¹' s * m ⁻¹' t ⊆ m ⁻¹' (s * t) 
goal: ⇑m ⁻¹' s + ⇑m ⁻¹' t ⊆ ⇑m ⁻¹' (s + t)

full_name: Set.preimage_mul
code: @[to_additive]
lemma preimage_mul (hm : Injective m) {s t : Set β} (hs : s ⊆ range m) (ht : t ⊆ range m) :
    m ⁻¹' (s * t) = m ⁻¹' s * m ⁻¹' t 
goal: ⇑m ⁻¹' (s * t) = ⇑m ⁻¹' s * ⇑m ⁻¹' t

full_name: Set.preimage_add
code: @[to_additive]
lemma preimage_mul (hm : Injective m) {s t : Set β} (hs : s ⊆ range m) (ht : t ⊆ range m) :
    m ⁻¹' (s * t) = m ⁻¹' s * m ⁻¹' t 
goal: ⇑m ⁻¹' (s + t) = ⇑m ⁻¹' s + ⇑m ⁻¹' t

full_name: Set.image_sub
code: @[to_additive]
theorem image_div : m '' (s / t) = m '' s / m '' t 
goal: ⇑m '' (s - t) = ⇑m '' s - ⇑m '' t

full_name: Set.image_div
code: @[to_additive]
theorem image_div : m '' (s / t) = m '' s / m '' t 
goal: ⇑m '' (s / t) = ⇑m '' s / ⇑m '' t

full_name: Set.sub_subset_range
code: @[to_additive]
lemma div_subset_range {s t : Set β} (hs : s ⊆ range m) (ht : t ⊆ range m) : s / t ⊆ range m 
goal: s - t ⊆ Set.range ⇑m

full_name: Set.div_subset_range
code: @[to_additive]
lemma div_subset_range {s t : Set β} (hs : s ⊆ range m) (ht : t ⊆ range m) : s / t ⊆ range m 
goal: s / t ⊆ Set.range ⇑m

full_name: Set.preimage_div_preimage_subset
code: @[to_additive]
theorem preimage_div_preimage_subset {s t : Set β} : m ⁻¹' s / m ⁻¹' t ⊆ m ⁻¹' (s / t) 
goal: ⇑m ⁻¹' s / ⇑m ⁻¹' t ⊆ ⇑m ⁻¹' (s / t)

full_name: Set.preimage_sub_preimage_subset
code: @[to_additive]
theorem preimage_div_preimage_subset {s t : Set β} : m ⁻¹' s / m ⁻¹' t ⊆ m ⁻¹' (s / t) 
goal: ⇑m ⁻¹' s - ⇑m ⁻¹' t ⊆ ⇑m ⁻¹' (s - t)

full_name: Set.preimage_div
code: @[to_additive]
lemma preimage_div (hm : Injective m) {s t : Set β} (hs : s ⊆ range m) (ht : t ⊆ range m) :
    m ⁻¹' (s / t) = m ⁻¹' s / m ⁻¹' t 
goal: ⇑m ⁻¹' (s / t) = ⇑m ⁻¹' s / ⇑m ⁻¹' t

full_name: Set.preimage_sub
code: @[to_additive]
lemma preimage_div (hm : Injective m) {s t : Set β} (hs : s ⊆ range m) (ht : t ⊆ range m) :
    m ⁻¹' (s / t) = m ⁻¹' s / m ⁻¹' t 
goal: ⇑m ⁻¹' (s - t) = ⇑m ⁻¹' s - ⇑m ⁻¹' t

full_name: AddGroup.card_nsmul_eq_card_nsmul_card_univ_aux
code: @[to_additive]
theorem card_pow_eq_card_pow_card_univ_aux {f : ℕ → ℕ} (h1 : Monotone f) {B : ℕ} (h2 : ∀ n, f n ≤ B)
    (h3 : ∀ n, f n = f (n + 1) → f (n + 1) = f (n + 2)) : ∀ k, B ≤ k → f k = f B 
goal: B ≤ k → f k = f B

full_name: Group.card_pow_eq_card_pow_card_univ_aux
code: @[to_additive]
theorem card_pow_eq_card_pow_card_univ_aux {f : ℕ → ℕ} (h1 : Monotone f) {B : ℕ} (h2 : ∀ n, f n ≤ B)
    (h3 : ∀ n, f n = f (n + 1) → f (n + 1) = f (n + 2)) : ∀ k, B ≤ k → f k = f B 
goal: B ≤ k → f k = f B