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

full_name: Set.smulSet
code: /-- The dilation of set `x • s` is defined as `{x • y | y ∈ s}` in locale `Pointwise`. -/
@[to_additive
      "The translation of set `x +ᵥ s` is defined as `{x +ᵥ y | y ∈ s}` in
      locale `Pointwise`."]
protected def smulSet [SMul α β] : SMul α (Set β) 
goal: SMul α (Set β)

full_name: Set.vaddSet
code: /-- The dilation of set `x • s` is defined as `{x • y | y ∈ s}` in locale `Pointwise`. -/
@[to_additive
      "The translation of set `x +ᵥ s` is defined as `{x +ᵥ y | y ∈ s}` in
      locale `Pointwise`."]
protected def smulSet [SMul α β] : SMul α (Set β) 
goal: VAdd α (Set β)

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

full_name: Set.vadd
code: /-- The pointwise scalar multiplication of sets `s • t` is defined as `{x • y | x ∈ s, y ∈ t}` in
locale `Pointwise`. -/
@[to_additive
      "The pointwise scalar addition of sets `s +ᵥ t` is defined as
      `{x +ᵥ y | x ∈ s, y ∈ t}` in locale `Pointwise`."]
protected def smul [SMul α β] : SMul (Set α) (Set β) 
goal: VAdd (Set α) (Set β)

full_name: Set.image2_smul
code: @[to_additive (attr := simp)]
theorem image2_smul : image2 SMul.smul s t = s • t 
goal: Set.image2 SMul.smul s t = s • t

full_name: Set.image2_vadd
code: @[to_additive (attr := simp)]
theorem image2_smul : image2 SMul.smul s t = s • t 
goal: Set.image2 VAdd.vadd s t = s +ᵥ t

full_name: Set.image_smul_prod
code: @[to_additive vadd_image_prod]
theorem image_smul_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.vadd_image_prod
code: @[to_additive vadd_image_prod]
theorem image_smul_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.mem_vadd
code: @[to_additive]
theorem mem_smul : b ∈ s • t ↔ ∃ x ∈ s, ∃ y ∈ t, x • y = b 
goal: b ∈ s +ᵥ t ↔ ∃ x ∈ s, ∃ y ∈ t, x +ᵥ y = b

full_name: Set.mem_smul
code: @[to_additive]
theorem mem_smul : b ∈ s • t ↔ ∃ x ∈ s, ∃ y ∈ t, x • y = b 
goal: b ∈ s • t ↔ ∃ x ∈ s, ∃ y ∈ t, x • y = b

full_name: Set.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: Set.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: Set.empty_vadd
code: @[to_additive (attr := simp)]
theorem empty_smul : (∅ : Set α) • t = ∅ 
goal: ∅ +ᵥ t = ∅

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

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

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

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

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

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

full_name: Set.vadd_nonempty
code: @[to_additive (attr := simp)]
theorem smul_nonempty : (s • t).Nonempty ↔ s.Nonempty ∧ t.Nonempty 
goal: (s +ᵥ t).Nonempty ↔ s.Nonempty ∧ t.Nonempty

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

full_name: Set.vadd_singleton
code: @[to_additive (attr := simp low+1)]
theorem smul_singleton : s • ({b} : Set β) = (· • b) '' s 
goal: s +ᵥ {b} = (fun x => x +ᵥ b) '' s

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

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

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

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

full_name: Set.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: Set.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: Set.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: Set.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: Set.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: Set.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: Set.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: Set.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: Set.union_vadd
code: @[to_additive]
theorem union_smul : (s₁ ∪ s₂) • t = s₁ • t ∪ s₂ • t 
goal: s₁ ∪ s₂ +ᵥ t = s₁ +ᵥ t ∪ (s₂ +ᵥ t)

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

full_name: Set.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: Set.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: Set.inter_vadd_subset
code: @[to_additive]
theorem inter_smul_subset : (s₁ ∩ s₂) • t ⊆ s₁ • t ∩ s₂ • t 
goal: s₁ ∩ s₂ +ᵥ t ⊆ (s₁ +ᵥ t) ∩ (s₂ +ᵥ t)

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

full_name: Set.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: Set.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: Set.inter_smul_union_subset_union
code: @[to_additive]
theorem inter_smul_union_subset_union : (s₁ ∩ s₂) • (t₁ ∪ t₂) ⊆ s₁ • t₁ ∪ s₂ • t₂ 
goal: (s₁ ∩ s₂) • (t₁ ∪ t₂) ⊆ s₁ • t₁ ∪ s₂ • t₂

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

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

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

full_name: Set.iUnion_smul_left_image
code: @[to_additive]
theorem iUnion_smul_left_image : ⋃ a ∈ s, a • t = s • t 
goal: ⋃ a ∈ s, a • t = s • t

full_name: Set.iUnion_vadd_left_image
code: @[to_additive]
theorem iUnion_smul_left_image : ⋃ a ∈ s, a • t = s • t 
goal: ⋃ a ∈ s, a +ᵥ t = s +ᵥ t

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

full_name: Set.iUnion_vadd_right_image
code: @[to_additive]
theorem iUnion_smul_right_image : ⋃ a ∈ t, (· • a) '' s = s • t 
goal: ⋃ a ∈ t, (fun x => x +ᵥ a) '' s = s +ᵥ t

full_name: Set.iUnion_vadd
code: @[to_additive]
theorem iUnion_smul (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_smul
code: @[to_additive]
theorem iUnion_smul (s : ι → Set α) (t : Set β) : (⋃ i, s i) • t = ⋃ i, s i • t 
goal: (⋃ i, s i) • t = ⋃ i, s i • t

full_name: Set.vadd_iUnion
code: @[to_additive]
theorem smul_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.smul_iUnion
code: @[to_additive]
theorem smul_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₂_smul
code: @[to_additive]
theorem iUnion₂_smul (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₂_vadd
code: @[to_additive]
theorem iUnion₂_smul (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.smul_iUnion₂
code: @[to_additive]
theorem smul_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.vadd_iUnion₂
code: @[to_additive]
theorem smul_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_vadd_subset
code: @[to_additive]
theorem iInter_smul_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_smul_subset
code: @[to_additive]
theorem iInter_smul_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.smul_iInter_subset
code: @[to_additive]
theorem smul_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.vadd_iInter_subset
code: @[to_additive]
theorem smul_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₂_smul_subset
code: @[to_additive]
theorem iInter₂_smul_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₂_vadd_subset
code: @[to_additive]
theorem iInter₂_smul_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.vadd_iInter₂_subset
code: @[to_additive]
theorem smul_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.smul_iInter₂_subset
code: @[to_additive]
theorem smul_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.vadd_set_subset_vadd
code: @[to_additive]
theorem smul_set_subset_smul {s : Set α} : a ∈ s → a • t ⊆ s • t 
goal: a ∈ s → a +ᵥ t ⊆ s +ᵥ t

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

full_name: Set.iUnion_smul_set
code: @[to_additive (attr := simp)]
theorem iUnion_smul_set (s : Set α) (t : Set β) : ⋃ a ∈ s, a • t = s • t 
goal: ⋃ a ∈ s, a • t = s • t

full_name: Set.iUnion_vadd_set
code: @[to_additive (attr := simp)]
theorem iUnion_smul_set (s : Set α) (t : Set β) : ⋃ a ∈ s, a • t = s • t 
goal: ⋃ a ∈ s, a +ᵥ t = s +ᵥ t

full_name: Set.image_smul
code: @[to_additive]
theorem image_smul : (fun x ↦ a • x) '' t = a • t 
goal: (fun x => a • x) '' t = a • t

full_name: Set.image_vadd
code: @[to_additive]
theorem image_smul : (fun x ↦ a • x) '' t = a • t 
goal: (fun x => a +ᵥ x) '' t = a +ᵥ t

full_name: Set.mem_smul_set
code: @[to_additive]
theorem mem_smul_set : x ∈ a • t ↔ ∃ y, y ∈ t ∧ a • y = x 
goal: x ∈ a • t ↔ ∃ y ∈ t, a • y = x

full_name: Set.mem_vadd_set
code: @[to_additive]
theorem mem_smul_set : x ∈ a • t ↔ ∃ y, y ∈ t ∧ a • y = x 
goal: x ∈ a +ᵥ t ↔ ∃ y ∈ t, a +ᵥ y = x

full_name: Set.vadd_mem_vadd_set
code: @[to_additive]
theorem smul_mem_smul_set : b ∈ s → a • b ∈ a • s 
goal: b ∈ s → a +ᵥ b ∈ a +ᵥ s

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

full_name: Set.vadd_set_empty
code: @[to_additive (attr := simp)]
theorem smul_set_empty : a • (∅ : Set β) = ∅ 
goal: a +ᵥ ∅ = ∅

full_name: Set.smul_set_empty
code: @[to_additive (attr := simp)]
theorem smul_set_empty : a • (∅ : Set β) = ∅ 
goal: a • ∅ = ∅

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

full_name: Set.vadd_set_eq_empty
code: @[to_additive (attr := simp)]
theorem smul_set_eq_empty : a • s = ∅ ↔ s = ∅ 
goal: a +ᵥ s = ∅ ↔ s = ∅

full_name: Set.vadd_set_nonempty
code: @[to_additive (attr := simp)]
theorem smul_set_nonempty : (a • s).Nonempty ↔ s.Nonempty 
goal: (a +ᵥ s).Nonempty ↔ s.Nonempty

full_name: Set.smul_set_nonempty
code: @[to_additive (attr := simp)]
theorem smul_set_nonempty : (a • s).Nonempty ↔ s.Nonempty 
goal: (a • s).Nonempty ↔ s.Nonempty

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

full_name: Set.vadd_set_singleton
code: @[to_additive (attr := simp)]
theorem smul_set_singleton : a • ({b} : Set β) = {a • b} 
goal: a +ᵥ {b} = {a +ᵥ b}

full_name: Set.vadd_set_mono
code: @[to_additive]
theorem smul_set_mono : s ⊆ t → a • s ⊆ a • t 
goal: s ⊆ t → a +ᵥ s ⊆ a +ᵥ t

full_name: Set.smul_set_mono
code: @[to_additive]
theorem smul_set_mono : s ⊆ t → a • s ⊆ a • t 
goal: s ⊆ t → a • s ⊆ a • t

full_name: Set.smul_set_subset_iff
code: @[to_additive]
theorem smul_set_subset_iff : a • s ⊆ t ↔ ∀ ⦃b⦄, b ∈ s → a • b ∈ t 
goal: a • s ⊆ t ↔ ∀ ⦃b : β⦄, b ∈ s → a • b ∈ t

full_name: Set.vadd_set_subset_iff
code: @[to_additive]
theorem smul_set_subset_iff : a • s ⊆ t ↔ ∀ ⦃b⦄, b ∈ s → a • b ∈ t 
goal: a +ᵥ s ⊆ t ↔ ∀ ⦃b : β⦄, b ∈ s → a +ᵥ b ∈ t

full_name: Set.smul_set_union
code: @[to_additive]
theorem smul_set_union : a • (t₁ ∪ t₂) = a • t₁ ∪ a • t₂ 
goal: a • (t₁ ∪ t₂) = a • t₁ ∪ a • t₂

full_name: Set.vadd_set_union
code: @[to_additive]
theorem smul_set_union : a • (t₁ ∪ t₂) = a • t₁ ∪ a • t₂ 
goal: a +ᵥ (t₁ ∪ t₂) = a +ᵥ t₁ ∪ (a +ᵥ t₂)

full_name: Set.smul_set_inter_subset
code: @[to_additive]
theorem smul_set_inter_subset : a • (t₁ ∩ t₂) ⊆ a • t₁ ∩ a • t₂ 
goal: a • (t₁ ∩ t₂) ⊆ a • t₁ ∩ a • t₂

full_name: Set.vadd_set_inter_subset
code: @[to_additive]
theorem smul_set_inter_subset : a • (t₁ ∩ t₂) ⊆ a • t₁ ∩ a • t₂ 
goal: a +ᵥ t₁ ∩ t₂ ⊆ (a +ᵥ t₁) ∩ (a +ᵥ t₂)

full_name: Set.smul_set_iUnion
code: @[to_additive]
theorem smul_set_iUnion (a : α) (s : ι → Set β) : (a • ⋃ i, s i) = ⋃ i, a • s i 
goal: a • ⋃ i, s i = ⋃ i, a • s i

full_name: Set.vadd_set_iUnion
code: @[to_additive]
theorem smul_set_iUnion (a : α) (s : ι → Set β) : (a • ⋃ i, s i) = ⋃ i, a • s i 
goal: a +ᵥ ⋃ i, s i = ⋃ i, a +ᵥ s i

full_name: Set.vadd_set_iUnion₂
code: @[to_additive]
theorem smul_set_iUnion₂ (a : α) (s : ∀ i, κ i → Set β) :
    (a • ⋃ (i) (j), s i j) = ⋃ (i) (j), a • s i j 
goal: a +ᵥ ⋃ i, ⋃ j, s i j = ⋃ i, ⋃ j, a +ᵥ s i j

full_name: Set.smul_set_iUnion₂
code: @[to_additive]
theorem smul_set_iUnion₂ (a : α) (s : ∀ i, κ i → Set β) :
    (a • ⋃ (i) (j), s i j) = ⋃ (i) (j), a • s i j 
goal: a • ⋃ i, ⋃ j, s i j = ⋃ i, ⋃ j, a • s i j

full_name: Set.smul_set_iInter_subset
code: @[to_additive]
theorem smul_set_iInter_subset (a : α) (t : ι → Set β) : (a • ⋂ i, t i) ⊆ ⋂ i, a • t i 
goal: a • ⋂ i, t i ⊆ ⋂ i, a • t i

full_name: Set.vadd_set_iInter_subset
code: @[to_additive]
theorem smul_set_iInter_subset (a : α) (t : ι → Set β) : (a • ⋂ i, t i) ⊆ ⋂ i, a • t i 
goal: a +ᵥ ⋂ i, t i ⊆ ⋂ i, a +ᵥ t i

full_name: Set.smul_set_iInter₂_subset
code: @[to_additive]
theorem smul_set_iInter₂_subset (a : α) (t : ∀ i, κ i → Set β) :
    (a • ⋂ (i) (j), t i j) ⊆ ⋂ (i) (j), a • t i j 
goal: a • ⋂ i, ⋂ j, t i j ⊆ ⋂ i, ⋂ j, a • t i j

full_name: Set.vadd_set_iInter₂_subset
code: @[to_additive]
theorem smul_set_iInter₂_subset (a : α) (t : ∀ i, κ i → Set β) :
    (a • ⋂ (i) (j), t i j) ⊆ ⋂ (i) (j), a • t i j 
goal: a +ᵥ ⋂ i, ⋂ j, t i j ⊆ ⋂ i, ⋂ j, a +ᵥ t i j

full_name: Set.Nonempty.smul_set
code: @[to_additive]
theorem Nonempty.smul_set : s.Nonempty → (a • s).Nonempty 
goal: s.Nonempty → (a • s).Nonempty

full_name: Set.Nonempty.vadd_set
code: @[to_additive]
theorem Nonempty.smul_set : s.Nonempty → (a • s).Nonempty 
goal: s.Nonempty → (a +ᵥ s).Nonempty

full_name: Set.op_vadd_set_subset_add
code: @[to_additive]
theorem op_smul_set_subset_mul : a ∈ t → op a • s ⊆ s * t 
goal: a ∈ t → AddOpposite.op a +ᵥ s ⊆ s + t

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

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

full_name: Set.image_op_vadd
code: @[to_additive]
theorem image_op_smul : (op '' s) • t = t * s 
goal: AddOpposite.op '' s +ᵥ t = t + s

full_name: Set.iUnion_op_smul_set
code: @[to_additive (attr := simp)]
theorem iUnion_op_smul_set (s t : Set α) : ⋃ a ∈ t, MulOpposite.op a • s = s * t 
goal: ⋃ a ∈ t, MulOpposite.op a • s = s * t

full_name: Set.iUnion_op_vadd_set
code: @[to_additive (attr := simp)]
theorem iUnion_op_smul_set (s t : Set α) : ⋃ a ∈ t, MulOpposite.op a • s = s * t 
goal: ⋃ a ∈ t, AddOpposite.op a +ᵥ s = s + t

full_name: Set.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: Set.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: Set.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: Set.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: Set.range_smul_range
code: @[to_additive]
theorem range_smul_range {ι κ : Type*} [SMul α β] (b : ι → α) (c : κ → β) :
    range b • range c = range fun p : ι × κ ↦ b p.1 • c p.2 
goal: Set.range b • Set.range c = Set.range fun p => b p.1 • c p.2

full_name: Set.range_vadd_range
code: @[to_additive]
theorem range_smul_range {ι κ : Type*} [SMul α β] (b : ι → α) (c : κ → β) :
    range b • range c = range fun p : ι × κ ↦ b p.1 • c p.2 
goal: Set.range b +ᵥ Set.range c = Set.range fun p => b p.1 +ᵥ c p.2

full_name: Set.vadd_set_range
code: @[to_additive]
theorem smul_set_range [SMul α β] {ι : Sort*} (a : α) (f : ι → β) :
    a • range f = range fun i ↦ a • f i 
goal: a +ᵥ Set.range f = Set.range fun i => a +ᵥ f i

full_name: Set.smul_set_range
code: @[to_additive]
theorem smul_set_range [SMul α β] {ι : Sort*} (a : α) (f : ι → β) :
    a • range f = range fun i ↦ a • f i 
goal: a • Set.range f = Set.range fun i => a • f i

full_name: Set.range_vadd
code: @[to_additive] lemma range_smul [SMul α β] {ι : Sort*} (a : α) (f : ι → β) :
    range (fun i ↦ a • f i) = a • range f 
goal: (Set.range fun i => a +ᵥ f i) = a +ᵥ Set.range f

full_name: Set.range_smul
code: @[to_additive] lemma range_smul [SMul α β] {ι : Sort*} (a : α) (f : ι → β) :
    range (fun i ↦ a • f i) = a • range f 
goal: (Set.range fun i => a • f i) = a • Set.range f

full_name: Set.range_add
code: @[to_additive] lemma range_mul [Mul α] {ι : Sort*} (a : α) (f : ι → α) :
    range (fun i ↦ a * f i) = a • range f 
goal: (Set.range fun i => a + f i) = a +ᵥ Set.range f

full_name: Set.range_mul
code: @[to_additive] lemma range_mul [Mul α] {ι : Sort*} (a : α) (f : ι → α) :
    range (fun i ↦ a * f i) = a • range f 
goal: (Set.range fun i => a * f i) = a • Set.range f

full_name: Set.vaddCommClass_set
code: @[to_additive]
instance smulCommClass_set [SMul α γ] [SMul β γ] [SMulCommClass α β γ] :
    SMulCommClass α β (Set γ) 
goal: VAddCommClass α β (Set γ)

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

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

full_name: Set.vaddCommClass_set'
code: @[to_additive]
instance smulCommClass_set' [SMul α γ] [SMul β γ] [SMulCommClass α β γ] :
    SMulCommClass α (Set β) (Set γ) 
goal: VAddCommClass α (Set β) (Set γ)

full_name: Set.vaddCommClass_set''
code: @[to_additive]
instance smulCommClass_set'' [SMul α γ] [SMul β γ] [SMulCommClass α β γ] :
    SMulCommClass (Set α) β (Set γ) 
goal: VAddCommClass (Set α) β (Set γ)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

full_name: Set.instNoZeroSMulDivisors
code: instance [Zero α] [Zero β] [SMul α β] [NoZeroSMulDivisors α β] :
    NoZeroSMulDivisors (Set α) (Set β) 
goal: NoZeroSMulDivisors (Set α) (Set β)

full_name: Set.noZeroSMulDivisors_set
code: instance noZeroSMulDivisors_set [Zero α] [Zero β] [SMul α β] [NoZeroSMulDivisors α β] :
    NoZeroSMulDivisors α (Set β) 
goal: NoZeroSMulDivisors α (Set β)

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

full_name: Set.vsub
code: instance vsub : VSub (Set α) (Set β) 
goal: VSub (Set α) (Set β)

full_name: Set.image2_vsub
code: @[simp]
theorem image2_vsub : (image2 VSub.vsub s t : Set α) = s -ᵥ t 
goal: Set.image2 VSub.vsub s t = s -ᵥ t

full_name: Set.image_vsub_prod
code: theorem image_vsub_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.mem_vsub
code: theorem mem_vsub : a ∈ s -ᵥ t ↔ ∃ x ∈ s, ∃ y ∈ t, x -ᵥ y = a 
goal: a ∈ s -ᵥ t ↔ ∃ x ∈ s, ∃ y ∈ t, x -ᵥ y = a

full_name: Set.vsub_mem_vsub
code: theorem vsub_mem_vsub (hb : b ∈ s) (hc : c ∈ t) : b -ᵥ c ∈ s -ᵥ t 
goal: b -ᵥ c ∈ s -ᵥ t

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

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

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

full_name: Set.vsub_nonempty
code: @[simp]
theorem vsub_nonempty : (s -ᵥ t : Set α).Nonempty ↔ s.Nonempty ∧ t.Nonempty 
goal: (s -ᵥ t).Nonempty ↔ s.Nonempty ∧ t.Nonempty

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

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

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

full_name: Set.vsub_singleton
code: @[simp low+1]
theorem vsub_singleton (s : Set β) (b : β) : s -ᵥ {b} = (· -ᵥ b) '' s 
goal: s -ᵥ {b} = (fun x => x -ᵥ b) '' s

full_name: Set.singleton_vsub
code: @[simp low+1]
theorem singleton_vsub (t : Set β) (b : β) : {b} -ᵥ t = (b -ᵥ ·) '' t 
goal: {b} -ᵥ t = (fun x => b -ᵥ x) '' t

full_name: Set.singleton_vsub_singleton
code: @[simp high]
theorem singleton_vsub_singleton : ({b} : Set β) -ᵥ {c} = {b -ᵥ c} 
goal: {b} -ᵥ {c} = {b -ᵥ c}

full_name: Set.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: Set.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: Set.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: Set.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: Set.vsub_self_mono
code: theorem vsub_self_mono (h : s ⊆ t) : s -ᵥ s ⊆ t -ᵥ t 
goal: s -ᵥ s ⊆ t -ᵥ t

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

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

full_name: Set.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: Set.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: Set.inter_vsub_union_subset_union
code: theorem inter_vsub_union_subset_union : s₁ ∩ s₂ -ᵥ (t₁ ∪ t₂) ⊆ s₁ -ᵥ t₁ ∪ (s₂ -ᵥ t₂) 
goal: s₁ ∩ s₂ -ᵥ (t₁ ∪ t₂) ⊆ s₁ -ᵥ t₁ ∪ (s₂ -ᵥ t₂)

full_name: Set.union_vsub_inter_subset_union
code: theorem union_vsub_inter_subset_union : s₁ ∪ s₂ -ᵥ t₁ ∩ t₂ ⊆ s₁ -ᵥ t₁ ∪ (s₂ -ᵥ t₂) 
goal: s₁ ∪ s₂ -ᵥ t₁ ∩ t₂ ⊆ s₁ -ᵥ t₁ ∪ (s₂ -ᵥ t₂)

full_name: Set.iUnion_vsub_left_image
code: theorem iUnion_vsub_left_image : ⋃ a ∈ s, (a -ᵥ ·) '' t = s -ᵥ t 
goal: ⋃ a ∈ s, (fun x => a -ᵥ x) '' t = s -ᵥ t

full_name: Set.iUnion_vsub_right_image
code: theorem iUnion_vsub_right_image : ⋃ a ∈ t, (· -ᵥ a) '' s = s -ᵥ t 
goal: ⋃ a ∈ t, (fun x => x -ᵥ a) '' s = s -ᵥ t

full_name: Set.iUnion_vsub
code: theorem iUnion_vsub (s : ι → Set β) (t : Set β) : (⋃ i, s i) -ᵥ t = ⋃ i, s i -ᵥ t 
goal: (⋃ i, s i) -ᵥ t = ⋃ i, s i -ᵥ t

full_name: Set.vsub_iUnion
code: theorem vsub_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₂_vsub
code: theorem iUnion₂_vsub (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.vsub_iUnion₂
code: theorem vsub_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_vsub_subset
code: theorem iInter_vsub_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.vsub_iInter_subset
code: theorem vsub_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₂_vsub_subset
code: theorem iInter₂_vsub_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.vsub_iInter₂_subset
code: theorem vsub_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.image_vadd_comm
code: @[to_additive]
theorem image_smul_comm [SMul α β] [SMul α γ] (f : β → γ) (a : α) (s : Set β) :
    (∀ b, f (a • b) = a • f b) → f '' (a • s) = a • f '' s 
goal: (∀ (b : β), f (a +ᵥ b) = a +ᵥ f b) → f '' (a +ᵥ s) = a +ᵥ f '' s

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

full_name: Set.image_vadd_distrib
code: @[to_additive]
theorem image_smul_distrib [MulOneClass α] [MulOneClass β] [FunLike F α β] [MonoidHomClass F α β]
    (f : F) (a : α) (s : Set α) :
    f '' (a • s) = f a • f '' s 
goal: ⇑f '' (a +ᵥ s) = f a +ᵥ ⇑f '' s

full_name: Set.image_smul_distrib
code: @[to_additive]
theorem image_smul_distrib [MulOneClass α] [MulOneClass β] [FunLike F α β] [MonoidHomClass F α β]
    (f : F) (a : α) (s : Set α) :
    f '' (a • s) = f a • f '' s 
goal: ⇑f '' (a • s) = f a • ⇑f '' s

full_name: Set.op_vadd_set_vadd_eq_vadd_vadd_set
code: @[to_additive]
theorem op_smul_set_smul_eq_smul_smul_set (a : α) (s : Set β) (t : Set γ)
    (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: Set.op_smul_set_smul_eq_smul_smul_set
code: @[to_additive]
theorem op_smul_set_smul_eq_smul_smul_set (a : α) (s : Set β) (t : Set γ)
    (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: Set.smul_zero_subset
code: theorem smul_zero_subset (s : Set α) : s • (0 : Set β) ⊆ 0 
goal: s • 0 ⊆ 0

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

full_name: Set.zero_mem_smul_set
code: theorem zero_mem_smul_set (h : (0 : β) ∈ t) : (0 : β) ∈ a • t 
goal: 0 ∈ a • t

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

full_name: Set.zero_smul_subset
code: theorem zero_smul_subset (t : Set β) : (0 : Set α) • t ⊆ 0 
goal: 0 • t ⊆ 0

full_name: Set.Nonempty.zero_smul
code: theorem Nonempty.zero_smul (ht : t.Nonempty) : (0 : Set α) • t = 0 
goal: 0 • t = 0

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

full_name: Set.zero_smul_set_subset
code: theorem zero_smul_set_subset (s : Set β) : (0 : α) • s ⊆ 0 
goal: 0 • s ⊆ 0

full_name: Set.subsingleton_zero_smul_set
code: theorem subsingleton_zero_smul_set (s : Set β) : ((0 : α) • s).Subsingleton 
goal: (0 • s).Subsingleton

full_name: Set.zero_mem_smul_iff
code: theorem 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: Set.op_vadd_set_add_eq_add_vadd_set
code: @[to_additive]
theorem op_smul_set_mul_eq_mul_smul_set (a : α) (s : Set α) (t : Set α) :
    op a • s * t = s * a • t 
goal: AddOpposite.op a +ᵥ s + t = s + (a +ᵥ t)

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

full_name: Set.pairwiseDisjoint_vadd_iff
code: @[to_additive]
theorem pairwiseDisjoint_smul_iff :
    s.PairwiseDisjoint (· • t) ↔ (s ×ˢ t).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: Set.pairwiseDisjoint_smul_iff
code: @[to_additive]
theorem pairwiseDisjoint_smul_iff :
    s.PairwiseDisjoint (· • t) ↔ (s ×ˢ t).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: Set.smul_mem_smul_set_iff
code: @[to_additive (attr := simp)]
theorem smul_mem_smul_set_iff : a • x ∈ a • s ↔ x ∈ s 
goal: a • x ∈ a • s ↔ x ∈ s

full_name: Set.vadd_mem_vadd_set_iff
code: @[to_additive (attr := simp)]
theorem smul_mem_smul_set_iff : a • x ∈ a • s ↔ x ∈ s 
goal: a +ᵥ x ∈ a +ᵥ s ↔ x ∈ s

full_name: Set.mem_vadd_set_iff_neg_vadd_mem
code: @[to_additive]
theorem mem_smul_set_iff_inv_smul_mem : x ∈ a • A ↔ a⁻¹ • x ∈ A 
goal: x ∈ a +ᵥ A ↔ -a +ᵥ x ∈ A

full_name: Set.mem_smul_set_iff_inv_smul_mem
code: @[to_additive]
theorem mem_smul_set_iff_inv_smul_mem : x ∈ a • A ↔ a⁻¹ • x ∈ A 
goal: x ∈ a • A ↔ a⁻¹ • x ∈ A

full_name: Set.mem_neg_vadd_set_iff
code: @[to_additive]
theorem mem_inv_smul_set_iff : x ∈ a⁻¹ • A ↔ a • x ∈ A 
goal: x ∈ -a +ᵥ A ↔ a +ᵥ x ∈ A

full_name: Set.mem_inv_smul_set_iff
code: @[to_additive]
theorem mem_inv_smul_set_iff : x ∈ a⁻¹ • A ↔ a • x ∈ A 
goal: x ∈ a⁻¹ • A ↔ a • x ∈ A

full_name: Set.preimage_smul
code: @[to_additive]
theorem preimage_smul (a : α) (t : Set β) : (fun x ↦ a • x) ⁻¹' t = a⁻¹ • t 
goal: (fun x => a • x) ⁻¹' t = a⁻¹ • t

full_name: Set.preimage_vadd
code: @[to_additive]
theorem preimage_smul (a : α) (t : Set β) : (fun x ↦ a • x) ⁻¹' t = a⁻¹ • t 
goal: (fun x => a +ᵥ x) ⁻¹' t = -a +ᵥ t

full_name: Set.preimage_smul_inv
code: @[to_additive]
theorem preimage_smul_inv (a : α) (t : Set β) : (fun x ↦ a⁻¹ • x) ⁻¹' t = a • t 
goal: (fun x => a⁻¹ • x) ⁻¹' t = a • t

full_name: Set.preimage_vadd_neg
code: @[to_additive]
theorem preimage_smul_inv (a : α) (t : Set β) : (fun x ↦ a⁻¹ • x) ⁻¹' t = a • t 
goal: (fun x => -a +ᵥ x) ⁻¹' t = a +ᵥ t

full_name: Set.set_smul_subset_set_smul_iff
code: @[to_additive (attr := simp)]
theorem set_smul_subset_set_smul_iff : a • A ⊆ a • B ↔ A ⊆ B 
goal: a • A ⊆ a • B ↔ A ⊆ B

full_name: Set.set_vadd_subset_set_vadd_iff
code: @[to_additive (attr := simp)]
theorem set_smul_subset_set_smul_iff : a • A ⊆ a • B ↔ A ⊆ B 
goal: a +ᵥ A ⊆ a +ᵥ B ↔ A ⊆ B

full_name: Set.set_smul_subset_iff
code: @[to_additive]
theorem set_smul_subset_iff : a • A ⊆ B ↔ A ⊆ a⁻¹ • B 
goal: a • A ⊆ B ↔ A ⊆ a⁻¹ • B

full_name: Set.set_vadd_subset_iff
code: @[to_additive]
theorem set_smul_subset_iff : a • A ⊆ B ↔ A ⊆ a⁻¹ • B 
goal: a +ᵥ A ⊆ B ↔ A ⊆ -a +ᵥ B

full_name: Set.subset_set_vadd_iff
code: @[to_additive]
theorem subset_set_smul_iff : A ⊆ a • B ↔ a⁻¹ • A ⊆ B 
goal: A ⊆ a +ᵥ B ↔ -a +ᵥ A ⊆ B

full_name: Set.subset_set_smul_iff
code: @[to_additive]
theorem subset_set_smul_iff : A ⊆ a • B ↔ a⁻¹ • A ⊆ B 
goal: A ⊆ a • B ↔ a⁻¹ • A ⊆ B

full_name: Set.vadd_set_inter
code: @[to_additive]
theorem smul_set_inter : a • (s ∩ t) = a • s ∩ a • t 
goal: a +ᵥ s ∩ t = (a +ᵥ s) ∩ (a +ᵥ t)

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

full_name: Set.smul_set_iInter
code: @[to_additive]
theorem smul_set_iInter {ι : Type*}
    (a : α) (t : ι → Set β) : (a • ⋂ i, t i) = ⋂ i, a • t i 
goal: a • ⋂ i, t i = ⋂ i, a • t i

full_name: Set.vadd_set_iInter
code: @[to_additive]
theorem smul_set_iInter {ι : Type*}
    (a : α) (t : ι → Set β) : (a • ⋂ i, t i) = ⋂ i, a • t i 
goal: a +ᵥ ⋂ i, t i = ⋂ i, a +ᵥ t i

full_name: Set.vadd_set_sdiff
code: @[to_additive]
theorem smul_set_sdiff : a • (s \ t) = a • s \ a • t 
goal: a +ᵥ s \ t = (a +ᵥ s) \ (a +ᵥ t)

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

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

full_name: Set.vadd_set_symmDiff
code: @[to_additive]
theorem smul_set_symmDiff : a • s ∆ t = (a • s) ∆ (a • t) 
goal: a +ᵥ symmDiff s t = symmDiff (a +ᵥ s) (a +ᵥ t)

full_name: Set.smul_set_univ
code: @[to_additive (attr := simp)]
theorem smul_set_univ : a • (univ : Set β) = univ 
goal: a • Set.univ = Set.univ

full_name: Set.vadd_set_univ
code: @[to_additive (attr := simp)]
theorem smul_set_univ : a • (univ : Set β) = univ 
goal: a +ᵥ Set.univ = Set.univ

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

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

full_name: Set.vadd_set_compl
code: @[to_additive]
theorem smul_set_compl : a • sᶜ = (a • s)ᶜ 
goal: a +ᵥ sᶜ = (a +ᵥ s)ᶜ

full_name: Set.smul_set_compl
code: @[to_additive]
theorem smul_set_compl : a • sᶜ = (a • s)ᶜ 
goal: a • sᶜ = (a • s)ᶜ

full_name: Set.smul_inter_ne_empty_iff
code: @[to_additive]
theorem smul_inter_ne_empty_iff {s t : Set α} {x : α} :
    x • s ∩ t ≠ ∅ ↔ ∃ a b, (a ∈ t ∧ b ∈ s) ∧ a * b⁻¹ = x 
goal: x • s ∩ t ≠ ∅ ↔ ∃ a b, (a ∈ t ∧ b ∈ s) ∧ a * b⁻¹ = x

full_name: Set.vadd_inter_ne_empty_iff
code: @[to_additive]
theorem smul_inter_ne_empty_iff {s t : Set α} {x : α} :
    x • s ∩ t ≠ ∅ ↔ ∃ a b, (a ∈ t ∧ b ∈ s) ∧ a * b⁻¹ = x 
goal: (x +ᵥ s) ∩ t ≠ ∅ ↔ ∃ a b, (a ∈ t ∧ b ∈ s) ∧ a + -b = x

full_name: Set.vadd_inter_ne_empty_iff'
code: @[to_additive]
theorem smul_inter_ne_empty_iff' {s t : Set α} {x : α} :
    x • s ∩ t ≠ ∅ ↔ ∃ a b, (a ∈ t ∧ b ∈ s) ∧ a / b = x 
goal: (x +ᵥ s) ∩ t ≠ ∅ ↔ ∃ a b, (a ∈ t ∧ b ∈ s) ∧ a - b = x

full_name: Set.smul_inter_ne_empty_iff'
code: @[to_additive]
theorem smul_inter_ne_empty_iff' {s t : Set α} {x : α} :
    x • s ∩ t ≠ ∅ ↔ ∃ a b, (a ∈ t ∧ b ∈ s) ∧ a / b = x 
goal: x • s ∩ t ≠ ∅ ↔ ∃ a b, (a ∈ t ∧ b ∈ s) ∧ a / b = x

full_name: Set.op_vadd_inter_ne_empty_iff
code: @[to_additive]
theorem op_smul_inter_ne_empty_iff {s t : Set α} {x : αᵐᵒᵖ} :
    x • s ∩ t ≠ ∅ ↔ ∃ a b, (a ∈ s ∧ b ∈ t) ∧ a⁻¹ * b = MulOpposite.unop x 
goal: (x +ᵥ s) ∩ t ≠ ∅ ↔ ∃ a b, (a ∈ s ∧ b ∈ t) ∧ -a + b = AddOpposite.unop x

full_name: Set.op_smul_inter_ne_empty_iff
code: @[to_additive]
theorem op_smul_inter_ne_empty_iff {s t : Set α} {x : αᵐᵒᵖ} :
    x • s ∩ t ≠ ∅ ↔ ∃ a b, (a ∈ s ∧ b ∈ t) ∧ a⁻¹ * b = MulOpposite.unop x 
goal: x • s ∩ t ≠ ∅ ↔ ∃ a b, (a ∈ s ∧ b ∈ t) ∧ a⁻¹ * b = MulOpposite.unop x

full_name: Set.iUnion_neg_vadd
code: @[to_additive (attr := simp)]
theorem iUnion_inv_smul : ⋃ g : α, g⁻¹ • s = ⋃ g : α, g • s 
goal: ⋃ g, -g +ᵥ s = ⋃ g, g +ᵥ s

full_name: Set.iUnion_inv_smul
code: @[to_additive (attr := simp)]
theorem iUnion_inv_smul : ⋃ g : α, g⁻¹ • s = ⋃ g : α, g • s 
goal: ⋃ g, g⁻¹ • s = ⋃ g, g • s

full_name: Set.iUnion_smul_eq_setOf_exists
code: @[to_additive]
theorem iUnion_smul_eq_setOf_exists {s : Set β} : ⋃ g : α, g • s = { a | ∃ g : α, g • a ∈ s } 
goal: ⋃ g, g • s = {a | ∃ g, g • a ∈ s}

full_name: Set.iUnion_vadd_eq_setOf_exists
code: @[to_additive]
theorem iUnion_smul_eq_setOf_exists {s : Set β} : ⋃ g : α, g • s = { a | ∃ g : α, g • a ∈ s } 
goal: ⋃ g, g +ᵥ s = {a | ∃ g, g +ᵥ a ∈ s}

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

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

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

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

full_name: Set.smul_set_disjoint_iff
code: @[to_additive (attr := simp)]
lemma smul_set_disjoint_iff : Disjoint (a • s) (a • t) ↔ Disjoint s t 
goal: Disjoint (a • s) (a • t) ↔ Disjoint s t

full_name: Set.vadd_set_disjoint_iff
code: @[to_additive (attr := simp)]
lemma smul_set_disjoint_iff : Disjoint (a • s) (a • t) ↔ Disjoint s t 
goal: Disjoint (a +ᵥ s) (a +ᵥ t) ↔ Disjoint s t

full_name: Set.smul_mem_smul_set_iff₀
code: @[simp]
theorem smul_mem_smul_set_iff₀ (ha : a ≠ 0) (A : Set β) (x : β) : a • x ∈ a • A ↔ x ∈ A 
goal: a • x ∈ a • A ↔ x ∈ A

full_name: Set.mem_smul_set_iff_inv_smul_mem₀
code: theorem mem_smul_set_iff_inv_smul_mem₀ (ha : a ≠ 0) (A : Set β) (x : β) : x ∈ a • A ↔ a⁻¹ • x ∈ A 
goal: x ∈ a • A ↔ a⁻¹ • x ∈ A

full_name: Set.mem_inv_smul_set_iff₀
code: theorem mem_inv_smul_set_iff₀ (ha : a ≠ 0) (A : Set β) (x : β) : x ∈ a⁻¹ • A ↔ a • x ∈ A 
goal: x ∈ a⁻¹ • A ↔ a • x ∈ A

full_name: Set.preimage_smul₀
code: theorem preimage_smul₀ (ha : a ≠ 0) (t : Set β) : (fun x ↦ a • x) ⁻¹' t = a⁻¹ • t 
goal: (fun x => a • x) ⁻¹' t = a⁻¹ • t

full_name: Set.preimage_smul_inv₀
code: theorem preimage_smul_inv₀ (ha : a ≠ 0) (t : Set β) : (fun x ↦ a⁻¹ • x) ⁻¹' t = a • t 
goal: (fun x => a⁻¹ • x) ⁻¹' t = a • t

full_name: Set.set_smul_subset_set_smul_iff₀
code: @[simp]
theorem set_smul_subset_set_smul_iff₀ (ha : a ≠ 0) {A B : Set β} : a • A ⊆ a • B ↔ A ⊆ B 
goal: a • A ⊆ a • B ↔ A ⊆ B

full_name: Set.set_smul_subset_iff₀
code: theorem set_smul_subset_iff₀ (ha : a ≠ 0) {A B : Set β} : a • A ⊆ B ↔ A ⊆ a⁻¹ • B 
goal: a • A ⊆ B ↔ A ⊆ a⁻¹ • B

full_name: Set.subset_set_smul_iff₀
code: theorem subset_set_smul_iff₀ (ha : a ≠ 0) {A B : Set β} : A ⊆ a • B ↔ a⁻¹ • A ⊆ B 
goal: A ⊆ a • B ↔ a⁻¹ • A ⊆ B

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

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

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

full_name: Set.smul_set_univ₀
code: theorem smul_set_univ₀ (ha : a ≠ 0) : a • (univ : Set β) = univ 
goal: a • Set.univ = Set.univ

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

full_name: Set.smul_univ₀'
code: theorem smul_univ₀' {s : Set α} (hs : s.Nontrivial) : s • (univ : Set β) = univ 
goal: s • Set.univ = Set.univ

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

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

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

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

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

full_name: Set.add_smul_subset
code: theorem add_smul_subset (a b : α) (s : Set β) : (a + b) • s ⊆ a • s + b • s 
goal: (a + b) • s ⊆ a • s + b • s

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

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