File: Mathlib/Data/Finset/Lattice.lean

full_name: Finset.sup
code: /-- Supremum of a finite set: `sup {a, b, c} f = f a ⊔ f b ⊔ f c` -/
def sup (s : Finset β) (f : β → α) : α 
goal: α

full_name: Finset.sup_def
code: theorem sup_def : s.sup f = (s.1.map f).sup 
goal: s.sup f = (Multiset.map f s.val).sup

full_name: Finset.sup_empty
code: @[simp]
theorem sup_empty : (∅ : Finset β).sup f = ⊥ 
goal: ∅.sup f = ⊥

full_name: Finset.sup_cons
code: @[simp]
theorem sup_cons {b : β} (h : b ∉ s) : (cons b s h).sup f = f b ⊔ s.sup f 
goal: (Finset.cons b s h).sup f = f b ⊔ s.sup f

full_name: Finset.sup_insert
code: @[simp]
theorem sup_insert [DecidableEq β] {b : β} : (insert b s : Finset β).sup f = f b ⊔ s.sup f 
goal: (insert b s).sup f = f b ⊔ s.sup f

full_name: Finset.sup_image
code: @[simp]
theorem sup_image [DecidableEq β] (s : Finset γ) (f : γ → β) (g : β → α) :
    (s.image f).sup g = s.sup (g ∘ f) 
goal: (Finset.image f s).sup g = s.sup (g ∘ f)

full_name: Finset.sup_map
code: @[simp]
theorem sup_map (s : Finset γ) (f : γ ↪ β) (g : β → α) : (s.map f).sup g = s.sup (g ∘ f) 
goal: (Finset.map f s).sup g = s.sup (g ∘ ⇑f)

full_name: Finset.sup_singleton
code: @[simp]
theorem sup_singleton {b : β} : ({b} : Finset β).sup f = f b 
goal: {b}.sup f = f b

full_name: Finset.sup_sup
code: theorem sup_sup : s.sup (f ⊔ g) = s.sup f ⊔ s.sup g 
goal: s.sup (f ⊔ g) = s.sup f ⊔ s.sup g

full_name: Finset.sup_congr
code: theorem sup_congr {f g : β → α} (hs : s₁ = s₂) (hfg : ∀ a ∈ s₂, f a = g a) :
    s₁.sup f = s₂.sup g 
goal: s₁.sup f = s₂.sup g

full_name: map_finset_sup
code: @[simp]
theorem _root_.map_finset_sup [SemilatticeSup β] [OrderBot β]
    [FunLike F α β] [SupBotHomClass F α β]
    (f : F) (s : Finset ι) (g : ι → α) : f (s.sup g) = s.sup (f ∘ g) 
goal: f (s.sup g) = s.sup (⇑f ∘ g)

full_name: Finset.sup_le_iff
code: @[simp]
protected theorem sup_le_iff {a : α} : s.sup f ≤ a ↔ ∀ b ∈ s, f b ≤ a 
goal: s.sup f ≤ a ↔ ∀ b ∈ s, f b ≤ a

full_name: Finset.sup_const_le
code: theorem sup_const_le : (s.sup fun _ => a) ≤ a 
goal: (s.sup fun x => a) ≤ a

full_name: Finset.le_sup
code: theorem le_sup {b : β} (hb : b ∈ s) : f b ≤ s.sup f 
goal: f b ≤ s.sup f

full_name: Finset.le_sup_of_le
code: theorem le_sup_of_le {b : β} (hb : b ∈ s) (h : a ≤ f b) : a ≤ s.sup f 
goal: a ≤ s.sup f

full_name: Finset.sup_union
code: theorem sup_union [DecidableEq β] : (s₁ ∪ s₂).sup f = s₁.sup f ⊔ s₂.sup f 
goal: (s₁ ∪ s₂).sup f = s₁.sup f ⊔ s₂.sup f

full_name: Finset.sup_biUnion
code: @[simp]
theorem sup_biUnion [DecidableEq β] (s : Finset γ) (t : γ → Finset β) :
    (s.biUnion t).sup f = s.sup fun x => (t x).sup f 
goal: (s.biUnion t).sup f = s.sup fun x => (t x).sup f

full_name: Finset.sup_const
code: theorem sup_const {s : Finset β} (h : s.Nonempty) (c : α) : (s.sup fun _ => c) = c 
goal: (s.sup fun x => c) = c

full_name: Finset.sup_bot
code: @[simp]
theorem sup_bot (s : Finset β) : (s.sup fun _ => ⊥) = (⊥ : α) 
goal: (s.sup fun x => ⊥) = ⊥

full_name: Finset.sup_ite
code: theorem sup_ite (p : β → Prop) [DecidablePred p] :
    (s.sup fun i => ite (p i) (f i) (g i)) = (s.filter p).sup f ⊔ (s.filter fun i => ¬p i).sup g 
goal: (s.sup fun i => if p i then f i else g i) = (Finset.filter p s).sup f ⊔ (Finset.filter (fun i => ¬p i) s).sup g

full_name: Finset.sup_mono_fun
code: theorem sup_mono_fun {g : β → α} (h : ∀ b ∈ s, f b ≤ g b) : s.sup f ≤ s.sup g 
goal: s.sup f ≤ s.sup g

full_name: Finset.sup_mono
code: @[gcongr]
theorem sup_mono (h : s₁ ⊆ s₂) : s₁.sup f ≤ s₂.sup f 
goal: s₁.sup f ≤ s₂.sup f

full_name: Finset.sup_comm
code: protected theorem sup_comm (s : Finset β) (t : Finset γ) (f : β → γ → α) :
    (s.sup fun b => t.sup (f b)) = t.sup fun c => s.sup fun b => f b c 
goal: (s.sup fun b => t.sup (f b)) = t.sup fun c => s.sup fun b => f b c

full_name: Finset.sup_attach
code: @[simp, nolint simpNF] -- Porting note: linter claims that LHS does not simplify
theorem sup_attach (s : Finset β) (f : β → α) : (s.attach.sup fun x => f x) = s.sup f 
goal: (s.attach.sup fun x => f ↑x) = s.sup f

full_name: Finset.sup_product_left
code: /-- See also `Finset.product_biUnion`. -/
theorem sup_product_left (s : Finset β) (t : Finset γ) (f : β × γ → α) :
    (s ×ˢ t).sup f = s.sup fun i => t.sup fun i' => f ⟨i, i'⟩ 
goal: (s ×ˢ t).sup f = s.sup fun i => t.sup fun i' => f (i, i')

full_name: Finset.sup_product_right
code: theorem sup_product_right (s : Finset β) (t : Finset γ) (f : β × γ → α) :
    (s ×ˢ t).sup f = t.sup fun i' => s.sup fun i => f ⟨i, i'⟩ 
goal: (s ×ˢ t).sup f = t.sup fun i' => s.sup fun i => f (i, i')

full_name: Finset.sup_prodMap
code: @[simp] lemma sup_prodMap (hs : s.Nonempty) (ht : t.Nonempty) (f : ι → α) (g : κ → β) :
    sup (s ×ˢ t) (Prod.map f g) = (sup s f, sup t g) 
goal: (s ×ˢ t).sup (Prod.map f g) = (s.sup f, t.sup g)

full_name: Finset.sup_erase_bot
code: @[simp]
theorem sup_erase_bot [DecidableEq α] (s : Finset α) : (s.erase ⊥).sup id = s.sup id 
goal: (s.erase ⊥).sup id = s.sup id

full_name: Finset.sup_sdiff_right
code: theorem sup_sdiff_right {α β : Type*} [GeneralizedBooleanAlgebra α] (s : Finset β) (f : β → α)
    (a : α) : (s.sup fun b => f b \ a) = s.sup f \ a 
goal: (s.sup fun b => f b \ a) = s.sup f \ a

full_name: Finset.comp_sup_eq_sup_comp
code: theorem comp_sup_eq_sup_comp [SemilatticeSup γ] [OrderBot γ] {s : Finset β} {f : β → α} (g : α → γ)
    (g_sup : ∀ x y, g (x ⊔ y) = g x ⊔ g y) (bot : g ⊥ = ⊥) : g (s.sup f) = s.sup (g ∘ f) 
goal: g (s.sup f) = s.sup (g ∘ f)

full_name: Finset.sup_coe
code: /-- Computing `sup` in a subtype (closed under `sup`) is the same as computing it in `α`. -/
theorem sup_coe {P : α → Prop} {Pbot : P ⊥} {Psup : ∀ ⦃x y⦄, P x → P y → P (x ⊔ y)} (t : Finset β)
    (f : β → { x : α // P x }) :
    (@sup { x // P x } _ (Subtype.semilatticeSup Psup) (Subtype.orderBot Pbot) t f : α) =
      t.sup fun x => ↑(f x) 
goal: ↑(t.sup f) = t.sup fun x => ↑(f x)

full_name: Finset.sup_toFinset
code: @[simp]
theorem sup_toFinset {α β} [DecidableEq β] (s : Finset α) (f : α → Multiset β) :
    (s.sup f).toFinset = s.sup fun x => (f x).toFinset 
goal: (s.sup f).toFinset = s.sup fun x => (f x).toFinset

full_name: List.foldr_sup_eq_sup_toFinset
code: theorem _root_.List.foldr_sup_eq_sup_toFinset [DecidableEq α] (l : List α) :
    l.foldr (· ⊔ ·) ⊥ = l.toFinset.sup id 
goal: List.foldr (fun x x_1 => x ⊔ x_1) ⊥ l = l.toFinset.sup id

full_name: Finset.subset_range_sup_succ
code: theorem subset_range_sup_succ (s : Finset ℕ) : s ⊆ range (s.sup id).succ 
goal: s ⊆ Finset.range (s.sup id).succ

full_name: Finset.exists_nat_subset_range
code: theorem exists_nat_subset_range (s : Finset ℕ) : ∃ n : ℕ, s ⊆ range n 
goal: ∃ n, s ⊆ Finset.range n

full_name: Finset.sup_induction
code: theorem sup_induction {p : α → Prop} (hb : p ⊥) (hp : ∀ a₁, p a₁ → ∀ a₂, p a₂ → p (a₁ ⊔ a₂))
    (hs : ∀ b ∈ s, p (f b)) : p (s.sup f) 
goal: p (s.sup f)

full_name: Finset.sup_le_of_le_directed
code: theorem sup_le_of_le_directed {α : Type*} [SemilatticeSup α] [OrderBot α] (s : Set α)
    (hs : s.Nonempty) (hdir : DirectedOn (· ≤ ·) s) (t : Finset α) :
    (∀ x ∈ t, ∃ y ∈ s, x ≤ y) → ∃ x ∈ s, t.sup id ≤ x 
goal: (∀ x ∈ t, ∃ y ∈ s, x ≤ y) → ∃ x ∈ s, t.sup id ≤ x

full_name: Finset.sup_mem
code: theorem sup_mem (s : Set α) (w₁ : ⊥ ∈ s) (w₂ : ∀ᵉ (x ∈ s) (y ∈ s), x ⊔ y ∈ s)
    {ι : Type*} (t : Finset ι) (p : ι → α) (h : ∀ i ∈ t, p i ∈ s) : t.sup p ∈ s 
goal: t.sup p ∈ s

full_name: Finset.sup_eq_bot_iff
code: @[simp]
protected theorem sup_eq_bot_iff (f : β → α) (S : Finset β) : S.sup f = ⊥ ↔ ∀ s ∈ S, f s = ⊥ 
goal: S.sup f = ⊥ ↔ ∀ s ∈ S, f s = ⊥

full_name: Finset.sup_eq_iSup
code: theorem sup_eq_iSup [CompleteLattice β] (s : Finset α) (f : α → β) : s.sup f = ⨆ a ∈ s, f a 
goal: s.sup f = ⨆ a ∈ s, f a

full_name: Finset.sup_id_eq_sSup
code: theorem sup_id_eq_sSup [CompleteLattice α] (s : Finset α) : s.sup id = sSup s 
goal: s.sup id = sSup ↑s

full_name: Finset.sup_id_set_eq_sUnion
code: theorem sup_id_set_eq_sUnion (s : Finset (Set α)) : s.sup id = ⋃₀ ↑s 
goal: s.sup id = ⋃₀ ↑s

full_name: Finset.sup_set_eq_biUnion
code: @[simp]
theorem sup_set_eq_biUnion (s : Finset α) (f : α → Set β) : s.sup f = ⋃ x ∈ s, f x 
goal: s.sup f = ⋃ x ∈ s, f x

full_name: Finset.sup_eq_sSup_image
code: theorem sup_eq_sSup_image [CompleteLattice β] (s : Finset α) (f : α → β) :
    s.sup f = sSup (f '' s) 
goal: s.sup f = sSup (f '' ↑s)

full_name: Finset.inf
code: /-- Infimum of a finite set: `inf {a, b, c} f = f a ⊓ f b ⊓ f c` -/
def inf (s : Finset β) (f : β → α) : α 
goal: α

full_name: Finset.inf_def
code: theorem inf_def : s.inf f = (s.1.map f).inf 
goal: s.inf f = (Multiset.map f s.val).inf

full_name: Finset.inf_empty
code: @[simp]
theorem inf_empty : (∅ : Finset β).inf f = ⊤ 
goal: ∅.inf f = ⊤

full_name: Finset.inf_cons
code: @[simp]
theorem inf_cons {b : β} (h : b ∉ s) : (cons b s h).inf f = f b ⊓ s.inf f 
goal: (Finset.cons b s h).inf f = f b ⊓ s.inf f

full_name: Finset.inf_insert
code: @[simp]
theorem inf_insert [DecidableEq β] {b : β} : (insert b s : Finset β).inf f = f b ⊓ s.inf f 
goal: (insert b s).inf f = f b ⊓ s.inf f

full_name: Finset.inf_image
code: @[simp]
theorem inf_image [DecidableEq β] (s : Finset γ) (f : γ → β) (g : β → α) :
    (s.image f).inf g = s.inf (g ∘ f) 
goal: (Finset.image f s).inf g = s.inf (g ∘ f)

full_name: Finset.inf_map
code: @[simp]
theorem inf_map (s : Finset γ) (f : γ ↪ β) (g : β → α) : (s.map f).inf g = s.inf (g ∘ f) 
goal: (Finset.map f s).inf g = s.inf (g ∘ ⇑f)

full_name: Finset.inf_singleton
code: @[simp]
theorem inf_singleton {b : β} : ({b} : Finset β).inf f = f b 
goal: {b}.inf f = f b

full_name: Finset.inf_inf
code: theorem inf_inf : s.inf (f ⊓ g) = s.inf f ⊓ s.inf g 
goal: s.inf (f ⊓ g) = s.inf f ⊓ s.inf g

full_name: Finset.inf_congr
code: theorem inf_congr {f g : β → α} (hs : s₁ = s₂) (hfg : ∀ a ∈ s₂, f a = g a) :
    s₁.inf f = s₂.inf g 
goal: s₁.inf f = s₂.inf g

full_name: map_finset_inf
code: @[simp]
theorem _root_.map_finset_inf [SemilatticeInf β] [OrderTop β]
    [FunLike F α β] [InfTopHomClass F α β]
    (f : F) (s : Finset ι) (g : ι → α) : f (s.inf g) = s.inf (f ∘ g) 
goal: f (s.inf g) = s.inf (⇑f ∘ g)

full_name: Finset.le_inf_iff
code: @[simp] protected theorem le_inf_iff {a : α} : a ≤ s.inf f ↔ ∀ b ∈ s, a ≤ f b 
goal: a ≤ s.inf f ↔ ∀ b ∈ s, a ≤ f b

full_name: Finset.le_inf_const_le
code: theorem le_inf_const_le : a ≤ s.inf fun _ => a 
goal: a ≤ s.inf fun x => a

full_name: Finset.inf_le
code: theorem inf_le {b : β} (hb : b ∈ s) : s.inf f ≤ f b 
goal: s.inf f ≤ f b

full_name: Finset.inf_le_of_le
code: theorem inf_le_of_le {b : β} (hb : b ∈ s) (h : f b ≤ a) : s.inf f ≤ a 
goal: s.inf f ≤ a

full_name: Finset.inf_union
code: theorem inf_union [DecidableEq β] : (s₁ ∪ s₂).inf f = s₁.inf f ⊓ s₂.inf f 
goal: (s₁ ∪ s₂).inf f = s₁.inf f ⊓ s₂.inf f

full_name: Finset.inf_biUnion
code: @[simp] theorem inf_biUnion [DecidableEq β] (s : Finset γ) (t : γ → Finset β) :
    (s.biUnion t).inf f = s.inf fun x => (t x).inf f 
goal: (s.biUnion t).inf f = s.inf fun x => (t x).inf f

full_name: Finset.inf_const
code: theorem inf_const (h : s.Nonempty) (c : α) : (s.inf fun _ => c) = c 
goal: (s.inf fun x => c) = c

full_name: Finset.inf_top
code: @[simp] theorem inf_top (s : Finset β) : (s.inf fun _ => ⊤) = (⊤ : α) 
goal: (s.inf fun x => ⊤) = ⊤

full_name: Finset.inf_ite
code: theorem inf_ite (p : β → Prop) [DecidablePred p] :
    (s.inf fun i ↦ ite (p i) (f i) (g i)) = (s.filter p).inf f ⊓ (s.filter fun i ↦ ¬ p i).inf g 
goal: (s.inf fun i => if p i then f i else g i) = (Finset.filter p s).inf f ⊓ (Finset.filter (fun i => ¬p i) s).inf g

full_name: Finset.inf_mono_fun
code: theorem inf_mono_fun {g : β → α} (h : ∀ b ∈ s, f b ≤ g b) : s.inf f ≤ s.inf g 
goal: s.inf f ≤ s.inf g

full_name: Finset.inf_mono
code: @[gcongr]
theorem inf_mono (h : s₁ ⊆ s₂) : s₂.inf f ≤ s₁.inf f 
goal: s₂.inf f ≤ s₁.inf f

full_name: Finset.inf_comm
code: protected theorem inf_comm (s : Finset β) (t : Finset γ) (f : β → γ → α) :
    (s.inf fun b => t.inf (f b)) = t.inf fun c => s.inf fun b => f b c 
goal: (s.inf fun b => t.inf (f b)) = t.inf fun c => s.inf fun b => f b c

full_name: Finset.inf_attach
code: theorem inf_attach (s : Finset β) (f : β → α) : (s.attach.inf fun x => f x) = s.inf f 
goal: (s.attach.inf fun x => f ↑x) = s.inf f

full_name: Finset.inf_product_left
code: theorem inf_product_left (s : Finset β) (t : Finset γ) (f : β × γ → α) :
    (s ×ˢ t).inf f = s.inf fun i => t.inf fun i' => f ⟨i, i'⟩ 
goal: (s ×ˢ t).inf f = s.inf fun i => t.inf fun i' => f (i, i')

full_name: Finset.inf_product_right
code: theorem inf_product_right (s : Finset β) (t : Finset γ) (f : β × γ → α) :
    (s ×ˢ t).inf f = t.inf fun i' => s.inf fun i => f ⟨i, i'⟩ 
goal: (s ×ˢ t).inf f = t.inf fun i' => s.inf fun i => f (i, i')

full_name: Finset.inf_prodMap
code: @[simp] lemma inf_prodMap (hs : s.Nonempty) (ht : t.Nonempty) (f : ι → α) (g : κ → β) :
    inf (s ×ˢ t) (Prod.map f g) = (inf s f, inf t g) 
goal: (s ×ˢ t).inf (Prod.map f g) = (s.inf f, t.inf g)

full_name: Finset.inf_erase_top
code: @[simp]
theorem inf_erase_top [DecidableEq α] (s : Finset α) : (s.erase ⊤).inf id = s.inf id 
goal: (s.erase ⊤).inf id = s.inf id

full_name: Finset.comp_inf_eq_inf_comp
code: theorem comp_inf_eq_inf_comp [SemilatticeInf γ] [OrderTop γ] {s : Finset β} {f : β → α} (g : α → γ)
    (g_inf : ∀ x y, g (x ⊓ y) = g x ⊓ g y) (top : g ⊤ = ⊤) : g (s.inf f) = s.inf (g ∘ f) 
goal: g (s.inf f) = s.inf (g ∘ f)

full_name: Finset.inf_coe
code: /-- Computing `inf` in a subtype (closed under `inf`) is the same as computing it in `α`. -/
theorem inf_coe {P : α → Prop} {Ptop : P ⊤} {Pinf : ∀ ⦃x y⦄, P x → P y → P (x ⊓ y)} (t : Finset β)
    (f : β → { x : α // P x }) :
    (@inf { x // P x } _ (Subtype.semilatticeInf Pinf) (Subtype.orderTop Ptop) t f : α) =
      t.inf fun x => ↑(f x) 
goal: ↑(t.inf f) = t.inf fun x => ↑(f x)

full_name: List.foldr_inf_eq_inf_toFinset
code: theorem _root_.List.foldr_inf_eq_inf_toFinset [DecidableEq α] (l : List α) :
    l.foldr (· ⊓ ·) ⊤ = l.toFinset.inf id 
goal: List.foldr (fun x x_1 => x ⊓ x_1) ⊤ l = l.toFinset.inf id

full_name: Finset.inf_induction
code: theorem inf_induction {p : α → Prop} (ht : p ⊤) (hp : ∀ a₁, p a₁ → ∀ a₂, p a₂ → p (a₁ ⊓ a₂))
    (hs : ∀ b ∈ s, p (f b)) : p (s.inf f) 
goal: p (s.inf f)

full_name: Finset.inf_mem
code: theorem inf_mem (s : Set α) (w₁ : ⊤ ∈ s) (w₂ : ∀ᵉ (x ∈ s) (y ∈ s), x ⊓ y ∈ s)
    {ι : Type*} (t : Finset ι) (p : ι → α) (h : ∀ i ∈ t, p i ∈ s) : t.inf p ∈ s 
goal: t.inf p ∈ s

full_name: Finset.inf_eq_top_iff
code: @[simp]
protected theorem inf_eq_top_iff (f : β → α) (S : Finset β) : S.inf f = ⊤ ↔ ∀ s ∈ S, f s = ⊤ 
goal: S.inf f = ⊤ ↔ ∀ s ∈ S, f s = ⊤

full_name: Finset.toDual_sup
code: @[simp]
theorem toDual_sup [SemilatticeSup α] [OrderBot α] (s : Finset β) (f : β → α) :
    toDual (s.sup f) = s.inf (toDual ∘ f) 
goal: OrderDual.toDual (s.sup f) = s.inf (⇑OrderDual.toDual ∘ f)

full_name: Finset.toDual_inf
code: @[simp]
theorem toDual_inf [SemilatticeInf α] [OrderTop α] (s : Finset β) (f : β → α) :
    toDual (s.inf f) = s.sup (toDual ∘ f) 
goal: OrderDual.toDual (s.inf f) = s.sup (⇑OrderDual.toDual ∘ f)

full_name: Finset.ofDual_sup
code: @[simp]
theorem ofDual_sup [SemilatticeInf α] [OrderTop α] (s : Finset β) (f : β → αᵒᵈ) :
    ofDual (s.sup f) = s.inf (ofDual ∘ f) 
goal: OrderDual.ofDual (s.sup f) = s.inf (⇑OrderDual.ofDual ∘ f)

full_name: Finset.ofDual_inf
code: @[simp]
theorem ofDual_inf [SemilatticeSup α] [OrderBot α] (s : Finset β) (f : β → αᵒᵈ) :
    ofDual (s.inf f) = s.sup (ofDual ∘ f) 
goal: OrderDual.ofDual (s.inf f) = s.sup (⇑OrderDual.ofDual ∘ f)

full_name: Finset.sup_inf_distrib_left
code: theorem sup_inf_distrib_left (s : Finset ι) (f : ι → α) (a : α) :
    a ⊓ s.sup f = s.sup fun i => a ⊓ f i 
goal: a ⊓ s.sup f = s.sup fun i => a ⊓ f i

full_name: Finset.sup_inf_distrib_right
code: theorem sup_inf_distrib_right (s : Finset ι) (f : ι → α) (a : α) :
    s.sup f ⊓ a = s.sup fun i => f i ⊓ a 
goal: s.sup f ⊓ a = s.sup fun i => f i ⊓ a

full_name: Finset.disjoint_sup_right
code: protected theorem disjoint_sup_right : Disjoint a (s.sup f) ↔ ∀ ⦃i⦄, i ∈ s → Disjoint a (f i) 
goal: Disjoint a (s.sup f) ↔ ∀ ⦃i : ι⦄, i ∈ s → Disjoint a (f i)

full_name: Finset.disjoint_sup_left
code: protected theorem disjoint_sup_left : Disjoint (s.sup f) a ↔ ∀ ⦃i⦄, i ∈ s → Disjoint (f i) a 
goal: Disjoint (s.sup f) a ↔ ∀ ⦃i : ι⦄, i ∈ s → Disjoint (f i) a

full_name: Finset.sup_inf_sup
code: theorem sup_inf_sup (s : Finset ι) (t : Finset κ) (f : ι → α) (g : κ → α) :
    s.sup f ⊓ t.sup g = (s ×ˢ t).sup fun i => f i.1 ⊓ g i.2 
goal: s.sup f ⊓ t.sup g = (s ×ˢ t).sup fun i => f i.1 ⊓ g i.2

full_name: Finset.inf_sup_distrib_left
code: theorem inf_sup_distrib_left (s : Finset ι) (f : ι → α) (a : α) :
    a ⊔ s.inf f = s.inf fun i => a ⊔ f i 
goal: a ⊔ s.inf f = s.inf fun i => a ⊔ f i

full_name: Finset.inf_sup_distrib_right
code: theorem inf_sup_distrib_right (s : Finset ι) (f : ι → α) (a : α) :
    s.inf f ⊔ a = s.inf fun i => f i ⊔ a 
goal: s.inf f ⊔ a = s.inf fun i => f i ⊔ a

full_name: Finset.codisjoint_inf_right
code: protected theorem codisjoint_inf_right :
    Codisjoint a (s.inf f) ↔ ∀ ⦃i⦄, i ∈ s → Codisjoint a (f i) 
goal: Codisjoint a (s.inf f) ↔ ∀ ⦃i : ι⦄, i ∈ s → Codisjoint a (f i)

full_name: Finset.codisjoint_inf_left
code: protected theorem codisjoint_inf_left :
    Codisjoint (s.inf f) a ↔ ∀ ⦃i⦄, i ∈ s → Codisjoint (f i) a 
goal: Codisjoint (s.inf f) a ↔ ∀ ⦃i : ι⦄, i ∈ s → Codisjoint (f i) a

full_name: Finset.inf_sup_inf
code: theorem inf_sup_inf (s : Finset ι) (t : Finset κ) (f : ι → α) (g : κ → α) :
    s.inf f ⊔ t.inf g = (s ×ˢ t).inf fun i => f i.1 ⊔ g i.2 
goal: s.inf f ⊔ t.inf g = (s ×ˢ t).inf fun i => f i.1 ⊔ g i.2

full_name: Finset.inf_sup
code: theorem inf_sup {κ : ι → Type*} (s : Finset ι) (t : ∀ i, Finset (κ i)) (f : ∀ i, κ i → α) :
    (s.inf fun i => (t i).sup (f i)) =
      (s.pi t).sup fun g => s.attach.inf fun i => f _ <| g _ i.2 
goal: (s.inf fun i => (t i).sup (f i)) = (s.pi t).sup fun g => s.attach.inf fun i => f (↑i) (g ↑i ⋯)

full_name: Finset.sup_inf
code: theorem sup_inf {κ : ι → Type*} (s : Finset ι) (t : ∀ i, Finset (κ i)) (f : ∀ i, κ i → α) :
    (s.sup fun i => (t i).inf (f i)) = (s.pi t).inf fun g => s.attach.sup fun i => f _ <| g _ i.2 
goal: (s.sup fun i => (t i).inf (f i)) = (s.pi t).inf fun g => s.attach.sup fun i => f (↑i) (g ↑i ⋯)

full_name: Finset.sup_sdiff_left
code: theorem sup_sdiff_left (s : Finset ι) (f : ι → α) (a : α) :
    (s.sup fun b => a \ f b) = a \ s.inf f 
goal: (s.sup fun b => a \ f b) = a \ s.inf f

full_name: Finset.inf_sdiff_left
code: theorem inf_sdiff_left (hs : s.Nonempty) (f : ι → α) (a : α) :
    (s.inf fun b => a \ f b) = a \ s.sup f 
goal: (s.inf fun b => a \ f b) = a \ s.sup f

full_name: Finset.inf_sdiff_right
code: theorem inf_sdiff_right (hs : s.Nonempty) (f : ι → α) (a : α) :
    (s.inf fun b => f b \ a) = s.inf f \ a 
goal: (s.inf fun b => f b \ a) = s.inf f \ a

full_name: Finset.inf_himp_right
code: theorem inf_himp_right (s : Finset ι) (f : ι → α) (a : α) :
    (s.inf fun b => f b ⇨ a) = s.sup f ⇨ a 
goal: (s.inf fun b => f b ⇨ a) = s.sup f ⇨ a

full_name: Finset.sup_himp_right
code: theorem sup_himp_right (hs : s.Nonempty) (f : ι → α) (a : α) :
    (s.sup fun b => f b ⇨ a) = s.inf f ⇨ a 
goal: (s.sup fun b => f b ⇨ a) = s.inf f ⇨ a

full_name: Finset.sup_himp_left
code: theorem sup_himp_left (hs : s.Nonempty) (f : ι → α) (a : α) :
    (s.sup fun b => a ⇨ f b) = a ⇨ s.sup f 
goal: (s.sup fun b => a ⇨ f b) = a ⇨ s.sup f

full_name: Finset.compl_sup
code: @[simp]
protected theorem compl_sup (s : Finset ι) (f : ι → α) : (s.sup f)ᶜ = s.inf fun i => (f i)ᶜ 
goal: (s.sup f)ᶜ = s.inf fun i => (f i)ᶜ

full_name: Finset.compl_inf
code: @[simp]
protected theorem compl_inf (s : Finset ι) (f : ι → α) : (s.inf f)ᶜ = s.sup fun i => (f i)ᶜ 
goal: (s.inf f)ᶜ = s.sup fun i => (f i)ᶜ

full_name: Finset.comp_sup_eq_sup_comp_of_is_total
code: theorem comp_sup_eq_sup_comp_of_is_total [SemilatticeSup β] [OrderBot β] (g : α → β)
    (mono_g : Monotone g) (bot : g ⊥ = ⊥) : g (s.sup f) = s.sup (g ∘ f) 
goal: g (s.sup f) = s.sup (g ∘ f)

full_name: Finset.le_sup_iff
code: @[simp]
protected theorem le_sup_iff (ha : ⊥ < a) : a ≤ s.sup f ↔ ∃ b ∈ s, a ≤ f b 
goal: a ≤ s.sup f ↔ ∃ b ∈ s, a ≤ f b

full_name: Finset.sup_eq_top_iff
code: protected theorem sup_eq_top_iff {α : Type*} [LinearOrder α] [BoundedOrder α] [Nontrivial α]
    {s : Finset ι} {f : ι → α} : s.sup f = ⊤ ↔ ∃ b ∈ s, f b = ⊤ 
goal: s.sup f = ⊤ ↔ ∃ b ∈ s, f b = ⊤

full_name: Finset.Nonempty.sup_eq_top_iff
code: protected theorem Nonempty.sup_eq_top_iff {α : Type*} [LinearOrder α] [BoundedOrder α]
    {s : Finset ι} {f : ι → α} (hs : s.Nonempty) : s.sup f = ⊤ ↔ ∃ b ∈ s, f b = ⊤ 
goal: s.sup f = ⊤ ↔ ∃ b ∈ s, f b = ⊤

full_name: Finset.lt_sup_iff
code: @[simp]
protected theorem lt_sup_iff : a < s.sup f ↔ ∃ b ∈ s, a < f b 
goal: a < s.sup f ↔ ∃ b ∈ s, a < f b

full_name: Finset.sup_lt_iff
code: @[simp]
protected theorem sup_lt_iff (ha : ⊥ < a) : s.sup f < a ↔ ∀ b ∈ s, f b < a 
goal: s.sup f < a ↔ ∀ b ∈ s, f b < a

full_name: Finset.comp_inf_eq_inf_comp_of_is_total
code: theorem comp_inf_eq_inf_comp_of_is_total [SemilatticeInf β] [OrderTop β] (g : α → β)
    (mono_g : Monotone g) (top : g ⊤ = ⊤) : g (s.inf f) = s.inf (g ∘ f) 
goal: g (s.inf f) = s.inf (g ∘ f)

full_name: Finset.inf_le_iff
code: @[simp]
protected theorem inf_le_iff (ha : a < ⊤) : s.inf f ≤ a ↔ ∃ b ∈ s, f b ≤ a 
goal: s.inf f ≤ a ↔ ∃ b ∈ s, f b ≤ a

full_name: Finset.inf_eq_bot_iff
code: protected theorem inf_eq_bot_iff {α : Type*} [LinearOrder α] [BoundedOrder α] [Nontrivial α]
    {s : Finset ι} {f : ι → α} : s.inf f = ⊥ ↔ ∃ b ∈ s, f b = ⊥ 
goal: s.inf f = ⊥ ↔ ∃ b ∈ s, f b = ⊥

full_name: Finset.Nonempty.inf_eq_bot_iff
code: protected theorem Nonempty.inf_eq_bot_iff {α : Type*} [LinearOrder α] [BoundedOrder α]
    {s : Finset ι} {f : ι → α} (h : s.Nonempty) : s.inf f = ⊥ ↔ ∃ b ∈ s, f b = ⊥ 
goal: s.inf f = ⊥ ↔ ∃ b ∈ s, f b = ⊥

full_name: Finset.inf_lt_iff
code: @[simp]
protected theorem inf_lt_iff : s.inf f < a ↔ ∃ b ∈ s, f b < a 
goal: s.inf f < a ↔ ∃ b ∈ s, f b < a

full_name: Finset.lt_inf_iff
code: @[simp]
protected theorem lt_inf_iff (ha : a < ⊤) : a < s.inf f ↔ ∀ b ∈ s, a < f b 
goal: a < s.inf f ↔ ∀ b ∈ s, a < f b

full_name: Finset.inf_eq_iInf
code: theorem inf_eq_iInf [CompleteLattice β] (s : Finset α) (f : α → β) : s.inf f = ⨅ a ∈ s, f a 
goal: s.inf f = ⨅ a ∈ s, f a

full_name: Finset.inf_id_eq_sInf
code: theorem inf_id_eq_sInf [CompleteLattice α] (s : Finset α) : s.inf id = sInf s 
goal: s.inf id = sInf ↑s

full_name: Finset.inf_id_set_eq_sInter
code: theorem inf_id_set_eq_sInter (s : Finset (Set α)) : s.inf id = ⋂₀ ↑s 
goal: s.inf id = ⋂₀ ↑s

full_name: Finset.inf_set_eq_iInter
code: @[simp]
theorem inf_set_eq_iInter (s : Finset α) (f : α → Set β) : s.inf f = ⋂ x ∈ s, f x 
goal: s.inf f = ⋂ x ∈ s, f x

full_name: Finset.inf_eq_sInf_image
code: theorem inf_eq_sInf_image [CompleteLattice β] (s : Finset α) (f : α → β) :
    s.inf f = sInf (f '' s) 
goal: s.inf f = sInf (f '' ↑s)

full_name: Finset.sup_of_mem
code: theorem sup_of_mem {s : Finset β} (f : β → α) {b : β} (h : b ∈ s) :
    ∃ a : α, s.sup ((↑) ∘ f : β → WithBot α) = ↑a 
goal: ∃ a, s.sup (WithBot.some ∘ f) = ↑a

full_name: Finset.sup'
code: /-- Given nonempty finset `s` then `s.sup' H f` is the supremum of its image under `f` in (possibly
unbounded) join-semilattice `α`, where `H` is a proof of nonemptiness. If `α` has a bottom element
you may instead use `Finset.sup` which does not require `s` nonempty. -/
def sup' (s : Finset β) (H : s.Nonempty) (f : β → α) : α 
goal: α

full_name: Finset.coe_sup'
code: @[simp]
theorem coe_sup' : ((s.sup' H f : α) : WithBot α) = s.sup ((↑) ∘ f) 
goal: ↑(s.sup' H f) = s.sup (WithBot.some ∘ f)

full_name: Finset.sup'_cons
code: @[simp]
theorem sup'_cons {b : β} {hb : b ∉ s} :
    (cons b s hb).sup' (nonempty_cons hb) f = f b ⊔ s.sup' H f 
goal: (Finset.cons b s hb).sup' ⋯ f = f b ⊔ s.sup' H f

full_name: Finset.sup'_insert
code: @[simp]
theorem sup'_insert [DecidableEq β] {b : β} :
    (insert b s).sup' (insert_nonempty _ _) f = f b ⊔ s.sup' H f 
goal: (insert b s).sup' ⋯ f = f b ⊔ s.sup' H f

full_name: Finset.sup'_singleton
code: @[simp]
theorem sup'_singleton {b : β} : ({b} : Finset β).sup' (singleton_nonempty _) f = f b 
goal: {b}.sup' ⋯ f = f b

full_name: Finset.sup'_le_iff
code: @[simp]
theorem sup'_le_iff {a : α} : s.sup' H f ≤ a ↔ ∀ b ∈ s, f b ≤ a 
goal: s.sup' H f ≤ a ↔ ∀ b ∈ s, f b ≤ a

full_name: Finset.le_sup'
code: theorem le_sup' {b : β} (h : b ∈ s) : f b ≤ s.sup' ⟨b, h⟩ f 
goal: f b ≤ s.sup' ⋯ f

full_name: Finset.le_sup'_of_le
code: theorem le_sup'_of_le {a : α} {b : β} (hb : b ∈ s) (h : a ≤ f b) : a ≤ s.sup' ⟨b, hb⟩ f 
goal: a ≤ s.sup' ⋯ f

full_name: Finset.sup'_const
code: @[simp]
theorem sup'_const (a : α) : s.sup' H (fun _ => a) = a 
goal: (s.sup' H fun x => a) = a

full_name: Finset.sup'_union
code: theorem sup'_union [DecidableEq β] {s₁ s₂ : Finset β} (h₁ : s₁.Nonempty) (h₂ : s₂.Nonempty)
    (f : β → α) :
    (s₁ ∪ s₂).sup' (h₁.mono subset_union_left) f = s₁.sup' h₁ f ⊔ s₂.sup' h₂ f 
goal: (s₁ ∪ s₂).sup' ⋯ f = s₁.sup' h₁ f ⊔ s₂.sup' h₂ f

full_name: Finset.sup'_biUnion
code: theorem sup'_biUnion [DecidableEq β] {s : Finset γ} (Hs : s.Nonempty) {t : γ → Finset β}
    (Ht : ∀ b, (t b).Nonempty) :
    (s.biUnion t).sup' (Hs.biUnion fun b _ => Ht b) f = s.sup' Hs (fun b => (t b).sup' (Ht b) f) 
goal: (s.biUnion t).sup' ⋯ f = s.sup' Hs fun b => (t b).sup' ⋯ f

full_name: Finset.sup'_comm
code: protected theorem sup'_comm {t : Finset γ} (hs : s.Nonempty) (ht : t.Nonempty) (f : β → γ → α) :
    (s.sup' hs fun b => t.sup' ht (f b)) = t.sup' ht fun c => s.sup' hs fun b => f b c 
goal: (s.sup' hs fun b => t.sup' ht (f b)) = t.sup' ht fun c => s.sup' hs fun b => f b c

full_name: Finset.sup'_product_left
code: theorem sup'_product_left {t : Finset γ} (h : (s ×ˢ t).Nonempty) (f : β × γ → α) :
    (s ×ˢ t).sup' h f = s.sup' h.fst fun i => t.sup' h.snd fun i' => f ⟨i, i'⟩ 
goal: (s ×ˢ t).sup' h f = s.sup' ⋯ fun i => t.sup' ⋯ fun i' => f (i, i')

full_name: Finset.sup'_product_right
code: theorem sup'_product_right {t : Finset γ} (h : (s ×ˢ t).Nonempty) (f : β × γ → α) :
    (s ×ˢ t).sup' h f = t.sup' h.snd fun i' => s.sup' h.fst fun i => f ⟨i, i'⟩ 
goal: (s ×ˢ t).sup' h f = t.sup' ⋯ fun i' => s.sup' ⋯ fun i => f (i, i')

full_name: Finset.prodMk_sup'_sup'
code: /-- See also `Finset.sup'_prodMap`. -/
lemma prodMk_sup'_sup' (hs : s.Nonempty) (ht : t.Nonempty) (f : ι → α) (g : κ → β) :
    (sup' s hs f, sup' t ht g) = sup' (s ×ˢ t) (hs.product ht) (Prod.map f g) 
goal: (s.sup' hs f, t.sup' ht g) = (s ×ˢ t).sup' ⋯ (Prod.map f g)

full_name: Finset.sup'_prodMap
code: /-- See also `Finset.prodMk_sup'_sup'`. -/
-- @[simp] -- TODO: Why does `Prod.map_apply` simplify the LHS?
lemma sup'_prodMap (hst : (s ×ˢ t).Nonempty) (f : ι → α) (g : κ → β) :
    sup' (s ×ˢ t) hst (Prod.map f g) = (sup' s hst.fst f, sup' t hst.snd g) 
goal: (s ×ˢ t).sup' hst (Prod.map f g) = (s.sup' ⋯ f, t.sup' ⋯ g)

full_name: Finset.sup'_induction
code: theorem sup'_induction {p : α → Prop} (hp : ∀ a₁, p a₁ → ∀ a₂, p a₂ → p (a₁ ⊔ a₂))
    (hs : ∀ b ∈ s, p (f b)) : p (s.sup' H f) 
goal: p (s.sup' H f)

full_name: Finset.sup'_mem
code: theorem sup'_mem (s : Set α) (w : ∀ᵉ (x ∈ s) (y ∈ s), x ⊔ y ∈ s) {ι : Type*}
    (t : Finset ι) (H : t.Nonempty) (p : ι → α) (h : ∀ i ∈ t, p i ∈ s) : t.sup' H p ∈ s 
goal: t.sup' H p ∈ s

full_name: Finset.sup'_congr
code: @[congr]
theorem sup'_congr {t : Finset β} {f g : β → α} (h₁ : s = t) (h₂ : ∀ x ∈ s, f x = g x) :
    s.sup' H f = t.sup' (h₁ ▸ H) g 
goal: s.sup' H f = t.sup' ⋯ g

full_name: Finset.comp_sup'_eq_sup'_comp
code: theorem comp_sup'_eq_sup'_comp [SemilatticeSup γ] {s : Finset β} (H : s.Nonempty) {f : β → α}
    (g : α → γ) (g_sup : ∀ x y, g (x ⊔ y) = g x ⊔ g y) : g (s.sup' H f) = s.sup' H (g ∘ f) 
goal: g (s.sup' H f) = s.sup' H (g ∘ f)

full_name: map_finset_sup'
code: @[simp]
theorem _root_.map_finset_sup' [SemilatticeSup β] [FunLike F α β] [SupHomClass F α β]
    (f : F) {s : Finset ι} (hs) (g : ι → α) :
    f (s.sup' hs g) = s.sup' hs (f ∘ g) 
goal: f (s.sup' hs g) = s.sup' hs (⇑f ∘ g)

full_name: Finset.nsmul_sup'
code: lemma nsmul_sup' {α'} [LinearOrderedAddCommMonoid β] {s : Finset α'}
    (hs : s.Nonempty) (f : α' → β) (n : ℕ) :
    s.sup' hs (fun a => n • f a) = n • s.sup' hs f 
goal: (s.sup' hs fun a => n • f a) = n • s.sup' hs f

full_name: Finset.sup'_image
code: /-- To rewrite from right to left, use `Finset.sup'_comp_eq_image`. -/
@[simp]
theorem sup'_image [DecidableEq β] {s : Finset γ} {f : γ → β} (hs : (s.image f).Nonempty)
    (g : β → α) :
    (s.image f).sup' hs g = s.sup' hs.of_image (g ∘ f) 
goal: (Finset.image f s).sup' hs g = s.sup' ⋯ (g ∘ f)

full_name: Finset.sup'_comp_eq_image
code: /-- A version of `Finset.sup'_image` with LHS and RHS reversed.
Also, this lemma assumes that `s` is nonempty instead of assuming that its image is nonempty. -/
lemma sup'_comp_eq_image [DecidableEq β] {s : Finset γ} {f : γ → β} (hs : s.Nonempty) (g : β → α) :
    s.sup' hs (g ∘ f) = (s.image f).sup' (hs.image f) g 
goal: s.sup' hs (g ∘ f) = (Finset.image f s).sup' ⋯ g

full_name: Finset.sup'_map
code: /-- To rewrite from right to left, use `Finset.sup'_comp_eq_map`. -/
@[simp]
theorem sup'_map {s : Finset γ} {f : γ ↪ β} (g : β → α) (hs : (s.map f).Nonempty) :
    (s.map f).sup' hs g = s.sup' (map_nonempty.1 hs) (g ∘ f) 
goal: (Finset.map f s).sup' hs g = s.sup' ⋯ (g ∘ ⇑f)

full_name: Finset.sup'_comp_eq_map
code: /-- A version of `Finset.sup'_map` with LHS and RHS reversed.
Also, this lemma assumes that `s` is nonempty instead of assuming that its image is nonempty. -/
lemma sup'_comp_eq_map {s : Finset γ} {f : γ ↪ β} (g : β → α) (hs : s.Nonempty) :
    s.sup' hs (g ∘ f) = (s.map f).sup' (map_nonempty.2 hs) g 
goal: s.sup' hs (g ∘ ⇑f) = (Finset.map f s).sup' ⋯ g

full_name: Finset.sup'_mono
code: theorem sup'_mono {s₁ s₂ : Finset β} (h : s₁ ⊆ s₂) (h₁ : s₁.Nonempty) :
    s₁.sup' h₁ f ≤ s₂.sup' (h₁.mono h) f 
goal: s₁.sup' h₁ f ≤ s₂.sup' ⋯ f

full_name: GCongr.finset_sup'_le
code: /-- A version of `Finset.sup'_mono` acceptable for `@[gcongr]`.
Instead of deducing `s₂.Nonempty` from `s₁.Nonempty` and `s₁ ⊆ s₂`,
this version takes it as an argument. -/
@[gcongr]
lemma _root_.GCongr.finset_sup'_le {s₁ s₂ : Finset β} (h : s₁ ⊆ s₂)
    {h₁ : s₁.Nonempty} {h₂ : s₂.Nonempty} : s₁.sup' h₁ f ≤ s₂.sup' h₂ f 
goal: s₁.sup' h₁ f ≤ s₂.sup' h₂ f

full_name: Finset.inf_of_mem
code: theorem inf_of_mem {s : Finset β} (f : β → α) {b : β} (h : b ∈ s) :
    ∃ a : α, s.inf ((↑) ∘ f : β → WithTop α) = ↑a 
goal: ∃ a, s.inf (WithTop.some ∘ f) = ↑a

full_name: Finset.inf'
code: /-- Given nonempty finset `s` then `s.inf' H f` is the infimum of its image under `f` in (possibly
unbounded) meet-semilattice `α`, where `H` is a proof of nonemptiness. If `α` has a top element you
may instead use `Finset.inf` which does not require `s` nonempty. -/
def inf' (s : Finset β) (H : s.Nonempty) (f : β → α) : α 
goal: α

full_name: Finset.coe_inf'
code: @[simp]
theorem coe_inf' : ((s.inf' H f : α) : WithTop α) = s.inf ((↑) ∘ f) 
goal: ↑(s.inf' H f) = s.inf (WithTop.some ∘ f)

full_name: Finset.inf'_cons
code: @[simp]
theorem inf'_cons {b : β} {hb : b ∉ s} :
    (cons b s hb).inf' (nonempty_cons hb) f = f b ⊓ s.inf' H f 
goal: (Finset.cons b s hb).inf' ⋯ f = f b ⊓ s.inf' H f

full_name: Finset.inf'_insert
code: @[simp]
theorem inf'_insert [DecidableEq β] {b : β} :
    (insert b s).inf' (insert_nonempty _ _) f = f b ⊓ s.inf' H f 
goal: (insert b s).inf' ⋯ f = f b ⊓ s.inf' H f

full_name: Finset.inf'_singleton
code: @[simp]
theorem inf'_singleton {b : β} : ({b} : Finset β).inf' (singleton_nonempty _) f = f b 
goal: {b}.inf' ⋯ f = f b

full_name: Finset.le_inf'_iff
code: @[simp]
theorem le_inf'_iff {a : α} : a ≤ s.inf' H f ↔ ∀ b ∈ s, a ≤ f b 
goal: a ≤ s.inf' H f ↔ ∀ b ∈ s, a ≤ f b

full_name: Finset.le_inf'
code: theorem le_inf' {a : α} (hs : ∀ b ∈ s, a ≤ f b) : a ≤ s.inf' H f 
goal: a ≤ s.inf' H f

full_name: Finset.inf'_le
code: theorem inf'_le {b : β} (h : b ∈ s) : s.inf' ⟨b, h⟩ f ≤ f b 
goal: s.inf' ⋯ f ≤ f b

full_name: Finset.inf'_le_of_le
code: theorem inf'_le_of_le {a : α} {b : β} (hb : b ∈ s) (h : f b ≤ a) :
    s.inf' ⟨b, hb⟩ f ≤ a 
goal: s.inf' ⋯ f ≤ a

full_name: Finset.inf'_const
code: @[simp]
theorem inf'_const (a : α) : (s.inf' H fun _ => a) = a 
goal: (s.inf' H fun x => a) = a

full_name: Finset.inf'_union
code: theorem inf'_union [DecidableEq β] {s₁ s₂ : Finset β} (h₁ : s₁.Nonempty) (h₂ : s₂.Nonempty)
    (f : β → α) :
    (s₁ ∪ s₂).inf' (h₁.mono subset_union_left) f = s₁.inf' h₁ f ⊓ s₂.inf' h₂ f 
goal: (s₁ ∪ s₂).inf' ⋯ f = s₁.inf' h₁ f ⊓ s₂.inf' h₂ f

full_name: Finset.inf'_biUnion
code: theorem inf'_biUnion [DecidableEq β] {s : Finset γ} (Hs : s.Nonempty) {t : γ → Finset β}
    (Ht : ∀ b, (t b).Nonempty) :
    (s.biUnion t).inf' (Hs.biUnion fun b _ => Ht b) f = s.inf' Hs (fun b => (t b).inf' (Ht b) f) 
goal: (s.biUnion t).inf' ⋯ f = s.inf' Hs fun b => (t b).inf' ⋯ f

full_name: Finset.inf'_comm
code: protected theorem inf'_comm {t : Finset γ} (hs : s.Nonempty) (ht : t.Nonempty) (f : β → γ → α) :
    (s.inf' hs fun b => t.inf' ht (f b)) = t.inf' ht fun c => s.inf' hs fun b => f b c 
goal: (s.inf' hs fun b => t.inf' ht (f b)) = t.inf' ht fun c => s.inf' hs fun b => f b c

full_name: Finset.inf'_product_left
code: theorem inf'_product_left {t : Finset γ} (h : (s ×ˢ t).Nonempty) (f : β × γ → α) :
    (s ×ˢ t).inf' h f = s.inf' h.fst fun i => t.inf' h.snd fun i' => f ⟨i, i'⟩ 
goal: (s ×ˢ t).inf' h f = s.inf' ⋯ fun i => t.inf' ⋯ fun i' => f (i, i')

full_name: Finset.inf'_product_right
code: theorem inf'_product_right {t : Finset γ} (h : (s ×ˢ t).Nonempty) (f : β × γ → α) :
    (s ×ˢ t).inf' h f = t.inf' h.snd fun i' => s.inf' h.fst fun i => f ⟨i, i'⟩ 
goal: (s ×ˢ t).inf' h f = t.inf' ⋯ fun i' => s.inf' ⋯ fun i => f (i, i')

full_name: Finset.prodMk_inf'_inf'
code: /-- See also `Finset.inf'_prodMap`. -/
lemma prodMk_inf'_inf' (hs : s.Nonempty) (ht : t.Nonempty) (f : ι → α) (g : κ → β) :
    (inf' s hs f, inf' t ht g) = inf' (s ×ˢ t) (hs.product ht) (Prod.map f g) 
goal: (s.inf' hs f, t.inf' ht g) = (s ×ˢ t).inf' ⋯ (Prod.map f g)

full_name: Finset.inf'_prodMap
code: /-- See also `Finset.prodMk_inf'_inf'`. -/
-- @[simp] -- TODO: Why does `Prod.map_apply` simplify the LHS?
lemma inf'_prodMap (hst : (s ×ˢ t).Nonempty) (f : ι → α) (g : κ → β) :
    inf' (s ×ˢ t) hst (Prod.map f g) = (inf' s hst.fst f, inf' t hst.snd g) 
goal: (s ×ˢ t).inf' hst (Prod.map f g) = (s.inf' ⋯ f, t.inf' ⋯ g)

full_name: Finset.comp_inf'_eq_inf'_comp
code: theorem comp_inf'_eq_inf'_comp [SemilatticeInf γ] {s : Finset β} (H : s.Nonempty) {f : β → α}
    (g : α → γ) (g_inf : ∀ x y, g (x ⊓ y) = g x ⊓ g y) : g (s.inf' H f) = s.inf' H (g ∘ f) 
goal: g (s.inf' H f) = s.inf' H (g ∘ f)

full_name: Finset.inf'_induction
code: theorem inf'_induction {p : α → Prop} (hp : ∀ a₁, p a₁ → ∀ a₂, p a₂ → p (a₁ ⊓ a₂))
    (hs : ∀ b ∈ s, p (f b)) : p (s.inf' H f) 
goal: p (s.inf' H f)

full_name: Finset.inf'_mem
code: theorem inf'_mem (s : Set α) (w : ∀ᵉ (x ∈ s) (y ∈ s), x ⊓ y ∈ s) {ι : Type*}
    (t : Finset ι) (H : t.Nonempty) (p : ι → α) (h : ∀ i ∈ t, p i ∈ s) : t.inf' H p ∈ s 
goal: t.inf' H p ∈ s

full_name: Finset.inf'_congr
code: @[congr]
theorem inf'_congr {t : Finset β} {f g : β → α} (h₁ : s = t) (h₂ : ∀ x ∈ s, f x = g x) :
    s.inf' H f = t.inf' (h₁ ▸ H) g 
goal: s.inf' H f = t.inf' ⋯ g

full_name: map_finset_inf'
code: @[simp]
theorem _root_.map_finset_inf' [SemilatticeInf β] [FunLike F α β] [InfHomClass F α β]
    (f : F) {s : Finset ι} (hs) (g : ι → α) :
    f (s.inf' hs g) = s.inf' hs (f ∘ g) 
goal: f (s.inf' hs g) = s.inf' hs (⇑f ∘ g)

full_name: Finset.nsmul_inf'
code: lemma nsmul_inf' {α'} [LinearOrderedAddCommMonoid β] {s : Finset α'}
    (hs : s.Nonempty) (f : α' → β) (n : ℕ) :
    s.inf' hs (fun a => n • f a) = n • s.inf' hs f 
goal: (s.inf' hs fun a => n • f a) = n • s.inf' hs f

full_name: Finset.inf'_image
code: /-- To rewrite from right to left, use `Finset.inf'_comp_eq_image`. -/
@[simp]
theorem inf'_image [DecidableEq β] {s : Finset γ} {f : γ → β} (hs : (s.image f).Nonempty)
    (g : β → α)  :
    (s.image f).inf' hs g = s.inf' hs.of_image (g ∘ f) 
goal: (Finset.image f s).inf' hs g = s.inf' ⋯ (g ∘ f)

full_name: Finset.inf'_comp_eq_image
code: /-- A version of `Finset.inf'_image` with LHS and RHS reversed.
Also, this lemma assumes that `s` is nonempty instead of assuming that its image is nonempty. -/
lemma inf'_comp_eq_image [DecidableEq β] {s : Finset γ} {f : γ → β} (hs : s.Nonempty) (g : β → α) :
    s.inf' hs (g ∘ f) = (s.image f).inf' (hs.image f) g 
goal: s.inf' hs (g ∘ f) = (Finset.image f s).inf' ⋯ g

full_name: Finset.inf'_map
code: /-- To rewrite from right to left, use `Finset.inf'_comp_eq_map`. -/
@[simp]
theorem inf'_map {s : Finset γ} {f : γ ↪ β} (g : β → α) (hs : (s.map f).Nonempty) :
    (s.map f).inf' hs g = s.inf' (map_nonempty.1 hs) (g ∘ f) 
goal: (Finset.map f s).inf' hs g = s.inf' ⋯ (g ∘ ⇑f)

full_name: Finset.inf'_comp_eq_map
code: /-- A version of `Finset.inf'_map` with LHS and RHS reversed.
Also, this lemma assumes that `s` is nonempty instead of assuming that its image is nonempty. -/
lemma inf'_comp_eq_map {s : Finset γ} {f : γ ↪ β} (g : β → α) (hs : s.Nonempty) :
    s.inf' hs (g ∘ f) = (s.map f).inf' (map_nonempty.2 hs) g 
goal: s.inf' hs (g ∘ ⇑f) = (Finset.map f s).inf' ⋯ g

full_name: Finset.inf'_mono
code: theorem inf'_mono {s₁ s₂ : Finset β} (h : s₁ ⊆ s₂) (h₁ : s₁.Nonempty) :
    s₂.inf' (h₁.mono h) f ≤ s₁.inf' h₁ f 
goal: s₂.inf' ⋯ f ≤ s₁.inf' h₁ f

full_name: GCongr.finset_inf'_mono
code: /-- A version of `Finset.inf'_mono` acceptable for `@[gcongr]`.
Instead of deducing `s₂.Nonempty` from `s₁.Nonempty` and `s₁ ⊆ s₂`,
this version takes it as an argument. -/
@[gcongr]
lemma _root_.GCongr.finset_inf'_mono {s₁ s₂ : Finset β} (h : s₁ ⊆ s₂)
    {h₁ : s₁.Nonempty} {h₂ : s₂.Nonempty} : s₂.inf' h₂ f ≤ s₁.inf' h₁ f 
goal: s₂.inf' h₂ f ≤ s₁.inf' h₁ f

full_name: Finset.sup'_eq_sup
code: theorem sup'_eq_sup {s : Finset β} (H : s.Nonempty) (f : β → α) : s.sup' H f = s.sup f 
goal: s.sup' H f = s.sup f

full_name: Finset.coe_sup_of_nonempty
code: theorem coe_sup_of_nonempty {s : Finset β} (h : s.Nonempty) (f : β → α) :
    (↑(s.sup f) : WithBot α) = s.sup ((↑) ∘ f) 
goal: ↑(s.sup f) = s.sup (WithBot.some ∘ f)

full_name: Finset.inf'_eq_inf
code: theorem inf'_eq_inf {s : Finset β} (H : s.Nonempty) (f : β → α) : s.inf' H f = s.inf f 
goal: s.inf' H f = s.inf f

full_name: Finset.coe_inf_of_nonempty
code: theorem coe_inf_of_nonempty {s : Finset β} (h : s.Nonempty) (f : β → α) :
    (↑(s.inf f) : WithTop α) = s.inf ((↑) ∘ f) 
goal: ↑(s.inf f) = s.inf (WithTop.some ∘ f)

full_name: Finset.sup_apply
code: @[simp]
protected theorem sup_apply {C : β → Type*} [∀ b : β, SemilatticeSup (C b)]
    [∀ b : β, OrderBot (C b)] (s : Finset α) (f : α → ∀ b : β, C b) (b : β) :
    s.sup f b = s.sup fun a => f a b 
goal: s.sup f b = s.sup fun a => f a b

full_name: Finset.inf_apply
code: @[simp]
protected theorem inf_apply {C : β → Type*} [∀ b : β, SemilatticeInf (C b)]
    [∀ b : β, OrderTop (C b)] (s : Finset α) (f : α → ∀ b : β, C b) (b : β) :
    s.inf f b = s.inf fun a => f a b 
goal: s.inf f b = s.inf fun a => f a b

full_name: Finset.sup'_apply
code: @[simp]
protected theorem sup'_apply {C : β → Type*} [∀ b : β, SemilatticeSup (C b)]
    {s : Finset α} (H : s.Nonempty) (f : α → ∀ b : β, C b) (b : β) :
    s.sup' H f b = s.sup' H fun a => f a b 
goal: s.sup' H f b = s.sup' H fun a => f a b

full_name: Finset.inf'_apply
code: @[simp]
protected theorem inf'_apply {C : β → Type*} [∀ b : β, SemilatticeInf (C b)]
    {s : Finset α} (H : s.Nonempty) (f : α → ∀ b : β, C b) (b : β) :
    s.inf' H f b = s.inf' H fun a => f a b 
goal: s.inf' H f b = s.inf' H fun a => f a b

full_name: Finset.toDual_sup'
code: @[simp]
theorem toDual_sup' [SemilatticeSup α] {s : Finset ι} (hs : s.Nonempty) (f : ι → α) :
    toDual (s.sup' hs f) = s.inf' hs (toDual ∘ f) 
goal: OrderDual.toDual (s.sup' hs f) = s.inf' hs (⇑OrderDual.toDual ∘ f)

full_name: Finset.toDual_inf'
code: @[simp]
theorem toDual_inf' [SemilatticeInf α] {s : Finset ι} (hs : s.Nonempty) (f : ι → α) :
    toDual (s.inf' hs f) = s.sup' hs (toDual ∘ f) 
goal: OrderDual.toDual (s.inf' hs f) = s.sup' hs (⇑OrderDual.toDual ∘ f)

full_name: Finset.ofDual_sup'
code: @[simp]
theorem ofDual_sup' [SemilatticeInf α] {s : Finset ι} (hs : s.Nonempty) (f : ι → αᵒᵈ) :
    ofDual (s.sup' hs f) = s.inf' hs (ofDual ∘ f) 
goal: OrderDual.ofDual (s.sup' hs f) = s.inf' hs (⇑OrderDual.ofDual ∘ f)

full_name: Finset.ofDual_inf'
code: @[simp]
theorem ofDual_inf' [SemilatticeSup α] {s : Finset ι} (hs : s.Nonempty) (f : ι → αᵒᵈ) :
    ofDual (s.inf' hs f) = s.sup' hs (ofDual ∘ f) 
goal: OrderDual.ofDual (s.inf' hs f) = s.sup' hs (⇑OrderDual.ofDual ∘ f)

full_name: Finset.sup'_inf_distrib_left
code: theorem sup'_inf_distrib_left (f : ι → α) (a : α) :
    a ⊓ s.sup' hs f = s.sup' hs fun i ↦ a ⊓ f i 
goal: a ⊓ s.sup' hs f = s.sup' hs fun i => a ⊓ f i

full_name: Finset.sup'_inf_distrib_right
code: theorem sup'_inf_distrib_right (f : ι → α) (a : α) :
    s.sup' hs f ⊓ a = s.sup' hs fun i => f i ⊓ a 
goal: s.sup' hs f ⊓ a = s.sup' hs fun i => f i ⊓ a

full_name: Finset.sup'_inf_sup'
code: theorem sup'_inf_sup' (f : ι → α) (g : κ → α) :
    s.sup' hs f ⊓ t.sup' ht g = (s ×ˢ t).sup' (hs.product ht) fun i => f i.1 ⊓ g i.2 
goal: s.sup' hs f ⊓ t.sup' ht g = (s ×ˢ t).sup' ⋯ fun i => f i.1 ⊓ g i.2

full_name: Finset.inf'_sup_distrib_left
code: theorem inf'_sup_distrib_left (f : ι → α) (a : α) : a ⊔ s.inf' hs f = s.inf' hs fun i => a ⊔ f i 
goal: a ⊔ s.inf' hs f = s.inf' hs fun i => a ⊔ f i

full_name: Finset.inf'_sup_distrib_right
code: theorem inf'_sup_distrib_right (f : ι → α) (a : α) : s.inf' hs f ⊔ a = s.inf' hs fun i => f i ⊔ a 
goal: s.inf' hs f ⊔ a = s.inf' hs fun i => f i ⊔ a

full_name: Finset.inf'_sup_inf'
code: theorem inf'_sup_inf' (f : ι → α) (g : κ → α) :
    s.inf' hs f ⊔ t.inf' ht g = (s ×ˢ t).inf' (hs.product ht) fun i => f i.1 ⊔ g i.2 
goal: s.inf' hs f ⊔ t.inf' ht g = (s ×ˢ t).inf' ⋯ fun i => f i.1 ⊔ g i.2

full_name: Finset.le_sup'_iff
code: @[simp]
theorem le_sup'_iff : a ≤ s.sup' H f ↔ ∃ b ∈ s, a ≤ f b 
goal: a ≤ s.sup' H f ↔ ∃ b ∈ s, a ≤ f b

full_name: Finset.lt_sup'_iff
code: @[simp]
theorem lt_sup'_iff : a < s.sup' H f ↔ ∃ b ∈ s, a < f b 
goal: a < s.sup' H f ↔ ∃ b ∈ s, a < f b

full_name: Finset.sup'_lt_iff
code: @[simp]
theorem sup'_lt_iff : s.sup' H f < a ↔ ∀ i ∈ s, f i < a 
goal: s.sup' H f < a ↔ ∀ i ∈ s, f i < a

full_name: Finset.inf'_le_iff
code: @[simp]
theorem inf'_le_iff : s.inf' H f ≤ a ↔ ∃ i ∈ s, f i ≤ a 
goal: s.inf' H f ≤ a ↔ ∃ i ∈ s, f i ≤ a

full_name: Finset.inf'_lt_iff
code: @[simp]
theorem inf'_lt_iff : s.inf' H f < a ↔ ∃ i ∈ s, f i < a 
goal: s.inf' H f < a ↔ ∃ i ∈ s, f i < a

full_name: Finset.lt_inf'_iff
code: @[simp]
theorem lt_inf'_iff : a < s.inf' H f ↔ ∀ i ∈ s, a < f i 
goal: a < s.inf' H f ↔ ∀ i ∈ s, a < f i

full_name: Finset.exists_mem_eq_sup'
code: theorem exists_mem_eq_sup' (f : ι → α) : ∃ i, i ∈ s ∧ s.sup' H f = f i 
goal: ∃ i ∈ s, s.sup' H f = f i

full_name: Finset.exists_mem_eq_inf'
code: theorem exists_mem_eq_inf' (f : ι → α) : ∃ i, i ∈ s ∧ s.inf' H f = f i 
goal: ∃ i ∈ s, s.inf' H f = f i

full_name: Finset.exists_mem_eq_sup
code: theorem exists_mem_eq_sup [OrderBot α] (s : Finset ι) (h : s.Nonempty) (f : ι → α) :
    ∃ i, i ∈ s ∧ s.sup f = f i 
goal: ∃ i ∈ s, s.sup f = f i

full_name: Finset.exists_mem_eq_inf
code: theorem exists_mem_eq_inf [OrderTop α] (s : Finset ι) (h : s.Nonempty) (f : ι → α) :
    ∃ i, i ∈ s ∧ s.inf f = f i 
goal: ∃ i ∈ s, s.inf f = f i

full_name: Finset.max
code: /-- Let `s` be a finset in a linear order. Then `s.max` is the maximum of `s` if `s` is not empty,
and `⊥` otherwise. It belongs to `WithBot α`. If you want to get an element of `α`, see
`s.max'`. -/
protected def max (s : Finset α) : WithBot α 
goal: WithBot α

full_name: Finset.max_eq_sup_coe
code: theorem max_eq_sup_coe {s : Finset α} : s.max = s.sup (↑) 
goal: s.max = s.sup WithBot.some

full_name: Finset.max_eq_sup_withBot
code: theorem max_eq_sup_withBot (s : Finset α) : s.max = sup s (↑) 
goal: s.max = s.sup WithBot.some

full_name: Finset.max_empty
code: @[simp]
theorem max_empty : (∅ : Finset α).max = ⊥ 
goal: ∅.max = ⊥

full_name: Finset.max_insert
code: @[simp]
theorem max_insert {a : α} {s : Finset α} : (insert a s).max = max ↑a s.max 
goal: (insert a s).max = max (↑a) s.max

full_name: Finset.max_singleton
code: @[simp]
theorem max_singleton {a : α} : Finset.max {a} = (a : WithBot α) 
goal: {a}.max = ↑a

full_name: Finset.max_of_mem
code: theorem max_of_mem {s : Finset α} {a : α} (h : a ∈ s) : ∃ b : α, s.max = b 
goal: ∃ b, s.max = ↑b

full_name: Finset.max_of_nonempty
code: theorem max_of_nonempty {s : Finset α} (h : s.Nonempty) : ∃ a : α, s.max = a 
goal: ∃ a, s.max = ↑a

full_name: Finset.max_eq_bot
code: theorem max_eq_bot {s : Finset α} : s.max = ⊥ ↔ s = ∅ 
goal: s.max = ⊥ ↔ s = ∅

full_name: Finset.mem_of_max
code: theorem mem_of_max {s : Finset α} : ∀ {a : α}, s.max = a → a ∈ s 
goal: s.max = ↑a → a ∈ s

full_name: Finset.le_max
code: theorem le_max {a : α} {s : Finset α} (as : a ∈ s) : ↑a ≤ s.max 
goal: ↑a ≤ s.max

full_name: Finset.not_mem_of_max_lt_coe
code: theorem not_mem_of_max_lt_coe {a : α} {s : Finset α} (h : s.max < a) : a ∉ s 
goal: a ∉ s

full_name: Finset.le_max_of_eq
code: theorem le_max_of_eq {s : Finset α} {a b : α} (h₁ : a ∈ s) (h₂ : s.max = b) : a ≤ b 
goal: a ≤ b

full_name: Finset.not_mem_of_max_lt
code: theorem not_mem_of_max_lt {s : Finset α} {a b : α} (h₁ : b < a) (h₂ : s.max = ↑b) : a ∉ s 
goal: a ∉ s

full_name: Finset.max_mono
code: @[gcongr]
theorem max_mono {s t : Finset α} (st : s ⊆ t) : s.max ≤ t.max 
goal: s.max ≤ t.max

full_name: Finset.max_le
code: protected theorem max_le {M : WithBot α} {s : Finset α} (st : ∀ a ∈ s, (a : WithBot α) ≤ M) :
    s.max ≤ M 
goal: s.max ≤ M

full_name: Finset.max_le_iff
code: @[simp]
protected lemma max_le_iff {m : WithBot α} {s : Finset α} : s.max ≤ m ↔ ∀ a ∈ s, a ≤ m 
goal: s.max ≤ m ↔ ∀ a ∈ s, ↑a ≤ m

full_name: Finset.max_eq_top
code: @[simp]
protected lemma max_eq_top [OrderTop α] {s : Finset α} : s.max = ⊤ ↔ ⊤ ∈ s 
goal: s.max = ⊤ ↔ ⊤ ∈ s

full_name: Finset.min
code: /-- Let `s` be a finset in a linear order. Then `s.min` is the minimum of `s` if `s` is not empty,
and `⊤` otherwise. It belongs to `WithTop α`. If you want to get an element of `α`, see
`s.min'`. -/
protected def min (s : Finset α) : WithTop α 
goal: WithTop α

full_name: Finset.min_eq_inf_withTop
code: theorem min_eq_inf_withTop (s : Finset α) : s.min = inf s (↑) 
goal: s.min = s.inf WithTop.some

full_name: Finset.min_empty
code: @[simp]
theorem min_empty : (∅ : Finset α).min = ⊤ 
goal: ∅.min = ⊤

full_name: Finset.min_insert
code: @[simp]
theorem min_insert {a : α} {s : Finset α} : (insert a s).min = min (↑a) s.min 
goal: (insert a s).min = min (↑a) s.min

full_name: Finset.min_singleton
code: @[simp]
theorem min_singleton {a : α} : Finset.min {a} = (a : WithTop α) 
goal: {a}.min = ↑a

full_name: Finset.min_of_mem
code: theorem min_of_mem {s : Finset α} {a : α} (h : a ∈ s) : ∃ b : α, s.min = b 
goal: ∃ b, s.min = ↑b

full_name: Finset.min_of_nonempty
code: theorem min_of_nonempty {s : Finset α} (h : s.Nonempty) : ∃ a : α, s.min = a 
goal: ∃ a, s.min = ↑a

full_name: Finset.min_eq_top
code: @[simp]
theorem min_eq_top {s : Finset α} : s.min = ⊤ ↔ s = ∅ 
goal: s.min = ⊤ ↔ s = ∅

full_name: Finset.mem_of_min
code: theorem mem_of_min {s : Finset α} : ∀ {a : α}, s.min = a → a ∈ s 
goal: s.min = ↑a → a ∈ s

full_name: Finset.min_le
code: theorem min_le {a : α} {s : Finset α} (as : a ∈ s) : s.min ≤ a 
goal: s.min ≤ ↑a

full_name: Finset.not_mem_of_coe_lt_min
code: theorem not_mem_of_coe_lt_min {a : α} {s : Finset α} (h : ↑a < s.min) : a ∉ s 
goal: a ∉ s

full_name: Finset.min_le_of_eq
code: theorem min_le_of_eq {s : Finset α} {a b : α} (h₁ : b ∈ s) (h₂ : s.min = a) : a ≤ b 
goal: a ≤ b

full_name: Finset.not_mem_of_lt_min
code: theorem not_mem_of_lt_min {s : Finset α} {a b : α} (h₁ : a < b) (h₂ : s.min = ↑b) : a ∉ s 
goal: a ∉ s

full_name: Finset.min_mono
code: @[gcongr]
theorem min_mono {s t : Finset α} (st : s ⊆ t) : t.min ≤ s.min 
goal: t.min ≤ s.min

full_name: Finset.le_min
code: protected theorem le_min {m : WithTop α} {s : Finset α} (st : ∀ a : α, a ∈ s → m ≤ a) : m ≤ s.min 
goal: m ≤ s.min

full_name: Finset.le_min_iff
code: @[simp]
protected theorem le_min_iff {m : WithTop α} {s : Finset α} : m ≤ s.min ↔ ∀ a ∈ s, m ≤ a 
goal: m ≤ s.min ↔ ∀ a ∈ s, m ≤ ↑a

full_name: Finset.min_eq_bot
code: @[simp]
protected theorem min_eq_bot [OrderBot α] {s : Finset α} : s.min = ⊥ ↔ ⊥ ∈ s 
goal: s.min = ⊥ ↔ ⊥ ∈ s

full_name: Finset.min'
code: /-- Given a nonempty finset `s` in a linear order `α`, then `s.min' h` is its minimum, as an
element of `α`, where `h` is a proof of nonemptiness. Without this assumption, use instead `s.min`,
taking values in `WithTop α`. -/
def min' (s : Finset α) (H : s.Nonempty) : α 
goal: α

full_name: Finset.max'
code: /-- Given a nonempty finset `s` in a linear order `α`, then `s.max' h` is its maximum, as an
element of `α`, where `h` is a proof of nonemptiness. Without this assumption, use instead `s.max`,
taking values in `WithBot α`. -/
def max' (s : Finset α) (H : s.Nonempty) : α 
goal: α

full_name: Finset.min'_mem
code: theorem min'_mem : s.min' H ∈ s 
goal: s.min' H ∈ s

full_name: Finset.min'_le
code: theorem min'_le (x) (H2 : x ∈ s) : s.min' ⟨x, H2⟩ ≤ x 
goal: s.min' ⋯ ≤ x

full_name: Finset.le_min'
code: theorem le_min' (x) (H2 : ∀ y ∈ s, x ≤ y) : x ≤ s.min' H 
goal: x ≤ s.min' H

full_name: Finset.isLeast_min'
code: theorem isLeast_min' : IsLeast (↑s) (s.min' H) 
goal: IsLeast (↑s) (s.min' H)

full_name: Finset.le_min'_iff
code: @[simp]
theorem le_min'_iff {x} : x ≤ s.min' H ↔ ∀ y ∈ s, x ≤ y 
goal: x ≤ s.min' H ↔ ∀ y ∈ s, x ≤ y

full_name: Finset.min'_singleton
code: /-- `{a}.min' _` is `a`. -/
@[simp]
theorem min'_singleton (a : α) : ({a} : Finset α).min' (singleton_nonempty _) = a 
goal: {a}.min' ⋯ = a

full_name: Finset.max'_mem
code: theorem max'_mem : s.max' H ∈ s 
goal: s.max' H ∈ s

full_name: Finset.le_max'
code: theorem le_max' (x) (H2 : x ∈ s) : x ≤ s.max' ⟨x, H2⟩ 
goal: x ≤ s.max' ⋯

full_name: Finset.max'_le
code: theorem max'_le (x) (H2 : ∀ y ∈ s, y ≤ x) : s.max' H ≤ x 
goal: s.max' H ≤ x

full_name: Finset.isGreatest_max'
code: theorem isGreatest_max' : IsGreatest (↑s) (s.max' H) 
goal: IsGreatest (↑s) (s.max' H)

full_name: Finset.max'_le_iff
code: @[simp]
theorem max'_le_iff {x} : s.max' H ≤ x ↔ ∀ y ∈ s, y ≤ x 
goal: s.max' H ≤ x ↔ ∀ y ∈ s, y ≤ x

full_name: Finset.max'_lt_iff
code: @[simp]
theorem max'_lt_iff {x} : s.max' H < x ↔ ∀ y ∈ s, y < x 
goal: s.max' H < x ↔ ∀ y ∈ s, y < x

full_name: Finset.lt_min'_iff
code: @[simp]
theorem lt_min'_iff : x < s.min' H ↔ ∀ y ∈ s, x < y 
goal: x < s.min' H ↔ ∀ y ∈ s, x < y

full_name: Finset.max'_eq_sup'
code: theorem max'_eq_sup' : s.max' H = s.sup' H id 
goal: s.max' H = s.sup' H id

full_name: Finset.min'_eq_inf'
code: theorem min'_eq_inf' : s.min' H = s.inf' H id 
goal: s.min' H = s.inf' H id

full_name: Finset.max'_singleton
code: /-- `{a}.max' _` is `a`. -/
@[simp]
theorem max'_singleton (a : α) : ({a} : Finset α).max' (singleton_nonempty _) = a 
goal: {a}.max' ⋯ = a

full_name: Finset.min'_lt_max'
code: theorem min'_lt_max' {i j} (H1 : i ∈ s) (H2 : j ∈ s) (H3 : i ≠ j) :
    s.min' ⟨i, H1⟩ < s.max' ⟨i, H1⟩ 
goal: s.min' ⋯ < s.max' ⋯

full_name: Finset.min'_lt_max'_of_card
code: /-- If there's more than 1 element, the min' is less than the max'. An alternate version of
`min'_lt_max'` which is sometimes more convenient.
-/
theorem min'_lt_max'_of_card (h₂ : 1 < card s) :
    s.min' (Finset.card_pos.1 <| by omega) < s.max' (Finset.card_pos.1 <| by omega) 
goal: s.min' ⋯ < s.max' ⋯

full_name: Finset.map_ofDual_min
code: theorem map_ofDual_min (s : Finset αᵒᵈ) : s.min.map ofDual = (s.image ofDual).max 
goal: WithTop.map (⇑OrderDual.ofDual) s.min = (Finset.image (⇑OrderDual.ofDual) s).max

full_name: Finset.map_ofDual_max
code: theorem map_ofDual_max (s : Finset αᵒᵈ) : s.max.map ofDual = (s.image ofDual).min 
goal: WithBot.map (⇑OrderDual.ofDual) s.max = (Finset.image (⇑OrderDual.ofDual) s).min

full_name: Finset.map_toDual_min
code: theorem map_toDual_min (s : Finset α) : s.min.map toDual = (s.image toDual).max 
goal: WithTop.map (⇑OrderDual.toDual) s.min = (Finset.image (⇑OrderDual.toDual) s).max

full_name: Finset.map_toDual_max
code: theorem map_toDual_max (s : Finset α) : s.max.map toDual = (s.image toDual).min 
goal: WithBot.map (⇑OrderDual.toDual) s.max = (Finset.image (⇑OrderDual.toDual) s).min

full_name: Finset.ofDual_min'
code: theorem ofDual_min' {s : Finset αᵒᵈ} (hs : s.Nonempty) :
    ofDual (min' s hs) = max' (s.image ofDual) (hs.image _) 
goal: OrderDual.ofDual (s.min' hs) = (Finset.image (⇑OrderDual.ofDual) s).max' ⋯

full_name: Finset.ofDual_max'
code: theorem ofDual_max' {s : Finset αᵒᵈ} (hs : s.Nonempty) :
    ofDual (max' s hs) = min' (s.image ofDual) (hs.image _) 
goal: OrderDual.ofDual (s.max' hs) = (Finset.image (⇑OrderDual.ofDual) s).min' ⋯

full_name: Finset.toDual_min'
code: theorem toDual_min' {s : Finset α} (hs : s.Nonempty) :
    toDual (min' s hs) = max' (s.image toDual) (hs.image _) 
goal: OrderDual.toDual (s.min' hs) = (Finset.image (⇑OrderDual.toDual) s).max' ⋯

full_name: Finset.toDual_max'
code: theorem toDual_max' {s : Finset α} (hs : s.Nonempty) :
    toDual (max' s hs) = min' (s.image toDual) (hs.image _) 
goal: OrderDual.toDual (s.max' hs) = (Finset.image (⇑OrderDual.toDual) s).min' ⋯

full_name: Finset.max'_subset
code: theorem max'_subset {s t : Finset α} (H : s.Nonempty) (hst : s ⊆ t) :
    s.max' H ≤ t.max' (H.mono hst) 
goal: s.max' H ≤ t.max' ⋯

full_name: Finset.min'_subset
code: theorem min'_subset {s t : Finset α} (H : s.Nonempty) (hst : s ⊆ t) :
    t.min' (H.mono hst) ≤ s.min' H 
goal: t.min' ⋯ ≤ s.min' H

full_name: Finset.max'_insert
code: theorem max'_insert (a : α) (s : Finset α) (H : s.Nonempty) :
    (insert a s).max' (s.insert_nonempty a) = max (s.max' H) a 
goal: (insert a s).max' ⋯ = max (s.max' H) a

full_name: Finset.min'_insert
code: theorem min'_insert (a : α) (s : Finset α) (H : s.Nonempty) :
    (insert a s).min' (s.insert_nonempty a) = min (s.min' H) a 
goal: (insert a s).min' ⋯ = min (s.min' H) a

full_name: Finset.lt_max'_of_mem_erase_max'
code: theorem lt_max'_of_mem_erase_max' [DecidableEq α] {a : α} (ha : a ∈ s.erase (s.max' H)) :
    a < s.max' H 
goal: a < s.max' H

full_name: Finset.min'_lt_of_mem_erase_min'
code: theorem min'_lt_of_mem_erase_min' [DecidableEq α] {a : α} (ha : a ∈ s.erase (s.min' H)) :
    s.min' H < a 
goal: s.min' H < a

full_name: Finset.max'_image
code: /-- To rewrite from right to left, use `Monotone.map_finset_max'`. -/
@[simp]
theorem max'_image [LinearOrder β] {f : α → β} (hf : Monotone f) (s : Finset α)
    (h : (s.image f).Nonempty) : (s.image f).max' h = f (s.max' h.of_image) 
goal: (Finset.image f s).max' h = f (s.max' ⋯)

full_name: Monotone.map_finset_max'
code: /-- A version of `Finset.max'_image` with LHS and RHS reversed.
Also, this version assumes that `s` is nonempty, not its image. -/
lemma _root_.Monotone.map_finset_max' [LinearOrder β] {f : α → β} (hf : Monotone f) {s : Finset α}
    (h : s.Nonempty) : f (s.max' h) = (s.image f).max' (h.image f) 
goal: f (s.max' h) = (Finset.image f s).max' ⋯

full_name: Finset.min'_image
code: /-- To rewrite from right to left, use `Monotone.map_finset_min'`. -/
@[simp]
theorem min'_image [LinearOrder β] {f : α → β} (hf : Monotone f) (s : Finset α)
    (h : (s.image f).Nonempty) : (s.image f).min' h = f (s.min' h.of_image) 
goal: (Finset.image f s).min' h = f (s.min' ⋯)

full_name: Monotone.map_finset_min'
code: /-- A version of `Finset.min'_image` with LHS and RHS reversed.
Also, this version assumes that `s` is nonempty, not its image. -/
lemma _root_.Monotone.map_finset_min' [LinearOrder β] {f : α → β} (hf : Monotone f) {s : Finset α}
    (h : s.Nonempty) : f (s.min' h) = (s.image f).min' (h.image f) 
goal: f (s.min' h) = (Finset.image f s).min' ⋯

full_name: Finset.coe_max'
code: theorem coe_max' {s : Finset α} (hs : s.Nonempty) : ↑(s.max' hs) = s.max 
goal: ↑(s.max' hs) = s.max

full_name: Finset.coe_min'
code: theorem coe_min' {s : Finset α} (hs : s.Nonempty) : ↑(s.min' hs) = s.min 
goal: ↑(s.min' hs) = s.min

full_name: Finset.max_mem_image_coe
code: theorem max_mem_image_coe {s : Finset α} (hs : s.Nonempty) :
    s.max ∈ (s.image (↑) : Finset (WithBot α)) 
goal: s.max ∈ Finset.image WithBot.some s

full_name: Finset.min_mem_image_coe
code: theorem min_mem_image_coe {s : Finset α} (hs : s.Nonempty) :
    s.min ∈ (s.image (↑) : Finset (WithTop α)) 
goal: s.min ∈ Finset.image WithTop.some s

full_name: Finset.max_mem_insert_bot_image_coe
code: theorem max_mem_insert_bot_image_coe (s : Finset α) :
    s.max ∈ (insert ⊥ (s.image (↑)) : Finset (WithBot α)) 
goal: s.max ∈ insert ⊥ (Finset.image WithBot.some s)

full_name: Finset.min_mem_insert_top_image_coe
code: theorem min_mem_insert_top_image_coe (s : Finset α) :
    s.min ∈ (insert ⊤ (s.image (↑)) : Finset (WithTop α)) 
goal: s.min ∈ insert ⊤ (Finset.image WithTop.some s)

full_name: Finset.max'_erase_ne_self
code: theorem max'_erase_ne_self {s : Finset α} (s0 : (s.erase x).Nonempty) : (s.erase x).max' s0 ≠ x 
goal: (s.erase x).max' s0 ≠ x

full_name: Finset.min'_erase_ne_self
code: theorem min'_erase_ne_self {s : Finset α} (s0 : (s.erase x).Nonempty) : (s.erase x).min' s0 ≠ x 
goal: (s.erase x).min' s0 ≠ x

full_name: Finset.max_erase_ne_self
code: theorem max_erase_ne_self {s : Finset α} : (s.erase x).max ≠ x 
goal: (s.erase x).max ≠ ↑x

full_name: Finset.min_erase_ne_self
code: theorem min_erase_ne_self {s : Finset α} : (s.erase x).min ≠ x 
goal: (s.erase x).min ≠ ↑x

full_name: Finset.exists_next_right
code: theorem exists_next_right {x : α} {s : Finset α} (h : ∃ y ∈ s, x < y) :
    ∃ y ∈ s, x < y ∧ ∀ z ∈ s, x < z → y ≤ z 
goal: ∃ y ∈ s, x < y ∧ ∀ z ∈ s, x < z → y ≤ z

full_name: Finset.exists_next_left
code: theorem exists_next_left {x : α} {s : Finset α} (h : ∃ y ∈ s, y < x) :
    ∃ y ∈ s, y < x ∧ ∀ z ∈ s, z < x → z ≤ y 
goal: ∃ y ∈ s, y < x ∧ ∀ z ∈ s, z < x → z ≤ y

full_name: Finset.card_le_of_interleaved
code: /-- If finsets `s` and `t` are interleaved, then `Finset.card s ≤ Finset.card t + 1`. -/
theorem card_le_of_interleaved {s t : Finset α}
    (h : ∀ᵉ (x ∈ s) (y ∈ s),
        x < y → (∀ z ∈ s, z ∉ Set.Ioo x y) → ∃ z ∈ t, x < z ∧ z < y) :
    s.card ≤ t.card + 1 
goal: s.card ≤ t.card + 1

full_name: Finset.card_le_diff_of_interleaved
code: /-- If finsets `s` and `t` are interleaved, then `Finset.card s ≤ Finset.card (t \ s) + 1`. -/
theorem card_le_diff_of_interleaved {s t : Finset α}
    (h :
      ∀ᵉ (x ∈ s) (y ∈ s),
        x < y → (∀ z ∈ s, z ∉ Set.Ioo x y) → ∃ z ∈ t, x < z ∧ z < y) :
    s.card ≤ (t \ s).card + 1 
goal: s.card ≤ (t \ s).card + 1

full_name: Finset.induction_on_max
code: /-- Induction principle for `Finset`s in a linearly ordered type: a predicate is true on all
`s : Finset α` provided that:

* it is true on the empty `Finset`,
* for every `s : Finset α` and an element `a` strictly greater than all elements of `s`, `p s`
  implies `p (insert a s)`. -/
@[elab_as_elim]
theorem induction_on_max [DecidableEq α] {p : Finset α → Prop} (s : Finset α) (h0 : p ∅)
    (step : ∀ a s, (∀ x ∈ s, x < a) → p s → p (insert a s)) : p s 
goal: p s

full_name: Finset.induction_on_min
code: /-- Induction principle for `Finset`s in a linearly ordered type: a predicate is true on all
`s : Finset α` provided that:

* it is true on the empty `Finset`,
* for every `s : Finset α` and an element `a` strictly less than all elements of `s`, `p s`
  implies `p (insert a s)`. -/
@[elab_as_elim]
theorem induction_on_min [DecidableEq α] {p : Finset α → Prop} (s : Finset α) (h0 : p ∅)
    (step : ∀ a s, (∀ x ∈ s, a < x) → p s → p (insert a s)) : p s 
goal: p s

full_name: Finset.induction_on_max_value
code: /-- Induction principle for `Finset`s in any type from which a given function `f` maps to a linearly
ordered type : a predicate is true on all `s : Finset α` provided that:

* it is true on the empty `Finset`,
* for every `s : Finset α` and an element `a` such that for elements of `s` denoted by `x` we have
  `f x ≤ f a`, `p s` implies `p (insert a s)`. -/
@[elab_as_elim]
theorem induction_on_max_value [DecidableEq ι] (f : ι → α) {p : Finset ι → Prop} (s : Finset ι)
    (h0 : p ∅) (step : ∀ a s, a ∉ s → (∀ x ∈ s, f x ≤ f a) → p s → p (insert a s)) : p s 
goal: p s

full_name: Finset.induction_on_min_value
code: /-- Induction principle for `Finset`s in any type from which a given function `f` maps to a linearly
ordered type : a predicate is true on all `s : Finset α` provided that:

* it is true on the empty `Finset`,
* for every `s : Finset α` and an element `a` such that for elements of `s` denoted by `x` we have
  `f a ≤ f x`, `p s` implies `p (insert a s)`. -/
@[elab_as_elim]
theorem induction_on_min_value [DecidableEq ι] (f : ι → α) {p : Finset ι → Prop} (s : Finset ι)
    (h0 : p ∅) (step : ∀ a s, a ∉ s → (∀ x ∈ s, f a ≤ f x) → p s → p (insert a s)) : p s 
goal: p s

full_name: Finset.exists_max_image
code: theorem exists_max_image (s : Finset β) (f : β → α) (h : s.Nonempty) :
    ∃ x ∈ s, ∀ x' ∈ s, f x' ≤ f x 
goal: ∃ x ∈ s, ∀ x' ∈ s, f x' ≤ f x

full_name: Finset.exists_min_image
code: theorem exists_min_image (s : Finset β) (f : β → α) (h : s.Nonempty) :
    ∃ x ∈ s, ∀ x' ∈ s, f x ≤ f x' 
goal: ∃ x ∈ s, ∀ x' ∈ s, f x ≤ f x'

full_name: Finset.isGLB_iff_isLeast
code: theorem isGLB_iff_isLeast [LinearOrder α] (i : α) (s : Finset α) (hs : s.Nonempty) :
    IsGLB (s : Set α) i ↔ IsLeast (↑s) i 
goal: IsGLB (↑s) i ↔ IsLeast (↑s) i

full_name: Finset.isLUB_iff_isGreatest
code: theorem isLUB_iff_isGreatest [LinearOrder α] (i : α) (s : Finset α) (hs : s.Nonempty) :
    IsLUB (s : Set α) i ↔ IsGreatest (↑s) i 
goal: IsLUB (↑s) i ↔ IsGreatest (↑s) i

full_name: Finset.isGLB_mem
code: theorem isGLB_mem [LinearOrder α] {i : α} (s : Finset α) (his : IsGLB (s : Set α) i)
    (hs : s.Nonempty) : i ∈ s 
goal: i ∈ s

full_name: Finset.isLUB_mem
code: theorem isLUB_mem [LinearOrder α] {i : α} (s : Finset α) (his : IsLUB (s : Set α) i)
    (hs : s.Nonempty) : i ∈ s 
goal: i ∈ s

full_name: Multiset.map_finset_sup
code: theorem map_finset_sup [DecidableEq α] [DecidableEq β] (s : Finset γ) (f : γ → Multiset β)
    (g : β → α) (hg : Function.Injective g) : map g (s.sup f) = s.sup (map g ∘ f) 
goal: Multiset.map g (s.sup f) = s.sup (Multiset.map g ∘ f)

full_name: Multiset.count_finset_sup
code: theorem count_finset_sup [DecidableEq β] (s : Finset α) (f : α → Multiset β) (b : β) :
    count b (s.sup f) = s.sup fun a => count b (f a) 
goal: Multiset.count b (s.sup f) = s.sup fun a => Multiset.count b (f a)

full_name: Multiset.mem_sup
code: theorem mem_sup {α β} [DecidableEq β] {s : Finset α} {f : α → Multiset β} {x : β} :
    x ∈ s.sup f ↔ ∃ v ∈ s, x ∈ f v 
goal: x ∈ s.sup f ↔ ∃ v ∈ s, x ∈ f v

full_name: Finset.mem_sup
code: theorem mem_sup {α β} [DecidableEq β] {s : Finset α} {f : α → Finset β} {x : β} :
    x ∈ s.sup f ↔ ∃ v ∈ s, x ∈ f v 
goal: x ∈ s.sup f ↔ ∃ v ∈ s, x ∈ f v

full_name: Finset.sup_eq_biUnion
code: theorem sup_eq_biUnion {α β} [DecidableEq β] (s : Finset α) (t : α → Finset β) :
    s.sup t = s.biUnion t 
goal: s.sup t = s.biUnion t

full_name: Finset.sup_singleton''
code: @[simp]
theorem sup_singleton'' [DecidableEq α] (s : Finset β) (f : β → α) :
    (s.sup fun b => {f b}) = s.image f 
goal: (s.sup fun b => {f b}) = Finset.image f s

full_name: Finset.sup_singleton'
code: @[simp]
theorem sup_singleton' [DecidableEq α] (s : Finset α) : s.sup singleton = s 
goal: s.sup singleton = s

full_name: iSup_eq_iSup_finset
code: /-- Supremum of `s i`, `i : ι`, is equal to the supremum over `t : Finset ι` of suprema
`⨆ i ∈ t, s i`. This version assumes `ι` is a `Type*`. See `iSup_eq_iSup_finset'` for a version
that works for `ι : Sort*`. -/
theorem iSup_eq_iSup_finset (s : ι → α) : ⨆ i, s i = ⨆ t : Finset ι, ⨆ i ∈ t, s i 
goal: ⨆ i, s i = ⨆ t, ⨆ i ∈ t, s i

full_name: iSup_eq_iSup_finset'
code: /-- Supremum of `s i`, `i : ι`, is equal to the supremum over `t : Finset ι` of suprema
`⨆ i ∈ t, s i`. This version works for `ι : Sort*`. See `iSup_eq_iSup_finset` for a version
that assumes `ι : Type*` but has no `PLift`s. -/
theorem iSup_eq_iSup_finset' (s : ι' → α) :
    ⨆ i, s i = ⨆ t : Finset (PLift ι'), ⨆ i ∈ t, s (PLift.down i) 
goal: ⨆ i, s i = ⨆ t, ⨆ i ∈ t, s i.down

full_name: iInf_eq_iInf_finset
code: /-- Infimum of `s i`, `i : ι`, is equal to the infimum over `t : Finset ι` of infima
`⨅ i ∈ t, s i`. This version assumes `ι` is a `Type*`. See `iInf_eq_iInf_finset'` for a version
that works for `ι : Sort*`. -/
theorem iInf_eq_iInf_finset (s : ι → α) : ⨅ i, s i = ⨅ (t : Finset ι) (i ∈ t), s i 
goal: ⨅ i, s i = ⨅ t, ⨅ i ∈ t, s i

full_name: iInf_eq_iInf_finset'
code: /-- Infimum of `s i`, `i : ι`, is equal to the infimum over `t : Finset ι` of infima
`⨅ i ∈ t, s i`. This version works for `ι : Sort*`. See `iInf_eq_iInf_finset` for a version
that assumes `ι : Type*` but has no `PLift`s. -/
theorem iInf_eq_iInf_finset' (s : ι' → α) :
    ⨅ i, s i = ⨅ t : Finset (PLift ι'), ⨅ i ∈ t, s (PLift.down i) 
goal: ⨅ i, s i = ⨅ t, ⨅ i ∈ t, s i.down

full_name: Set.iUnion_eq_iUnion_finset
code: /-- Union of an indexed family of sets `s : ι → Set α` is equal to the union of the unions
of finite subfamilies. This version assumes `ι : Type*`. See also `iUnion_eq_iUnion_finset'` for
a version that works for `ι : Sort*`. -/
theorem iUnion_eq_iUnion_finset (s : ι → Set α) : ⋃ i, s i = ⋃ t : Finset ι, ⋃ i ∈ t, s i 
goal: ⋃ i, s i = ⋃ t, ⋃ i ∈ t, s i

full_name: Set.iUnion_eq_iUnion_finset'
code: /-- Union of an indexed family of sets `s : ι → Set α` is equal to the union of the unions
of finite subfamilies. This version works for `ι : Sort*`. See also `iUnion_eq_iUnion_finset` for
a version that assumes `ι : Type*` but avoids `PLift`s in the right hand side. -/
theorem iUnion_eq_iUnion_finset' (s : ι' → Set α) :
    ⋃ i, s i = ⋃ t : Finset (PLift ι'), ⋃ i ∈ t, s (PLift.down i) 
goal: ⋃ i, s i = ⋃ t, ⋃ i ∈ t, s i.down

full_name: Set.iInter_eq_iInter_finset
code: /-- Intersection of an indexed family of sets `s : ι → Set α` is equal to the intersection of the
intersections of finite subfamilies. This version assumes `ι : Type*`. See also
`iInter_eq_iInter_finset'` for a version that works for `ι : Sort*`. -/
theorem iInter_eq_iInter_finset (s : ι → Set α) : ⋂ i, s i = ⋂ t : Finset ι, ⋂ i ∈ t, s i 
goal: ⋂ i, s i = ⋂ t, ⋂ i ∈ t, s i

full_name: Set.iInter_eq_iInter_finset'
code: /-- Intersection of an indexed family of sets `s : ι → Set α` is equal to the intersection of the
intersections of finite subfamilies. This version works for `ι : Sort*`. See also
`iInter_eq_iInter_finset` for a version that assumes `ι : Type*` but avoids `PLift`s in the right
hand side. -/
theorem iInter_eq_iInter_finset' (s : ι' → Set α) :
    ⋂ i, s i = ⋂ t : Finset (PLift ι'), ⋂ i ∈ t, s (PLift.down i) 
goal: ⋂ i, s i = ⋂ t, ⋂ i ∈ t, s i.down

full_name: Finset.mem_maximals_iff_forall_insert
code: theorem mem_maximals_iff_forall_insert (hP : ∀ ⦃s t⦄, P t → s ⊆ t → P s) :
    s ∈ maximals (· ⊆ ·) {t | P t} ↔ P s ∧ ∀ x ∉ s, ¬ P (insert x s) 
goal: s ∈ maximals (fun x x_1 => x ⊆ x_1) {t | P t} ↔ P s ∧ ∀ x ∉ s, ¬P (insert x s)

full_name: Finset.mem_minimals_iff_forall_erase
code: theorem mem_minimals_iff_forall_erase (hP : ∀ ⦃s t⦄, P s → s ⊆ t → P t) :
    s ∈ minimals (· ⊆ ·) {t | P t} ↔ P s ∧ ∀ x ∈ s, ¬ P (s.erase x) 
goal: s ∈ minimals (fun x x_1 => x ⊆ x_1) {t | P t} ↔ P s ∧ ∀ x ∈ s, ¬P (s.erase x)

full_name: Finset.iSup_coe
code: theorem iSup_coe [SupSet β] (f : α → β) (s : Finset α) : ⨆ x ∈ (↑s : Set α), f x = ⨆ x ∈ s, f x 
goal: ⨆ x ∈ ↑s, f x = ⨆ x ∈ s, f x

full_name: Finset.iInf_coe
code: theorem iInf_coe [InfSet β] (f : α → β) (s : Finset α) : ⨅ x ∈ (↑s : Set α), f x = ⨅ x ∈ s, f x 
goal: ⨅ x ∈ ↑s, f x = ⨅ x ∈ s, f x

full_name: Finset.iSup_singleton
code: theorem iSup_singleton (a : α) (s : α → β) : ⨆ x ∈ ({a} : Finset α), s x = s a 
goal: ⨆ x ∈ {a}, s x = s a

full_name: Finset.iInf_singleton
code: theorem iInf_singleton (a : α) (s : α → β) : ⨅ x ∈ ({a} : Finset α), s x = s a 
goal: ⨅ x ∈ {a}, s x = s a

full_name: Finset.iSup_option_toFinset
code: theorem iSup_option_toFinset (o : Option α) (f : α → β) : ⨆ x ∈ o.toFinset, f x = ⨆ x ∈ o, f x 
goal: ⨆ x ∈ o.toFinset, f x = ⨆ x ∈ o, f x

full_name: Finset.iInf_option_toFinset
code: theorem iInf_option_toFinset (o : Option α) (f : α → β) : ⨅ x ∈ o.toFinset, f x = ⨅ x ∈ o, f x 
goal: ⨅ x ∈ o.toFinset, f x = ⨅ x ∈ o, f x

full_name: Finset.iSup_union
code: theorem iSup_union {f : α → β} {s t : Finset α} :
    ⨆ x ∈ s ∪ t, f x = (⨆ x ∈ s, f x) ⊔ ⨆ x ∈ t, f x 
goal: ⨆ x ∈ s ∪ t, f x = (⨆ x ∈ s, f x) ⊔ ⨆ x ∈ t, f x

full_name: Finset.iInf_union
code: theorem iInf_union {f : α → β} {s t : Finset α} :
    ⨅ x ∈ s ∪ t, f x = (⨅ x ∈ s, f x) ⊓ ⨅ x ∈ t, f x 
goal: ⨅ x ∈ s ∪ t, f x = (⨅ x ∈ s, f x) ⊓ ⨅ x ∈ t, f x

full_name: Finset.iSup_insert
code: theorem iSup_insert (a : α) (s : Finset α) (t : α → β) :
    ⨆ x ∈ insert a s, t x = t a ⊔ ⨆ x ∈ s, t x 
goal: ⨆ x ∈ insert a s, t x = t a ⊔ ⨆ x ∈ s, t x

full_name: Finset.iInf_insert
code: theorem iInf_insert (a : α) (s : Finset α) (t : α → β) :
    ⨅ x ∈ insert a s, t x = t a ⊓ ⨅ x ∈ s, t x 
goal: ⨅ x ∈ insert a s, t x = t a ⊓ ⨅ x ∈ s, t x

full_name: Finset.iSup_finset_image
code: theorem iSup_finset_image {f : γ → α} {g : α → β} {s : Finset γ} :
    ⨆ x ∈ s.image f, g x = ⨆ y ∈ s, g (f y) 
goal: ⨆ x ∈ Finset.image f s, g x = ⨆ y ∈ s, g (f y)

full_name: Finset.iInf_finset_image
code: theorem iInf_finset_image {f : γ → α} {g : α → β} {s : Finset γ} :
    ⨅ x ∈ s.image f, g x = ⨅ y ∈ s, g (f y) 
goal: ⨅ x ∈ Finset.image f s, g x = ⨅ y ∈ s, g (f y)

full_name: Finset.iSup_insert_update
code: theorem iSup_insert_update {x : α} {t : Finset α} (f : α → β) {s : β} (hx : x ∉ t) :
    ⨆ i ∈ insert x t, Function.update f x s i = s ⊔ ⨆ i ∈ t, f i 
goal: ⨆ i ∈ insert x t, Function.update f x s i = s ⊔ ⨆ i ∈ t, f i

full_name: Finset.iInf_insert_update
code: theorem iInf_insert_update {x : α} {t : Finset α} (f : α → β) {s : β} (hx : x ∉ t) :
    ⨅ i ∈ insert x t, update f x s i = s ⊓ ⨅ i ∈ t, f i 
goal: ⨅ i ∈ insert x t, Function.update f x s i = s ⊓ ⨅ i ∈ t, f i

full_name: Finset.iSup_biUnion
code: theorem iSup_biUnion (s : Finset γ) (t : γ → Finset α) (f : α → β) :
    ⨆ y ∈ s.biUnion t, f y = ⨆ (x ∈ s) (y ∈ t x), f y 
goal: ⨆ y ∈ s.biUnion t, f y = ⨆ x ∈ s, ⨆ y ∈ t x, f y

full_name: Finset.iInf_biUnion
code: theorem iInf_biUnion (s : Finset γ) (t : γ → Finset α) (f : α → β) :
    ⨅ y ∈ s.biUnion t, f y = ⨅ (x ∈ s) (y ∈ t x), f y 
goal: ⨅ y ∈ s.biUnion t, f y = ⨅ x ∈ s, ⨅ y ∈ t x, f y

full_name: Finset.set_biUnion_coe
code: theorem set_biUnion_coe (s : Finset α) (t : α → Set β) : ⋃ x ∈ (↑s : Set α), t x = ⋃ x ∈ s, t x 
goal: ⋃ x ∈ ↑s, t x = ⋃ x ∈ s, t x

full_name: Finset.set_biInter_coe
code: theorem set_biInter_coe (s : Finset α) (t : α → Set β) : ⋂ x ∈ (↑s : Set α), t x = ⋂ x ∈ s, t x 
goal: ⋂ x ∈ ↑s, t x = ⋂ x ∈ s, t x

full_name: Finset.set_biUnion_singleton
code: theorem set_biUnion_singleton (a : α) (s : α → Set β) : ⋃ x ∈ ({a} : Finset α), s x = s a 
goal: ⋃ x ∈ {a}, s x = s a

full_name: Finset.set_biInter_singleton
code: theorem set_biInter_singleton (a : α) (s : α → Set β) : ⋂ x ∈ ({a} : Finset α), s x = s a 
goal: ⋂ x ∈ {a}, s x = s a

full_name: Finset.set_biUnion_preimage_singleton
code: @[simp]
theorem set_biUnion_preimage_singleton (f : α → β) (s : Finset β) :
    ⋃ y ∈ s, f ⁻¹' {y} = f ⁻¹' s 
goal: ⋃ y ∈ s, f ⁻¹' {y} = f ⁻¹' ↑s

full_name: Finset.set_biUnion_option_toFinset
code: theorem set_biUnion_option_toFinset (o : Option α) (f : α → Set β) :
    ⋃ x ∈ o.toFinset, f x = ⋃ x ∈ o, f x 
goal: ⋃ x ∈ o.toFinset, f x = ⋃ x ∈ o, f x

full_name: Finset.set_biInter_option_toFinset
code: theorem set_biInter_option_toFinset (o : Option α) (f : α → Set β) :
    ⋂ x ∈ o.toFinset, f x = ⋂ x ∈ o, f x 
goal: ⋂ x ∈ o.toFinset, f x = ⋂ x ∈ o, f x

full_name: Finset.subset_set_biUnion_of_mem
code: theorem subset_set_biUnion_of_mem {s : Finset α} {f : α → Set β} {x : α} (h : x ∈ s) :
    f x ⊆ ⋃ y ∈ s, f y 
goal: f x ⊆ ⋃ y ∈ s, f y

full_name: Finset.set_biUnion_union
code: theorem set_biUnion_union (s t : Finset α) (u : α → Set β) :
    ⋃ x ∈ s ∪ t, u x = (⋃ x ∈ s, u x) ∪ ⋃ x ∈ t, u x 
goal: ⋃ x ∈ s ∪ t, u x = (⋃ x ∈ s, u x) ∪ ⋃ x ∈ t, u x

full_name: Finset.set_biInter_inter
code: theorem set_biInter_inter (s t : Finset α) (u : α → Set β) :
    ⋂ x ∈ s ∪ t, u x = (⋂ x ∈ s, u x) ∩ ⋂ x ∈ t, u x 
goal: ⋂ x ∈ s ∪ t, u x = (⋂ x ∈ s, u x) ∩ ⋂ x ∈ t, u x

full_name: Finset.set_biUnion_insert
code: theorem set_biUnion_insert (a : α) (s : Finset α) (t : α → Set β) :
    ⋃ x ∈ insert a s, t x = t a ∪ ⋃ x ∈ s, t x 
goal: ⋃ x ∈ insert a s, t x = t a ∪ ⋃ x ∈ s, t x

full_name: Finset.set_biInter_insert
code: theorem set_biInter_insert (a : α) (s : Finset α) (t : α → Set β) :
    ⋂ x ∈ insert a s, t x = t a ∩ ⋂ x ∈ s, t x 
goal: ⋂ x ∈ insert a s, t x = t a ∩ ⋂ x ∈ s, t x

full_name: Finset.set_biUnion_finset_image
code: theorem set_biUnion_finset_image {f : γ → α} {g : α → Set β} {s : Finset γ} :
    ⋃ x ∈ s.image f, g x = ⋃ y ∈ s, g (f y) 
goal: ⋃ x ∈ Finset.image f s, g x = ⋃ y ∈ s, g (f y)

full_name: Finset.set_biInter_finset_image
code: theorem set_biInter_finset_image {f : γ → α} {g : α → Set β} {s : Finset γ} :
    ⋂ x ∈ s.image f, g x = ⋂ y ∈ s, g (f y) 
goal: ⋂ x ∈ Finset.image f s, g x = ⋂ y ∈ s, g (f y)

full_name: Finset.set_biUnion_insert_update
code: theorem set_biUnion_insert_update {x : α} {t : Finset α} (f : α → Set β) {s : Set β} (hx : x ∉ t) :
    ⋃ i ∈ insert x t, @update _ _ _ f x s i = s ∪ ⋃ i ∈ t, f i 
goal: ⋃ i ∈ insert x t, Function.update f x s i = s ∪ ⋃ i ∈ t, f i

full_name: Finset.set_biInter_insert_update
code: theorem set_biInter_insert_update {x : α} {t : Finset α} (f : α → Set β) {s : Set β} (hx : x ∉ t) :
    ⋂ i ∈ insert x t, @update _ _ _ f x s i = s ∩ ⋂ i ∈ t, f i 
goal: ⋂ i ∈ insert x t, Function.update f x s i = s ∩ ⋂ i ∈ t, f i

full_name: Finset.set_biUnion_biUnion
code: theorem set_biUnion_biUnion (s : Finset γ) (t : γ → Finset α) (f : α → Set β) :
    ⋃ y ∈ s.biUnion t, f y = ⋃ (x ∈ s) (y ∈ t x), f y 
goal: ⋃ y ∈ s.biUnion t, f y = ⋃ x ∈ s, ⋃ y ∈ t x, f y

full_name: Finset.set_biInter_biUnion
code: theorem set_biInter_biUnion (s : Finset γ) (t : γ → Finset α) (f : α → Set β) :
    ⋂ y ∈ s.biUnion t, f y = ⋂ (x ∈ s) (y ∈ t x), f y 
goal: ⋂ y ∈ s.biUnion t, f y = ⋂ x ∈ s, ⋂ y ∈ t x, f y