File: Mathlib/Order/Minimal.lean

full_name: maximals
code: /-- Turns a set into an antichain by keeping only the "maximal" elements. -/
def maximals : Set α 
goal: Set α

full_name: minimals
code: /-- Turns a set into an antichain by keeping only the "minimal" elements. -/
def minimals : Set α 
goal: Set α

full_name: maximals_subset
code: theorem maximals_subset : maximals r s ⊆ s 
goal: maximals r s ⊆ s

full_name: minimals_subset
code: theorem minimals_subset : minimals r s ⊆ s 
goal: minimals r s ⊆ s

full_name: maximals_empty
code: @[simp]
theorem maximals_empty : maximals r ∅ = ∅ 
goal: maximals r ∅ = ∅

full_name: minimals_empty
code: @[simp]
theorem minimals_empty : minimals r ∅ = ∅ 
goal: minimals r ∅ = ∅

full_name: maximals_singleton
code: @[simp]
theorem maximals_singleton : maximals r {a} = {a} 
goal: maximals r {a} = {a}

full_name: minimals_singleton
code: @[simp]
theorem minimals_singleton : minimals r {a} = {a} 
goal: minimals r {a} = {a}

full_name: maximals_swap
code: theorem maximals_swap : maximals (swap r) s = minimals r s 
goal: maximals (Function.swap r) s = minimals r s

full_name: minimals_swap
code: theorem minimals_swap : minimals (swap r) s = maximals r s 
goal: minimals (Function.swap r) s = maximals r s

full_name: mem_minimals_iff_forall_lt_not_mem'
code: /-- This theorem can't be used to rewrite without specifying `rlt`, since `rlt` would have to be
  guessed. See `mem_minimals_iff_forall_ssubset_not_mem` and `mem_minimals_iff_forall_lt_not_mem`
  for `⊆` and `≤` versions.  -/
theorem mem_minimals_iff_forall_lt_not_mem'
    (rlt : α → α → Prop) [IsNonstrictStrictOrder α r rlt] :
    x ∈ minimals r s ↔ x ∈ s ∧ ∀ ⦃y⦄, rlt y x → y ∉ s 
goal: x ∈ minimals r s ↔ x ∈ s ∧ ∀ ⦃y : α⦄, rlt y x → y ∉ s

full_name: mem_maximals_iff_forall_lt_not_mem'
code: theorem mem_maximals_iff_forall_lt_not_mem'
    (rlt : α → α → Prop) [IsNonstrictStrictOrder α r rlt] :
    x ∈ maximals r s ↔ x ∈ s ∧ ∀ ⦃y⦄, rlt x y → y ∉ s 
goal: x ∈ maximals r s ↔ x ∈ s ∧ ∀ ⦃y : α⦄, rlt x y → y ∉ s

full_name: eq_of_mem_maximals
code: theorem eq_of_mem_maximals (ha : a ∈ maximals r s) (hb : b ∈ s) (h : r a b) : a = b 
goal: a = b

full_name: eq_of_mem_minimals
code: theorem eq_of_mem_minimals (ha : a ∈ minimals r s) (hb : b ∈ s) (h : r b a) : a = b 
goal: a = b

full_name: mem_maximals_iff
code: theorem mem_maximals_iff : x ∈ maximals r s ↔ x ∈ s ∧ ∀ ⦃y⦄, y ∈ s → r x y → x = y 
goal: x ∈ maximals r s ↔ x ∈ s ∧ ∀ ⦃y : α⦄, y ∈ s → r x y → x = y

full_name: mem_maximals_setOf_iff
code: theorem mem_maximals_setOf_iff {P : α → Prop} :
    x ∈ maximals r (setOf P) ↔ P x ∧ ∀ ⦃y⦄, P y → r x y → x = y 
goal: x ∈ maximals r (setOf P) ↔ P x ∧ ∀ ⦃y : α⦄, P y → r x y → x = y

full_name: mem_minimals_iff
code: theorem mem_minimals_iff : x ∈ minimals r s ↔ x ∈ s ∧ ∀ ⦃y⦄, y ∈ s → r y x → x = y 
goal: x ∈ minimals r s ↔ x ∈ s ∧ ∀ ⦃y : α⦄, y ∈ s → r y x → x = y

full_name: mem_minimals_setOf_iff
code: theorem mem_minimals_setOf_iff {P : α → Prop} :
    x ∈ minimals r (setOf P) ↔ P x ∧ ∀ ⦃y⦄, P y → r y x → x = y 
goal: x ∈ minimals r (setOf P) ↔ P x ∧ ∀ ⦃y : α⦄, P y → r y x → x = y

full_name: minimals_eq_minimals_of_subset_of_forall
code: theorem minimals_eq_minimals_of_subset_of_forall [IsTrans α r] (hts : t ⊆ s)
    (h : ∀ x ∈ s, ∃ y ∈ t, r y x) : minimals r s = minimals r t 
goal: minimals r s = minimals r t

full_name: maximals_eq_maximals_of_subset_of_forall
code: theorem maximals_eq_maximals_of_subset_of_forall [IsTrans α r] (hts : t ⊆ s)
    (h : ∀ x ∈ s, ∃ y ∈ t, r x y) : maximals r s = maximals r t 
goal: maximals r s = maximals r t

full_name: maximals_antichain
code: theorem maximals_antichain : IsAntichain r (maximals r s) 
goal: IsAntichain r (maximals r s)

full_name: minimals_antichain
code: theorem minimals_antichain : IsAntichain r (minimals r s) 
goal: IsAntichain r (minimals r s)

full_name: mem_minimals_iff_forall_ssubset_not_mem
code: theorem mem_minimals_iff_forall_ssubset_not_mem {x : Set α} (s : Set (Set α)) :
    x ∈ minimals (· ⊆ ·) s ↔ x ∈ s ∧ ∀ ⦃y⦄, y ⊂ x → y ∉ s 
goal: x ∈ minimals (fun x x_1 => x ⊆ x_1) s ↔ x ∈ s ∧ ∀ ⦃y : Set α⦄, y ⊂ x → y ∉ s

full_name: mem_minimals_iff_forall_lt_not_mem
code: theorem mem_minimals_iff_forall_lt_not_mem [Preorder α] {x : α} {s : Set α} :
    x ∈ minimals (· ≤ ·) s ↔ x ∈ s ∧ ∀ ⦃y⦄, y < x → y ∉ s 
goal: x ∈ minimals (fun x x_1 => x ≤ x_1) s ↔ x ∈ s ∧ ∀ ⦃y : α⦄, y < x → y ∉ s

full_name: mem_maximals_iff_forall_ssubset_not_mem
code: theorem mem_maximals_iff_forall_ssubset_not_mem {x : Set α} {s : Set (Set α)} :
    x ∈ maximals (· ⊆ ·) s ↔ x ∈ s ∧ ∀ ⦃y⦄, x ⊂ y → y ∉ s 
goal: x ∈ maximals (fun x x_1 => x ⊆ x_1) s ↔ x ∈ s ∧ ∀ ⦃y : Set α⦄, x ⊂ y → y ∉ s

full_name: mem_maximals_iff_forall_lt_not_mem
code: theorem mem_maximals_iff_forall_lt_not_mem [Preorder α] {x : α} {s : Set α} :
    x ∈ maximals (· ≤ ·) s ↔ x ∈ s ∧ ∀ ⦃y⦄, x < y → y ∉ s 
goal: x ∈ maximals (fun x x_1 => x ≤ x_1) s ↔ x ∈ s ∧ ∀ ⦃y : α⦄, x < y → y ∉ s

full_name: Set.mem_maximals_iff_forall_insert
code: theorem Set.mem_maximals_iff_forall_insert {P : Set α → Prop} (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: Set.mem_minimals_iff_forall_diff_singleton
code: theorem Set.mem_minimals_iff_forall_diff_singleton {P : Set α → Prop}
    (hP : ∀ ⦃s t⦄, P s → s ⊆ t → P t) :
    s ∈ minimals (· ⊆ ·) {t | P t} ↔ P s ∧ ∀ x ∈ s, ¬ P (s \ {x}) 
goal: s ∈ minimals (fun x x_1 => x ⊆ x_1) {t | P t} ↔ P s ∧ ∀ x ∈ s, ¬P (s \ {x})

full_name: maximals_of_symm
code: theorem maximals_of_symm [IsSymm α r] : maximals r s = s 
goal: maximals r s = s

full_name: minimals_of_symm
code: theorem minimals_of_symm [IsSymm α r] : minimals r s = s 
goal: minimals r s = s

full_name: maximals_eq_minimals
code: theorem maximals_eq_minimals [IsSymm α r] : maximals r s = minimals r s 
goal: maximals r s = minimals r s

full_name: Set.Subsingleton.maximals_eq
code: theorem Set.Subsingleton.maximals_eq (h : s.Subsingleton) : maximals r s = s 
goal: maximals r s = s

full_name: Set.Subsingleton.minimals_eq
code: theorem Set.Subsingleton.minimals_eq (h : s.Subsingleton) : minimals r s = s 
goal: minimals r s = s

full_name: maximals_mono
code: theorem maximals_mono [IsAntisymm α r₂] (h : ∀ a b, r₁ a b → r₂ a b) :
    maximals r₂ s ⊆ maximals r₁ s 
goal: maximals r₂ s ⊆ maximals r₁ s

full_name: minimals_mono
code: theorem minimals_mono [IsAntisymm α r₂] (h : ∀ a b, r₁ a b → r₂ a b) :
    minimals r₂ s ⊆ minimals r₁ s 
goal: minimals r₂ s ⊆ minimals r₁ s

full_name: maximals_union
code: theorem maximals_union : maximals r (s ∪ t) ⊆ maximals r s ∪ maximals r t 
goal: maximals r (s ∪ t) ⊆ maximals r s ∪ maximals r t

full_name: minimals_union
code: theorem minimals_union : minimals r (s ∪ t) ⊆ minimals r s ∪ minimals r t 
goal: minimals r (s ∪ t) ⊆ minimals r s ∪ minimals r t

full_name: maximals_inter_subset
code: theorem maximals_inter_subset : maximals r s ∩ t ⊆ maximals r (s ∩ t) 
goal: maximals r s ∩ t ⊆ maximals r (s ∩ t)

full_name: minimals_inter_subset
code: theorem minimals_inter_subset : minimals r s ∩ t ⊆ minimals r (s ∩ t) 
goal: minimals r s ∩ t ⊆ minimals r (s ∩ t)

full_name: inter_maximals_subset
code: theorem inter_maximals_subset : s ∩ maximals r t ⊆ maximals r (s ∩ t) 
goal: s ∩ maximals r t ⊆ maximals r (s ∩ t)

full_name: inter_minimals_subset
code: theorem inter_minimals_subset : s ∩ minimals r t ⊆ minimals r (s ∩ t) 
goal: s ∩ minimals r t ⊆ minimals r (s ∩ t)

full_name: IsAntichain.maximals_eq
code: theorem IsAntichain.maximals_eq (h : IsAntichain r s) : maximals r s = s 
goal: maximals r s = s

full_name: IsAntichain.minimals_eq
code: theorem IsAntichain.minimals_eq (h : IsAntichain r s) : minimals r s = s 
goal: minimals r s = s

full_name: maximals_idem
code: @[simp]
theorem maximals_idem : maximals r (maximals r s) = maximals r s 
goal: maximals r (maximals r s) = maximals r s

full_name: minimals_idem
code: @[simp]
theorem minimals_idem : minimals r (minimals r s) = minimals r s 
goal: minimals r (minimals r s) = minimals r s

full_name: IsAntichain.max_maximals
code: /-- If `maximals r s` is included in but *shadows* the antichain `t`, then it is actually
equal to `t`. -/
theorem IsAntichain.max_maximals (ht : IsAntichain r t) (h : maximals r s ⊆ t)
    (hs : ∀ ⦃a⦄, a ∈ t → ∃ b ∈ maximals r s, r b a) : maximals r s = t 
goal: maximals r s = t

full_name: IsAntichain.max_minimals
code: /-- If `minimals r s` is included in but *shadows* the antichain `t`, then it is actually
equal to `t`. -/
theorem IsAntichain.max_minimals (ht : IsAntichain r t) (h : minimals r s ⊆ t)
    (hs : ∀ ⦃a⦄, a ∈ t → ∃ b ∈ minimals r s, r a b) : minimals r s = t 
goal: minimals r s = t

full_name: IsLeast.mem_minimals
code: theorem IsLeast.mem_minimals [Preorder α] (h : IsLeast s a) : a ∈ minimals (· ≤ ·) s 
goal: a ∈ minimals (fun x x_1 => x ≤ x_1) s

full_name: IsGreatest.mem_maximals
code: theorem IsGreatest.mem_maximals [Preorder α] (h : IsGreatest s a) : a ∈ maximals (· ≤ ·) s 
goal: a ∈ maximals (fun x x_1 => x ≤ x_1) s

full_name: IsLeast.minimals_eq
code: theorem IsLeast.minimals_eq [PartialOrder α] (h : IsLeast s a) : minimals (· ≤ ·) s = {a} 
goal: minimals (fun x x_1 => x ≤ x_1) s = {a}

full_name: IsGreatest.maximals_eq
code: theorem IsGreatest.maximals_eq [PartialOrder α] (h : IsGreatest s a) : maximals (· ≤ ·) s = {a} 
goal: maximals (fun x x_1 => x ≤ x_1) s = {a}

full_name: IsAntichain.minimals_upperClosure
code: theorem IsAntichain.minimals_upperClosure [PartialOrder α] (hs : IsAntichain (· ≤ ·) s) :
    minimals (· ≤ ·) (upperClosure s : Set α) = s 
goal: minimals (fun x x_1 => x ≤ x_1) ↑(upperClosure s) = s

full_name: IsAntichain.maximals_lowerClosure
code: theorem IsAntichain.maximals_lowerClosure [PartialOrder α] (hs : IsAntichain (· ≤ ·) s) :
    maximals (· ≤ ·) (lowerClosure s : Set α) = s 
goal: maximals (fun x x_1 => x ≤ x_1) ↑(lowerClosure s) = s

full_name: map_mem_minimals
code: theorem map_mem_minimals (ha : a ∈ minimals r x) : f a ∈ minimals s (f '' x) 
goal: f a ∈ minimals s (f '' x)

full_name: map_mem_maximals
code: theorem map_mem_maximals (ha : a ∈ maximals r x) : f a ∈ maximals s (f '' x) 
goal: f a ∈ maximals s (f '' x)

full_name: map_mem_minimals_iff
code: theorem map_mem_minimals_iff (ha : a ∈ x) : f a ∈ minimals s (f '' x) ↔ a ∈ minimals r x 
goal: f a ∈ minimals s (f '' x) ↔ a ∈ minimals r x

full_name: map_mem_maximals_iff
code: theorem map_mem_maximals_iff (ha : a ∈ x) : f a ∈ maximals s (f '' x) ↔ a ∈ maximals r x 
goal: f a ∈ maximals s (f '' x) ↔ a ∈ maximals r x

full_name: image_minimals_of_rel_iff_rel
code: theorem image_minimals_of_rel_iff_rel : f '' minimals r x = minimals s (f '' x) 
goal: f '' minimals r x = minimals s (f '' x)

full_name: image_maximals_of_rel_iff_rel
code: theorem image_maximals_of_rel_iff_rel : f '' maximals r x = maximals s (f '' x) 
goal: f '' maximals r x = maximals s (f '' x)

full_name: RelEmbedding.image_minimals_eq
code: theorem RelEmbedding.image_minimals_eq (f : r ↪r s) (x : Set α) :
    f '' minimals r x = minimals s (f '' x) 
goal: ⇑f '' minimals r x = minimals s (⇑f '' x)

full_name: RelEmbedding.image_maximals_eq
code: theorem RelEmbedding.image_maximals_eq (f : r ↪r s) (x : Set α) :
    f '' maximals r x = maximals s (f '' x) 
goal: ⇑f '' maximals r x = maximals s (⇑f '' x)

full_name: image_minimals_univ
code: theorem image_minimals_univ :
    Subtype.val '' minimals (· ≤ ·) (univ : Set s) = minimals (· ≤ ·) s 
goal: Subtype.val '' minimals (fun x x_1 => x ≤ x_1) Set.univ = minimals (fun x x_1 => x ≤ x_1) s

full_name: image_maximals_univ
code: theorem image_maximals_univ :
    Subtype.val '' maximals (· ≤ ·) (univ : Set s) = maximals (· ≤ ·) s 
goal: Subtype.val '' maximals (fun x x_1 => x ≤ x_1) Set.univ = maximals (fun x x_1 => x ≤ x_1) s

full_name: OrderIso.map_mem_minimals
code: nonrec theorem OrderIso.map_mem_minimals (f : s ≃o t) {x : α}
    (hx : x ∈ minimals (· ≤ ·) s) : (f ⟨x, hx.1⟩).val ∈ minimals (· ≤ ·) t 
goal: ↑(f ⟨x, ⋯⟩) ∈ minimals (fun x x_1 => x ≤ x_1) t

full_name: OrderIso.map_mem_maximals
code: theorem OrderIso.map_mem_maximals (f : s ≃o t) {x : α}
    (hx : x ∈ maximals (· ≤ ·) s) : (f ⟨x, hx.1⟩).val ∈ maximals (· ≤ ·) t 
goal: ↑(f ⟨x, ⋯⟩) ∈ maximals (fun x x_1 => x ≤ x_1) t

full_name: OrderIso.mapMinimals
code: /-- If two sets are order isomorphic, their minimals are also order isomorphic. -/
def OrderIso.mapMinimals (f : s ≃o t) : minimals (· ≤ ·) s ≃o minimals (· ≤ ·) t 
goal: ↑(minimals (fun x x_1 => x ≤ x_1) s) ≃o ↑(minimals (fun x x_1 => x ≤ x_1) t)

full_name: OrderIso.mapMaximals
code: /-- If two sets are order isomorphic, their maximals are also order isomorphic. -/
def OrderIso.mapMaximals (f : s ≃o t) : maximals (· ≤ ·) s ≃o maximals (· ≤ ·) t 
goal: ↑(maximals (fun x x_1 => x ≤ x_1) s) ≃o ↑(maximals (fun x x_1 => x ≤ x_1) t)

full_name: OrderIso.minimalsIsoMaximals
code: /-- If two sets are antitonically order isomorphic, their minimals are too. -/
def OrderIso.minimalsIsoMaximals (f : s ≃o tᵒᵈ) :
    minimals (· ≤ ·) s ≃o (maximals (· ≤ ·) t)ᵒᵈ 
goal: ↑(minimals (fun x x_1 => x ≤ x_1) s) ≃o (↑(maximals (fun x x_1 => x ≤ x_1) t))ᵒᵈ

full_name: OrderIso.maximalsIsoMinimals
code: /-- If two sets are antitonically order isomorphic, their minimals are too. -/
def OrderIso.maximalsIsoMinimals (f : s ≃o tᵒᵈ) :
    maximals (· ≤ ·) s ≃o (minimals (· ≤ ·) t)ᵒᵈ 
goal: ↑(maximals (fun x x_1 => x ≤ x_1) s) ≃o (↑(minimals (fun x x_1 => x ≤ x_1) t))ᵒᵈ

full_name: inter_minimals_preimage_inter_eq_of_rel_iff_rel_on
code: theorem inter_minimals_preimage_inter_eq_of_rel_iff_rel_on
    {x : Set α} (hf : ∀ ⦃a a'⦄, a ∈ x → a' ∈ x → (r a a' ↔ s (f a) (f a'))) (y : Set β) :
    x ∩ f ⁻¹' (minimals s ((f '' x) ∩ y)) = minimals r (x ∩ f ⁻¹' y) 
goal: x ∩ f ⁻¹' minimals s (f '' x ∩ y) = minimals r (x ∩ f ⁻¹' y)

full_name: inter_preimage_minimals_eq_of_rel_iff_rel_on_of_subset
code: theorem inter_preimage_minimals_eq_of_rel_iff_rel_on_of_subset {x : Set α} {y : Set β}
    (hf : ∀ ⦃a a'⦄, a ∈ x → a' ∈ x → (r a a' ↔ s (f a) (f a'))) (hy : y ⊆ f '' x) :
    x ∩ f ⁻¹' (minimals s y) = minimals r (x ∩ f ⁻¹' y) 
goal: x ∩ f ⁻¹' minimals s y = minimals r (x ∩ f ⁻¹' y)

full_name: RelEmbedding.inter_preimage_minimals_eq
code: theorem RelEmbedding.inter_preimage_minimals_eq (f : r ↪r s) (x : Set α) (y : Set β) :
    x ∩ f⁻¹' (minimals s ((f '' x) ∩ y)) = minimals r (x ∩ f ⁻¹' y) 
goal: x ∩ ⇑f ⁻¹' minimals s (⇑f '' x ∩ y) = minimals r (x ∩ ⇑f ⁻¹' y)

full_name: RelEmbedding.inter_preimage_minimals_eq_of_subset
code: theorem RelEmbedding.inter_preimage_minimals_eq_of_subset {y : Set β} {x : Set α}
    (f : r ↪r s) (h : y ⊆ f '' x) :
    x ∩ f ⁻¹' (minimals s y) = minimals r (x ∩ f ⁻¹' y) 
goal: x ∩ ⇑f ⁻¹' minimals s y = minimals r (x ∩ ⇑f ⁻¹' y)

full_name: RelEmbedding.minimals_preimage_eq
code: theorem RelEmbedding.minimals_preimage_eq (f : r ↪r s) (y : Set β) :
    minimals r (f ⁻¹' y) = f ⁻¹' minimals s (y ∩ range f) 
goal: minimals r (⇑f ⁻¹' y) = ⇑f ⁻¹' minimals s (y ∩ Set.range ⇑f)

full_name: RelIso.minimals_preimage_eq
code: theorem RelIso.minimals_preimage_eq (f : r ≃r s) (y : Set β) :
    minimals r (f ⁻¹' y) = f ⁻¹' (minimals s y) 
goal: minimals r (⇑f ⁻¹' y) = ⇑f ⁻¹' minimals s y

full_name: RelIso.maximals_preimage_eq
code: theorem RelIso.maximals_preimage_eq (f : r ≃r s) (y : Set β) :
    maximals r (f ⁻¹' y) = f ⁻¹' (maximals s y) 
goal: maximals r (⇑f ⁻¹' y) = ⇑f ⁻¹' maximals s y

full_name: inter_maximals_preimage_inter_eq_of_rel_iff_rel_on
code: theorem inter_maximals_preimage_inter_eq_of_rel_iff_rel_on {x : Set α}
    (hf : ∀ ⦃a a'⦄, a ∈ x → a' ∈ x → (r a a' ↔ s (f a) (f a'))) (y : Set β) :
    x ∩ f ⁻¹' (maximals s ((f '' x) ∩ y)) = maximals r (x ∩ f ⁻¹' y) 
goal: x ∩ f ⁻¹' maximals s (f '' x ∩ y) = maximals r (x ∩ f ⁻¹' y)

full_name: inter_preimage_maximals_eq_of_rel_iff_rel_on_of_subset
code: theorem inter_preimage_maximals_eq_of_rel_iff_rel_on_of_subset {y : Set β} {x : Set α}
    (hf : ∀ ⦃a a'⦄, a ∈ x → a' ∈ x → (r a a' ↔ s (f a) (f a'))) (hy : y ⊆ f '' x) :
    x ∩ f ⁻¹' (maximals s y) = maximals r (x ∩ f ⁻¹' y) 
goal: x ∩ f ⁻¹' maximals s y = maximals r (x ∩ f ⁻¹' y)

full_name: RelEmbedding.inter_preimage_maximals_eq
code: theorem RelEmbedding.inter_preimage_maximals_eq (f : r ↪r s) (x : Set α) (y : Set β) :
    x ∩ f⁻¹' (maximals s ((f '' x) ∩ y)) = maximals r (x ∩ f ⁻¹' y) 
goal: x ∩ ⇑f ⁻¹' maximals s (⇑f '' x ∩ y) = maximals r (x ∩ ⇑f ⁻¹' y)

full_name: RelEmbedding.inter_preimage_maximals_eq_of_subset
code: theorem RelEmbedding.inter_preimage_maximals_eq_of_subset {y : Set β} {x : Set α}
    (f : r ↪r s) (h : y ⊆ f '' x) : x ∩ f ⁻¹' (maximals s y) = maximals r (x ∩ f ⁻¹' y) 
goal: x ∩ ⇑f ⁻¹' maximals s y = maximals r (x ∩ ⇑f ⁻¹' y)

full_name: RelEmbedding.maximals_preimage_eq
code: theorem RelEmbedding.maximals_preimage_eq (f : r ↪r s) (y : Set β) :
    maximals r (f ⁻¹' y) = f ⁻¹' maximals s (y ∩ range f) 
goal: maximals r (⇑f ⁻¹' y) = ⇑f ⁻¹' maximals s (y ∩ Set.range ⇑f)

full_name: maximals_Iic
code: @[simp] theorem maximals_Iic (a : α) : maximals (· ≤ ·) (Iic a) = {a} 
goal: maximals (fun x x_1 => x ≤ x_1) (Set.Iic a) = {a}

full_name: minimals_Ici
code: @[simp] theorem minimals_Ici (a : α) : minimals (· ≤ ·) (Ici a) = {a} 
goal: minimals (fun x x_1 => x ≤ x_1) (Set.Ici a) = {a}

full_name: maximals_Icc
code: theorem maximals_Icc (hab : a ≤ b) : maximals (· ≤ ·) (Icc a b) = {b} 
goal: maximals (fun x x_1 => x ≤ x_1) (Set.Icc a b) = {b}

full_name: minimals_Icc
code: theorem minimals_Icc (hab : a ≤ b) : minimals (· ≤ ·) (Icc a b) = {a} 
goal: minimals (fun x x_1 => x ≤ x_1) (Set.Icc a b) = {a}

full_name: maximals_Ioc
code: theorem maximals_Ioc (hab : a < b) : maximals (· ≤ ·) (Ioc a b) = {b} 
goal: maximals (fun x x_1 => x ≤ x_1) (Set.Ioc a b) = {b}

full_name: minimals_Ico
code: theorem minimals_Ico (hab : a < b) : minimals (· ≤ ·) (Ico a b) = {a} 
goal: minimals (fun x x_1 => x ≤ x_1) (Set.Ico a b) = {a}