# Pointwise operations of sets #

This file defines pointwise algebraic operations on sets.

## Main declarations #

For sets s and t and scalar a:

• s * t: Multiplication, set of all x * y where x ∈ s and y ∈ t.
• s + t: Addition, set of all x + y where x ∈ s and y ∈ t.
• s⁻¹: Inversion, set of all x⁻¹ where x ∈ s.
• -s: Negation, set of all -x where x ∈ s.
• s / t: Division, set of all x / y where x ∈ s and y ∈ t.
• s - t: Subtraction, set of all x - y where x ∈ s and y ∈ t.

For α a semigroup/monoid, Set α is a semigroup/monoid. As an unfortunate side effect, this means that n • s, where n : ℕ, is ambiguous between pointwise scaling and repeated pointwise addition; the former has (2 : ℕ) • {1, 2} = {2, 4}, while the latter has (2 : ℕ) • {1, 2} = {2, 3, 4}. See note [pointwise nat action].

Appropriate definitions and results are also transported to the additive theory via to_additive.

## Implementation notes #

• The following expressions are considered in simp-normal form in a group: (fun h ↦ h * g) ⁻¹' s, (fun h ↦ g * h) ⁻¹' s, (fun h ↦ h * g⁻¹) ⁻¹' s, (fun h ↦ g⁻¹ * h) ⁻¹' s, s * t, s⁻¹, (1 : Set _) (and similarly for additive variants). Expressions equal to one of these will be simplified.
• We put all instances in the locale Pointwise, so that these instances are not available by default. Note that we do not mark them as reducible (as argued by note [reducible non-instances]) since we expect the locale to be open whenever the instances are actually used (and making the instances reducible changes the behavior of simp.

## Tags #

### 0/1 as sets #

noncomputable def Set.zero {α : Type u_2} [Zero α] :
Zero (Set α)

The set 0 : Set α is defined as {0} in locale Pointwise.

Equations
• Set.zero = { zero := {0} }
Instances For
noncomputable def Set.one {α : Type u_2} [One α] :
One (Set α)

The set 1 : Set α is defined as {1} in locale Pointwise.

Equations
• Set.one = { one := {1} }
Instances For
theorem Set.singleton_zero {α : Type u_2} [Zero α] :
{0} = 0
theorem Set.singleton_one {α : Type u_2} [One α] :
{1} = 1
@[simp]
theorem Set.mem_zero {α : Type u_2} [Zero α] {a : α} :
a 0 a = 0
@[simp]
theorem Set.mem_one {α : Type u_2} [One α] {a : α} :
a 1 a = 1
theorem Set.zero_mem_zero {α : Type u_2} [Zero α] :
0 0
theorem Set.one_mem_one {α : Type u_2} [One α] :
1 1
@[simp]
theorem Set.zero_subset {α : Type u_2} [Zero α] {s : Set α} :
0 s 0 s
@[simp]
theorem Set.one_subset {α : Type u_2} [One α] {s : Set α} :
1 s 1 s
theorem Set.zero_nonempty {α : Type u_2} [Zero α] :
theorem Set.one_nonempty {α : Type u_2} [One α] :
@[simp]
theorem Set.image_zero {α : Type u_2} {β : Type u_3} [Zero α] {f : αβ} :
f '' 0 = {f 0}
@[simp]
theorem Set.image_one {α : Type u_2} {β : Type u_3} [One α] {f : αβ} :
f '' 1 = {f 1}
theorem Set.subset_zero_iff_eq {α : Type u_2} [Zero α] {s : Set α} :
s 0 s = s = 0
theorem Set.subset_one_iff_eq {α : Type u_2} [One α] {s : Set α} :
s 1 s = s = 1
theorem Set.Nonempty.subset_zero_iff {α : Type u_2} [Zero α] {s : Set α} (h : s.Nonempty) :
s 0 s = 0
theorem Set.Nonempty.subset_one_iff {α : Type u_2} [One α] {s : Set α} (h : s.Nonempty) :
s 1 s = 1
noncomputable def Set.singletonZeroHom {α : Type u_2} [Zero α] :
ZeroHom α (Set α)

The singleton operation as a ZeroHom.

Equations
• Set.singletonZeroHom = { toFun := singleton, map_zero' := }
Instances For
noncomputable def Set.singletonOneHom {α : Type u_2} [One α] :
OneHom α (Set α)

The singleton operation as a OneHom.

Equations
• Set.singletonOneHom = { toFun := singleton, map_one' := }
Instances For
@[simp]
theorem Set.coe_singletonZeroHom {α : Type u_2} [Zero α] :
Set.singletonZeroHom = singleton
@[simp]
theorem Set.coe_singletonOneHom {α : Type u_2} [One α] :
Set.singletonOneHom = singleton

### Set negation/inversion #

def Set.neg {α : Type u_2} [Neg α] :
Neg (Set α)

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.

Equations
Instances For
def Set.inv {α : Type u_2} [Inv α] :
Inv (Set α)

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.

Equations
Instances For
@[simp]
theorem Set.mem_neg {α : Type u_2} [Neg α] {s : Set α} {a : α} :
a -s -a s
@[simp]
theorem Set.mem_inv {α : Type u_2} [Inv α] {s : Set α} {a : α} :
@[simp]
theorem Set.neg_preimage {α : Type u_2} [Neg α] {s : Set α} :
Neg.neg ⁻¹' s = -s
@[simp]
theorem Set.inv_preimage {α : Type u_2} [Inv α] {s : Set α} :
Inv.inv ⁻¹' s = s⁻¹
@[simp]
theorem Set.neg_empty {α : Type u_2} [Neg α] :
@[simp]
theorem Set.inv_empty {α : Type u_2} [Inv α] :
@[simp]
theorem Set.neg_univ {α : Type u_2} [Neg α] :
-Set.univ = Set.univ
@[simp]
theorem Set.inv_univ {α : Type u_2} [Inv α] :
Set.univ⁻¹ = Set.univ
@[simp]
theorem Set.inter_neg {α : Type u_2} [Neg α] {s : Set α} {t : Set α} :
-(s t) = -s -t
@[simp]
theorem Set.inter_inv {α : Type u_2} [Inv α] {s : Set α} {t : Set α} :
@[simp]
theorem Set.union_neg {α : Type u_2} [Neg α] {s : Set α} {t : Set α} :
-(s t) = -s -t
@[simp]
theorem Set.union_inv {α : Type u_2} [Inv α] {s : Set α} {t : Set α} :
@[simp]
theorem Set.iInter_neg {α : Type u_2} {ι : Sort u_5} [Neg α] (s : ιSet α) :
-⋂ (i : ι), s i = ⋂ (i : ι), -s i
@[simp]
theorem Set.iInter_inv {α : Type u_2} {ι : Sort u_5} [Inv α] (s : ιSet α) :
(⋂ (i : ι), s i)⁻¹ = ⋂ (i : ι), (s i)⁻¹
@[simp]
theorem Set.iUnion_neg {α : Type u_2} {ι : Sort u_5} [Neg α] (s : ιSet α) :
-⋃ (i : ι), s i = ⋃ (i : ι), -s i
@[simp]
theorem Set.iUnion_inv {α : Type u_2} {ι : Sort u_5} [Inv α] (s : ιSet α) :
(⋃ (i : ι), s i)⁻¹ = ⋃ (i : ι), (s i)⁻¹
@[simp]
theorem Set.compl_neg {α : Type u_2} [Neg α] {s : Set α} :
-s = (-s)
@[simp]
theorem Set.compl_inv {α : Type u_2} [Inv α] {s : Set α} :
theorem Set.neg_mem_neg {α : Type u_2} [] {s : Set α} {a : α} :
-a -s a s
theorem Set.inv_mem_inv {α : Type u_2} [] {s : Set α} {a : α} :
@[simp]
theorem Set.nonempty_neg {α : Type u_2} [] {s : Set α} :
(-s).Nonempty s.Nonempty
@[simp]
theorem Set.nonempty_inv {α : Type u_2} [] {s : Set α} :
s⁻¹.Nonempty s.Nonempty
theorem Set.Nonempty.neg {α : Type u_2} [] {s : Set α} (h : s.Nonempty) :
(-s).Nonempty
theorem Set.Nonempty.inv {α : Type u_2} [] {s : Set α} (h : s.Nonempty) :
s⁻¹.Nonempty
@[simp]
theorem Set.image_neg {α : Type u_2} [] {s : Set α} :
Neg.neg '' s = -s
@[simp]
theorem Set.image_inv {α : Type u_2} [] {s : Set α} :
Inv.inv '' s = s⁻¹
@[simp]
theorem Set.neg_eq_empty {α : Type u_2} [] {s : Set α} :
-s = s =
@[simp]
theorem Set.inv_eq_empty {α : Type u_2} [] {s : Set α} :
noncomputable instance Set.involutiveNeg {α : Type u_2} [] :
Equations
• Set.involutiveNeg =
theorem Set.involutiveNeg.proof_1 {α : Type u_1} [] (s : Set α) :
(fun (x : α) => - -x) ⁻¹' s = s
noncomputable instance Set.involutiveInv {α : Type u_2} [] :
Equations
• Set.involutiveInv =
@[simp]
theorem Set.neg_subset_neg {α : Type u_2} [] {s : Set α} {t : Set α} :
-s -t s t
@[simp]
theorem Set.inv_subset_inv {α : Type u_2} [] {s : Set α} {t : Set α} :
theorem Set.neg_subset {α : Type u_2} [] {s : Set α} {t : Set α} :
-s t s -t
theorem Set.inv_subset {α : Type u_2} [] {s : Set α} {t : Set α} :
@[simp]
theorem Set.neg_singleton {α : Type u_2} [] (a : α) :
-{a} = {-a}
@[simp]
theorem Set.inv_singleton {α : Type u_2} [] (a : α) :
{a}⁻¹ = {a⁻¹}
@[simp]
theorem Set.neg_insert {α : Type u_2} [] (a : α) (s : Set α) :
-insert a s = insert (-a) (-s)
@[simp]
theorem Set.inv_insert {α : Type u_2} [] (a : α) (s : Set α) :
(insert a s)⁻¹ =
theorem Set.neg_range {α : Type u_2} [] {ι : Sort u_5} {f : ια} :
= Set.range fun (i : ι) => -f i
theorem Set.inv_range {α : Type u_2} [] {ι : Sort u_5} {f : ια} :
()⁻¹ = Set.range fun (i : ι) => (f i)⁻¹
theorem Set.image_op_neg {α : Type u_2} [] {s : Set α} :
theorem Set.image_op_inv {α : Type u_2} [] {s : Set α} :
MulOpposite.op '' s⁻¹ = (MulOpposite.op '' s)⁻¹

The pointwise addition of sets s + t is defined as {x + y | x ∈ s, y ∈ t} in locale Pointwise.

Equations
Instances For
def Set.mul {α : Type u_2} [Mul α] :
Mul (Set α)

The pointwise multiplication of sets s * t and t is defined as {x * y | x ∈ s, y ∈ t} in locale Pointwise.

Equations
Instances For
@[simp]
theorem Set.image2_add {α : Type u_2} [Add α] {s : Set α} {t : Set α} :
Set.image2 (fun (x x_1 : α) => x + x_1) s t = s + t
@[simp]
theorem Set.image2_mul {α : Type u_2} [Mul α] {s : Set α} {t : Set α} :
Set.image2 (fun (x x_1 : α) => x * x_1) s t = s * t
theorem Set.mem_add {α : Type u_2} [Add α] {s : Set α} {t : Set α} {a : α} :
a s + t xs, yt, x + y = a
theorem Set.mem_mul {α : Type u_2} [Mul α] {s : Set α} {t : Set α} {a : α} :
a s * t xs, yt, x * y = a
theorem Set.add_mem_add {α : Type u_2} [Add α] {s : Set α} {t : Set α} {a : α} {b : α} :
a sb ta + b s + t
theorem Set.mul_mem_mul {α : Type u_2} [Mul α] {s : Set α} {t : Set α} {a : α} {b : α} :
a sb ta * b s * t
theorem Set.add_image_prod {α : Type u_2} [Add α] {s : Set α} {t : Set α} :
(fun (x : α × α) => x.1 + x.2) '' s ×ˢ t = s + t
theorem Set.image_mul_prod {α : Type u_2} [Mul α] {s : Set α} {t : Set α} :
(fun (x : α × α) => x.1 * x.2) '' s ×ˢ t = s * t
@[simp]
theorem Set.empty_add {α : Type u_2} [Add α] {s : Set α} :
@[simp]
theorem Set.empty_mul {α : Type u_2} [Mul α] {s : Set α} :
@[simp]
theorem Set.add_empty {α : Type u_2} [Add α] {s : Set α} :
@[simp]
theorem Set.mul_empty {α : Type u_2} [Mul α] {s : Set α} :
@[simp]
theorem Set.add_eq_empty {α : Type u_2} [Add α] {s : Set α} {t : Set α} :
s + t = s = t =
@[simp]
theorem Set.mul_eq_empty {α : Type u_2} [Mul α] {s : Set α} {t : Set α} :
s * t = s = t =
@[simp]
theorem Set.add_nonempty {α : Type u_2} [Add α] {s : Set α} {t : Set α} :
(s + t).Nonempty s.Nonempty t.Nonempty
@[simp]
theorem Set.mul_nonempty {α : Type u_2} [Mul α] {s : Set α} {t : Set α} :
(s * t).Nonempty s.Nonempty t.Nonempty
theorem Set.Nonempty.add {α : Type u_2} [Add α] {s : Set α} {t : Set α} :
s.Nonemptyt.Nonempty(s + t).Nonempty
theorem Set.Nonempty.mul {α : Type u_2} [Mul α] {s : Set α} {t : Set α} :
s.Nonemptyt.Nonempty(s * t).Nonempty
theorem Set.Nonempty.of_add_left {α : Type u_2} [Add α] {s : Set α} {t : Set α} :
(s + t).Nonemptys.Nonempty
theorem Set.Nonempty.of_mul_left {α : Type u_2} [Mul α] {s : Set α} {t : Set α} :
(s * t).Nonemptys.Nonempty
theorem Set.Nonempty.of_add_right {α : Type u_2} [Add α] {s : Set α} {t : Set α} :
(s + t).Nonemptyt.Nonempty
theorem Set.Nonempty.of_mul_right {α : Type u_2} [Mul α] {s : Set α} {t : Set α} :
(s * t).Nonemptyt.Nonempty
@[simp]
theorem Set.add_singleton {α : Type u_2} [Add α] {s : Set α} {b : α} :
s + {b} = (fun (x : α) => x + b) '' s
@[simp]
theorem Set.mul_singleton {α : Type u_2} [Mul α] {s : Set α} {b : α} :
s * {b} = (fun (x : α) => x * b) '' s
@[simp]
theorem Set.singleton_add {α : Type u_2} [Add α] {t : Set α} {a : α} :
{a} + t = (fun (x : α) => a + x) '' t
@[simp]
theorem Set.singleton_mul {α : Type u_2} [Mul α] {t : Set α} {a : α} :
{a} * t = (fun (x : α) => a * x) '' t
theorem Set.singleton_add_singleton {α : Type u_2} [Add α] {a : α} {b : α} :
{a} + {b} = {a + b}
theorem Set.singleton_mul_singleton {α : Type u_2} [Mul α] {a : α} {b : α} :
{a} * {b} = {a * b}
theorem Set.add_subset_add {α : Type u_2} [Add α] {s₁ : Set α} {s₂ : Set α} {t₁ : Set α} {t₂ : Set α} :
s₁ t₁s₂ t₂s₁ + s₂ t₁ + t₂
theorem Set.mul_subset_mul {α : Type u_2} [Mul α] {s₁ : Set α} {s₂ : Set α} {t₁ : Set α} {t₂ : Set α} :
s₁ t₁s₂ t₂s₁ * s₂ t₁ * t₂
theorem Set.add_subset_add_left {α : Type u_2} [Add α] {s : Set α} {t₁ : Set α} {t₂ : Set α} :
t₁ t₂s + t₁ s + t₂
theorem Set.mul_subset_mul_left {α : Type u_2} [Mul α] {s : Set α} {t₁ : Set α} {t₂ : Set α} :
t₁ t₂s * t₁ s * t₂
theorem Set.add_subset_add_right {α : Type u_2} [Add α] {s₁ : Set α} {s₂ : Set α} {t : Set α} :
s₁ s₂s₁ + t s₂ + t
theorem Set.mul_subset_mul_right {α : Type u_2} [Mul α] {s₁ : Set α} {s₂ : Set α} {t : Set α} :
s₁ s₂s₁ * t s₂ * t
theorem Set.add_subset_iff {α : Type u_2} [Add α] {s : Set α} {t : Set α} {u : Set α} :
s + t u xs, yt, x + y u
theorem Set.mul_subset_iff {α : Type u_2} [Mul α] {s : Set α} {t : Set α} {u : Set α} :
s * t u xs, yt, x * y u
theorem Set.union_add {α : Type u_2} [Add α] {s₁ : Set α} {s₂ : Set α} {t : Set α} :
s₁ s₂ + t = s₁ + t (s₂ + t)
theorem Set.union_mul {α : Type u_2} [Mul α] {s₁ : Set α} {s₂ : Set α} {t : Set α} :
(s₁ s₂) * t = s₁ * t s₂ * t
theorem Set.add_union {α : Type u_2} [Add α] {s : Set α} {t₁ : Set α} {t₂ : Set α} :
s + (t₁ t₂) = s + t₁ (s + t₂)
theorem Set.mul_union {α : Type u_2} [Mul α] {s : Set α} {t₁ : Set α} {t₂ : Set α} :
s * (t₁ t₂) = s * t₁ s * t₂
theorem Set.inter_add_subset {α : Type u_2} [Add α] {s₁ : Set α} {s₂ : Set α} {t : Set α} :
s₁ s₂ + t (s₁ + t) (s₂ + t)
theorem Set.inter_mul_subset {α : Type u_2} [Mul α] {s₁ : Set α} {s₂ : Set α} {t : Set α} :
s₁ s₂ * t s₁ * t (s₂ * t)
theorem Set.add_inter_subset {α : Type u_2} [Add α] {s : Set α} {t₁ : Set α} {t₂ : Set α} :
s + t₁ t₂ (s + t₁) (s + t₂)
theorem Set.mul_inter_subset {α : Type u_2} [Mul α] {s : Set α} {t₁ : Set α} {t₂ : Set α} :
s * (t₁ t₂) s * t₁ (s * t₂)
theorem Set.inter_add_union_subset_union {α : Type u_2} [Add α] {s₁ : Set α} {s₂ : Set α} {t₁ : Set α} {t₂ : Set α} :
s₁ s₂ + (t₁ t₂) s₁ + t₁ (s₂ + t₂)
theorem Set.inter_mul_union_subset_union {α : Type u_2} [Mul α] {s₁ : Set α} {s₂ : Set α} {t₁ : Set α} {t₂ : Set α} :
s₁ s₂ * (t₁ t₂) s₁ * t₁ s₂ * t₂
theorem Set.union_add_inter_subset_union {α : Type u_2} [Add α] {s₁ : Set α} {s₂ : Set α} {t₁ : Set α} {t₂ : Set α} :
s₁ s₂ + t₁ t₂ s₁ + t₁ (s₂ + t₂)
theorem Set.union_mul_inter_subset_union {α : Type u_2} [Mul α] {s₁ : Set α} {s₂ : Set α} {t₁ : Set α} {t₂ : Set α} :
(s₁ s₂) * (t₁ t₂) s₁ * t₁ s₂ * t₂
theorem Set.iUnion_add_left_image {α : Type u_2} [Add α] {s : Set α} {t : Set α} :
as, (fun (x : α) => a + x) '' t = s + t
theorem Set.iUnion_mul_left_image {α : Type u_2} [Mul α] {s : Set α} {t : Set α} :
as, (fun (x : α) => a * x) '' t = s * t
theorem Set.iUnion_add_right_image {α : Type u_2} [Add α] {s : Set α} {t : Set α} :
at, (fun (x : α) => x + a) '' s = s + t
theorem Set.iUnion_mul_right_image {α : Type u_2} [Mul α] {s : Set α} {t : Set α} :
at, (fun (x : α) => x * a) '' s = s * t
theorem Set.iUnion_add {α : Type u_2} {ι : Sort u_5} [Add α] (s : ιSet α) (t : Set α) :
(⋃ (i : ι), s i) + t = ⋃ (i : ι), s i + t
theorem Set.iUnion_mul {α : Type u_2} {ι : Sort u_5} [Mul α] (s : ιSet α) (t : Set α) :
(⋃ (i : ι), s i) * t = ⋃ (i : ι), s i * t
theorem Set.add_iUnion {α : Type u_2} {ι : Sort u_5} [Add α] (s : Set α) (t : ιSet α) :
s + ⋃ (i : ι), t i = ⋃ (i : ι), s + t i
theorem Set.mul_iUnion {α : Type u_2} {ι : Sort u_5} [Mul α] (s : Set α) (t : ιSet α) :
s * ⋃ (i : ι), t i = ⋃ (i : ι), s * t i
theorem Set.iUnion₂_add {α : Type u_2} {ι : Sort u_5} {κ : ιSort u_6} [Add α] (s : (i : ι) → κ iSet α) (t : Set α) :
(⋃ (i : ι), ⋃ (j : κ i), s i j) + t = ⋃ (i : ι), ⋃ (j : κ i), s i j + t
theorem Set.iUnion₂_mul {α : Type u_2} {ι : Sort u_5} {κ : ιSort u_6} [Mul α] (s : (i : ι) → κ iSet α) (t : Set α) :
(⋃ (i : ι), ⋃ (j : κ i), s i j) * t = ⋃ (i : ι), ⋃ (j : κ i), s i j * t
theorem Set.add_iUnion₂ {α : Type u_2} {ι : Sort u_5} {κ : ιSort u_6} [Add α] (s : Set α) (t : (i : ι) → κ iSet α) :
s + ⋃ (i : ι), ⋃ (j : κ i), t i j = ⋃ (i : ι), ⋃ (j : κ i), s + t i j
theorem Set.mul_iUnion₂ {α : Type u_2} {ι : Sort u_5} {κ : ιSort u_6} [Mul α] (s : Set α) (t : (i : ι) → κ iSet α) :
s * ⋃ (i : ι), ⋃ (j : κ i), t i j = ⋃ (i : ι), ⋃ (j : κ i), s * t i j
theorem Set.iInter_add_subset {α : Type u_2} {ι : Sort u_5} [Add α] (s : ιSet α) (t : Set α) :
(⋂ (i : ι), s i) + t ⋂ (i : ι), s i + t
theorem Set.iInter_mul_subset {α : Type u_2} {ι : Sort u_5} [Mul α] (s : ιSet α) (t : Set α) :
(⋂ (i : ι), s i) * t ⋂ (i : ι), s i * t
theorem Set.add_iInter_subset {α : Type u_2} {ι : Sort u_5} [Add α] (s : Set α) (t : ιSet α) :
s + ⋂ (i : ι), t i ⋂ (i : ι), s + t i
theorem Set.mul_iInter_subset {α : Type u_2} {ι : Sort u_5} [Mul α] (s : Set α) (t : ιSet α) :
s * ⋂ (i : ι), t i ⋂ (i : ι), s * t i
theorem Set.iInter₂_add_subset {α : Type u_2} {ι : Sort u_5} {κ : ιSort u_6} [Add α] (s : (i : ι) → κ iSet α) (t : Set α) :
(⋂ (i : ι), ⋂ (j : κ i), s i j) + t ⋂ (i : ι), ⋂ (j : κ i), s i j + t
theorem Set.iInter₂_mul_subset {α : Type u_2} {ι : Sort u_5} {κ : ιSort u_6} [Mul α] (s : (i : ι) → κ iSet α) (t : Set α) :
(⋂ (i : ι), ⋂ (j : κ i), s i j) * t ⋂ (i : ι), ⋂ (j : κ i), s i j * t
theorem Set.add_iInter₂_subset {α : Type u_2} {ι : Sort u_5} {κ : ιSort u_6} [Add α] (s : Set α) (t : (i : ι) → κ iSet α) :
s + ⋂ (i : ι), ⋂ (j : κ i), t i j ⋂ (i : ι), ⋂ (j : κ i), s + t i j
theorem Set.mul_iInter₂_subset {α : Type u_2} {ι : Sort u_5} {κ : ιSort u_6} [Mul α] (s : Set α) (t : (i : ι) → κ iSet α) :
s * ⋂ (i : ι), ⋂ (j : κ i), t i j ⋂ (i : ι), ⋂ (j : κ i), s * t i j
∀ (x x_1 : α), {x + x_1} = {x} + {x_1}

The singleton operation as an AddHom.

Equations
Instances For
noncomputable def Set.singletonMulHom {α : Type u_2} [Mul α] :
α →ₙ* Set α

The singleton operation as a MulHom.

Equations
• Set.singletonMulHom = { toFun := singleton, map_mul' := }
Instances For
@[simp]
@[simp]
theorem Set.coe_singletonMulHom {α : Type u_2} [Mul α] :
Set.singletonMulHom = singleton
@[simp]
theorem Set.singletonAddHom_apply {α : Type u_2} [Add α] (a : α) :
@[simp]
theorem Set.singletonMulHom_apply {α : Type u_2} [Mul α] (a : α) :
Set.singletonMulHom a = {a}
@[simp]
theorem Set.image_op_add {α : Type u_2} [Add α] {s : Set α} {t : Set α} :
@[simp]
theorem Set.image_op_mul {α : Type u_2} [Mul α] {s : Set α} {t : Set α} :
MulOpposite.op '' (s * t) = MulOpposite.op '' t * MulOpposite.op '' s

### Set subtraction/division #

def Set.sub {α : Type u_2} [Sub α] :
Sub (Set α)

The pointwise subtraction of sets s - t is defined as {x - y | x ∈ s, y ∈ t} in locale Pointwise.

Equations
Instances For
def Set.div {α : Type u_2} [Div α] :
Div (Set α)

The pointwise division of sets s / t is defined as {x / y | x ∈ s, y ∈ t} in locale Pointwise.

Equations
Instances For
@[simp]
theorem Set.image2_sub {α : Type u_2} [Sub α] {s : Set α} {t : Set α} :
Set.image2 Sub.sub s t = s - t
@[simp]
theorem Set.image2_div {α : Type u_2} [Div α] {s : Set α} {t : Set α} :
Set.image2 Div.div s t = s / t
theorem Set.mem_sub {α : Type u_2} [Sub α] {s : Set α} {t : Set α} {a : α} :
a s - t xs, yt, x - y = a
theorem Set.mem_div {α : Type u_2} [Div α] {s : Set α} {t : Set α} {a : α} :
a s / t xs, yt, x / y = a
theorem Set.sub_mem_sub {α : Type u_2} [Sub α] {s : Set α} {t : Set α} {a : α} {b : α} :
a sb ta - b s - t
theorem Set.div_mem_div {α : Type u_2} [Div α] {s : Set α} {t : Set α} {a : α} {b : α} :
a sb ta / b s / t
theorem Set.sub_image_prod {α : Type u_2} [Sub α] {s : Set α} {t : Set α} :
(fun (x : α × α) => x.1 - x.2) '' s ×ˢ t = s - t
theorem Set.image_div_prod {α : Type u_2} [Div α] {s : Set α} {t : Set α} :
(fun (x : α × α) => x.1 / x.2) '' s ×ˢ t = s / t
@[simp]
theorem Set.empty_sub {α : Type u_2} [Sub α] {s : Set α} :
@[simp]
theorem Set.empty_div {α : Type u_2} [Div α] {s : Set α} :
@[simp]
theorem Set.sub_empty {α : Type u_2} [Sub α] {s : Set α} :
@[simp]
theorem Set.div_empty {α : Type u_2} [Div α] {s : Set α} :
@[simp]
theorem Set.sub_eq_empty {α : Type u_2} [Sub α] {s : Set α} {t : Set α} :
s - t = s = t =
@[simp]
theorem Set.div_eq_empty {α : Type u_2} [Div α] {s : Set α} {t : Set α} :
s / t = s = t =
@[simp]
theorem Set.sub_nonempty {α : Type u_2} [Sub α] {s : Set α} {t : Set α} :
(s - t).Nonempty s.Nonempty t.Nonempty
@[simp]
theorem Set.div_nonempty {α : Type u_2} [Div α] {s : Set α} {t : Set α} :
(s / t).Nonempty s.Nonempty t.Nonempty
theorem Set.Nonempty.sub {α : Type u_2} [Sub α] {s : Set α} {t : Set α} :
s.Nonemptyt.Nonempty(s - t).Nonempty
theorem Set.Nonempty.div {α : Type u_2} [Div α] {s : Set α} {t : Set α} :
s.Nonemptyt.Nonempty(s / t).Nonempty
theorem Set.Nonempty.of_sub_left {α : Type u_2} [Sub α] {s : Set α} {t : Set α} :
(s - t).Nonemptys.Nonempty
theorem Set.Nonempty.of_div_left {α : Type u_2} [Div α] {s : Set α} {t : Set α} :
(s / t).Nonemptys.Nonempty
theorem Set.Nonempty.of_sub_right {α : Type u_2} [Sub α] {s : Set α} {t : Set α} :
(s - t).Nonemptyt.Nonempty
theorem Set.Nonempty.of_div_right {α : Type u_2} [Div α] {s : Set α} {t : Set α} :
(s / t).Nonemptyt.Nonempty
@[simp]
theorem Set.sub_singleton {α : Type u_2} [Sub α] {s : Set α} {b : α} :
s - {b} = (fun (x : α) => x - b) '' s
@[simp]
theorem Set.div_singleton {α : Type u_2} [Div α] {s : Set α} {b : α} :
s / {b} = (fun (x : α) => x / b) '' s
@[simp]
theorem Set.singleton_sub {α : Type u_2} [Sub α] {t : Set α} {a : α} :
{a} - t = (fun (x x_1 : α) => x - x_1) a '' t
@[simp]
theorem Set.singleton_div {α : Type u_2} [Div α] {t : Set α} {a : α} :
{a} / t = (fun (x x_1 : α) => x / x_1) a '' t
theorem Set.singleton_sub_singleton {α : Type u_2} [Sub α] {a : α} {b : α} :
{a} - {b} = {a - b}
theorem Set.singleton_div_singleton {α : Type u_2} [Div α] {a : α} {b : α} :
{a} / {b} = {a / b}
theorem Set.sub_subset_sub {α : Type u_2} [Sub α] {s₁ : Set α} {s₂ : Set α} {t₁ : Set α} {t₂ : Set α} :
s₁ t₁s₂ t₂s₁ - s₂ t₁ - t₂
theorem Set.div_subset_div {α : Type u_2} [Div α] {s₁ : Set α} {s₂ : Set α} {t₁ : Set α} {t₂ : Set α} :
s₁ t₁s₂ t₂s₁ / s₂ t₁ / t₂
theorem Set.sub_subset_sub_left {α : Type u_2} [Sub α] {s : Set α} {t₁ : Set α} {t₂ : Set α} :
t₁ t₂s - t₁ s - t₂
theorem Set.div_subset_div_left {α : Type u_2} [Div α] {s : Set α} {t₁ : Set α} {t₂ : Set α} :
t₁ t₂s / t₁ s / t₂
theorem Set.sub_subset_sub_right {α : Type u_2} [Sub α] {s₁ : Set α} {s₂ : Set α} {t : Set α} :
s₁ s₂s₁ - t s₂ - t
theorem Set.div_subset_div_right {α : Type u_2} [Div α] {s₁ : Set α} {s₂ : Set α} {t : Set α} :
s₁ s₂s₁ / t s₂ / t
theorem Set.sub_subset_iff {α : Type u_2} [Sub α] {s : Set α} {t : Set α} {u : Set α} :
s - t u xs, yt, x - y u
theorem Set.div_subset_iff {α : Type u_2} [Div α] {s : Set α} {t : Set α} {u : Set α} :
s / t u xs, yt, x / y u
theorem Set.union_sub {α : Type u_2} [Sub α] {s₁ : Set α} {s₂ : Set α} {t : Set α} :
s₁ s₂ - t = s₁ - t (s₂ - t)
theorem Set.union_div {α : Type u_2} [Div α] {s₁ : Set α} {s₂ : Set α} {t : Set α} :
(s₁ s₂) / t = s₁ / t s₂ / t
theorem Set.sub_union {α : Type u_2} [Sub α] {s : Set α} {t₁ : Set α} {t₂ : Set α} :
s - (t₁ t₂) = s - t₁ (s - t₂)
theorem Set.div_union {α : Type u_2} [Div α] {s : Set α} {t₁ : Set α} {t₂ : Set α} :
s / (t₁ t₂) = s / t₁ s / t₂
theorem Set.inter_sub_subset {α : Type u_2} [Sub α] {s₁ : Set α} {s₂ : Set α} {t : Set α} :
s₁ s₂ - t (s₁ - t) (s₂ - t)
theorem Set.inter_div_subset {α : Type u_2} [Div α] {s₁ : Set α} {s₂ : Set α} {t : Set α} :
s₁ s₂ / t s₁ / t (s₂ / t)
theorem Set.sub_inter_subset {α : Type u_2} [Sub α] {s : Set α} {t₁ : Set α} {t₂ : Set α} :
s - t₁ t₂ (s - t₁) (s - t₂)
theorem Set.div_inter_subset {α : Type u_2} [Div α] {s : Set α} {t₁ : Set α} {t₂ : Set α} :
s / (t₁ t₂) s / t₁ (s / t₂)
theorem Set.inter_sub_union_subset_union {α : Type u_2} [Sub α] {s₁ : Set α} {s₂ : Set α} {t₁ : Set α} {t₂ : Set α} :
s₁ s₂ - (t₁ t₂) s₁ - t₁ (s₂ - t₂)
theorem Set.inter_div_union_subset_union {α : Type u_2} [Div α] {s₁ : Set α} {s₂ : Set α} {t₁ : Set α} {t₂ : Set α} :
s₁ s₂ / (t₁ t₂) s₁ / t₁ s₂ / t₂
theorem Set.union_sub_inter_subset_union {α : Type u_2} [Sub α] {s₁ : Set α} {s₂ : Set α} {t₁ : Set α} {t₂ : Set α} :
s₁ s₂ - t₁ t₂ s₁ - t₁ (s₂ - t₂)
theorem Set.union_div_inter_subset_union {α : Type u_2} [Div α] {s₁ : Set α} {s₂ : Set α} {t₁ : Set α} {t₂ : Set α} :
(s₁ s₂) / (t₁ t₂) s₁ / t₁ s₂ / t₂
theorem Set.iUnion_sub_left_image {α : Type u_2} [Sub α] {s : Set α} {t : Set α} :
as, (fun (x : α) => a - x) '' t = s - t
theorem Set.iUnion_div_left_image {α : Type u_2} [Div α] {s : Set α} {t : Set α} :
as, (fun (x : α) => a / x) '' t = s / t
theorem Set.iUnion_sub_right_image {α : Type u_2} [Sub α] {s : Set α} {t : Set α} :
at, (fun (x : α) => x - a) '' s = s - t
theorem Set.iUnion_div_right_image {α : Type u_2} [Div α] {s : Set α} {t : Set α} :
at, (fun (x : α) => x / a) '' s = s / t
theorem Set.iUnion_sub {α : Type u_2} {ι : Sort u_5} [Sub α] (s : ιSet α) (t : Set α) :
(⋃ (i : ι), s i) - t = ⋃ (i : ι), s i - t
theorem Set.iUnion_div {α : Type u_2} {ι : Sort u_5} [Div α] (s : ιSet α) (t : Set α) :
(⋃ (i : ι), s i) / t = ⋃ (i : ι), s i / t
theorem Set.sub_iUnion {α : Type u_2} {ι : Sort u_5} [Sub α] (s : Set α) (t : ιSet α) :
s - ⋃ (i : ι), t i = ⋃ (i : ι), s - t i
theorem Set.div_iUnion {α : Type u_2} {ι : Sort u_5} [Div α] (s : Set α) (t : ιSet α) :
s / ⋃ (i : ι), t i = ⋃ (i : ι), s / t i
theorem Set.iUnion₂_sub {α : Type u_2} {ι : Sort u_5} {κ : ιSort u_6} [Sub α] (s : (i : ι) → κ iSet α) (t : Set α) :
(⋃ (i : ι), ⋃ (j : κ i), s i j) - t = ⋃ (i : ι), ⋃ (j : κ i), s i j - t
theorem Set.iUnion₂_div {α : Type u_2} {ι : Sort u_5} {κ : ιSort u_6} [Div α] (s : (i : ι) → κ iSet α) (t : Set α) :
(⋃ (i : ι), ⋃ (j : κ i), s i j) / t = ⋃ (i : ι), ⋃ (j : κ i), s i j / t
theorem Set.sub_iUnion₂ {α : Type u_2} {ι : Sort u_5} {κ : ιSort u_6} [Sub α] (s : Set α) (t : (i : ι) → κ iSet α) :
s - ⋃ (i : ι), ⋃ (j : κ i), t i j = ⋃ (i : ι), ⋃ (j : κ i), s - t i j
theorem Set.div_iUnion₂ {α : Type u_2} {ι : Sort u_5} {κ : ιSort u_6} [Div α] (s : Set α) (t : (i : ι) → κ iSet α) :
s / ⋃ (i : ι), ⋃ (j : κ i), t i j = ⋃ (i : ι), ⋃ (j : κ i), s / t i j
theorem Set.iInter_sub_subset {α : Type u_2} {ι : Sort u_5} [Sub α] (s : ιSet α) (t : Set α) :
(⋂ (i : ι), s i) - t ⋂ (i : ι), s i - t
theorem Set.iInter_div_subset {α : Type u_2} {ι : Sort u_5} [Div α] (s : ιSet α) (t : Set α) :
(⋂ (i : ι), s i) / t ⋂ (i : ι), s i / t
theorem Set.sub_iInter_subset {α : Type u_2} {ι : Sort u_5} [Sub α] (s : Set α) (t : ιSet α) :
s - ⋂ (i : ι), t i ⋂ (i : ι), s - t i
theorem Set.div_iInter_subset {α : Type u_2} {ι : Sort u_5} [Div α] (s : Set α) (t : ιSet α) :
s / ⋂ (i : ι), t i ⋂ (i : ι), s / t i
theorem Set.iInter₂_sub_subset {α : Type u_2} {ι : Sort u_5} {κ : ιSort u_6} [Sub α] (s : (i : ι) → κ iSet α) (t : Set α) :
(⋂ (i : ι), ⋂ (j : κ i), s i j) - t ⋂ (i : ι), ⋂ (j : κ i), s i j - t
theorem Set.iInter₂_div_subset {α : Type u_2} {ι : Sort u_5} {κ : ιSort u_6} [Div α] (s : (i : ι) → κ iSet α) (t : Set α) :
(⋂ (i : ι), ⋂ (j : κ i), s i j) / t ⋂ (i : ι), ⋂ (j : κ i), s i j / t
theorem Set.sub_iInter₂_subset {α : Type u_2} {ι : Sort u_5} {κ : ιSort u_6} [Sub α] (s : Set α) (t : (i : ι) → κ iSet α) :
s - ⋂ (i : ι), ⋂ (j : κ i), t i j ⋂ (i : ι), ⋂ (j : κ i), s - t i j
theorem Set.div_iInter₂_subset {α : Type u_2} {ι : Sort u_5} {κ : ιSort u_6} [Div α] (s : Set α) (t : (i : ι) → κ iSet α) :
s / ⋂ (i : ι), ⋂ (j : κ i), t i j ⋂ (i : ι), ⋂ (j : κ i), s / t i j
def Set.NSMul {α : Type u_2} [Zero α] [Add α] :
SMul (Set α)

Repeated pointwise addition (not the same as pointwise repeated addition!) of a Set. See note [pointwise nat action].

Equations
• Set.NSMul = { smul := nsmulRec }
Instances For
def Set.NPow {α : Type u_2} [One α] [Mul α] :
Pow (Set α)

Repeated pointwise multiplication (not the same as pointwise repeated multiplication!) of a Set. See note [pointwise nat action].

Equations
Instances For
def Set.ZSMul {α : Type u_2} [Zero α] [Add α] [Neg α] :
SMul (Set α)

Repeated pointwise addition/subtraction (not the same as pointwise repeated addition/subtraction!) of a Set. See note [pointwise nat action].

Equations
• Set.ZSMul = { smul := zsmulRec }
Instances For
def Set.ZPow {α : Type u_2} [One α] [Mul α] [Inv α] :
Pow (Set α)

Repeated pointwise multiplication/division (not the same as pointwise repeated multiplication/division!) of a Set. See note [pointwise nat action].

Equations
• Set.ZPow = { pow := fun (s : Set α) (n : ) => zpowRec npowRec n s }
Instances For
theorem Set.addSemigroup.proof_1 {α : Type u_1} [] :
∀ (x x_1 x_2 : Set α), Set.image2 (fun (x x_3 : α) => x + x_3) (Set.image2 (fun (x x_3 : α) => x + x_3) x x_1) x_2 = Set.image2 (fun (x x_3 : α) => x + x_3) x (Set.image2 (fun (x x_3 : α) => x + x_3) x_1 x_2)
noncomputable def Set.addSemigroup {α : Type u_2} [] :

Set α is an AddSemigroup under pointwise operations if α is.

Equations
Instances For
noncomputable def Set.semigroup {α : Type u_2} [] :

Set α is a Semigroup under pointwise operations if α is.

Equations
• Set.semigroup = let __src := Set.mul;
Instances For
theorem Set.addCommSemigroup.proof_1 {α : Type u_1} [] :
∀ (x x_1 : Set α), Set.image2 (fun (x x_2 : α) => x + x_2) x x_1 = Set.image2 (fun (x x_2 : α) => x + x_2) x_1 x
noncomputable def Set.addCommSemigroup {α : Type u_2} [] :

Set α is an AddCommSemigroup under pointwise operations if α is.

Equations
Instances For
noncomputable def Set.commSemigroup {α : Type u_2} [] :

Set α is a CommSemigroup under pointwise operations if α is.

Equations
• Set.commSemigroup = let __src := Set.semigroup;
Instances For
theorem Set.inter_add_union_subset {α : Type u_2} [] {s : Set α} {t : Set α} :
s t + (s t) s + t
theorem Set.inter_mul_union_subset {α : Type u_2} [] {s : Set α} {t : Set α} :
s t * (s t) s * t
theorem Set.union_add_inter_subset {α : Type u_2} [] {s : Set α} {t : Set α} :
s t + s t s + t
theorem Set.union_mul_inter_subset {α : Type u_2} [] {s : Set α} {t : Set α} :
(s t) * (s t) s * t
theorem Set.addZeroClass.proof_2 {α : Type u_1} [] (s : Set α) :
Set.image2 (fun (x x_1 : α) => x + x_1) s {0} = s
noncomputable def Set.addZeroClass {α : Type u_2} [] :

Set α is an AddZeroClass under pointwise operations if α is.

Equations
Instances For
theorem Set.addZeroClass.proof_1 {α : Type u_1} [] (t : Set α) :
Set.image2 (fun (x x_1 : α) => x + x_1) {0} t = t
noncomputable def Set.mulOneClass {α : Type u_2} [] :

Set α is a MulOneClass under pointwise operations if α is.

Equations
• Set.mulOneClass = let __src := Set.one; let __src_1 := Set.mul;
Instances For
theorem Set.subset_add_left {α : Type u_2} [] (s : Set α) {t : Set α} (ht : 0 t) :
s s + t
theorem Set.subset_mul_left {α : Type u_2} [] (s : Set α) {t : Set α} (ht : 1 t) :
s s * t
theorem Set.subset_add_right {α : Type u_2} [] {s : Set α} (t : Set α) (hs : 0 s) :
t s + t
theorem Set.subset_mul_right {α : Type u_2} [] {s : Set α} (t : Set α) (hs : 1 s) :
t s * t
noncomputable def Set.singletonAddMonoidHom {α : Type u_2} [] :
α →+ Set α

The singleton operation as an AddMonoidHom.

Equations
• Set.singletonAddMonoidHom = let __src := Set.singletonAddHom; let __src_1 := Set.singletonZeroHom; { toFun := __src.toFun, map_zero' := , map_add' := }
Instances For
theorem Set.singletonAddMonoidHom.proof_1 {α : Type u_1} [] :
Set.singletonZeroHom.toFun 0 = 0
theorem Set.singletonAddMonoidHom.proof_2 {α : Type u_1} [] (x : α) (y : α) :
noncomputable def Set.singletonMonoidHom {α : Type u_2} [] :
α →* Set α

The singleton operation as a MonoidHom.

Equations
• Set.singletonMonoidHom = let __src := Set.singletonMulHom; let __src_1 := Set.singletonOneHom; { toFun := __src.toFun, map_one' := , map_mul' := }
Instances For
@[simp]
theorem Set.coe_singletonAddMonoidHom {α : Type u_2} [] :
@[simp]
theorem Set.coe_singletonMonoidHom {α : Type u_2} [] :
Set.singletonMonoidHom = singleton
@[simp]
theorem Set.singletonAddMonoidHom_apply {α : Type u_2} [] (a : α) :
@[simp]
theorem Set.singletonMonoidHom_apply {α : Type u_2} [] (a : α) :
Set.singletonMonoidHom a = {a}
theorem Set.addMonoid.proof_4 {α : Type u_1} [] :
∀ (n : ) (x : Set α), nsmulRec (n + 1) x = nsmulRec (n + 1) x
noncomputable def Set.addMonoid {α : Type u_2} [] :

Set α is an AddMonoid under pointwise operations if α is.

Equations
Instances For
theorem Set.addMonoid.proof_3 {α : Type u_1} [] :
∀ (x : Set α), nsmulRec 0 x = nsmulRec 0 x
theorem Set.addMonoid.proof_1 {α : Type u_1} [] (a : Set α) :
0 + a = a
theorem Set.addMonoid.proof_2 {α : Type u_1} [] (a : Set α) :
a + 0 = a
noncomputable def Set.monoid {α : Type u_2} [] :
Monoid (Set α)

Set α is a Monoid under pointwise operations if α is.

Equations
• Set.monoid = let __src := Set.semigroup; let __src_1 := Set.mulOneClass; let __src_2 := Set.NPow; Monoid.mk npowRec
Instances For
theorem Set.nsmul_mem_nsmul {α : Type u_2} [] {s : Set α} {a : α} (ha : a s) (n : ) :
n a n s
abbrev Set.nsmul_mem_nsmul.match_1 (motive : ) :
∀ (x : ), (Unitmotive 0)(∀ (n : ), motive n.succ)motive x
Equations
• =
Instances For
theorem Set.pow_mem_pow {α : Type u_2} [] {s : Set α} {a : α} (ha : a s) (n : ) :
a ^ n s ^ n
theorem Set.nsmul_subset_nsmul {α : Type u_2} [] {s : Set α} {t : Set α} (hst : s t) (n : ) :
n s n t
theorem Set.pow_subset_pow {α : Type u_2} [] {s : Set α} {t : Set α} (hst : s t) (n : ) :
s ^ n t ^ n
theorem Set.nsmul_subset_nsmul_of_zero_mem {α : Type u_2} [] {s : Set α} {m : } {n : } (hs : 0 s) (hn : m n) :
m s n s
theorem Set.pow_subset_pow_of_one_mem {α : Type u_2} [] {s : Set α} {m : } {n : } (hs : 1 s) (hn : m n) :
s ^ m s ^ n
@[simp]
theorem Set.empty_nsmul {α : Type u_2} [] {n : } (hn : n 0) :
@[simp]
theorem Set.empty_pow {α : Type u_2} [] {n : } (hn : n 0) :
theorem Set.add_univ_of_zero_mem {α : Type u_2} [] {s : Set α} (hs : 0 s) :
s + Set.univ = Set.univ
theorem Set.mul_univ_of_one_mem {α : Type u_2} [] {s : Set α} (hs : 1 s) :
s * Set.univ = Set.univ
theorem Set.univ_add_of_zero_mem {α : Type u_2} [] {t : Set α} (ht : 0 t) :
Set.univ + t = Set.univ
theorem Set.univ_mul_of_one_mem {α : Type u_2} [] {t : Set α} (ht : 1 t) :
Set.univ * t = Set.univ
@[simp]
theorem Set.univ_add_univ {α : Type u_2} [] :
Set.univ + Set.univ = Set.univ
@[simp]
theorem Set.univ_mul_univ {α : Type u_2} [] :
Set.univ * Set.univ = Set.univ
@[simp]
theorem Set.nsmul_univ {α : Type u_5} [] {n : } :
n 0n Set.univ = Set.univ
@[simp]
theorem Set.univ_pow {α : Type u_2} [] {n : } :
n 0Set.univ ^ n = Set.univ
theorem IsAddUnit.set {α : Type u_2} [] {a : α} :
theorem IsUnit.set {α : Type u_2} [] {a : α} :
IsUnit {a}
theorem Set.addCommMonoid.proof_1 {α : Type u_1} [] (a : Set α) (b : Set α) :
a + b = b + a
noncomputable def Set.addCommMonoid {α : Type u_2} [] :

Set α is an AddCommMonoid under pointwise operations if α is.

Equations
Instances For
noncomputable def Set.commMonoid {α : Type u_2} [] :

Set α is a CommMonoid under pointwise operations if α is.

Equations
• Set.commMonoid = let __src := Set.monoid; let __src_1 := Set.commSemigroup;
Instances For
theorem Set.add_eq_zero_iff {α : Type u_2} {s : Set α} {t : Set α} :
s + t = 0 ∃ (a : α) (b : α), s = {a} t = {b} a + b = 0
theorem Set.mul_eq_one_iff {α : Type u_2} [] {s : Set α} {t : Set α} :
s * t = 1 ∃ (a : α) (b : α), s = {a} t = {b} a * b = 1
theorem Set.subtractionMonoid.proof_5 {α : Type u_1} (x : Set α) :
- -x = x
theorem Set.subtractionMonoid.proof_4 {α : Type u_1} :
∀ (n : ) (a : Set α), zsmulRec () a = zsmulRec () a
theorem Set.subtractionMonoid.proof_3 {α : Type u_1} :
∀ (n : ) (a : Set α), zsmulRec (Int.ofNat n.succ) a = zsmulRec (Int.ofNat n.succ) a
theorem Set.subtractionMonoid.proof_7 {α : Type u_1} (s : Set α) (t : Set α) (h : s + t = 0) :
-s = t
theorem Set.subtractionMonoid.proof_2 {α : Type u_1} :
∀ (a : Set α), zsmulRec 0 a = zsmulRec 0 a
theorem Set.subtractionMonoid.proof_6 {α : Type u_1} (s : Set α) (t : Set α) :
-(s + t) = -t + -s
theorem Set.subtractionMonoid.proof_1 {α : Type u_1} (s : Set α) (t : Set α) :
s - t = s + -t
noncomputable def Set.subtractionMonoid {α : Type u_2} :

Set α is a subtraction monoid under pointwise operations if α is.

Equations
• Set.subtractionMonoid = let __src := Set.addMonoid; let __src_1 := Set.involutiveNeg; let __src_2 := Set.sub; let __src_3 := Set.ZSMul;
Instances For
noncomputable def Set.divisionMonoid {α : Type u_2} [] :

Set α is a division monoid under pointwise operations if α is.

Equations
• Set.divisionMonoid = let __src := Set.monoid; let __src_1 := Set.involutiveInv; let __src_2 := Set.div; let __src_3 := Set.ZPow;
Instances For
@[simp]
theorem Set.isAddUnit_iff {α : Type u_2} {s : Set α} :
∃ (a : α), s = {a}
@[simp]
theorem Set.isUnit_iff {α : Type u_2} [] {s : Set α} :
∃ (a : α), s = {a}
@[simp]
theorem Set.univ_sub_univ {α : Type u_2} :
Set.univ - Set.univ = Set.univ
@[simp]
theorem Set.univ_div_univ {α : Type u_2} [] :
Set.univ / Set.univ = Set.univ
noncomputable def Set.subtractionCommMonoid {α : Type u_2} :

Set α is a commutative subtraction monoid under pointwise operations if α is.

Equations
• Set.subtractionCommMonoid = let __src := Set.subtractionMonoid; let __src_1 := Set.addCommSemigroup;
Instances For
theorem Set.subtractionCommMonoid.proof_1 {α : Type u_1} (a : Set α) (b : Set α) :
a + b = b + a
noncomputable def Set.divisionCommMonoid {α : Type u_2} :

Set α is a commutative division monoid under pointwise operations if α is.

Equations
• Set.divisionCommMonoid = let __src := Set.divisionMonoid; let __src_1 := Set.commSemigroup;
Instances For
noncomputable def Set.hasDistribNeg {α : Type u_2} [Mul α] [] :

Set α has distributive negation if α has.

Equations
• Set.hasDistribNeg = let __src := Set.involutiveNeg;
Instances For

Note that Set α is not a Distrib because s * t + s * u has cross terms that s * (t + u) lacks.

theorem Set.mul_add_subset {α : Type u_2} [] (s : Set α) (t : Set α) (u : Set α) :
s * (t + u) s * t + s * u
theorem Set.add_mul_subset {α : Type u_2} [] (s : Set α) (t : Set α) (u : Set α) :
(s + t) * u s * u + t * u

Note that Set is not a MulZeroClass because 0 * ∅ ≠ 0.

theorem Set.mul_zero_subset {α : Type u_2} [] (s : Set α) :
s * 0 0
theorem Set.zero_mul_subset {α : Type u_2} [] (s : Set α) :
0 * s 0
theorem Set.Nonempty.mul_zero {α : Type u_2} [] {s : Set α} (hs : s.Nonempty) :
s * 0 = 0
theorem Set.Nonempty.zero_mul {α : Type u_2} [] {s : Set α} (hs : s.Nonempty) :
0 * s = 0

Note that Set is not a Group because s / s ≠ 1 in general.

@[simp]
theorem Set.zero_mem_sub_iff {α : Type u_2} [] {s : Set α} {t : Set α} :
0 s - t ¬Disjoint s t
@[simp]
theorem Set.one_mem_div_iff {α : Type u_2} [] {s : Set α} {t : Set α} :
1 s / t ¬Disjoint s t
theorem Set.not_zero_mem_sub_iff {α : Type u_2} [] {s : Set α} {t : Set α} :
0s - t Disjoint s t
theorem Set.not_one_mem_div_iff {α : Type u_2} [] {s : Set α} {t : Set α} :
1s / t Disjoint s t
theorem Disjoint.one_not_mem_div_set {α : Type u_2} [] {s : Set α} {t : Set α} :
Disjoint s t1s / t

Alias of the reverse direction of Set.not_one_mem_div_iff.

theorem Disjoint.zero_not_mem_sub_set {α : Type u_2} [] {s : Set α} {t : Set α} :
Disjoint s t0s - t
abbrev Set.Nonempty.zero_mem_sub.match_1 {α : Type u_1} {s : Set α} (motive : s.NonemptyProp) :
∀ (h : s.Nonempty), (∀ (a : α) (ha : a s), motive )motive h
Equations
• =
Instances For
theorem Set.Nonempty.zero_mem_sub {α : Type u_2} [] {s : Set α} (h : s.Nonempty) :
0 s - s
theorem Set.Nonempty.one_mem_div {α : Type u_2} [] {s : Set α} (h : s.Nonempty) :
1 s / s
theorem Set.isAddUnit_singleton {α : Type u_2} [] (a : α) :
theorem Set.isUnit_singleton {α : Type u_2} [] (a : α) :
IsUnit {a}
@[simp]
theorem Set.isAddUnit_iff_singleton {α : Type u_2} [] {s : Set α} :
∃ (a : α), s = {a}
@[simp]
theorem Set.isUnit_iff_singleton {α : Type u_2} [] {s : Set α} :
∃ (a : α), s = {a}
@[simp]
theorem Set.image_add_left {α : Type u_2} [] {t : Set α} {a : α} :
(fun (x : α) => a + x) '' t = (fun (x : α) => -a + x) ⁻¹' t
@[simp]
theorem Set.image_mul_left {α : Type u_2} [] {t : Set α} {a : α} :
(fun (x : α) => a * x) '' t = (fun (x : α) => a⁻¹ * x) ⁻¹' t
@[simp]
theorem Set.image_add_right {α : Type u_2} [] {t : Set α} {b : α} :
(fun (x : α) => x + b) '' t = (fun (x : α) => x + -b) ⁻¹' t
@[simp]
theorem Set.image_mul_right {α : Type u_2} [] {t : Set α} {b : α} :
(fun (x : α) => x * b) '' t = (fun (x : α) => x * b⁻¹) ⁻¹' t
theorem Set.image_add_left' {α : Type u_2} [] {t : Set α} {a : α} :
(fun (x : α) => -a + x) '' t = (fun (x : α) => a + x) ⁻¹' t
theorem Set.image_mul_left' {α : Type u_2} [] {t : Set α} {a : α} :
(fun (x : α) => a⁻¹ * x) '' t = (fun (x : α) => a * x) ⁻¹' t
theorem Set.image_add_right' {α : Type u_2} [] {t : Set α} {b : α} :
(fun (x : α) => x + -b) '' t = (fun (x : α) => x + b) ⁻¹' t
theorem Set.image_mul_right' {α : Type u_2} [] {t : Set α} {b : α} :
(fun (x : α) => x * b⁻¹) '' t = (fun (x : α) => x * b) ⁻¹' t
@[simp]
theorem Set.preimage_add_left_singleton {α : Type u_2} [] {a : α} {b : α} :
(fun (x : α) => a + x) ⁻¹' {b} = {-a + b}
@[simp]
theorem Set.preimage_mul_left_singleton {α : Type u_2} [] {a : α} {b : α} :
(fun (x : α) => a * x) ⁻¹' {b} = {a⁻¹ * b}
@[simp]
theorem Set.preimage_add_right_singleton {α : Type u_2} [] {a : α} {b : α} :
(fun (x : α) => x + a) ⁻¹' {b} = {b + -a}
@[simp]
theorem Set.preimage_mul_right_singleton {α : Type u_2} [] {a : α} {b : α} :
(fun (x : α) => x * a) ⁻¹' {b} = {b * a⁻¹}
@[simp]
theorem Set.preimage_add_left_zero {α : Type u_2} [] {a : α} :
(fun (x : α) => a + x) ⁻¹' 0 = {-a}
@[simp]
theorem Set.preimage_mul_left_one {α : Type u_2} [] {a : α} :
(fun (x : α) => a * x) ⁻¹' 1 = {a⁻¹}
@[simp]
theorem Set.preimage_add_right_zero {α : Type u_2} [] {b : α} :
(fun (x : α) => x + b) ⁻¹' 0 = {-b}
@[simp]
theorem Set.preimage_mul_right_one {α : Type u_2} [] {b : α} :
(fun (x : α) => x * b) ⁻¹' 1 = {b⁻¹}
theorem Set.preimage_add_left_zero' {α : Type u_2} [] {a : α} :
(fun (x : α) => -a + x) ⁻¹' 0 = {a}
theorem Set.preimage_mul_left_one' {α : Type u_2} [] {a : α} :
(fun (x : α) => a⁻¹ * x) ⁻¹' 1 = {a}
theorem Set.preimage_add_right_zero' {α : Type u_2} [] {b : α} :
(fun (x : α) => x + -b) ⁻¹' 0 = {b}
theorem Set.preimage_mul_right_one' {α : Type u_2} [] {b : α} :
(fun (x : α) => x * b⁻¹) ⁻¹' 1 = {b}
@[simp]
theorem Set.add_univ {α : Type u_2} [] {s : Set α} (hs : s.Nonempty) :
s + Set.univ = Set.univ
@[simp]
theorem Set.mul_univ {α : Type u_2} [] {s : Set α} (hs : s.Nonempty) :
s * Set.univ = Set.univ
@[simp]
theorem Set.univ_add {α : Type u_2} [] {t : Set α} (ht : t.Nonempty) :
Set.univ + t = Set.univ
@[simp]
theorem Set.univ_mul {α : Type u_2} [] {t : Set α} (ht : t.Nonempty) :
Set.univ * t = Set.univ
theorem Set.div_zero_subset {α : Type u_2} [] (s : Set α) :
s / 0 0
theorem Set.zero_div_subset {α : Type u_2} [] (s : Set α) :
0 / s 0
theorem Set.Nonempty.div_zero {α : Type u_2} [] {s : Set α} (hs : s.Nonempty) :
s / 0 = 0
theorem Set.Nonempty.zero_div {α : Type u_2} [] {s : Set α} (hs : s.Nonempty) :
0 / s = 0
theorem Set.image_add {F : Type u_1} {α : Type u_2} {β : Type u_3} [Add α] [Add β] [FunLike F α β] [AddHomClass F α β] (m : F) {s : Set α} {t : Set α} :
m '' (s + t) = m '' s + m '' t
theorem Set.image_mul {F : Type u_1} {α : Type u_2} {β : Type u_3} [Mul α] [Mul β] [FunLike F α β] [MulHomClass F α β] (m : F) {s : Set α} {t : Set α} :
m '' (s * t) = m '' s * m '' t
theorem Set.add_subset_range {F : Type u_1} {α : Type u_2} {β : Type u_3} [Add α] [Add β] [FunLike F α β] [AddHomClass F α β] (m : F) {s : Set β} {t : Set β} (hs : s ) (ht : t ) :
s + t
theorem Set.mul_subset_range {F : Type u_1} {α : Type u_2} {β : Type u_3} [Mul α] [Mul β] [FunLike F α β] [MulHomClass F α β] (m : F) {s : Set β} {t : Set β} (hs : s ) (ht : t ) :
s * t
theorem Set.preimage_add_preimage_subset {F : Type u_1} {α : Type u_2} {β : Type u_3} [Add α] [Add β] [FunLike F α β] [AddHomClass F α β] (m : F) {s : Set β} {t : Set β} :
m ⁻¹' s + m ⁻¹' t m ⁻¹' (s + t)
theorem Set.preimage_mul_preimage_subset {F : Type u_1} {α : Type u_2} {β : Type u_3} [Mul α] [Mul β] [FunLike F α β] [MulHomClass F α β] (m : F) {s : Set β} {t : Set β} :
m ⁻¹' s * m ⁻¹' t m ⁻¹' (s * t)
theorem Set.preimage_add {F : Type u_1} {α : Type u_2} {β : Type u_3} [Add α] [Add β] [FunLike F α β] [AddHomClass F α β] (m : F) (hm : ) {s : Set β} {t : Set β} (hs : s ) (ht : t ) :
m ⁻¹' (s + t) = m ⁻¹' s + m ⁻¹' t
theorem Set.preimage_mul {F : Type u_1} {α : Type u_2} {β : Type u_3} [Mul α] [Mul β] [FunLike F α β] [MulHomClass F α β] (m : F) (hm : ) {s : Set β} {t : Set β} (hs : s ) (ht : t ) :
m ⁻¹' (s * t) = m ⁻¹' s * m ⁻¹' t
theorem Set.image_sub {F : Type u_1} {α : Type u_2} {β : Type u_3} [] [FunLike F α β] [] (m : F) {s : Set α} {t : Set α} :
m '' (s - t) = m '' s - m '' t
theorem Set.image_div {F : Type u_1} {α : Type u_2} {β : Type u_3} [] [] [FunLike F α β] [] (m : F) {s : Set α} {t : Set α} :
m '' (s / t) = m '' s / m '' t
theorem Set.sub_subset_range {F : Type u_1} {α : Type u_2} {β : Type u_3} [] [FunLike F α β] [] (m : F) {s : Set β} {t : Set β} (hs : s ) (ht : t ) :
s - t
theorem Set.div_subset_range {F : Type u_1} {α : Type u_2} {β : Type u_3} [] [] [FunLike F α β] [] (m : F) {s : Set β} {t : Set β} (hs : s ) (ht : t ) :
s / t
theorem Set.preimage_sub_preimage_subset {F : Type u_1} {α : Type u_2} {β : Type u_3} [] [FunLike F α β] [] (m : F) {s : Set β} {t : Set β} :
m ⁻¹' s - m ⁻¹' t m ⁻¹' (s - t)
theorem Set.preimage_div_preimage_subset {F : Type u_1} {α : Type u_2} {β : Type u_3} [] [] [FunLike F α β] [] (m : F) {s : Set β} {t : Set β} :
m ⁻¹' s / m ⁻¹' t m ⁻¹' (s / t)
theorem Set.preimage_sub {F : Type u_1} {α : Type u_2} {β : Type u_3} [] [FunLike F α β] [] (m : F) (hm : ) {s : Set β} {t : Set β} (hs : s ) (ht : t ) :
m ⁻¹' (s - t) = m ⁻¹' s - m ⁻¹' t
theorem Set.preimage_div {F : Type u_1} {α : Type u_2} {β : Type u_3} [] [] [FunLike F α β] [] (m : F) (hm : ) {s : Set β} {t : Set β} (hs : s ) (ht : t ) :
m ⁻¹' (s / t) = m ⁻¹' s / m ⁻¹' t
theorem Set.BddAbove.add {α : Type u_2} {A : Set α} {B : Set α} (hA : ) (hB : ) :
BddAbove (A + B)
theorem Set.BddAbove.mul {α : Type u_2} {A : Set α} {B : Set α} (hA : ) (hB : ) :
BddAbove (A * B)

### Miscellaneous #

theorem AddGroup.card_nsmul_eq_card_nsmul_card_univ_aux {f : } (h1 : ) {B : } (h2 : ∀ (n : ), f n B) (h3 : ∀ (n : ), f n = f (n + 1)f (n + 1) = f (n + 2)) (k : ) :
B kf k = f B
theorem Group.card_pow_eq_card_pow_card_univ_aux {f : } (h1 : ) {B : } (h2 : ∀ (n : ), f n B) (h3 : ∀ (n : ), f n = f (n + 1)f (n + 1) = f (n + 2)) (k : ) :
B kf k = f B