Documentation

Mathlib.Data.Set.Pointwise.Basic

Pointwise operations of sets #

This file defines pointwise algebraic operations on sets.

Main declarations #

For sets s and t and scalar a:

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 #

Tags #

set multiplication, set addition, pointwise addition, pointwise multiplication, pointwise subtraction

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} [InvolutiveNeg α] {s : Set α} {a : α} :
              -a -s a s
              theorem Set.inv_mem_inv {α : Type u_2} [InvolutiveInv α] {s : Set α} {a : α} :
              @[simp]
              theorem Set.nonempty_neg {α : Type u_2} [InvolutiveNeg α] {s : Set α} :
              (-s).Nonempty s.Nonempty
              @[simp]
              theorem Set.nonempty_inv {α : Type u_2} [InvolutiveInv α] {s : Set α} :
              s⁻¹.Nonempty s.Nonempty
              theorem Set.Nonempty.neg {α : Type u_2} [InvolutiveNeg α] {s : Set α} (h : s.Nonempty) :
              (-s).Nonempty
              theorem Set.Nonempty.inv {α : Type u_2} [InvolutiveInv α] {s : Set α} (h : s.Nonempty) :
              s⁻¹.Nonempty
              @[simp]
              theorem Set.image_neg {α : Type u_2} [InvolutiveNeg α] {s : Set α} :
              Neg.neg '' s = -s
              @[simp]
              theorem Set.image_inv {α : Type u_2} [InvolutiveInv α] {s : Set α} :
              Inv.inv '' s = s⁻¹
              @[simp]
              theorem Set.neg_eq_empty {α : Type u_2} [InvolutiveNeg α] {s : Set α} :
              -s = s =
              @[simp]
              theorem Set.inv_eq_empty {α : Type u_2} [InvolutiveInv α] {s : Set α} :
              noncomputable instance Set.involutiveNeg {α : Type u_2} [InvolutiveNeg α] :
              Equations
              theorem Set.involutiveNeg.proof_1 {α : Type u_1} [InvolutiveNeg α] (s : Set α) :
              (fun (x : α) => - -x) ⁻¹' s = s
              noncomputable instance Set.involutiveInv {α : Type u_2} [InvolutiveInv α] :
              Equations
              @[simp]
              theorem Set.neg_subset_neg {α : Type u_2} [InvolutiveNeg α] {s : Set α} {t : Set α} :
              -s -t s t
              @[simp]
              theorem Set.inv_subset_inv {α : Type u_2} [InvolutiveInv α] {s : Set α} {t : Set α} :
              theorem Set.neg_subset {α : Type u_2} [InvolutiveNeg α] {s : Set α} {t : Set α} :
              -s t s -t
              theorem Set.inv_subset {α : Type u_2} [InvolutiveInv α] {s : Set α} {t : Set α} :
              @[simp]
              theorem Set.neg_singleton {α : Type u_2} [InvolutiveNeg α] (a : α) :
              -{a} = {-a}
              @[simp]
              theorem Set.inv_singleton {α : Type u_2} [InvolutiveInv α] (a : α) :
              {a}⁻¹ = {a⁻¹}
              @[simp]
              theorem Set.neg_insert {α : Type u_2} [InvolutiveNeg α] (a : α) (s : Set α) :
              -insert a s = insert (-a) (-s)
              @[simp]
              theorem Set.inv_insert {α : Type u_2} [InvolutiveInv α] (a : α) (s : Set α) :
              theorem Set.neg_range {α : Type u_2} [InvolutiveNeg α] {ι : Sort u_5} {f : ια} :
              -Set.range f = Set.range fun (i : ι) => -f i
              theorem Set.inv_range {α : Type u_2} [InvolutiveInv α] {ι : Sort u_5} {f : ια} :
              (Set.range f)⁻¹ = Set.range fun (i : ι) => (f i)⁻¹
              theorem Set.image_op_neg {α : Type u_2} [InvolutiveNeg α] {s : Set α} :
              AddOpposite.op '' (-s) = -AddOpposite.op '' s
              theorem Set.image_op_inv {α : Type u_2} [InvolutiveInv α] {s : Set α} :
              MulOpposite.op '' s⁻¹ = (MulOpposite.op '' s)⁻¹

              Set addition/multiplication #

              def Set.add {α : Type u_2} [Add α] :
              Add (Set α)

              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
                  theorem Set.singletonAddHom.proof_1 {α : Type u_1} [Add α] :
                  ∀ (x x_1 : α), {x + x_1} = {x} + {x_1}
                  noncomputable def Set.singletonAddHom {α : Type u_2} [Add α] :
                  AddHom α (Set α)

                  The singleton operation as an AddHom.

                  Equations
                  • Set.singletonAddHom = { toFun := singleton, map_add' := }
                  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]
                      theorem Set.coe_singletonAddHom {α : Type u_2} [Add α] :
                      Set.singletonAddHom = singleton
                      @[simp]
                      theorem Set.coe_singletonMulHom {α : Type u_2} [Mul α] :
                      Set.singletonMulHom = singleton
                      @[simp]
                      theorem Set.singletonAddHom_apply {α : Type u_2} [Add α] (a : α) :
                      Set.singletonAddHom a = {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 α} :
                      AddOpposite.op '' (s + t) = AddOpposite.op '' t + AddOpposite.op '' s
                      @[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} [AddSemigroup α] :
                                  ∀ (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} [AddSemigroup α] :

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

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

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

                                    Equations
                                    Instances For
                                      theorem Set.addCommSemigroup.proof_1 {α : Type u_1} [AddCommSemigroup α] :
                                      ∀ (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} [AddCommSemigroup α] :

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

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

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

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

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

                                          Equations
                                          • Set.addZeroClass = let __src := Set.zero; let __src_1 := Set.add; AddZeroClass.mk
                                          Instances For
                                            theorem Set.addZeroClass.proof_1 {α : Type u_1} [AddZeroClass α] (t : Set α) :
                                            Set.image2 (fun (x x_1 : α) => x + x_1) {0} t = t
                                            noncomputable def Set.mulOneClass {α : Type u_2} [MulOneClass α] :

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

                                            Equations
                                            • Set.mulOneClass = let __src := Set.one; let __src_1 := Set.mul; MulOneClass.mk
                                            Instances For
                                              theorem Set.subset_add_left {α : Type u_2} [AddZeroClass α] (s : Set α) {t : Set α} (ht : 0 t) :
                                              s s + t
                                              theorem Set.subset_mul_left {α : Type u_2} [MulOneClass α] (s : Set α) {t : Set α} (ht : 1 t) :
                                              s s * t
                                              theorem Set.subset_add_right {α : Type u_2} [AddZeroClass α] {s : Set α} (t : Set α) (hs : 0 s) :
                                              t s + t
                                              theorem Set.subset_mul_right {α : Type u_2} [MulOneClass α] {s : Set α} (t : Set α) (hs : 1 s) :
                                              t s * t
                                              noncomputable def Set.singletonAddMonoidHom {α : Type u_2} [AddZeroClass α] :
                                              α →+ 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} [AddZeroClass α] :
                                                Set.singletonZeroHom.toFun 0 = 0
                                                theorem Set.singletonAddMonoidHom.proof_2 {α : Type u_1} [AddZeroClass α] (x : α) (y : α) :
                                                Set.singletonAddHom.toFun (x + y) = Set.singletonAddHom.toFun x + Set.singletonAddHom.toFun y
                                                noncomputable def Set.singletonMonoidHom {α : Type u_2} [MulOneClass α] :
                                                α →* 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} [AddZeroClass α] :
                                                  Set.singletonAddMonoidHom = singleton
                                                  @[simp]
                                                  theorem Set.coe_singletonMonoidHom {α : Type u_2} [MulOneClass α] :
                                                  Set.singletonMonoidHom = singleton
                                                  @[simp]
                                                  theorem Set.singletonAddMonoidHom_apply {α : Type u_2} [AddZeroClass α] (a : α) :
                                                  Set.singletonAddMonoidHom a = {a}
                                                  @[simp]
                                                  theorem Set.singletonMonoidHom_apply {α : Type u_2} [MulOneClass α] (a : α) :
                                                  Set.singletonMonoidHom a = {a}
                                                  theorem Set.addMonoid.proof_4 {α : Type u_1} [AddMonoid α] :
                                                  ∀ (n : ) (x : Set α), nsmulRec (n + 1) x = nsmulRec (n + 1) x
                                                  noncomputable def Set.addMonoid {α : Type u_2} [AddMonoid α] :

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

                                                  Equations
                                                  • Set.addMonoid = let __src := Set.addSemigroup; let __src_1 := Set.addZeroClass; let __src_2 := Set.NSMul; AddMonoid.mk nsmulRec
                                                  Instances For
                                                    theorem Set.addMonoid.proof_3 {α : Type u_1} [AddMonoid α] :
                                                    ∀ (x : Set α), nsmulRec 0 x = nsmulRec 0 x
                                                    theorem Set.addMonoid.proof_1 {α : Type u_1} [AddMonoid α] (a : Set α) :
                                                    0 + a = a
                                                    theorem Set.addMonoid.proof_2 {α : Type u_1} [AddMonoid α] (a : Set α) :
                                                    a + 0 = a
                                                    noncomputable def Set.monoid {α : Type u_2} [Monoid α] :
                                                    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} [AddMonoid α] {s : Set α} {a : α} (ha : a s) (n : ) :
                                                      n a n s
                                                      abbrev Set.nsmul_mem_nsmul.match_1 (motive : Prop) :
                                                      ∀ (x : ), (Unitmotive 0)(∀ (n : ), motive n.succ)motive x
                                                      Equations
                                                      • =
                                                      Instances For
                                                        theorem Set.pow_mem_pow {α : Type u_2} [Monoid α] {s : Set α} {a : α} (ha : a s) (n : ) :
                                                        a ^ n s ^ n
                                                        theorem Set.nsmul_subset_nsmul {α : Type u_2} [AddMonoid α] {s : Set α} {t : Set α} (hst : s t) (n : ) :
                                                        n s n t
                                                        theorem Set.pow_subset_pow {α : Type u_2} [Monoid α] {s : Set α} {t : Set α} (hst : s t) (n : ) :
                                                        s ^ n t ^ n
                                                        theorem Set.nsmul_subset_nsmul_of_zero_mem {α : Type u_2} [AddMonoid α] {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} [Monoid α] {s : Set α} {m : } {n : } (hs : 1 s) (hn : m n) :
                                                        s ^ m s ^ n
                                                        @[simp]
                                                        theorem Set.empty_nsmul {α : Type u_2} [AddMonoid α] {n : } (hn : n 0) :
                                                        @[simp]
                                                        theorem Set.empty_pow {α : Type u_2} [Monoid α] {n : } (hn : n 0) :
                                                        theorem Set.add_univ_of_zero_mem {α : Type u_2} [AddMonoid α] {s : Set α} (hs : 0 s) :
                                                        s + Set.univ = Set.univ
                                                        theorem Set.mul_univ_of_one_mem {α : Type u_2} [Monoid α] {s : Set α} (hs : 1 s) :
                                                        s * Set.univ = Set.univ
                                                        theorem Set.univ_add_of_zero_mem {α : Type u_2} [AddMonoid α] {t : Set α} (ht : 0 t) :
                                                        Set.univ + t = Set.univ
                                                        theorem Set.univ_mul_of_one_mem {α : Type u_2} [Monoid α] {t : Set α} (ht : 1 t) :
                                                        Set.univ * t = Set.univ
                                                        @[simp]
                                                        theorem Set.univ_add_univ {α : Type u_2} [AddMonoid α] :
                                                        Set.univ + Set.univ = Set.univ
                                                        @[simp]
                                                        theorem Set.univ_mul_univ {α : Type u_2} [Monoid α] :
                                                        Set.univ * Set.univ = Set.univ
                                                        @[simp]
                                                        theorem Set.nsmul_univ {α : Type u_5} [AddMonoid α] {n : } :
                                                        n 0n Set.univ = Set.univ
                                                        @[simp]
                                                        theorem Set.univ_pow {α : Type u_2} [Monoid α] {n : } :
                                                        n 0Set.univ ^ n = Set.univ
                                                        theorem IsAddUnit.set {α : Type u_2} [AddMonoid α] {a : α} :
                                                        theorem IsUnit.set {α : Type u_2} [Monoid α] {a : α} :
                                                        IsUnit aIsUnit {a}
                                                        theorem Set.addCommMonoid.proof_1 {α : Type u_1} [AddCommMonoid α] (a : Set α) (b : Set α) :
                                                        a + b = b + a
                                                        noncomputable def Set.addCommMonoid {α : Type u_2} [AddCommMonoid α] :

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

                                                        Equations
                                                        • Set.addCommMonoid = let __src := Set.addMonoid; let __src_1 := Set.addCommSemigroup; AddCommMonoid.mk
                                                        Instances For
                                                          noncomputable def Set.commMonoid {α : Type u_2} [CommMonoid α] :

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

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

                                                            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; SubtractionMonoid.mk
                                                            Instances For
                                                              noncomputable def Set.divisionMonoid {α : Type u_2} [DivisionMonoid α] :

                                                              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; DivisionMonoid.mk
                                                              Instances For
                                                                @[simp]
                                                                theorem Set.isAddUnit_iff {α : Type u_2} [SubtractionMonoid α] {s : Set α} :
                                                                IsAddUnit s ∃ (a : α), s = {a} IsAddUnit a
                                                                @[simp]
                                                                theorem Set.isUnit_iff {α : Type u_2} [DivisionMonoid α] {s : Set α} :
                                                                IsUnit s ∃ (a : α), s = {a} IsUnit a
                                                                @[simp]
                                                                theorem Set.univ_sub_univ {α : Type u_2} [SubtractionMonoid α] :
                                                                Set.univ - Set.univ = Set.univ
                                                                @[simp]
                                                                theorem Set.univ_div_univ {α : Type u_2} [DivisionMonoid α] :
                                                                Set.univ / Set.univ = Set.univ

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

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

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

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

                                                                    Set α has distributive negation if α has.

                                                                    Equations
                                                                    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} [Distrib α] (s : Set α) (t : Set α) (u : Set α) :
                                                                      s * (t + u) s * t + s * u
                                                                      theorem Set.add_mul_subset {α : Type u_2} [Distrib α] (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} [MulZeroClass α] (s : Set α) :
                                                                      s * 0 0
                                                                      theorem Set.zero_mul_subset {α : Type u_2} [MulZeroClass α] (s : Set α) :
                                                                      0 * s 0
                                                                      theorem Set.Nonempty.mul_zero {α : Type u_2} [MulZeroClass α] {s : Set α} (hs : s.Nonempty) :
                                                                      s * 0 = 0
                                                                      theorem Set.Nonempty.zero_mul {α : Type u_2} [MulZeroClass α] {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} [AddGroup α] {s : Set α} {t : Set α} :
                                                                      0 s - t ¬Disjoint s t
                                                                      @[simp]
                                                                      theorem Set.one_mem_div_iff {α : Type u_2} [Group α] {s : Set α} {t : Set α} :
                                                                      1 s / t ¬Disjoint s t
                                                                      theorem Set.not_zero_mem_sub_iff {α : Type u_2} [AddGroup α] {s : Set α} {t : Set α} :
                                                                      0s - t Disjoint s t
                                                                      theorem Set.not_one_mem_div_iff {α : Type u_2} [Group α] {s : Set α} {t : Set α} :
                                                                      1s / t Disjoint s t
                                                                      theorem Disjoint.one_not_mem_div_set {α : Type u_2} [Group α] {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} [AddGroup α] {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} [AddGroup α] {s : Set α} (h : s.Nonempty) :
                                                                        0 s - s
                                                                        theorem Set.Nonempty.one_mem_div {α : Type u_2} [Group α] {s : Set α} (h : s.Nonempty) :
                                                                        1 s / s
                                                                        theorem Set.isAddUnit_singleton {α : Type u_2} [AddGroup α] (a : α) :
                                                                        theorem Set.isUnit_singleton {α : Type u_2} [Group α] (a : α) :
                                                                        IsUnit {a}
                                                                        @[simp]
                                                                        theorem Set.isAddUnit_iff_singleton {α : Type u_2} [AddGroup α] {s : Set α} :
                                                                        IsAddUnit s ∃ (a : α), s = {a}
                                                                        @[simp]
                                                                        theorem Set.isUnit_iff_singleton {α : Type u_2} [Group α] {s : Set α} :
                                                                        IsUnit s ∃ (a : α), s = {a}
                                                                        @[simp]
                                                                        theorem Set.image_add_left {α : Type u_2} [AddGroup α] {t : Set α} {a : α} :
                                                                        (fun (x : α) => a + x) '' t = (fun (x : α) => -a + x) ⁻¹' t
                                                                        @[simp]
                                                                        theorem Set.image_mul_left {α : Type u_2} [Group α] {t : Set α} {a : α} :
                                                                        (fun (x : α) => a * x) '' t = (fun (x : α) => a⁻¹ * x) ⁻¹' t
                                                                        @[simp]
                                                                        theorem Set.image_add_right {α : Type u_2} [AddGroup α] {t : Set α} {b : α} :
                                                                        (fun (x : α) => x + b) '' t = (fun (x : α) => x + -b) ⁻¹' t
                                                                        @[simp]
                                                                        theorem Set.image_mul_right {α : Type u_2} [Group α] {t : Set α} {b : α} :
                                                                        (fun (x : α) => x * b) '' t = (fun (x : α) => x * b⁻¹) ⁻¹' t
                                                                        theorem Set.image_add_left' {α : Type u_2} [AddGroup α] {t : Set α} {a : α} :
                                                                        (fun (x : α) => -a + x) '' t = (fun (x : α) => a + x) ⁻¹' t
                                                                        theorem Set.image_mul_left' {α : Type u_2} [Group α] {t : Set α} {a : α} :
                                                                        (fun (x : α) => a⁻¹ * x) '' t = (fun (x : α) => a * x) ⁻¹' t
                                                                        theorem Set.image_add_right' {α : Type u_2} [AddGroup α] {t : Set α} {b : α} :
                                                                        (fun (x : α) => x + -b) '' t = (fun (x : α) => x + b) ⁻¹' t
                                                                        theorem Set.image_mul_right' {α : Type u_2} [Group α] {t : Set α} {b : α} :
                                                                        (fun (x : α) => x * b⁻¹) '' t = (fun (x : α) => x * b) ⁻¹' t
                                                                        @[simp]
                                                                        theorem Set.preimage_add_left_singleton {α : Type u_2} [AddGroup α] {a : α} {b : α} :
                                                                        (fun (x : α) => a + x) ⁻¹' {b} = {-a + b}
                                                                        @[simp]
                                                                        theorem Set.preimage_mul_left_singleton {α : Type u_2} [Group α] {a : α} {b : α} :
                                                                        (fun (x : α) => a * x) ⁻¹' {b} = {a⁻¹ * b}
                                                                        @[simp]
                                                                        theorem Set.preimage_add_right_singleton {α : Type u_2} [AddGroup α] {a : α} {b : α} :
                                                                        (fun (x : α) => x + a) ⁻¹' {b} = {b + -a}
                                                                        @[simp]
                                                                        theorem Set.preimage_mul_right_singleton {α : Type u_2} [Group α] {a : α} {b : α} :
                                                                        (fun (x : α) => x * a) ⁻¹' {b} = {b * a⁻¹}
                                                                        @[simp]
                                                                        theorem Set.preimage_add_left_zero {α : Type u_2} [AddGroup α] {a : α} :
                                                                        (fun (x : α) => a + x) ⁻¹' 0 = {-a}
                                                                        @[simp]
                                                                        theorem Set.preimage_mul_left_one {α : Type u_2} [Group α] {a : α} :
                                                                        (fun (x : α) => a * x) ⁻¹' 1 = {a⁻¹}
                                                                        @[simp]
                                                                        theorem Set.preimage_add_right_zero {α : Type u_2} [AddGroup α] {b : α} :
                                                                        (fun (x : α) => x + b) ⁻¹' 0 = {-b}
                                                                        @[simp]
                                                                        theorem Set.preimage_mul_right_one {α : Type u_2} [Group α] {b : α} :
                                                                        (fun (x : α) => x * b) ⁻¹' 1 = {b⁻¹}
                                                                        theorem Set.preimage_add_left_zero' {α : Type u_2} [AddGroup α] {a : α} :
                                                                        (fun (x : α) => -a + x) ⁻¹' 0 = {a}
                                                                        theorem Set.preimage_mul_left_one' {α : Type u_2} [Group α] {a : α} :
                                                                        (fun (x : α) => a⁻¹ * x) ⁻¹' 1 = {a}
                                                                        theorem Set.preimage_add_right_zero' {α : Type u_2} [AddGroup α] {b : α} :
                                                                        (fun (x : α) => x + -b) ⁻¹' 0 = {b}
                                                                        theorem Set.preimage_mul_right_one' {α : Type u_2} [Group α] {b : α} :
                                                                        (fun (x : α) => x * b⁻¹) ⁻¹' 1 = {b}
                                                                        @[simp]
                                                                        theorem Set.add_univ {α : Type u_2} [AddGroup α] {s : Set α} (hs : s.Nonempty) :
                                                                        s + Set.univ = Set.univ
                                                                        @[simp]
                                                                        theorem Set.mul_univ {α : Type u_2} [Group α] {s : Set α} (hs : s.Nonempty) :
                                                                        s * Set.univ = Set.univ
                                                                        @[simp]
                                                                        theorem Set.univ_add {α : Type u_2} [AddGroup α] {t : Set α} (ht : t.Nonempty) :
                                                                        Set.univ + t = Set.univ
                                                                        @[simp]
                                                                        theorem Set.univ_mul {α : Type u_2} [Group α] {t : Set α} (ht : t.Nonempty) :
                                                                        Set.univ * t = Set.univ
                                                                        theorem Set.div_zero_subset {α : Type u_2} [GroupWithZero α] (s : Set α) :
                                                                        s / 0 0
                                                                        theorem Set.zero_div_subset {α : Type u_2} [GroupWithZero α] (s : Set α) :
                                                                        0 / s 0
                                                                        theorem Set.Nonempty.div_zero {α : Type u_2} [GroupWithZero α] {s : Set α} (hs : s.Nonempty) :
                                                                        s / 0 = 0
                                                                        theorem Set.Nonempty.zero_div {α : Type u_2} [GroupWithZero α] {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 Set.range m) (ht : t Set.range m) :
                                                                        s + t Set.range m
                                                                        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 Set.range m) (ht : t Set.range m) :
                                                                        s * t Set.range m
                                                                        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 : Function.Injective m) {s : Set β} {t : Set β} (hs : s Set.range m) (ht : t Set.range m) :
                                                                        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 : Function.Injective m) {s : Set β} {t : Set β} (hs : s Set.range m) (ht : t Set.range m) :
                                                                        m ⁻¹' (s * t) = m ⁻¹' s * m ⁻¹' t
                                                                        theorem Set.image_sub {F : Type u_1} {α : Type u_2} {β : Type u_3} [AddGroup α] [SubtractionMonoid β] [FunLike F α β] [AddMonoidHomClass 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} [Group α] [DivisionMonoid β] [FunLike F α β] [MonoidHomClass 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} [AddGroup α] [SubtractionMonoid β] [FunLike F α β] [AddMonoidHomClass F α β] (m : F) {s : Set β} {t : Set β} (hs : s Set.range m) (ht : t Set.range m) :
                                                                        s - t Set.range m
                                                                        theorem Set.div_subset_range {F : Type u_1} {α : Type u_2} {β : Type u_3} [Group α] [DivisionMonoid β] [FunLike F α β] [MonoidHomClass F α β] (m : F) {s : Set β} {t : Set β} (hs : s Set.range m) (ht : t Set.range m) :
                                                                        s / t Set.range m
                                                                        theorem Set.preimage_sub_preimage_subset {F : Type u_1} {α : Type u_2} {β : Type u_3} [AddGroup α] [SubtractionMonoid β] [FunLike F α β] [AddMonoidHomClass 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} [Group α] [DivisionMonoid β] [FunLike F α β] [MonoidHomClass 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} [AddGroup α] [SubtractionMonoid β] [FunLike F α β] [AddMonoidHomClass F α β] (m : F) (hm : Function.Injective m) {s : Set β} {t : Set β} (hs : s Set.range m) (ht : t Set.range m) :
                                                                        m ⁻¹' (s - t) = m ⁻¹' s - m ⁻¹' t
                                                                        theorem Set.preimage_div {F : Type u_1} {α : Type u_2} {β : Type u_3} [Group α] [DivisionMonoid β] [FunLike F α β] [MonoidHomClass F α β] (m : F) (hm : Function.Injective m) {s : Set β} {t : Set β} (hs : s Set.range m) (ht : t Set.range m) :
                                                                        m ⁻¹' (s / t) = m ⁻¹' s / m ⁻¹' t
                                                                        theorem Set.BddAbove.add {α : Type u_2} [OrderedAddCommMonoid α] {A : Set α} {B : Set α} (hA : BddAbove A) (hB : BddAbove B) :
                                                                        BddAbove (A + B)
                                                                        theorem Set.BddAbove.mul {α : Type u_2} [OrderedCommMonoid α] {A : Set α} {B : Set α} (hA : BddAbove A) (hB : BddAbove B) :
                                                                        BddAbove (A * B)

                                                                        Miscellaneous #

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