File: Mathlib/Order/Interval/Finset/Basic.lean

full_name: Finset.nonempty_Icc
code: @[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem nonempty_Icc : (Icc a b).Nonempty ↔ a ≤ b 
goal: (Finset.Icc a b).Nonempty ↔ a ≤ b

full_name: Finset.nonempty_Ico
code: @[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem nonempty_Ico : (Ico a b).Nonempty ↔ a < b 
goal: (Finset.Ico a b).Nonempty ↔ a < b

full_name: Finset.nonempty_Ioc
code: @[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem nonempty_Ioc : (Ioc a b).Nonempty ↔ a < b 
goal: (Finset.Ioc a b).Nonempty ↔ a < b

full_name: Finset.nonempty_Ioo
code: @[simp]
theorem nonempty_Ioo [DenselyOrdered α] : (Ioo a b).Nonempty ↔ a < b 
goal: (Finset.Ioo a b).Nonempty ↔ a < b

full_name: Finset.Icc_eq_empty_iff
code: @[simp]
theorem Icc_eq_empty_iff : Icc a b = ∅ ↔ ¬a ≤ b 
goal: Finset.Icc a b = ∅ ↔ ¬a ≤ b

full_name: Finset.Ico_eq_empty_iff
code: @[simp]
theorem Ico_eq_empty_iff : Ico a b = ∅ ↔ ¬a < b 
goal: Finset.Ico a b = ∅ ↔ ¬a < b

full_name: Finset.Ioc_eq_empty_iff
code: @[simp]
theorem Ioc_eq_empty_iff : Ioc a b = ∅ ↔ ¬a < b 
goal: Finset.Ioc a b = ∅ ↔ ¬a < b

full_name: Finset.Ioo_eq_empty_iff
code: @[simp]
theorem Ioo_eq_empty_iff [DenselyOrdered α] : Ioo a b = ∅ ↔ ¬a < b 
goal: Finset.Ioo a b = ∅ ↔ ¬a < b

full_name: Finset.Ioo_eq_empty
code: @[simp]
theorem Ioo_eq_empty (h : ¬a < b) : Ioo a b = ∅ 
goal: Finset.Ioo a b = ∅

full_name: Finset.Icc_eq_empty_of_lt
code: @[simp]
theorem Icc_eq_empty_of_lt (h : b < a) : Icc a b = ∅ 
goal: Finset.Icc a b = ∅

full_name: Finset.Ico_eq_empty_of_le
code: @[simp]
theorem Ico_eq_empty_of_le (h : b ≤ a) : Ico a b = ∅ 
goal: Finset.Ico a b = ∅

full_name: Finset.Ioc_eq_empty_of_le
code: @[simp]
theorem Ioc_eq_empty_of_le (h : b ≤ a) : Ioc a b = ∅ 
goal: Finset.Ioc a b = ∅

full_name: Finset.Ioo_eq_empty_of_le
code: @[simp]
theorem Ioo_eq_empty_of_le (h : b ≤ a) : Ioo a b = ∅ 
goal: Finset.Ioo a b = ∅

full_name: Finset.left_mem_Icc
code: theorem left_mem_Icc : a ∈ Icc a b ↔ a ≤ b 
goal: a ∈ Finset.Icc a b ↔ a ≤ b

full_name: Finset.left_mem_Ico
code: theorem left_mem_Ico : a ∈ Ico a b ↔ a < b 
goal: a ∈ Finset.Ico a b ↔ a < b

full_name: Finset.right_mem_Icc
code: theorem right_mem_Icc : b ∈ Icc a b ↔ a ≤ b 
goal: b ∈ Finset.Icc a b ↔ a ≤ b

full_name: Finset.right_mem_Ioc
code: theorem right_mem_Ioc : b ∈ Ioc a b ↔ a < b 
goal: b ∈ Finset.Ioc a b ↔ a < b

full_name: Finset.left_not_mem_Ioc
code: theorem left_not_mem_Ioc : a ∉ Ioc a b 
goal: a ∉ Finset.Ioc a b

full_name: Finset.left_not_mem_Ioo
code: theorem left_not_mem_Ioo : a ∉ Ioo a b 
goal: a ∉ Finset.Ioo a b

full_name: Finset.right_not_mem_Ico
code: theorem right_not_mem_Ico : b ∉ Ico a b 
goal: b ∉ Finset.Ico a b

full_name: Finset.right_not_mem_Ioo
code: theorem right_not_mem_Ioo : b ∉ Ioo a b 
goal: b ∉ Finset.Ioo a b

full_name: Finset.Icc_subset_Icc
code: theorem Icc_subset_Icc (ha : a₂ ≤ a₁) (hb : b₁ ≤ b₂) : Icc a₁ b₁ ⊆ Icc a₂ b₂ 
goal: Finset.Icc a₁ b₁ ⊆ Finset.Icc a₂ b₂

full_name: Finset.Ico_subset_Ico
code: theorem Ico_subset_Ico (ha : a₂ ≤ a₁) (hb : b₁ ≤ b₂) : Ico a₁ b₁ ⊆ Ico a₂ b₂ 
goal: Finset.Ico a₁ b₁ ⊆ Finset.Ico a₂ b₂

full_name: Finset.Ioc_subset_Ioc
code: theorem Ioc_subset_Ioc (ha : a₂ ≤ a₁) (hb : b₁ ≤ b₂) : Ioc a₁ b₁ ⊆ Ioc a₂ b₂ 
goal: Finset.Ioc a₁ b₁ ⊆ Finset.Ioc a₂ b₂

full_name: Finset.Ioo_subset_Ioo
code: theorem Ioo_subset_Ioo (ha : a₂ ≤ a₁) (hb : b₁ ≤ b₂) : Ioo a₁ b₁ ⊆ Ioo a₂ b₂ 
goal: Finset.Ioo a₁ b₁ ⊆ Finset.Ioo a₂ b₂

full_name: Finset.Icc_subset_Icc_left
code: theorem Icc_subset_Icc_left (h : a₁ ≤ a₂) : Icc a₂ b ⊆ Icc a₁ b 
goal: Finset.Icc a₂ b ⊆ Finset.Icc a₁ b

full_name: Finset.Ico_subset_Ico_left
code: theorem Ico_subset_Ico_left (h : a₁ ≤ a₂) : Ico a₂ b ⊆ Ico a₁ b 
goal: Finset.Ico a₂ b ⊆ Finset.Ico a₁ b

full_name: Finset.Ioc_subset_Ioc_left
code: theorem Ioc_subset_Ioc_left (h : a₁ ≤ a₂) : Ioc a₂ b ⊆ Ioc a₁ b 
goal: Finset.Ioc a₂ b ⊆ Finset.Ioc a₁ b

full_name: Finset.Ioo_subset_Ioo_left
code: theorem Ioo_subset_Ioo_left (h : a₁ ≤ a₂) : Ioo a₂ b ⊆ Ioo a₁ b 
goal: Finset.Ioo a₂ b ⊆ Finset.Ioo a₁ b

full_name: Finset.Icc_subset_Icc_right
code: theorem Icc_subset_Icc_right (h : b₁ ≤ b₂) : Icc a b₁ ⊆ Icc a b₂ 
goal: Finset.Icc a b₁ ⊆ Finset.Icc a b₂

full_name: Finset.Ico_subset_Ico_right
code: theorem Ico_subset_Ico_right (h : b₁ ≤ b₂) : Ico a b₁ ⊆ Ico a b₂ 
goal: Finset.Ico a b₁ ⊆ Finset.Ico a b₂

full_name: Finset.Ioc_subset_Ioc_right
code: theorem Ioc_subset_Ioc_right (h : b₁ ≤ b₂) : Ioc a b₁ ⊆ Ioc a b₂ 
goal: Finset.Ioc a b₁ ⊆ Finset.Ioc a b₂

full_name: Finset.Ioo_subset_Ioo_right
code: theorem Ioo_subset_Ioo_right (h : b₁ ≤ b₂) : Ioo a b₁ ⊆ Ioo a b₂ 
goal: Finset.Ioo a b₁ ⊆ Finset.Ioo a b₂

full_name: Finset.Ico_subset_Ioo_left
code: theorem Ico_subset_Ioo_left (h : a₁ < a₂) : Ico a₂ b ⊆ Ioo a₁ b 
goal: Finset.Ico a₂ b ⊆ Finset.Ioo a₁ b

full_name: Finset.Ioc_subset_Ioo_right
code: theorem Ioc_subset_Ioo_right (h : b₁ < b₂) : Ioc a b₁ ⊆ Ioo a b₂ 
goal: Finset.Ioc a b₁ ⊆ Finset.Ioo a b₂

full_name: Finset.Icc_subset_Ico_right
code: theorem Icc_subset_Ico_right (h : b₁ < b₂) : Icc a b₁ ⊆ Ico a b₂ 
goal: Finset.Icc a b₁ ⊆ Finset.Ico a b₂

full_name: Finset.Ioo_subset_Ico_self
code: theorem Ioo_subset_Ico_self : Ioo a b ⊆ Ico a b 
goal: Finset.Ioo a b ⊆ Finset.Ico a b

full_name: Finset.Ioo_subset_Ioc_self
code: theorem Ioo_subset_Ioc_self : Ioo a b ⊆ Ioc a b 
goal: Finset.Ioo a b ⊆ Finset.Ioc a b

full_name: Finset.Ico_subset_Icc_self
code: theorem Ico_subset_Icc_self : Ico a b ⊆ Icc a b 
goal: Finset.Ico a b ⊆ Finset.Icc a b

full_name: Finset.Ioc_subset_Icc_self
code: theorem Ioc_subset_Icc_self : Ioc a b ⊆ Icc a b 
goal: Finset.Ioc a b ⊆ Finset.Icc a b

full_name: Finset.Ioo_subset_Icc_self
code: theorem Ioo_subset_Icc_self : Ioo a b ⊆ Icc a b 
goal: Finset.Ioo a b ⊆ Finset.Icc a b

full_name: Finset.Icc_subset_Icc_iff
code: theorem Icc_subset_Icc_iff (h₁ : a₁ ≤ b₁) : Icc a₁ b₁ ⊆ Icc a₂ b₂ ↔ a₂ ≤ a₁ ∧ b₁ ≤ b₂ 
goal: Finset.Icc a₁ b₁ ⊆ Finset.Icc a₂ b₂ ↔ a₂ ≤ a₁ ∧ b₁ ≤ b₂

full_name: Finset.Icc_subset_Ioo_iff
code: theorem Icc_subset_Ioo_iff (h₁ : a₁ ≤ b₁) : Icc a₁ b₁ ⊆ Ioo a₂ b₂ ↔ a₂ < a₁ ∧ b₁ < b₂ 
goal: Finset.Icc a₁ b₁ ⊆ Finset.Ioo a₂ b₂ ↔ a₂ < a₁ ∧ b₁ < b₂

full_name: Finset.Icc_subset_Ico_iff
code: theorem Icc_subset_Ico_iff (h₁ : a₁ ≤ b₁) : Icc a₁ b₁ ⊆ Ico a₂ b₂ ↔ a₂ ≤ a₁ ∧ b₁ < b₂ 
goal: Finset.Icc a₁ b₁ ⊆ Finset.Ico a₂ b₂ ↔ a₂ ≤ a₁ ∧ b₁ < b₂

full_name: Finset.Icc_subset_Ioc_iff
code: theorem Icc_subset_Ioc_iff (h₁ : a₁ ≤ b₁) : Icc a₁ b₁ ⊆ Ioc a₂ b₂ ↔ a₂ < a₁ ∧ b₁ ≤ b₂ 
goal: Finset.Icc a₁ b₁ ⊆ Finset.Ioc a₂ b₂ ↔ a₂ < a₁ ∧ b₁ ≤ b₂

full_name: Finset.Icc_ssubset_Icc_left
code: theorem Icc_ssubset_Icc_left (hI : a₂ ≤ b₂) (ha : a₂ < a₁) (hb : b₁ ≤ b₂) :
    Icc a₁ b₁ ⊂ Icc a₂ b₂ 
goal: Finset.Icc a₁ b₁ ⊂ Finset.Icc a₂ b₂

full_name: Finset.Icc_ssubset_Icc_right
code: theorem Icc_ssubset_Icc_right (hI : a₂ ≤ b₂) (ha : a₂ ≤ a₁) (hb : b₁ < b₂) :
    Icc a₁ b₁ ⊂ Icc a₂ b₂ 
goal: Finset.Icc a₁ b₁ ⊂ Finset.Icc a₂ b₂

full_name: Finset.Ico_self
code: theorem Ico_self : Ico a a = ∅ 
goal: Finset.Ico a a = ∅

full_name: Finset.Ioc_self
code: theorem Ioc_self : Ioc a a = ∅ 
goal: Finset.Ioc a a = ∅

full_name: Finset.Ioo_self
code: theorem Ioo_self : Ioo a a = ∅ 
goal: Finset.Ioo a a = ∅

full_name: Set.fintypeOfMemBounds
code: /-- A set with upper and lower bounds in a locally finite order is a fintype -/
def _root_.Set.fintypeOfMemBounds {s : Set α} [DecidablePred (· ∈ s)] (ha : a ∈ lowerBounds s)
    (hb : b ∈ upperBounds s) : Fintype s 
goal: Fintype ↑s

full_name: Finset.Ico_filter_lt_of_le_left
code: theorem Ico_filter_lt_of_le_left [DecidablePred (· < c)] (hca : c ≤ a) :
    (Ico a b).filter (· < c) = ∅ 
goal: Finset.filter (fun x => x < c) (Finset.Ico a b) = ∅

full_name: Finset.Ico_filter_lt_of_right_le
code: theorem Ico_filter_lt_of_right_le [DecidablePred (· < c)] (hbc : b ≤ c) :
    (Ico a b).filter (· < c) = Ico a b 
goal: Finset.filter (fun x => x < c) (Finset.Ico a b) = Finset.Ico a b

full_name: Finset.Ico_filter_lt_of_le_right
code: theorem Ico_filter_lt_of_le_right [DecidablePred (· < c)] (hcb : c ≤ b) :
    (Ico a b).filter (· < c) = Ico a c 
goal: Finset.filter (fun x => x < c) (Finset.Ico a b) = Finset.Ico a c

full_name: Finset.Ico_filter_le_of_le_left
code: theorem Ico_filter_le_of_le_left {a b c : α} [DecidablePred (c ≤ ·)] (hca : c ≤ a) :
    (Ico a b).filter (c ≤ ·) = Ico a b 
goal: Finset.filter (fun x => c ≤ x) (Finset.Ico a b) = Finset.Ico a b

full_name: Finset.Ico_filter_le_of_right_le
code: theorem Ico_filter_le_of_right_le {a b : α} [DecidablePred (b ≤ ·)] :
    (Ico a b).filter (b ≤ ·) = ∅ 
goal: Finset.filter (fun x => b ≤ x) (Finset.Ico a b) = ∅

full_name: Finset.Ico_filter_le_of_left_le
code: theorem Ico_filter_le_of_left_le {a b c : α} [DecidablePred (c ≤ ·)] (hac : a ≤ c) :
    (Ico a b).filter (c ≤ ·) = Ico c b 
goal: Finset.filter (fun x => c ≤ x) (Finset.Ico a b) = Finset.Ico c b

full_name: Finset.Icc_filter_lt_of_lt_right
code: theorem Icc_filter_lt_of_lt_right {a b c : α} [DecidablePred (· < c)] (h : b < c) :
    (Icc a b).filter (· < c) = Icc a b 
goal: Finset.filter (fun x => x < c) (Finset.Icc a b) = Finset.Icc a b

full_name: Finset.Ioc_filter_lt_of_lt_right
code: theorem Ioc_filter_lt_of_lt_right {a b c : α} [DecidablePred (· < c)] (h : b < c) :
    (Ioc a b).filter (· < c) = Ioc a b 
goal: Finset.filter (fun x => x < c) (Finset.Ioc a b) = Finset.Ioc a b

full_name: Finset.Iic_filter_lt_of_lt_right
code: theorem Iic_filter_lt_of_lt_right {α} [Preorder α] [LocallyFiniteOrderBot α] {a c : α}
    [DecidablePred (· < c)] (h : a < c) : (Iic a).filter (· < c) = Iic a 
goal: Finset.filter (fun x => x < c) (Finset.Iic a) = Finset.Iic a

full_name: Finset.filter_lt_lt_eq_Ioo
code: theorem filter_lt_lt_eq_Ioo [DecidablePred fun j => a < j ∧ j < b] :
    (univ.filter fun j => a < j ∧ j < b) = Ioo a b 
goal: Finset.filter (fun j => a < j ∧ j < b) Finset.univ = Finset.Ioo a b

full_name: Finset.filter_lt_le_eq_Ioc
code: theorem filter_lt_le_eq_Ioc [DecidablePred fun j => a < j ∧ j ≤ b] :
    (univ.filter fun j => a < j ∧ j ≤ b) = Ioc a b 
goal: Finset.filter (fun j => a < j ∧ j ≤ b) Finset.univ = Finset.Ioc a b

full_name: Finset.filter_le_lt_eq_Ico
code: theorem filter_le_lt_eq_Ico [DecidablePred fun j => a ≤ j ∧ j < b] :
    (univ.filter fun j => a ≤ j ∧ j < b) = Ico a b 
goal: Finset.filter (fun j => a ≤ j ∧ j < b) Finset.univ = Finset.Ico a b

full_name: Finset.filter_le_le_eq_Icc
code: theorem filter_le_le_eq_Icc [DecidablePred fun j => a ≤ j ∧ j ≤ b] :
    (univ.filter fun j => a ≤ j ∧ j ≤ b) = Icc a b 
goal: Finset.filter (fun j => a ≤ j ∧ j ≤ b) Finset.univ = Finset.Icc a b

full_name: Finset.nonempty_Ici
code: @[simp, aesop safe apply (rule_sets := [finsetNonempty])]
lemma nonempty_Ici : (Ici a).Nonempty 
goal: (Finset.Ici a).Nonempty

full_name: Finset.nonempty_Ioi
code: @[simp, aesop safe apply (rule_sets := [finsetNonempty])]
lemma nonempty_Ioi : (Ioi a).Nonempty ↔ ¬ IsMax a 
goal: (Finset.Ioi a).Nonempty ↔ ¬IsMax a

full_name: Finset.Icc_subset_Ici_self
code: theorem Icc_subset_Ici_self : Icc a b ⊆ Ici a 
goal: Finset.Icc a b ⊆ Finset.Ici a

full_name: Finset.Ico_subset_Ici_self
code: theorem Ico_subset_Ici_self : Ico a b ⊆ Ici a 
goal: Finset.Ico a b ⊆ Finset.Ici a

full_name: Finset.Ioc_subset_Ioi_self
code: theorem Ioc_subset_Ioi_self : Ioc a b ⊆ Ioi a 
goal: Finset.Ioc a b ⊆ Finset.Ioi a

full_name: Finset.Ioo_subset_Ioi_self
code: theorem Ioo_subset_Ioi_self : Ioo a b ⊆ Ioi a 
goal: Finset.Ioo a b ⊆ Finset.Ioi a

full_name: Finset.Ioc_subset_Ici_self
code: theorem Ioc_subset_Ici_self : Ioc a b ⊆ Ici a 
goal: Finset.Ioc a b ⊆ Finset.Ici a

full_name: Finset.Ioo_subset_Ici_self
code: theorem Ioo_subset_Ici_self : Ioo a b ⊆ Ici a 
goal: Finset.Ioo a b ⊆ Finset.Ici a

full_name: Finset.nonempty_Iic
code: @[simp] lemma nonempty_Iic : (Iic a).Nonempty 
goal: (Finset.Iic a).Nonempty

full_name: Finset.nonempty_Iio
code: @[simp] lemma nonempty_Iio : (Iio a).Nonempty ↔ ¬ IsMin a 
goal: (Finset.Iio a).Nonempty ↔ ¬IsMin a

full_name: Finset.Icc_subset_Iic_self
code: theorem Icc_subset_Iic_self : Icc a b ⊆ Iic b 
goal: Finset.Icc a b ⊆ Finset.Iic b

full_name: Finset.Ioc_subset_Iic_self
code: theorem Ioc_subset_Iic_self : Ioc a b ⊆ Iic b 
goal: Finset.Ioc a b ⊆ Finset.Iic b

full_name: Finset.Ico_subset_Iio_self
code: theorem Ico_subset_Iio_self : Ico a b ⊆ Iio b 
goal: Finset.Ico a b ⊆ Finset.Iio b

full_name: Finset.Ioo_subset_Iio_self
code: theorem Ioo_subset_Iio_self : Ioo a b ⊆ Iio b 
goal: Finset.Ioo a b ⊆ Finset.Iio b

full_name: Finset.Ico_subset_Iic_self
code: theorem Ico_subset_Iic_self : Ico a b ⊆ Iic b 
goal: Finset.Ico a b ⊆ Finset.Iic b

full_name: Finset.Ioo_subset_Iic_self
code: theorem Ioo_subset_Iic_self : Ioo a b ⊆ Iic b 
goal: Finset.Ioo a b ⊆ Finset.Iic b

full_name: Finset.Ioi_subset_Ici_self
code: theorem Ioi_subset_Ici_self : Ioi a ⊆ Ici a 
goal: Finset.Ioi a ⊆ Finset.Ici a

full_name: BddBelow.finite
code: theorem _root_.BddBelow.finite {s : Set α} (hs : BddBelow s) : s.Finite 
goal: s.Finite

full_name: Set.Infinite.not_bddBelow
code: theorem _root_.Set.Infinite.not_bddBelow {s : Set α} : s.Infinite → ¬BddBelow s 
goal: s.Infinite → ¬BddBelow s

full_name: Finset.filter_lt_eq_Ioi
code: theorem filter_lt_eq_Ioi [DecidablePred (a < ·)] : univ.filter (a < ·) = Ioi a 
goal: Finset.filter (fun x => a < x) Finset.univ = Finset.Ioi a

full_name: Finset.filter_le_eq_Ici
code: theorem filter_le_eq_Ici [DecidablePred (a ≤ ·)] : univ.filter (a ≤ ·) = Ici a 
goal: Finset.filter (fun x => a ≤ x) Finset.univ = Finset.Ici a

full_name: Finset.Iio_subset_Iic_self
code: theorem Iio_subset_Iic_self : Iio a ⊆ Iic a 
goal: Finset.Iio a ⊆ Finset.Iic a

full_name: BddAbove.finite
code: theorem _root_.BddAbove.finite {s : Set α} (hs : BddAbove s) : s.Finite 
goal: s.Finite

full_name: Set.Infinite.not_bddAbove
code: theorem _root_.Set.Infinite.not_bddAbove {s : Set α} : s.Infinite → ¬BddAbove s 
goal: s.Infinite → ¬BddAbove s

full_name: Finset.filter_gt_eq_Iio
code: theorem filter_gt_eq_Iio [DecidablePred (· < a)] : univ.filter (· < a) = Iio a 
goal: Finset.filter (fun x => x < a) Finset.univ = Finset.Iio a

full_name: Finset.filter_ge_eq_Iic
code: theorem filter_ge_eq_Iic [DecidablePred (· ≤ a)] : univ.filter (· ≤ a) = Iic a 
goal: Finset.filter (fun x => x ≤ a) Finset.univ = Finset.Iic a

full_name: Finset.disjoint_Ioi_Iio
code: theorem disjoint_Ioi_Iio (a : α) : Disjoint (Ioi a) (Iio a) 
goal: Disjoint (Finset.Ioi a) (Finset.Iio a)

full_name: Finset.Icc_self
code: @[simp]
theorem Icc_self (a : α) : Icc a a = {a} 
goal: Finset.Icc a a = {a}

full_name: Finset.Icc_eq_singleton_iff
code: @[simp]
theorem Icc_eq_singleton_iff : Icc a b = {c} ↔ a = c ∧ b = c 
goal: Finset.Icc a b = {c} ↔ a = c ∧ b = c

full_name: Finset.Ico_disjoint_Ico_consecutive
code: theorem Ico_disjoint_Ico_consecutive (a b c : α) : Disjoint (Ico a b) (Ico b c) 
goal: Disjoint (Finset.Ico a b) (Finset.Ico b c)

full_name: Finset.Icc_erase_left
code: @[simp]
theorem Icc_erase_left (a b : α) : (Icc a b).erase a = Ioc a b 
goal: (Finset.Icc a b).erase a = Finset.Ioc a b

full_name: Finset.Icc_erase_right
code: @[simp]
theorem Icc_erase_right (a b : α) : (Icc a b).erase b = Ico a b 
goal: (Finset.Icc a b).erase b = Finset.Ico a b

full_name: Finset.Ico_erase_left
code: @[simp]
theorem Ico_erase_left (a b : α) : (Ico a b).erase a = Ioo a b 
goal: (Finset.Ico a b).erase a = Finset.Ioo a b

full_name: Finset.Ioc_erase_right
code: @[simp]
theorem Ioc_erase_right (a b : α) : (Ioc a b).erase b = Ioo a b 
goal: (Finset.Ioc a b).erase b = Finset.Ioo a b

full_name: Finset.Icc_diff_both
code: @[simp]
theorem Icc_diff_both (a b : α) : Icc a b \ {a, b} = Ioo a b 
goal: Finset.Icc a b \ {a, b} = Finset.Ioo a b

full_name: Finset.Ico_insert_right
code: @[simp]
theorem Ico_insert_right (h : a ≤ b) : insert b (Ico a b) = Icc a b 
goal: insert b (Finset.Ico a b) = Finset.Icc a b

full_name: Finset.Ioc_insert_left
code: @[simp]
theorem Ioc_insert_left (h : a ≤ b) : insert a (Ioc a b) = Icc a b 
goal: insert a (Finset.Ioc a b) = Finset.Icc a b

full_name: Finset.Ioo_insert_left
code: @[simp]
theorem Ioo_insert_left (h : a < b) : insert a (Ioo a b) = Ico a b 
goal: insert a (Finset.Ioo a b) = Finset.Ico a b

full_name: Finset.Ioo_insert_right
code: @[simp]
theorem Ioo_insert_right (h : a < b) : insert b (Ioo a b) = Ioc a b 
goal: insert b (Finset.Ioo a b) = Finset.Ioc a b

full_name: Finset.Icc_diff_Ico_self
code: @[simp]
theorem Icc_diff_Ico_self (h : a ≤ b) : Icc a b \ Ico a b = {b} 
goal: Finset.Icc a b \ Finset.Ico a b = {b}

full_name: Finset.Icc_diff_Ioc_self
code: @[simp]
theorem Icc_diff_Ioc_self (h : a ≤ b) : Icc a b \ Ioc a b = {a} 
goal: Finset.Icc a b \ Finset.Ioc a b = {a}

full_name: Finset.Icc_diff_Ioo_self
code: @[simp]
theorem Icc_diff_Ioo_self (h : a ≤ b) : Icc a b \ Ioo a b = {a, b} 
goal: Finset.Icc a b \ Finset.Ioo a b = {a, b}

full_name: Finset.Ico_diff_Ioo_self
code: @[simp]
theorem Ico_diff_Ioo_self (h : a < b) : Ico a b \ Ioo a b = {a} 
goal: Finset.Ico a b \ Finset.Ioo a b = {a}

full_name: Finset.Ioc_diff_Ioo_self
code: @[simp]
theorem Ioc_diff_Ioo_self (h : a < b) : Ioc a b \ Ioo a b = {b} 
goal: Finset.Ioc a b \ Finset.Ioo a b = {b}

full_name: Finset.Ico_inter_Ico_consecutive
code: @[simp]
theorem Ico_inter_Ico_consecutive (a b c : α) : Ico a b ∩ Ico b c = ∅ 
goal: Finset.Ico a b ∩ Finset.Ico b c = ∅

full_name: Finset.Icc_eq_cons_Ico
code: /-- `Finset.cons` version of `Finset.Ico_insert_right`. -/
theorem Icc_eq_cons_Ico (h : a ≤ b) : Icc a b = (Ico a b).cons b right_not_mem_Ico 
goal: Finset.Icc a b = Finset.cons b (Finset.Ico a b) ⋯

full_name: Finset.Icc_eq_cons_Ioc
code: /-- `Finset.cons` version of `Finset.Ioc_insert_left`. -/
theorem Icc_eq_cons_Ioc (h : a ≤ b) : Icc a b = (Ioc a b).cons a left_not_mem_Ioc 
goal: Finset.Icc a b = Finset.cons a (Finset.Ioc a b) ⋯

full_name: Finset.Ioc_eq_cons_Ioo
code: /-- `Finset.cons` version of `Finset.Ioo_insert_right`. -/
theorem Ioc_eq_cons_Ioo (h : a < b) : Ioc a b = (Ioo a b).cons b right_not_mem_Ioo 
goal: Finset.Ioc a b = Finset.cons b (Finset.Ioo a b) ⋯

full_name: Finset.Ico_eq_cons_Ioo
code: /-- `Finset.cons` version of `Finset.Ioo_insert_left`. -/
theorem Ico_eq_cons_Ioo (h : a < b) : Ico a b = (Ioo a b).cons a left_not_mem_Ioo 
goal: Finset.Ico a b = Finset.cons a (Finset.Ioo a b) ⋯

full_name: Finset.Ico_filter_le_left
code: theorem Ico_filter_le_left {a b : α} [DecidablePred (· ≤ a)] (hab : a < b) :
    ((Ico a b).filter fun x => x ≤ a) = {a} 
goal: Finset.filter (fun x => x ≤ a) (Finset.Ico a b) = {a}

full_name: Finset.card_Ico_eq_card_Icc_sub_one
code: theorem card_Ico_eq_card_Icc_sub_one (a b : α) : (Ico a b).card = (Icc a b).card - 1 
goal: (Finset.Ico a b).card = (Finset.Icc a b).card - 1

full_name: Finset.card_Ioc_eq_card_Icc_sub_one
code: theorem card_Ioc_eq_card_Icc_sub_one (a b : α) : (Ioc a b).card = (Icc a b).card - 1 
goal: (Finset.Ioc a b).card = (Finset.Icc a b).card - 1

full_name: Finset.card_Ioo_eq_card_Ico_sub_one
code: theorem card_Ioo_eq_card_Ico_sub_one (a b : α) : (Ioo a b).card = (Ico a b).card - 1 
goal: (Finset.Ioo a b).card = (Finset.Ico a b).card - 1

full_name: Finset.card_Ioo_eq_card_Ioc_sub_one
code: theorem card_Ioo_eq_card_Ioc_sub_one (a b : α) : (Ioo a b).card = (Ioc a b).card - 1 
goal: (Finset.Ioo a b).card = (Finset.Ioc a b).card - 1

full_name: Finset.card_Ioo_eq_card_Icc_sub_two
code: theorem card_Ioo_eq_card_Icc_sub_two (a b : α) : (Ioo a b).card = (Icc a b).card - 2 
goal: (Finset.Ioo a b).card = (Finset.Icc a b).card - 2

full_name: Finset.Ici_erase
code: @[simp]
theorem Ici_erase [DecidableEq α] (a : α) : (Ici a).erase a = Ioi a 
goal: (Finset.Ici a).erase a = Finset.Ioi a

full_name: Finset.Ioi_insert
code: @[simp]
theorem Ioi_insert [DecidableEq α] (a : α) : insert a (Ioi a) = Ici a 
goal: insert a (Finset.Ioi a) = Finset.Ici a

full_name: Finset.not_mem_Ioi_self
code: theorem not_mem_Ioi_self {b : α} : b ∉ Ioi b 
goal: b ∉ Finset.Ioi b

full_name: Finset.Ici_eq_cons_Ioi
code: /-- `Finset.cons` version of `Finset.Ioi_insert`. -/
theorem Ici_eq_cons_Ioi (a : α) : Ici a = (Ioi a).cons a not_mem_Ioi_self 
goal: Finset.Ici a = Finset.cons a (Finset.Ioi a) ⋯

full_name: Finset.card_Ioi_eq_card_Ici_sub_one
code: theorem card_Ioi_eq_card_Ici_sub_one (a : α) : (Ioi a).card = (Ici a).card - 1 
goal: (Finset.Ioi a).card = (Finset.Ici a).card - 1

full_name: Finset.Iic_erase
code: @[simp]
theorem Iic_erase [DecidableEq α] (b : α) : (Iic b).erase b = Iio b 
goal: (Finset.Iic b).erase b = Finset.Iio b

full_name: Finset.Iio_insert
code: @[simp]
theorem Iio_insert [DecidableEq α] (b : α) : insert b (Iio b) = Iic b 
goal: insert b (Finset.Iio b) = Finset.Iic b

full_name: Finset.not_mem_Iio_self
code: theorem not_mem_Iio_self {b : α} : b ∉ Iio b 
goal: b ∉ Finset.Iio b

full_name: Finset.Iic_eq_cons_Iio
code: /-- `Finset.cons` version of `Finset.Iio_insert`. -/
theorem Iic_eq_cons_Iio (b : α) : Iic b = (Iio b).cons b not_mem_Iio_self 
goal: Finset.Iic b = Finset.cons b (Finset.Iio b) ⋯

full_name: Finset.card_Iio_eq_card_Iic_sub_one
code: theorem card_Iio_eq_card_Iic_sub_one (a : α) : (Iio a).card = (Iic a).card - 1 
goal: (Finset.Iio a).card = (Finset.Iic a).card - 1

full_name: Finset.sup'_Iic
code: lemma sup'_Iic (a : α) : (Iic a).sup' nonempty_Iic id = a 
goal: (Finset.Iic a).sup' ⋯ id = a

full_name: Finset.sup_Iic
code: @[simp] lemma sup_Iic [OrderBot α] (a : α) : (Iic a).sup id = a 
goal: (Finset.Iic a).sup id = a

full_name: Finset.inf'_Ici
code: lemma inf'_Ici (a : α) : (Ici a).inf' nonempty_Ici id = a 
goal: (Finset.Ici a).inf' ⋯ id = a

full_name: Finset.inf_Ici
code: @[simp] lemma inf_Ici [OrderTop α] (a : α) : (Ici a).inf id = a 
goal: (Finset.Ici a).inf id = a

full_name: Finset.Ico_subset_Ico_iff
code: theorem Ico_subset_Ico_iff {a₁ b₁ a₂ b₂ : α} (h : a₁ < b₁) :
    Ico a₁ b₁ ⊆ Ico a₂ b₂ ↔ a₂ ≤ a₁ ∧ b₁ ≤ b₂ 
goal: Finset.Ico a₁ b₁ ⊆ Finset.Ico a₂ b₂ ↔ a₂ ≤ a₁ ∧ b₁ ≤ b₂

full_name: Finset.Ico_union_Ico_eq_Ico
code: theorem Ico_union_Ico_eq_Ico {a b c : α} (hab : a ≤ b) (hbc : b ≤ c) :
    Ico a b ∪ Ico b c = Ico a c 
goal: Finset.Ico a b ∪ Finset.Ico b c = Finset.Ico a c

full_name: Finset.Ioc_union_Ioc_eq_Ioc
code: @[simp]
theorem Ioc_union_Ioc_eq_Ioc {a b c : α} (h₁ : a ≤ b) (h₂ : b ≤ c) :
    Ioc a b ∪ Ioc b c = Ioc a c 
goal: Finset.Ioc a b ∪ Finset.Ioc b c = Finset.Ioc a c

full_name: Finset.Ico_subset_Ico_union_Ico
code: theorem Ico_subset_Ico_union_Ico {a b c : α} : Ico a c ⊆ Ico a b ∪ Ico b c 
goal: Finset.Ico a c ⊆ Finset.Ico a b ∪ Finset.Ico b c

full_name: Finset.Ico_union_Ico'
code: theorem Ico_union_Ico' {a b c d : α} (hcb : c ≤ b) (had : a ≤ d) :
    Ico a b ∪ Ico c d = Ico (min a c) (max b d) 
goal: Finset.Ico a b ∪ Finset.Ico c d = Finset.Ico (min a c) (max b d)

full_name: Finset.Ico_union_Ico
code: theorem Ico_union_Ico {a b c d : α} (h₁ : min a b ≤ max c d) (h₂ : min c d ≤ max a b) :
    Ico a b ∪ Ico c d = Ico (min a c) (max b d) 
goal: Finset.Ico a b ∪ Finset.Ico c d = Finset.Ico (min a c) (max b d)

full_name: Finset.Ico_inter_Ico
code: theorem Ico_inter_Ico {a b c d : α} : Ico a b ∩ Ico c d = Ico (max a c) (min b d) 
goal: Finset.Ico a b ∩ Finset.Ico c d = Finset.Ico (max a c) (min b d)

full_name: Finset.Ico_filter_lt
code: @[simp]
theorem Ico_filter_lt (a b c : α) : ((Ico a b).filter fun x => x < c) = Ico a (min b c) 
goal: Finset.filter (fun x => x < c) (Finset.Ico a b) = Finset.Ico a (min b c)

full_name: Finset.Ico_filter_le
code: @[simp]
theorem Ico_filter_le (a b c : α) : ((Ico a b).filter fun x => c ≤ x) = Ico (max a c) b 
goal: Finset.filter (fun x => c ≤ x) (Finset.Ico a b) = Finset.Ico (max a c) b

full_name: Finset.Ioo_filter_lt
code: @[simp]
theorem Ioo_filter_lt (a b c : α) : (Ioo a b).filter (· < c) = Ioo a (min b c) 
goal: Finset.filter (fun x => x < c) (Finset.Ioo a b) = Finset.Ioo a (min b c)

full_name: Finset.Iio_filter_lt
code: @[simp]
theorem Iio_filter_lt {α} [LinearOrder α] [LocallyFiniteOrderBot α] (a b : α) :
    (Iio a).filter (· < b) = Iio (min a b) 
goal: Finset.filter (fun x => x < b) (Finset.Iio a) = Finset.Iio (min a b)

full_name: Finset.Ico_diff_Ico_left
code: @[simp]
theorem Ico_diff_Ico_left (a b c : α) : Ico a b \ Ico a c = Ico (max a c) b 
goal: Finset.Ico a b \ Finset.Ico a c = Finset.Ico (max a c) b

full_name: Finset.Ico_diff_Ico_right
code: @[simp]
theorem Ico_diff_Ico_right (a b c : α) : Ico a b \ Ico c b = Ico a (min b c) 
goal: Finset.Ico a b \ Finset.Ico c b = Finset.Ico a (min b c)

full_name: Set.Infinite.exists_gt
code: theorem _root_.Set.Infinite.exists_gt (hs : s.Infinite) : ∀ a, ∃ b ∈ s, a < b 
goal: ∃ b ∈ s, a < b

full_name: Set.infinite_iff_exists_gt
code: theorem _root_.Set.infinite_iff_exists_gt [Nonempty α] : s.Infinite ↔ ∀ a, ∃ b ∈ s, a < b 
goal: s.Infinite ↔ ∀ (a : α), ∃ b ∈ s, a < b

full_name: Set.Infinite.exists_lt
code: theorem _root_.Set.Infinite.exists_lt (hs : s.Infinite) : ∀ a, ∃ b ∈ s, b < a 
goal: ∃ b ∈ s, b < a

full_name: Set.infinite_iff_exists_lt
code: theorem _root_.Set.infinite_iff_exists_lt [Nonempty α] : s.Infinite ↔ ∀ a, ∃ b ∈ s, b < a 
goal: s.Infinite ↔ ∀ (a : α), ∃ b ∈ s, b < a

full_name: Finset.Ioi_disjUnion_Iio
code: theorem Ioi_disjUnion_Iio (a : α) :
    (Ioi a).disjUnion (Iio a) (disjoint_Ioi_Iio a) = ({a} : Finset α)ᶜ 
goal: (Finset.Ioi a).disjUnion (Finset.Iio a) ⋯ = {a}ᶜ

full_name: Finset.uIcc_toDual
code: theorem uIcc_toDual (a b : α) : [[toDual a, toDual b]] = [[a, b]].map toDual.toEmbedding 
goal: [[OrderDual.toDual a, OrderDual.toDual b]] = Finset.map OrderDual.toDual.toEmbedding [[a, b]]

full_name: Finset.uIcc_of_le
code: @[simp]
theorem uIcc_of_le (h : a ≤ b) : [[a, b]] = Icc a b 
goal: [[a, b]] = Finset.Icc a b

full_name: Finset.uIcc_of_ge
code: @[simp]
theorem uIcc_of_ge (h : b ≤ a) : [[a, b]] = Icc b a 
goal: [[a, b]] = Finset.Icc b a

full_name: Finset.uIcc_comm
code: theorem uIcc_comm (a b : α) : [[a, b]] = [[b, a]] 
goal: [[a, b]] = [[b, a]]

full_name: Finset.uIcc_self
code: theorem uIcc_self : [[a, a]] = {a} 
goal: [[a, a]] = {a}

full_name: Finset.nonempty_uIcc
code: @[simp]
theorem nonempty_uIcc : Finset.Nonempty [[a, b]] 
goal: [[a, b]].Nonempty

full_name: Finset.Icc_subset_uIcc
code: theorem Icc_subset_uIcc : Icc a b ⊆ [[a, b]] 
goal: Finset.Icc a b ⊆ [[a, b]]

full_name: Finset.Icc_subset_uIcc'
code: theorem Icc_subset_uIcc' : Icc b a ⊆ [[a, b]] 
goal: Finset.Icc b a ⊆ [[a, b]]

full_name: Finset.left_mem_uIcc
code: theorem left_mem_uIcc : a ∈ [[a, b]] 
goal: a ∈ [[a, b]]

full_name: Finset.right_mem_uIcc
code: theorem right_mem_uIcc : b ∈ [[a, b]] 
goal: b ∈ [[a, b]]

full_name: Finset.mem_uIcc_of_le
code: theorem mem_uIcc_of_le (ha : a ≤ x) (hb : x ≤ b) : x ∈ [[a, b]] 
goal: x ∈ [[a, b]]

full_name: Finset.mem_uIcc_of_ge
code: theorem mem_uIcc_of_ge (hb : b ≤ x) (ha : x ≤ a) : x ∈ [[a, b]] 
goal: x ∈ [[a, b]]

full_name: Finset.uIcc_subset_uIcc
code: theorem uIcc_subset_uIcc (h₁ : a₁ ∈ [[a₂, b₂]]) (h₂ : b₁ ∈ [[a₂, b₂]]) :
    [[a₁, b₁]] ⊆ [[a₂, b₂]] 
goal: [[a₁, b₁]] ⊆ [[a₂, b₂]]

full_name: Finset.uIcc_subset_Icc
code: theorem uIcc_subset_Icc (ha : a₁ ∈ Icc a₂ b₂) (hb : b₁ ∈ Icc a₂ b₂) : [[a₁, b₁]] ⊆ Icc a₂ b₂ 
goal: [[a₁, b₁]] ⊆ Finset.Icc a₂ b₂

full_name: Finset.uIcc_subset_uIcc_iff_mem
code: theorem uIcc_subset_uIcc_iff_mem : [[a₁, b₁]] ⊆ [[a₂, b₂]] ↔ a₁ ∈ [[a₂, b₂]] ∧ b₁ ∈ [[a₂, b₂]] 
goal: [[a₁, b₁]] ⊆ [[a₂, b₂]] ↔ a₁ ∈ [[a₂, b₂]] ∧ b₁ ∈ [[a₂, b₂]]

full_name: Finset.uIcc_subset_uIcc_iff_le'
code: theorem uIcc_subset_uIcc_iff_le' :
    [[a₁, b₁]] ⊆ [[a₂, b₂]] ↔ a₂ ⊓ b₂ ≤ a₁ ⊓ b₁ ∧ a₁ ⊔ b₁ ≤ a₂ ⊔ b₂ 
goal: [[a₁, b₁]] ⊆ [[a₂, b₂]] ↔ a₂ ⊓ b₂ ≤ a₁ ⊓ b₁ ∧ a₁ ⊔ b₁ ≤ a₂ ⊔ b₂

full_name: Finset.uIcc_subset_uIcc_right
code: theorem uIcc_subset_uIcc_right (h : x ∈ [[a, b]]) : [[x, b]] ⊆ [[a, b]] 
goal: [[x, b]] ⊆ [[a, b]]

full_name: Finset.uIcc_subset_uIcc_left
code: theorem uIcc_subset_uIcc_left (h : x ∈ [[a, b]]) : [[a, x]] ⊆ [[a, b]] 
goal: [[a, x]] ⊆ [[a, b]]

full_name: Finset.eq_of_mem_uIcc_of_mem_uIcc
code: theorem eq_of_mem_uIcc_of_mem_uIcc : a ∈ [[b, c]] → b ∈ [[a, c]] → a = b 
goal: a ∈ [[b, c]] → b ∈ [[a, c]] → a = b

full_name: Finset.eq_of_mem_uIcc_of_mem_uIcc'
code: theorem eq_of_mem_uIcc_of_mem_uIcc' : b ∈ [[a, c]] → c ∈ [[a, b]] → b = c 
goal: b ∈ [[a, c]] → c ∈ [[a, b]] → b = c

full_name: Finset.uIcc_injective_right
code: theorem uIcc_injective_right (a : α) : Injective fun b => [[b, a]] 
goal: Function.Injective fun b => [[b, a]]

full_name: Finset.uIcc_injective_left
code: theorem uIcc_injective_left (a : α) : Injective (uIcc a) 
goal: Function.Injective (Finset.uIcc a)

full_name: Finset.Icc_min_max
code: theorem Icc_min_max : Icc (min a b) (max a b) = [[a, b]] 
goal: Finset.Icc (min a b) (max a b) = [[a, b]]

full_name: Finset.uIcc_of_not_le
code: theorem uIcc_of_not_le (h : ¬a ≤ b) : [[a, b]] = Icc b a 
goal: [[a, b]] = Finset.Icc b a

full_name: Finset.uIcc_of_not_ge
code: theorem uIcc_of_not_ge (h : ¬b ≤ a) : [[a, b]] = Icc a b 
goal: [[a, b]] = Finset.Icc a b

full_name: Finset.uIcc_eq_union
code: theorem uIcc_eq_union : [[a, b]] = Icc a b ∪ Icc b a 
goal: [[a, b]] = Finset.Icc a b ∪ Finset.Icc b a

full_name: Finset.mem_uIcc'
code: theorem mem_uIcc' : a ∈ [[b, c]] ↔ b ≤ a ∧ a ≤ c ∨ c ≤ a ∧ a ≤ b 
goal: a ∈ [[b, c]] ↔ b ≤ a ∧ a ≤ c ∨ c ≤ a ∧ a ≤ b

full_name: Finset.not_mem_uIcc_of_lt
code: theorem not_mem_uIcc_of_lt : c < a → c < b → c ∉ [[a, b]] 
goal: c < a → c < b → c ∉ [[a, b]]

full_name: Finset.not_mem_uIcc_of_gt
code: theorem not_mem_uIcc_of_gt : a < c → b < c → c ∉ [[a, b]] 
goal: a < c → b < c → c ∉ [[a, b]]

full_name: Finset.uIcc_subset_uIcc_iff_le
code: theorem uIcc_subset_uIcc_iff_le :
    [[a₁, b₁]] ⊆ [[a₂, b₂]] ↔ min a₂ b₂ ≤ min a₁ b₁ ∧ max a₁ b₁ ≤ max a₂ b₂ 
goal: [[a₁, b₁]] ⊆ [[a₂, b₂]] ↔ min a₂ b₂ ≤ min a₁ b₁ ∧ max a₁ b₁ ≤ max a₂ b₂

full_name: Finset.uIcc_subset_uIcc_union_uIcc
code: /-- A sort of triangle inequality. -/
theorem uIcc_subset_uIcc_union_uIcc : [[a, c]] ⊆ [[a, b]] ∪ [[b, c]] 
goal: [[a, c]] ⊆ [[a, b]] ∪ [[b, c]]

full_name: transGen_wcovBy_of_le
code: lemma transGen_wcovBy_of_le [Preorder α] [LocallyFiniteOrder α] {x y : α} (hxy : x ≤ y) :
    TransGen (· ⩿ ·) x y 
goal: Relation.TransGen (fun x x_1 => x ⩿ x_1) x y

full_name: le_iff_transGen_wcovBy
code: /-- In a locally finite preorder, `≤` is the transitive closure of `⩿`. -/
lemma le_iff_transGen_wcovBy [Preorder α] [LocallyFiniteOrder α] {x y : α} :
    x ≤ y ↔ TransGen (· ⩿ ·) x y 
goal: x ≤ y ↔ Relation.TransGen (fun x x_1 => x ⩿ x_1) x y

full_name: le_iff_reflTransGen_covBy
code: /-- In a locally finite partial order, `≤` is the reflexive transitive closure of `⋖`. -/
lemma le_iff_reflTransGen_covBy [PartialOrder α] [LocallyFiniteOrder α] {x y : α} :
    x ≤ y ↔ ReflTransGen (· ⋖ ·) x y 
goal: x ≤ y ↔ Relation.ReflTransGen (fun x x_1 => x ⋖ x_1) x y

full_name: transGen_covBy_of_lt
code: lemma transGen_covBy_of_lt [Preorder α] [LocallyFiniteOrder α] {x y : α} (hxy : x < y) :
    TransGen (· ⋖ ·) x y 
goal: Relation.TransGen (fun x x_1 => x ⋖ x_1) x y

full_name: lt_iff_transGen_covBy
code: /-- In a locally finite preorder, `<` is the transitive closure of `⋖`. -/
lemma lt_iff_transGen_covBy [Preorder α] [LocallyFiniteOrder α] {x y : α} :
    x < y ↔ TransGen (· ⋖ ·) x y 
goal: x < y ↔ Relation.TransGen (fun x x_1 => x ⋖ x_1) x y

full_name: monotone_iff_forall_wcovBy
code: /-- A function from a locally finite preorder is monotone if and only if it is monotone when
restricted to pairs satisfying `a ⩿ b`. -/
lemma monotone_iff_forall_wcovBy [Preorder α] [LocallyFiniteOrder α] [Preorder β]
    (f : α → β) : Monotone f ↔ ∀ a b : α, a ⩿ b → f a ≤ f b 
goal: Monotone f ↔ ∀ (a b : α), a ⩿ b → f a ≤ f b

full_name: monotone_iff_forall_covBy
code: /-- A function from a locally finite partial order is monotone if and only if it is monotone when
restricted to pairs satisfying `a ⋖ b`. -/
lemma monotone_iff_forall_covBy [PartialOrder α] [LocallyFiniteOrder α] [Preorder β]
    (f : α → β) : Monotone f ↔ ∀ a b : α, a ⋖ b → f a ≤ f b 
goal: Monotone f ↔ ∀ (a b : α), a ⋖ b → f a ≤ f b

full_name: strictMono_iff_forall_covBy
code: /-- A function from a locally finite preorder is strictly monotone if and only if it is strictly
monotone when restricted to pairs satisfying `a ⋖ b`. -/
lemma strictMono_iff_forall_covBy [Preorder α] [LocallyFiniteOrder α] [Preorder β]
    (f : α → β) : StrictMono f ↔ ∀ a b : α, a ⋖ b → f a < f b 
goal: StrictMono f ↔ ∀ (a b : α), a ⋖ b → f a < f b

full_name: antitone_iff_forall_wcovBy
code: /-- A function from a locally finite preorder is antitone if and only if it is antitone when
restricted to pairs satisfying `a ⩿ b`. -/
lemma antitone_iff_forall_wcovBy [Preorder α] [LocallyFiniteOrder α] [Preorder β]
    (f : α → β) : Antitone f ↔ ∀ a b : α, a ⩿ b → f b ≤ f a 
goal: Antitone f ↔ ∀ (a b : α), a ⩿ b → f b ≤ f a

full_name: antitone_iff_forall_covBy
code: /-- A function from a locally finite partial order is antitone if and only if it is antitone when
restricted to pairs satisfying `a ⋖ b`. -/
lemma antitone_iff_forall_covBy [PartialOrder α] [LocallyFiniteOrder α] [Preorder β]
    (f : α → β) : Antitone f ↔ ∀ a b : α, a ⋖ b → f b ≤ f a 
goal: Antitone f ↔ ∀ (a b : α), a ⋖ b → f b ≤ f a

full_name: strictAnti_iff_forall_covBy
code: /-- A function from a locally finite preorder is strictly antitone if and only if it is strictly
antitone when restricted to pairs satisfying `a ⋖ b`. -/
lemma strictAnti_iff_forall_covBy [Preorder α] [LocallyFiniteOrder α] [Preorder β]
    (f : α → β) : StrictAnti f ↔ ∀ a b : α, a ⋖ b → f b < f a 
goal: StrictAnti f ↔ ∀ (a b : α), a ⋖ b → f b < f a