File: Mathlib/Data/Finset/Sups.lean

full_name: Finset.hasSups
code: /-- `s ⊻ t` is the finset of elements of the form `a ⊔ b` where `a ∈ s`, `b ∈ t`. -/
protected def hasSups : HasSups (Finset α) 
goal: HasSups (Finset α)

full_name: Finset.mem_sups
code: @[simp]
theorem mem_sups : c ∈ s ⊻ t ↔ ∃ a ∈ s, ∃ b ∈ t, a ⊔ b = c 
goal: c ∈ s ⊻ t ↔ ∃ a ∈ s, ∃ b ∈ t, a ⊔ b = c

full_name: Finset.coe_sups
code: @[simp, norm_cast]
theorem coe_sups : (↑(s ⊻ t) : Set α) = ↑s ⊻ ↑t 
goal: ↑(s ⊻ t) = ↑s ⊻ ↑t

full_name: Finset.card_sups_le
code: theorem card_sups_le : (s ⊻ t).card ≤ s.card * t.card 
goal: (s ⊻ t).card ≤ s.card * t.card

full_name: Finset.card_sups_iff
code: theorem card_sups_iff :
    (s ⊻ t).card = s.card * t.card ↔ (s ×ˢ t : Set (α × α)).InjOn fun x => x.1 ⊔ x.2 
goal: (s ⊻ t).card = s.card * t.card ↔ Set.InjOn (fun x => x.1 ⊔ x.2) (↑s ×ˢ ↑t)

full_name: Finset.sup_mem_sups
code: theorem sup_mem_sups : a ∈ s → b ∈ t → a ⊔ b ∈ s ⊻ t 
goal: a ∈ s → b ∈ t → a ⊔ b ∈ s ⊻ t

full_name: Finset.sups_subset
code: theorem sups_subset : s₁ ⊆ s₂ → t₁ ⊆ t₂ → s₁ ⊻ t₁ ⊆ s₂ ⊻ t₂ 
goal: s₁ ⊆ s₂ → t₁ ⊆ t₂ → s₁ ⊻ t₁ ⊆ s₂ ⊻ t₂

full_name: Finset.sups_subset_left
code: theorem sups_subset_left : t₁ ⊆ t₂ → s ⊻ t₁ ⊆ s ⊻ t₂ 
goal: t₁ ⊆ t₂ → s ⊻ t₁ ⊆ s ⊻ t₂

full_name: Finset.sups_subset_right
code: theorem sups_subset_right : s₁ ⊆ s₂ → s₁ ⊻ t ⊆ s₂ ⊻ t 
goal: s₁ ⊆ s₂ → s₁ ⊻ t ⊆ s₂ ⊻ t

full_name: Finset.image_subset_sups_left
code: lemma image_subset_sups_left : b ∈ t → s.image (· ⊔ b) ⊆ s ⊻ t 
goal: b ∈ t → Finset.image (fun x => x ⊔ b) s ⊆ s ⊻ t

full_name: Finset.image_subset_sups_right
code: lemma image_subset_sups_right : a ∈ s → t.image (a ⊔ ·) ⊆ s ⊻ t 
goal: a ∈ s → Finset.image (fun x => a ⊔ x) t ⊆ s ⊻ t

full_name: Finset.forall_sups_iff
code: theorem forall_sups_iff {p : α → Prop} : (∀ c ∈ s ⊻ t, p c) ↔ ∀ a ∈ s, ∀ b ∈ t, p (a ⊔ b) 
goal: (∀ c ∈ s ⊻ t, p c) ↔ ∀ a ∈ s, ∀ b ∈ t, p (a ⊔ b)

full_name: Finset.sups_subset_iff
code: @[simp]
theorem sups_subset_iff : s ⊻ t ⊆ u ↔ ∀ a ∈ s, ∀ b ∈ t, a ⊔ b ∈ u 
goal: s ⊻ t ⊆ u ↔ ∀ a ∈ s, ∀ b ∈ t, a ⊔ b ∈ u

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

full_name: Finset.Nonempty.sups
code: protected theorem Nonempty.sups : s.Nonempty → t.Nonempty → (s ⊻ t).Nonempty 
goal: s.Nonempty → t.Nonempty → (s ⊻ t).Nonempty

full_name: Finset.Nonempty.of_sups_left
code: theorem Nonempty.of_sups_left : (s ⊻ t).Nonempty → s.Nonempty 
goal: (s ⊻ t).Nonempty → s.Nonempty

full_name: Finset.Nonempty.of_sups_right
code: theorem Nonempty.of_sups_right : (s ⊻ t).Nonempty → t.Nonempty 
goal: (s ⊻ t).Nonempty → t.Nonempty

full_name: Finset.empty_sups
code: @[simp]
theorem empty_sups : ∅ ⊻ t = ∅ 
goal: ∅ ⊻ t = ∅

full_name: Finset.sups_empty
code: @[simp]
theorem sups_empty : s ⊻ ∅ = ∅ 
goal: s ⊻ ∅ = ∅

full_name: Finset.sups_eq_empty
code: @[simp]
theorem sups_eq_empty : s ⊻ t = ∅ ↔ s = ∅ ∨ t = ∅ 
goal: s ⊻ t = ∅ ↔ s = ∅ ∨ t = ∅

full_name: Finset.singleton_sups
code: @[simp] lemma singleton_sups : {a} ⊻ t = t.image (a ⊔ ·) 
goal: {a} ⊻ t = Finset.image (fun x => a ⊔ x) t

full_name: Finset.sups_singleton
code: @[simp] lemma sups_singleton : s ⊻ {b} = s.image (· ⊔ b) 
goal: s ⊻ {b} = Finset.image (fun x => x ⊔ b) s

full_name: Finset.singleton_sups_singleton
code: theorem singleton_sups_singleton : ({a} ⊻ {b} : Finset α) = {a ⊔ b} 
goal: {a} ⊻ {b} = {a ⊔ b}

full_name: Finset.sups_union_left
code: theorem sups_union_left : (s₁ ∪ s₂) ⊻ t = s₁ ⊻ t ∪ s₂ ⊻ t 
goal: (s₁ ∪ s₂) ⊻ t = s₁ ⊻ t ∪ s₂ ⊻ t

full_name: Finset.sups_union_right
code: theorem sups_union_right : s ⊻ (t₁ ∪ t₂) = s ⊻ t₁ ∪ s ⊻ t₂ 
goal: s ⊻ (t₁ ∪ t₂) = s ⊻ t₁ ∪ s ⊻ t₂

full_name: Finset.sups_inter_subset_left
code: theorem sups_inter_subset_left : (s₁ ∩ s₂) ⊻ t ⊆ s₁ ⊻ t ∩ s₂ ⊻ t 
goal: (s₁ ∩ s₂) ⊻ t ⊆ s₁ ⊻ t ∩ s₂ ⊻ t

full_name: Finset.sups_inter_subset_right
code: theorem sups_inter_subset_right : s ⊻ (t₁ ∩ t₂) ⊆ s ⊻ t₁ ∩ s ⊻ t₂ 
goal: s ⊻ (t₁ ∩ t₂) ⊆ s ⊻ t₁ ∩ s ⊻ t₂

full_name: Finset.subset_sups
code: theorem subset_sups {s t : Set α} :
    ↑u ⊆ s ⊻ t → ∃ s' t' : Finset α, ↑s' ⊆ s ∧ ↑t' ⊆ t ∧ u ⊆ s' ⊻ t' 
goal: ↑u ⊆ s ⊻ t → ∃ s' t', ↑s' ⊆ s ∧ ↑t' ⊆ t ∧ u ⊆ s' ⊻ t'

full_name: Finset.image_sups
code: lemma image_sups (f : F) (s t : Finset α) : image f (s ⊻ t) = image f s ⊻ image f t 
goal: Finset.image (⇑f) (s ⊻ t) = Finset.image (⇑f) s ⊻ Finset.image (⇑f) t

full_name: Finset.map_sups
code: lemma map_sups (f : F) (hf) (s t : Finset α) :
    map ⟨f, hf⟩ (s ⊻ t) = map ⟨f, hf⟩ s ⊻ map ⟨f, hf⟩ t 
goal: Finset.map { toFun := ⇑f, inj' := hf } (s ⊻ t) =
  Finset.map { toFun := ⇑f, inj' := hf } s ⊻ Finset.map { toFun := ⇑f, inj' := hf } t

full_name: Finset.subset_sups_self
code: lemma subset_sups_self : s ⊆ s ⊻ s 
goal: s ⊆ s ⊻ s

full_name: Finset.sups_subset_self
code: lemma sups_subset_self : s ⊻ s ⊆ s ↔ SupClosed (s : Set α) 
goal: s ⊻ s ⊆ s ↔ SupClosed ↑s

full_name: Finset.sups_eq_self
code: @[simp] lemma sups_eq_self : s ⊻ s = s ↔ SupClosed (s : Set α) 
goal: s ⊻ s = s ↔ SupClosed ↑s

full_name: Finset.univ_sups_univ
code: @[simp] lemma univ_sups_univ [Fintype α] : (univ : Finset α) ⊻ univ = univ 
goal: Finset.univ ⊻ Finset.univ = Finset.univ

full_name: Finset.filter_sups_le
code: lemma filter_sups_le [@DecidableRel α (· ≤ ·)] (s t : Finset α) (a : α) :
    (s ⊻ t).filter (· ≤ a) = s.filter (· ≤ a) ⊻ t.filter (· ≤ a) 
goal: Finset.filter (fun x => x ≤ a) (s ⊻ t) = Finset.filter (fun x => x ≤ a) s ⊻ Finset.filter (fun x => x ≤ a) t

full_name: Finset.biUnion_image_sup_left
code: lemma biUnion_image_sup_left : s.biUnion (fun a ↦ t.image (a ⊔ ·)) = s ⊻ t 
goal: (s.biUnion fun a => Finset.image (fun x => a ⊔ x) t) = s ⊻ t

full_name: Finset.biUnion_image_sup_right
code: lemma biUnion_image_sup_right : t.biUnion (fun b ↦ s.image (· ⊔ b)) = s ⊻ t 
goal: (t.biUnion fun b => Finset.image (fun x => x ⊔ b) s) = s ⊻ t

full_name: Finset.image_sup_product
code: theorem image_sup_product (s t : Finset α) : (s ×ˢ t).image (uncurry (· ⊔ ·)) = s ⊻ t 
goal: Finset.image (Function.uncurry fun x x_1 => x ⊔ x_1) (s ×ˢ t) = s ⊻ t

full_name: Finset.sups_assoc
code: theorem sups_assoc : s ⊻ t ⊻ u = s ⊻ (t ⊻ u) 
goal: s ⊻ t ⊻ u = s ⊻ (t ⊻ u)

full_name: Finset.sups_comm
code: theorem sups_comm : s ⊻ t = t ⊻ s 
goal: s ⊻ t = t ⊻ s

full_name: Finset.sups_left_comm
code: theorem sups_left_comm : s ⊻ (t ⊻ u) = t ⊻ (s ⊻ u) 
goal: s ⊻ (t ⊻ u) = t ⊻ (s ⊻ u)

full_name: Finset.sups_right_comm
code: theorem sups_right_comm : s ⊻ t ⊻ u = s ⊻ u ⊻ t 
goal: s ⊻ t ⊻ u = s ⊻ u ⊻ t

full_name: Finset.sups_sups_sups_comm
code: theorem sups_sups_sups_comm : s ⊻ t ⊻ (u ⊻ v) = s ⊻ u ⊻ (t ⊻ v) 
goal: s ⊻ t ⊻ (u ⊻ v) = s ⊻ u ⊻ (t ⊻ v)

full_name: Finset.hasInfs
code: /-- `s ⊼ t` is the finset of elements of the form `a ⊓ b` where `a ∈ s`, `b ∈ t`. -/
protected def hasInfs : HasInfs (Finset α) 
goal: HasInfs (Finset α)

full_name: Finset.mem_infs
code: @[simp]
theorem mem_infs : c ∈ s ⊼ t ↔ ∃ a ∈ s, ∃ b ∈ t, a ⊓ b = c 
goal: c ∈ s ⊼ t ↔ ∃ a ∈ s, ∃ b ∈ t, a ⊓ b = c

full_name: Finset.coe_infs
code: @[simp, norm_cast]
theorem coe_infs : (↑(s ⊼ t) : Set α) = ↑s ⊼ ↑t 
goal: ↑(s ⊼ t) = ↑s ⊼ ↑t

full_name: Finset.card_infs_le
code: theorem card_infs_le : (s ⊼ t).card ≤ s.card * t.card 
goal: (s ⊼ t).card ≤ s.card * t.card

full_name: Finset.card_infs_iff
code: theorem card_infs_iff :
    (s ⊼ t).card = s.card * t.card ↔ (s ×ˢ t : Set (α × α)).InjOn fun x => x.1 ⊓ x.2 
goal: (s ⊼ t).card = s.card * t.card ↔ Set.InjOn (fun x => x.1 ⊓ x.2) (↑s ×ˢ ↑t)

full_name: Finset.inf_mem_infs
code: theorem inf_mem_infs : a ∈ s → b ∈ t → a ⊓ b ∈ s ⊼ t 
goal: a ∈ s → b ∈ t → a ⊓ b ∈ s ⊼ t

full_name: Finset.infs_subset
code: theorem infs_subset : s₁ ⊆ s₂ → t₁ ⊆ t₂ → s₁ ⊼ t₁ ⊆ s₂ ⊼ t₂ 
goal: s₁ ⊆ s₂ → t₁ ⊆ t₂ → s₁ ⊼ t₁ ⊆ s₂ ⊼ t₂

full_name: Finset.infs_subset_left
code: theorem infs_subset_left : t₁ ⊆ t₂ → s ⊼ t₁ ⊆ s ⊼ t₂ 
goal: t₁ ⊆ t₂ → s ⊼ t₁ ⊆ s ⊼ t₂

full_name: Finset.infs_subset_right
code: theorem infs_subset_right : s₁ ⊆ s₂ → s₁ ⊼ t ⊆ s₂ ⊼ t 
goal: s₁ ⊆ s₂ → s₁ ⊼ t ⊆ s₂ ⊼ t

full_name: Finset.image_subset_infs_left
code: lemma image_subset_infs_left : b ∈ t → s.image (· ⊓ b) ⊆ s ⊼ t 
goal: b ∈ t → Finset.image (fun x => x ⊓ b) s ⊆ s ⊼ t

full_name: Finset.image_subset_infs_right
code: lemma image_subset_infs_right : a ∈ s → t.image (a ⊓ ·) ⊆ s ⊼ t 
goal: a ∈ s → Finset.image (fun x => a ⊓ x) t ⊆ s ⊼ t

full_name: Finset.forall_infs_iff
code: theorem forall_infs_iff {p : α → Prop} : (∀ c ∈ s ⊼ t, p c) ↔ ∀ a ∈ s, ∀ b ∈ t, p (a ⊓ b) 
goal: (∀ c ∈ s ⊼ t, p c) ↔ ∀ a ∈ s, ∀ b ∈ t, p (a ⊓ b)

full_name: Finset.infs_subset_iff
code: @[simp]
theorem infs_subset_iff : s ⊼ t ⊆ u ↔ ∀ a ∈ s, ∀ b ∈ t, a ⊓ b ∈ u 
goal: s ⊼ t ⊆ u ↔ ∀ a ∈ s, ∀ b ∈ t, a ⊓ b ∈ u

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

full_name: Finset.Nonempty.infs
code: protected theorem Nonempty.infs : s.Nonempty → t.Nonempty → (s ⊼ t).Nonempty 
goal: s.Nonempty → t.Nonempty → (s ⊼ t).Nonempty

full_name: Finset.Nonempty.of_infs_left
code: theorem Nonempty.of_infs_left : (s ⊼ t).Nonempty → s.Nonempty 
goal: (s ⊼ t).Nonempty → s.Nonempty

full_name: Finset.Nonempty.of_infs_right
code: theorem Nonempty.of_infs_right : (s ⊼ t).Nonempty → t.Nonempty 
goal: (s ⊼ t).Nonempty → t.Nonempty

full_name: Finset.empty_infs
code: @[simp]
theorem empty_infs : ∅ ⊼ t = ∅ 
goal: ∅ ⊼ t = ∅

full_name: Finset.infs_empty
code: @[simp]
theorem infs_empty : s ⊼ ∅ = ∅ 
goal: s ⊼ ∅ = ∅

full_name: Finset.infs_eq_empty
code: @[simp]
theorem infs_eq_empty : s ⊼ t = ∅ ↔ s = ∅ ∨ t = ∅ 
goal: s ⊼ t = ∅ ↔ s = ∅ ∨ t = ∅

full_name: Finset.singleton_infs
code: @[simp] lemma singleton_infs : {a} ⊼ t = t.image (a ⊓ ·) 
goal: {a} ⊼ t = Finset.image (fun x => a ⊓ x) t

full_name: Finset.infs_singleton
code: @[simp] lemma infs_singleton : s ⊼ {b} = s.image (· ⊓ b) 
goal: s ⊼ {b} = Finset.image (fun x => x ⊓ b) s

full_name: Finset.singleton_infs_singleton
code: theorem singleton_infs_singleton : ({a} ⊼ {b} : Finset α) = {a ⊓ b} 
goal: {a} ⊼ {b} = {a ⊓ b}

full_name: Finset.infs_union_left
code: theorem infs_union_left : (s₁ ∪ s₂) ⊼ t = s₁ ⊼ t ∪ s₂ ⊼ t 
goal: (s₁ ∪ s₂) ⊼ t = s₁ ⊼ t ∪ s₂ ⊼ t

full_name: Finset.infs_union_right
code: theorem infs_union_right : s ⊼ (t₁ ∪ t₂) = s ⊼ t₁ ∪ s ⊼ t₂ 
goal: s ⊼ (t₁ ∪ t₂) = s ⊼ t₁ ∪ s ⊼ t₂

full_name: Finset.infs_inter_subset_left
code: theorem infs_inter_subset_left : (s₁ ∩ s₂) ⊼ t ⊆ s₁ ⊼ t ∩ s₂ ⊼ t 
goal: (s₁ ∩ s₂) ⊼ t ⊆ s₁ ⊼ t ∩ s₂ ⊼ t

full_name: Finset.infs_inter_subset_right
code: theorem infs_inter_subset_right : s ⊼ (t₁ ∩ t₂) ⊆ s ⊼ t₁ ∩ s ⊼ t₂ 
goal: s ⊼ (t₁ ∩ t₂) ⊆ s ⊼ t₁ ∩ s ⊼ t₂

full_name: Finset.subset_infs
code: theorem subset_infs {s t : Set α} :
    ↑u ⊆ s ⊼ t → ∃ s' t' : Finset α, ↑s' ⊆ s ∧ ↑t' ⊆ t ∧ u ⊆ s' ⊼ t' 
goal: ↑u ⊆ s ⊼ t → ∃ s' t', ↑s' ⊆ s ∧ ↑t' ⊆ t ∧ u ⊆ s' ⊼ t'

full_name: Finset.image_infs
code: lemma image_infs (f : F) (s t : Finset α) : image f (s ⊼ t) = image f s ⊼ image f t 
goal: Finset.image (⇑f) (s ⊼ t) = Finset.image (⇑f) s ⊼ Finset.image (⇑f) t

full_name: Finset.map_infs
code: lemma map_infs (f : F) (hf) (s t : Finset α) :
    map ⟨f, hf⟩ (s ⊼ t) = map ⟨f, hf⟩ s ⊼ map ⟨f, hf⟩ t 
goal: Finset.map { toFun := ⇑f, inj' := hf } (s ⊼ t) =
  Finset.map { toFun := ⇑f, inj' := hf } s ⊼ Finset.map { toFun := ⇑f, inj' := hf } t

full_name: Finset.subset_infs_self
code: lemma subset_infs_self : s ⊆ s ⊼ s 
goal: s ⊆ s ⊼ s

full_name: Finset.infs_self_subset
code: lemma infs_self_subset : s ⊼ s ⊆ s ↔ InfClosed (s : Set α) 
goal: s ⊼ s ⊆ s ↔ InfClosed ↑s

full_name: Finset.infs_self
code: @[simp] lemma infs_self : s ⊼ s = s ↔ InfClosed (s : Set α) 
goal: s ⊼ s = s ↔ InfClosed ↑s

full_name: Finset.univ_infs_univ
code: @[simp] lemma univ_infs_univ [Fintype α] : (univ : Finset α) ⊼ univ = univ 
goal: Finset.univ ⊼ Finset.univ = Finset.univ

full_name: Finset.filter_infs_le
code: lemma filter_infs_le [@DecidableRel α (· ≤ ·)] (s t : Finset α) (a : α) :
    (s ⊼ t).filter (a ≤ ·) = s.filter (a ≤ ·) ⊼ t.filter (a ≤ ·) 
goal: Finset.filter (fun x => a ≤ x) (s ⊼ t) = Finset.filter (fun x => a ≤ x) s ⊼ Finset.filter (fun x => a ≤ x) t

full_name: Finset.biUnion_image_inf_left
code: lemma biUnion_image_inf_left : s.biUnion (fun a ↦ t.image (a ⊓ ·)) = s ⊼ t 
goal: (s.biUnion fun a => Finset.image (fun x => a ⊓ x) t) = s ⊼ t

full_name: Finset.biUnion_image_inf_right
code: lemma biUnion_image_inf_right : t.biUnion (fun b ↦ s.image (· ⊓ b)) = s ⊼ t 
goal: (t.biUnion fun b => Finset.image (fun x => x ⊓ b) s) = s ⊼ t

full_name: Finset.image_inf_product
code: theorem image_inf_product (s t : Finset α) : (s ×ˢ t).image (uncurry (· ⊓ ·)) = s ⊼ t 
goal: Finset.image (Function.uncurry fun x x_1 => x ⊓ x_1) (s ×ˢ t) = s ⊼ t

full_name: Finset.infs_assoc
code: theorem infs_assoc : s ⊼ t ⊼ u = s ⊼ (t ⊼ u) 
goal: s ⊼ t ⊼ u = s ⊼ (t ⊼ u)

full_name: Finset.infs_comm
code: theorem infs_comm : s ⊼ t = t ⊼ s 
goal: s ⊼ t = t ⊼ s

full_name: Finset.infs_left_comm
code: theorem infs_left_comm : s ⊼ (t ⊼ u) = t ⊼ (s ⊼ u) 
goal: s ⊼ (t ⊼ u) = t ⊼ (s ⊼ u)

full_name: Finset.infs_right_comm
code: theorem infs_right_comm : s ⊼ t ⊼ u = s ⊼ u ⊼ t 
goal: s ⊼ t ⊼ u = s ⊼ u ⊼ t

full_name: Finset.infs_infs_infs_comm
code: theorem infs_infs_infs_comm : s ⊼ t ⊼ (u ⊼ v) = s ⊼ u ⊼ (t ⊼ v) 
goal: s ⊼ t ⊼ (u ⊼ v) = s ⊼ u ⊼ (t ⊼ v)

full_name: Finset.sups_infs_subset_left
code: theorem sups_infs_subset_left : s ⊻ t ⊼ u ⊆ (s ⊻ t) ⊼ (s ⊻ u) 
goal: s ⊻ t ⊼ u ⊆ (s ⊻ t) ⊼ (s ⊻ u)

full_name: Finset.sups_infs_subset_right
code: theorem sups_infs_subset_right : t ⊼ u ⊻ s ⊆ (t ⊻ s) ⊼ (u ⊻ s) 
goal: t ⊼ u ⊻ s ⊆ (t ⊻ s) ⊼ (u ⊻ s)

full_name: Finset.infs_sups_subset_left
code: theorem infs_sups_subset_left : s ⊼ (t ⊻ u) ⊆ s ⊼ t ⊻ s ⊼ u 
goal: s ⊼ (t ⊻ u) ⊆ s ⊼ t ⊻ s ⊼ u

full_name: Finset.infs_sups_subset_right
code: theorem infs_sups_subset_right : (t ⊻ u) ⊼ s ⊆ t ⊼ s ⊻ u ⊼ s 
goal: (t ⊻ u) ⊼ s ⊆ t ⊼ s ⊻ u ⊼ s

full_name: Finset.powerset_union
code: @[simp] lemma powerset_union (s t : Finset α) : (s ∪ t).powerset = s.powerset ⊻ t.powerset 
goal: (s ∪ t).powerset = s.powerset ⊻ t.powerset

full_name: Finset.powerset_inter
code: @[simp] lemma powerset_inter (s t : Finset α) : (s ∩ t).powerset = s.powerset ⊼ t.powerset 
goal: (s ∩ t).powerset = s.powerset ⊼ t.powerset

full_name: Finset.powerset_sups_powerset_self
code: @[simp] lemma powerset_sups_powerset_self (s : Finset α) :
    s.powerset ⊻ s.powerset = s.powerset 
goal: s.powerset ⊻ s.powerset = s.powerset

full_name: Finset.powerset_infs_powerset_self
code: @[simp] lemma powerset_infs_powerset_self (s : Finset α) :
    s.powerset ⊼ s.powerset = s.powerset 
goal: s.powerset ⊼ s.powerset = s.powerset

full_name: Finset.union_mem_sups
code: lemma union_mem_sups : s ∈ 𝒜 → t ∈ ℬ → s ∪ t ∈ 𝒜 ⊻ ℬ 
goal: s ∈ 𝒜 → t ∈ ℬ → s ∪ t ∈ 𝒜 ⊻ ℬ

full_name: Finset.inter_mem_infs
code: lemma inter_mem_infs : s ∈ 𝒜 → t ∈ ℬ → s ∩ t ∈ 𝒜 ⊼ ℬ 
goal: s ∈ 𝒜 → t ∈ ℬ → s ∩ t ∈ 𝒜 ⊼ ℬ

full_name: Finset.disjSups
code: /-- The finset of elements of the form `a ⊔ b` where `a ∈ s`, `b ∈ t` and `a` and `b` are disjoint.
-/
def disjSups : Finset α 
goal: Finset α

full_name: FinsetFamily.«_aux_Mathlib_Data_Finset_Sups___macroRules_FinsetFamily_term_○__1»
code: @[inherit_doc]
scoped[FinsetFamily] infixl:74 " ○ " => Finset.disjSups
goal: Lean.Macro

full_name: FinsetFamily._aux_Mathlib_Data_Finset_Sups___unexpand_Finset_disjSups_1
code: @[inherit_doc]
scoped[FinsetFamily] infixl:74 " ○ " => Finset.disjSups
goal: Lean.PrettyPrinter.Unexpander

full_name: Finset.mem_disjSups
code: @[simp]
theorem mem_disjSups : c ∈ s ○ t ↔ ∃ a ∈ s, ∃ b ∈ t, Disjoint a b ∧ a ⊔ b = c 
goal: c ∈ s.disjSups t ↔ ∃ a ∈ s, ∃ b ∈ t, Disjoint a b ∧ a ⊔ b = c

full_name: Finset.disjSups_subset_sups
code: theorem disjSups_subset_sups : s ○ t ⊆ s ⊻ t 
goal: s.disjSups t ⊆ s ⊻ t

full_name: Finset.card_disjSups_le
code: theorem card_disjSups_le : (s ○ t).card ≤ s.card * t.card 
goal: (s.disjSups t).card ≤ s.card * t.card

full_name: Finset.disjSups_subset
code: theorem disjSups_subset (hs : s₁ ⊆ s₂) (ht : t₁ ⊆ t₂) : s₁ ○ t₁ ⊆ s₂ ○ t₂ 
goal: s₁.disjSups t₁ ⊆ s₂.disjSups t₂

full_name: Finset.disjSups_subset_left
code: theorem disjSups_subset_left (ht : t₁ ⊆ t₂) : s ○ t₁ ⊆ s ○ t₂ 
goal: s.disjSups t₁ ⊆ s.disjSups t₂

full_name: Finset.disjSups_subset_right
code: theorem disjSups_subset_right (hs : s₁ ⊆ s₂) : s₁ ○ t ⊆ s₂ ○ t 
goal: s₁.disjSups t ⊆ s₂.disjSups t

full_name: Finset.forall_disjSups_iff
code: theorem forall_disjSups_iff {p : α → Prop} :
    (∀ c ∈ s ○ t, p c) ↔ ∀ a ∈ s, ∀ b ∈ t, Disjoint a b → p (a ⊔ b) 
goal: (∀ c ∈ s.disjSups t, p c) ↔ ∀ a ∈ s, ∀ b ∈ t, Disjoint a b → p (a ⊔ b)

full_name: Finset.disjSups_subset_iff
code: @[simp]
theorem disjSups_subset_iff : s ○ t ⊆ u ↔ ∀ a ∈ s, ∀ b ∈ t, Disjoint a b → a ⊔ b ∈ u 
goal: s.disjSups t ⊆ u ↔ ∀ a ∈ s, ∀ b ∈ t, Disjoint a b → a ⊔ b ∈ u

full_name: Finset.Nonempty.of_disjSups_left
code: theorem Nonempty.of_disjSups_left : (s ○ t).Nonempty → s.Nonempty 
goal: (s.disjSups t).Nonempty → s.Nonempty

full_name: Finset.Nonempty.of_disjSups_right
code: theorem Nonempty.of_disjSups_right : (s ○ t).Nonempty → t.Nonempty 
goal: (s.disjSups t).Nonempty → t.Nonempty

full_name: Finset.disjSups_empty_left
code: @[simp]
theorem disjSups_empty_left : ∅ ○ t = ∅ 
goal: ∅.disjSups t = ∅

full_name: Finset.disjSups_empty_right
code: @[simp]
theorem disjSups_empty_right : s ○ ∅ = ∅ 
goal: s.disjSups ∅ = ∅

full_name: Finset.disjSups_singleton
code: theorem disjSups_singleton : ({a} ○ {b} : Finset α) = if Disjoint a b then {a ⊔ b} else ∅ 
goal: {a}.disjSups {b} = if Disjoint a b then {a ⊔ b} else ∅

full_name: Finset.disjSups_union_left
code: theorem disjSups_union_left : (s₁ ∪ s₂) ○ t = s₁ ○ t ∪ s₂ ○ t 
goal: (s₁ ∪ s₂).disjSups t = s₁.disjSups t ∪ s₂.disjSups t

full_name: Finset.disjSups_union_right
code: theorem disjSups_union_right : s ○ (t₁ ∪ t₂) = s ○ t₁ ∪ s ○ t₂ 
goal: s.disjSups (t₁ ∪ t₂) = s.disjSups t₁ ∪ s.disjSups t₂

full_name: Finset.disjSups_inter_subset_left
code: theorem disjSups_inter_subset_left : (s₁ ∩ s₂) ○ t ⊆ s₁ ○ t ∩ s₂ ○ t 
goal: (s₁ ∩ s₂).disjSups t ⊆ s₁.disjSups t ∩ s₂.disjSups t

full_name: Finset.disjSups_inter_subset_right
code: theorem disjSups_inter_subset_right : s ○ (t₁ ∩ t₂) ⊆ s ○ t₁ ∩ s ○ t₂ 
goal: s.disjSups (t₁ ∩ t₂) ⊆ s.disjSups t₁ ∩ s.disjSups t₂

full_name: Finset.disjSups_comm
code: theorem disjSups_comm : s ○ t = t ○ s 
goal: s.disjSups t = t.disjSups s

full_name: Finset.disjSups_assoc
code: theorem disjSups_assoc : ∀ s t u : Finset α, s ○ t ○ u = s ○ (t ○ u) 
goal: (s.disjSups t).disjSups u = s.disjSups (t.disjSups u)

full_name: Finset.disjSups_left_comm
code: theorem disjSups_left_comm : s ○ (t ○ u) = t ○ (s ○ u) 
goal: s.disjSups (t.disjSups u) = t.disjSups (s.disjSups u)

full_name: Finset.disjSups_right_comm
code: theorem disjSups_right_comm : s ○ t ○ u = s ○ u ○ t 
goal: (s.disjSups t).disjSups u = (s.disjSups u).disjSups t

full_name: Finset.disjSups_disjSups_disjSups_comm
code: theorem disjSups_disjSups_disjSups_comm : s ○ t ○ (u ○ v) = s ○ u ○ (t ○ v) 
goal: (s.disjSups t).disjSups (u.disjSups v) = (s.disjSups u).disjSups (t.disjSups v)

full_name: Finset.diffs
code: /-- `s \\ t` is the finset of elements of the form `a \ b` where `a ∈ s`, `b ∈ t`. -/
def diffs : Finset α → Finset α → Finset α 
goal: Finset α → Finset α → Finset α

full_name: FinsetFamily.«_aux_Mathlib_Data_Finset_Sups___macroRules_FinsetFamily_term_\\__1»
code: @[inherit_doc]
scoped[FinsetFamily] infixl:74 " \\\\ " => Finset.diffs
goal: Lean.Macro

full_name: FinsetFamily._aux_Mathlib_Data_Finset_Sups___unexpand_Finset_diffs_1
code: @[inherit_doc]
scoped[FinsetFamily] infixl:74 " \\\\ " => Finset.diffs
goal: Lean.PrettyPrinter.Unexpander

full_name: Finset.mem_diffs
code: @[simp] lemma mem_diffs : c ∈ s \\ t ↔ ∃ a ∈ s, ∃ b ∈ t, a \ b = c 
goal: c ∈ s.diffs t ↔ ∃ a ∈ s, ∃ b ∈ t, a \ b = c

full_name: Finset.coe_diffs
code: @[simp, norm_cast] lemma coe_diffs : (↑(s \\ t) : Set α) = Set.image2 (· \ ·) s t 
goal: ↑(s.diffs t) = Set.image2 (fun x x_1 => x \ x_1) ↑s ↑t

full_name: Finset.card_diffs_le
code: lemma card_diffs_le : (s \\ t).card ≤ s.card * t.card 
goal: (s.diffs t).card ≤ s.card * t.card

full_name: Finset.card_diffs_iff
code: lemma card_diffs_iff :
    (s \\ t).card = s.card * t.card ↔ (s ×ˢ t : Set (α × α)).InjOn fun x ↦ x.1 \ x.2 
goal: (s.diffs t).card = s.card * t.card ↔ Set.InjOn (fun x => x.1 \ x.2) (↑s ×ˢ ↑t)

full_name: Finset.sdiff_mem_diffs
code: lemma sdiff_mem_diffs : a ∈ s → b ∈ t → a \ b ∈ s \\ t 
goal: a ∈ s → b ∈ t → a \ b ∈ s.diffs t

full_name: Finset.diffs_subset
code: lemma diffs_subset : s₁ ⊆ s₂ → t₁ ⊆ t₂ → s₁ \\ t₁ ⊆ s₂ \\ t₂ 
goal: s₁ ⊆ s₂ → t₁ ⊆ t₂ → s₁.diffs t₁ ⊆ s₂.diffs t₂

full_name: Finset.diffs_subset_left
code: lemma diffs_subset_left : t₁ ⊆ t₂ → s \\ t₁ ⊆ s \\ t₂ 
goal: t₁ ⊆ t₂ → s.diffs t₁ ⊆ s.diffs t₂

full_name: Finset.diffs_subset_right
code: lemma diffs_subset_right : s₁ ⊆ s₂ → s₁ \\ t ⊆ s₂ \\ t 
goal: s₁ ⊆ s₂ → s₁.diffs t ⊆ s₂.diffs t

full_name: Finset.image_subset_diffs_left
code: lemma image_subset_diffs_left : b ∈ t → s.image (· \ b) ⊆ s \\ t 
goal: b ∈ t → Finset.image (fun x => x \ b) s ⊆ s.diffs t

full_name: Finset.image_subset_diffs_right
code: lemma image_subset_diffs_right : a ∈ s → t.image (a \ ·) ⊆ s \\ t 
goal: a ∈ s → Finset.image (fun x => a \ x) t ⊆ s.diffs t

full_name: Finset.forall_mem_diffs
code: lemma forall_mem_diffs {p : α → Prop} : (∀ c ∈ s \\ t, p c) ↔ ∀ a ∈ s, ∀ b ∈ t, p (a \ b) 
goal: (∀ c ∈ s.diffs t, p c) ↔ ∀ a ∈ s, ∀ b ∈ t, p (a \ b)

full_name: Finset.diffs_subset_iff
code: @[simp] lemma diffs_subset_iff : s \\ t ⊆ u ↔ ∀ a ∈ s, ∀ b ∈ t, a \ b ∈ u 
goal: s.diffs t ⊆ u ↔ ∀ a ∈ s, ∀ b ∈ t, a \ b ∈ u

full_name: Finset.diffs_nonempty
code: @[simp, aesop safe apply (rule_sets := [finsetNonempty])]
lemma diffs_nonempty : (s \\ t).Nonempty ↔ s.Nonempty ∧ t.Nonempty 
goal: (s.diffs t).Nonempty ↔ s.Nonempty ∧ t.Nonempty

full_name: Finset.Nonempty.diffs
code: protected lemma Nonempty.diffs : s.Nonempty → t.Nonempty → (s \\ t).Nonempty 
goal: s.Nonempty → t.Nonempty → (s.diffs t).Nonempty

full_name: Finset.Nonempty.of_diffs_left
code: lemma Nonempty.of_diffs_left : (s \\ t).Nonempty → s.Nonempty 
goal: (s.diffs t).Nonempty → s.Nonempty

full_name: Finset.Nonempty.of_diffs_right
code: lemma Nonempty.of_diffs_right : (s \\ t).Nonempty → t.Nonempty 
goal: (s.diffs t).Nonempty → t.Nonempty

full_name: Finset.empty_diffs
code: @[simp] lemma empty_diffs : ∅ \\ t = ∅ 
goal: ∅.diffs t = ∅

full_name: Finset.diffs_empty
code: @[simp] lemma diffs_empty : s \\ ∅ = ∅ 
goal: s.diffs ∅ = ∅

full_name: Finset.diffs_eq_empty
code: @[simp] lemma diffs_eq_empty : s \\ t = ∅ ↔ s = ∅ ∨ t = ∅ 
goal: s.diffs t = ∅ ↔ s = ∅ ∨ t = ∅

full_name: Finset.singleton_diffs
code: @[simp] lemma singleton_diffs : {a} \\ t = t.image (a \ ·) 
goal: {a}.diffs t = Finset.image (fun x => a \ x) t

full_name: Finset.diffs_singleton
code: @[simp] lemma diffs_singleton : s \\ {b} = s.image (· \ b) 
goal: s.diffs {b} = Finset.image (fun x => x \ b) s

full_name: Finset.singleton_diffs_singleton
code: lemma singleton_diffs_singleton : ({a} \\ {b} : Finset α) = {a \ b} 
goal: {a}.diffs {b} = {a \ b}

full_name: Finset.diffs_union_left
code: lemma diffs_union_left : (s₁ ∪ s₂) \\ t = s₁ \\ t ∪ s₂ \\ t 
goal: (s₁ ∪ s₂).diffs t = s₁.diffs t ∪ s₂.diffs t

full_name: Finset.diffs_union_right
code: lemma diffs_union_right : s \\ (t₁ ∪ t₂) = s \\ t₁ ∪ s \\ t₂ 
goal: s.diffs (t₁ ∪ t₂) = s.diffs t₁ ∪ s.diffs t₂

full_name: Finset.diffs_inter_subset_left
code: lemma diffs_inter_subset_left : (s₁ ∩ s₂) \\ t ⊆ s₁ \\ t ∩ s₂ \\ t 
goal: (s₁ ∩ s₂).diffs t ⊆ s₁.diffs t ∩ s₂.diffs t

full_name: Finset.diffs_inter_subset_right
code: lemma diffs_inter_subset_right : s \\ (t₁ ∩ t₂) ⊆ s \\ t₁ ∩ s \\ t₂ 
goal: s.diffs (t₁ ∩ t₂) ⊆ s.diffs t₁ ∩ s.diffs t₂

full_name: Finset.subset_diffs
code: lemma subset_diffs {s t : Set α} :
    ↑u ⊆ Set.image2 (· \ ·) s t → ∃ s' t' : Finset α, ↑s' ⊆ s ∧ ↑t' ⊆ t ∧ u ⊆ s' \\ t' 
goal: ↑u ⊆ Set.image2 (fun x x_1 => x \ x_1) s t → ∃ s' t', ↑s' ⊆ s ∧ ↑t' ⊆ t ∧ u ⊆ s'.diffs t'

full_name: Finset.biUnion_image_sdiff_left
code: lemma biUnion_image_sdiff_left : s.biUnion (fun a ↦ t.image (a \ ·)) = s \\ t 
goal: (s.biUnion fun a => Finset.image (fun x => a \ x) t) = s.diffs t

full_name: Finset.biUnion_image_sdiff_right
code: lemma biUnion_image_sdiff_right : t.biUnion (fun b ↦ s.image (· \ b)) = s \\ t 
goal: (t.biUnion fun b => Finset.image (fun x => x \ b) s) = s.diffs t

full_name: Finset.image_sdiff_product
code: lemma image_sdiff_product (s t : Finset α) : (s ×ˢ t).image (uncurry (· \ ·)) = s \\ t 
goal: Finset.image (Function.uncurry fun x x_1 => x \ x_1) (s ×ˢ t) = s.diffs t

full_name: Finset.diffs_right_comm
code: lemma diffs_right_comm : s \\ t \\ u = s \\ u \\ t 
goal: (s.diffs t).diffs u = (s.diffs u).diffs t

full_name: Finset.compls
code: /-- `sᶜˢ` is the finset of elements of the form `aᶜ` where `a ∈ s`. -/
def compls : Finset α → Finset α 
goal: Finset α → Finset α

full_name: FinsetFamily.«_aux_Mathlib_Data_Finset_Sups___macroRules_FinsetFamily_term_ᶜˢ_1»
code: @[inherit_doc]
scoped[FinsetFamily] postfix:max "ᶜˢ" => Finset.compls
goal: Lean.Macro

full_name: FinsetFamily._aux_Mathlib_Data_Finset_Sups___unexpand_Finset_compls_1
code: @[inherit_doc]
scoped[FinsetFamily] postfix:max "ᶜˢ" => Finset.compls
goal: Lean.PrettyPrinter.Unexpander

full_name: Finset.mem_compls
code: @[simp] lemma mem_compls : a ∈ sᶜˢ ↔ aᶜ ∈ s 
goal: a ∈ s.compls ↔ aᶜ ∈ s

full_name: Finset.image_compl
code: @[simp] lemma image_compl : s.image compl = sᶜˢ 
goal: Finset.image compl s = s.compls

full_name: Finset.coe_compls
code: @[simp, norm_cast] lemma coe_compls : (↑sᶜˢ : Set α) = compl '' ↑s 
goal: ↑s.compls = compl '' ↑s

full_name: Finset.card_compls
code: @[simp] lemma card_compls : sᶜˢ.card = s.card 
goal: s.compls.card = s.card

full_name: Finset.compl_mem_compls
code: lemma compl_mem_compls : a ∈ s → aᶜ ∈ sᶜˢ 
goal: a ∈ s → aᶜ ∈ s.compls

full_name: Finset.compls_subset_compls
code: @[simp] lemma compls_subset_compls : s₁ᶜˢ ⊆ s₂ᶜˢ ↔ s₁ ⊆ s₂ 
goal: s₁.compls ⊆ s₂.compls ↔ s₁ ⊆ s₂

full_name: Finset.forall_mem_compls
code: lemma forall_mem_compls {p : α → Prop} : (∀ a ∈ sᶜˢ, p a) ↔ ∀ a ∈ s, p aᶜ 
goal: (∀ a ∈ s.compls, p a) ↔ ∀ a ∈ s, p aᶜ

full_name: Finset.exists_compls_iff
code: lemma exists_compls_iff {p : α → Prop} : (∃ a ∈ sᶜˢ, p a) ↔ ∃ a ∈ s, p aᶜ 
goal: (∃ a ∈ s.compls, p a) ↔ ∃ a ∈ s, p aᶜ

full_name: Finset.compls_compls
code: @[simp] lemma compls_compls (s : Finset α) : sᶜˢᶜˢ = s 
goal: s.compls.compls = s

full_name: Finset.compls_subset_iff
code: lemma compls_subset_iff : sᶜˢ ⊆ t ↔ s ⊆ tᶜˢ 
goal: s.compls ⊆ t ↔ s ⊆ t.compls

full_name: Finset.compls_nonempty
code: @[simp, aesop safe apply (rule_sets := [finsetNonempty])]
lemma compls_nonempty : sᶜˢ.Nonempty ↔ s.Nonempty 
goal: s.compls.Nonempty ↔ s.Nonempty

full_name: Finset.compls_empty
code: @[simp] lemma compls_empty : (∅ : Finset α)ᶜˢ = ∅ 
goal: ∅.compls = ∅

full_name: Finset.compls_eq_empty
code: @[simp] lemma compls_eq_empty : sᶜˢ = ∅ ↔ s = ∅ 
goal: s.compls = ∅ ↔ s = ∅

full_name: Finset.compls_singleton
code: @[simp] lemma compls_singleton (a : α) : {a}ᶜˢ = {aᶜ} 
goal: {a}.compls = {aᶜ}

full_name: Finset.compls_univ
code: @[simp] lemma compls_univ [Fintype α] : (univ : Finset α)ᶜˢ = univ 
goal: Finset.univ.compls = Finset.univ

full_name: Finset.compls_union
code: @[simp] lemma compls_union (s t : Finset α) : (s ∪ t)ᶜˢ = sᶜˢ ∪ tᶜˢ 
goal: (s ∪ t).compls = s.compls ∪ t.compls

full_name: Finset.compls_inter
code: @[simp] lemma compls_inter (s t : Finset α) : (s ∩ t)ᶜˢ = sᶜˢ ∩ tᶜˢ 
goal: (s ∩ t).compls = s.compls ∩ t.compls

full_name: Finset.compls_infs
code: @[simp] lemma compls_infs (s t : Finset α) : (s ⊼ t)ᶜˢ = sᶜˢ ⊻ tᶜˢ 
goal: (s ⊼ t).compls = s.compls ⊻ t.compls

full_name: Finset.compls_sups
code: @[simp] lemma compls_sups (s t : Finset α) : (s ⊻ t)ᶜˢ = sᶜˢ ⊼ tᶜˢ 
goal: (s ⊻ t).compls = s.compls ⊼ t.compls

full_name: Finset.infs_compls_eq_diffs
code: @[simp] lemma infs_compls_eq_diffs (s t : Finset α) : s ⊼ tᶜˢ = s \\ t 
goal: s ⊼ t.compls = s.diffs t

full_name: Finset.compls_infs_eq_diffs
code: @[simp] lemma compls_infs_eq_diffs (s t : Finset α) : sᶜˢ ⊼ t = t \\ s 
goal: s.compls ⊼ t = t.diffs s

full_name: Finset.diffs_compls_eq_infs
code: @[simp] lemma diffs_compls_eq_infs (s t : Finset α) : s \\ tᶜˢ = s ⊼ t 
goal: s.diffs t.compls = s ⊼ t

full_name: Set.Sized.compls
code: protected lemma _root_.Set.Sized.compls (h𝒜 : (𝒜 : Set (Finset α)).Sized n) :
    (𝒜ᶜˢ : Set (Finset α)).Sized (Fintype.card α - n) 
goal: Set.Sized (Fintype.card α - n) ↑𝒜.compls

full_name: Finset.sized_compls
code: lemma sized_compls (hn : n ≤ Fintype.card α) :
    (𝒜ᶜˢ : Set (Finset α)).Sized n ↔ (𝒜 : Set (Finset α)).Sized (Fintype.card α - n) 
goal: Set.Sized n ↑𝒜.compls ↔ Set.Sized (Fintype.card α - n) ↑𝒜