File: Mathlib/Order/Ideal.lean

full_name: Order.Ideal.directed'
code: /-- An ideal on an order `P` is a subset of `P` that is
  - nonempty
  - upward directed (any pair of elements in the ideal has an upper bound in the ideal)
  - downward closed (any element less than an element of the ideal is in the ideal). -/
structure Ideal (P) [LE P] extends LowerSet P where
  /-- The ideal is nonempty. -/
  nonempty' : carrier.Nonempty
  /-- The ideal is upward directed. -/
  directed' : DirectedOn (· ≤ ·) carrier
goal: DirectedOn (fun x x_1 => x ≤ x_1) self.carrier

full_name: Order.Ideal
code: /-- An ideal on an order `P` is a subset of `P` that is
  - nonempty
  - upward directed (any pair of elements in the ideal has an upper bound in the ideal)
  - downward closed (any element less than an element of the ideal is in the ideal). -/
structure Ideal (P) [LE P] extends LowerSet P where
  /-- The ideal is nonempty. -/
  nonempty' : carrier.Nonempty
  /-- The ideal is upward directed. -/
  directed' : DirectedOn (· ≤ ·) carrier
goal: Type u_2

full_name: Order.Ideal.nonempty'
code: /-- An ideal on an order `P` is a subset of `P` that is
  - nonempty
  - upward directed (any pair of elements in the ideal has an upper bound in the ideal)
  - downward closed (any element less than an element of the ideal is in the ideal). -/
structure Ideal (P) [LE P] extends LowerSet P where
  /-- The ideal is nonempty. -/
  nonempty' : carrier.Nonempty
  /-- The ideal is upward directed. -/
  directed' : DirectedOn (· ≤ ·) carrier
goal: self.carrier.Nonempty

full_name: Order.IsIdeal.Nonempty
code: /-- A subset of a preorder `P` is an ideal if it is
  - nonempty
  - upward directed (any pair of elements in the ideal has an upper bound in the ideal)
  - downward closed (any element less than an element of the ideal is in the ideal). -/
@[mk_iff]
structure IsIdeal {P} [LE P] (I : Set P) : Prop where
  /-- The ideal is downward closed. -/
  IsLowerSet : IsLowerSet I
  /-- The ideal is nonempty. -/
  Nonempty : I.Nonempty
  /-- The ideal is upward directed. -/
  Directed : DirectedOn (· ≤ ·) I
goal: I.Nonempty

full_name: Order.IsIdeal
code: /-- A subset of a preorder `P` is an ideal if it is
  - nonempty
  - upward directed (any pair of elements in the ideal has an upper bound in the ideal)
  - downward closed (any element less than an element of the ideal is in the ideal). -/
@[mk_iff]
structure IsIdeal {P} [LE P] (I : Set P) : Prop where
  /-- The ideal is downward closed. -/
  IsLowerSet : IsLowerSet I
  /-- The ideal is nonempty. -/
  Nonempty : I.Nonempty
  /-- The ideal is upward directed. -/
  Directed : DirectedOn (· ≤ ·) I
goal: Prop

full_name: Order.IsIdeal.IsLowerSet
code: /-- A subset of a preorder `P` is an ideal if it is
  - nonempty
  - upward directed (any pair of elements in the ideal has an upper bound in the ideal)
  - downward closed (any element less than an element of the ideal is in the ideal). -/
@[mk_iff]
structure IsIdeal {P} [LE P] (I : Set P) : Prop where
  /-- The ideal is downward closed. -/
  IsLowerSet : IsLowerSet I
  /-- The ideal is nonempty. -/
  Nonempty : I.Nonempty
  /-- The ideal is upward directed. -/
  Directed : DirectedOn (· ≤ ·) I
goal: IsLowerSet I

full_name: Order.IsIdeal.Directed
code: /-- A subset of a preorder `P` is an ideal if it is
  - nonempty
  - upward directed (any pair of elements in the ideal has an upper bound in the ideal)
  - downward closed (any element less than an element of the ideal is in the ideal). -/
@[mk_iff]
structure IsIdeal {P} [LE P] (I : Set P) : Prop where
  /-- The ideal is downward closed. -/
  IsLowerSet : IsLowerSet I
  /-- The ideal is nonempty. -/
  Nonempty : I.Nonempty
  /-- The ideal is upward directed. -/
  Directed : DirectedOn (· ≤ ·) I
goal: DirectedOn (fun x x_1 => x ≤ x_1) I

full_name: Order.isIdeal_iff
code: /-- A subset of a preorder `P` is an ideal if it is
  - nonempty
  - upward directed (any pair of elements in the ideal has an upper bound in the ideal)
  - downward closed (any element less than an element of the ideal is in the ideal). -/
@[mk_iff]
structure IsIdeal {P} [LE P] (I : Set P) : Prop where
  /-- The ideal is downward closed. -/
  IsLowerSet : IsLowerSet I
  /-- The ideal is nonempty. -/
  Nonempty : I.Nonempty
  /-- The ideal is upward directed. -/
  Directed : DirectedOn (· ≤ ·) I
goal: Order.IsIdeal I ↔ IsLowerSet I ∧ I.Nonempty ∧ DirectedOn (fun x x_1 => x ≤ x_1) I

full_name: Order.IsIdeal.toIdeal
code: /-- Create an element of type `Order.Ideal` from a set satisfying the predicate
`Order.IsIdeal`. -/
def IsIdeal.toIdeal [LE P] {I : Set P} (h : IsIdeal I) : Ideal P 
goal: Order.Ideal P

full_name: Order.Ideal.toLowerSet_injective
code: theorem toLowerSet_injective : Injective (toLowerSet : Ideal P → LowerSet P) 
goal: Function.Injective Order.Ideal.toLowerSet

full_name: Order.Ideal.instSetLike
code: instance : SetLike (Ideal P) P 
goal: SetLike (Order.Ideal P) P

full_name: Order.Ideal.ext
code: @[ext]
theorem ext {s t : Ideal P} : (s : Set P) = t → s = t 
goal: ↑s = ↑t → s = t

full_name: Order.Ideal.carrier_eq_coe
code: @[simp]
theorem carrier_eq_coe (s : Ideal P) : s.carrier = s 
goal: s.carrier = ↑s

full_name: Order.Ideal.coe_toLowerSet
code: @[simp]
theorem coe_toLowerSet (s : Ideal P) : (s.toLowerSet : Set P) = s 
goal: ↑s.toLowerSet = ↑s

full_name: Order.Ideal.lower
code: protected theorem lower (s : Ideal P) : IsLowerSet (s : Set P) 
goal: IsLowerSet ↑s

full_name: Order.Ideal.nonempty
code: protected theorem nonempty (s : Ideal P) : (s : Set P).Nonempty 
goal: (↑s).Nonempty

full_name: Order.Ideal.directed
code: protected theorem directed (s : Ideal P) : DirectedOn (· ≤ ·) (s : Set P) 
goal: DirectedOn (fun x x_1 => x ≤ x_1) ↑s

full_name: Order.Ideal.isIdeal
code: protected theorem isIdeal (s : Ideal P) : IsIdeal (s : Set P) 
goal: Order.IsIdeal ↑s

full_name: Order.Ideal.mem_compl_of_ge
code: theorem mem_compl_of_ge {x y : P} : x ≤ y → x ∈ (I : Set P)ᶜ → y ∈ (I : Set P)ᶜ 
goal: x ≤ y → x ∈ (↑I)ᶜ → y ∈ (↑I)ᶜ

full_name: Order.Ideal.instPartialOrderIdeal
code: /-- The partial ordering by subset inclusion, inherited from `Set P`. -/
instance instPartialOrderIdeal : PartialOrder (Ideal P) 
goal: PartialOrder (Order.Ideal P)

full_name: Order.Ideal.coe_subset_coe
code: theorem coe_subset_coe : (s : Set P) ⊆ t ↔ s ≤ t 
goal: ↑s ⊆ ↑t ↔ s ≤ t

full_name: Order.Ideal.coe_ssubset_coe
code: theorem coe_ssubset_coe : (s : Set P) ⊂ t ↔ s < t 
goal: ↑s ⊂ ↑t ↔ s < t

full_name: Order.Ideal.mem_of_mem_of_le
code: @[trans]
theorem mem_of_mem_of_le {x : P} {I J : Ideal P} : x ∈ I → I ≤ J → x ∈ J 
goal: x ∈ I → I ≤ J → x ∈ J

full_name: Order.Ideal.IsProper
code: /-- A proper ideal is one that is not the whole set.
    Note that the whole set might not be an ideal. -/
@[mk_iff]
class IsProper (I : Ideal P) : Prop where
  /-- This ideal is not the whole set. -/
  ne_univ : (I : Set P) ≠ univ
goal: Prop

full_name: Order.Ideal.isProper_iff
code: /-- A proper ideal is one that is not the whole set.
    Note that the whole set might not be an ideal. -/
@[mk_iff]
class IsProper (I : Ideal P) : Prop where
  /-- This ideal is not the whole set. -/
  ne_univ : (I : Set P) ≠ univ
goal: I.IsProper ↔ ↑I ≠ Set.univ

full_name: Order.Ideal.IsProper.ne_univ
code: /-- A proper ideal is one that is not the whole set.
    Note that the whole set might not be an ideal. -/
@[mk_iff]
class IsProper (I : Ideal P) : Prop where
  /-- This ideal is not the whole set. -/
  ne_univ : (I : Set P) ≠ univ
goal: ↑I ≠ Set.univ

full_name: Order.Ideal.isProper_of_not_mem
code: theorem isProper_of_not_mem {I : Ideal P} {p : P} (nmem : p ∉ I) : IsProper I 
goal: I.IsProper

full_name: Order.Ideal.isMaximal_iff
code: /-- An ideal is maximal if it is maximal in the collection of proper ideals.

Note that `IsCoatom` is less general because ideals only have a top element when `P` is directed
and nonempty. -/
@[mk_iff]
class IsMaximal (I : Ideal P) extends IsProper I : Prop where
  /-- This ideal is maximal in the collection of proper ideals. -/
  maximal_proper : ∀ ⦃J : Ideal P⦄, I < J → (J : Set P) = univ
goal: I.IsMaximal ↔ I.IsProper ∧ ∀ ⦃J : Order.Ideal P⦄, I < J → ↑J = Set.univ

full_name: Order.Ideal.IsMaximal.maximal_proper
code: /-- An ideal is maximal if it is maximal in the collection of proper ideals.

Note that `IsCoatom` is less general because ideals only have a top element when `P` is directed
and nonempty. -/
@[mk_iff]
class IsMaximal (I : Ideal P) extends IsProper I : Prop where
  /-- This ideal is maximal in the collection of proper ideals. -/
  maximal_proper : ∀ ⦃J : Ideal P⦄, I < J → (J : Set P) = univ
goal: I < J → ↑J = Set.univ

full_name: Order.Ideal.IsMaximal
code: /-- An ideal is maximal if it is maximal in the collection of proper ideals.

Note that `IsCoatom` is less general because ideals only have a top element when `P` is directed
and nonempty. -/
@[mk_iff]
class IsMaximal (I : Ideal P) extends IsProper I : Prop where
  /-- This ideal is maximal in the collection of proper ideals. -/
  maximal_proper : ∀ ⦃J : Ideal P⦄, I < J → (J : Set P) = univ
goal: Prop

full_name: Order.Ideal.inter_nonempty
code: theorem inter_nonempty [IsDirected P (· ≥ ·)] (I J : Ideal P) : (I ∩ J : Set P).Nonempty 
goal: (↑I ∩ ↑J).Nonempty

full_name: Order.Ideal.instOrderTop
code: /-- In a directed and nonempty order, the top ideal of a is `univ`. -/
instance : OrderTop (Ideal P) 
goal: OrderTop (Order.Ideal P)

full_name: Order.Ideal.top_toLowerSet
code: @[simp]
theorem top_toLowerSet : (⊤ : Ideal P).toLowerSet = ⊤ 
goal: ⊤.toLowerSet = ⊤

full_name: Order.Ideal.coe_top
code: @[simp]
theorem coe_top : ((⊤ : Ideal P) : Set P) = univ 
goal: ↑⊤ = Set.univ

full_name: Order.Ideal.isProper_of_ne_top
code: theorem isProper_of_ne_top (ne_top : I ≠ ⊤) : IsProper I 
goal: I.IsProper

full_name: Order.Ideal.IsProper.ne_top
code: theorem IsProper.ne_top (_ : IsProper I) : I ≠ ⊤ 
goal: I.IsProper → I ≠ ⊤

full_name: IsCoatom.isProper
code: theorem _root_.IsCoatom.isProper (hI : IsCoatom I) : IsProper I 
goal: I.IsProper

full_name: Order.Ideal.isProper_iff_ne_top
code: theorem isProper_iff_ne_top : IsProper I ↔ I ≠ ⊤ 
goal: I.IsProper ↔ I ≠ ⊤

full_name: Order.Ideal.IsMaximal.isCoatom
code: theorem IsMaximal.isCoatom (_ : IsMaximal I) : IsCoatom I 
goal: I.IsMaximal → IsCoatom I

full_name: Order.Ideal.IsMaximal.isCoatom'
code: theorem IsMaximal.isCoatom' [IsMaximal I] : IsCoatom I 
goal: IsCoatom I

full_name: IsCoatom.isMaximal
code: theorem _root_.IsCoatom.isMaximal (hI : IsCoatom I) : IsMaximal I 
goal: I.IsMaximal

full_name: Order.Ideal.isMaximal_iff_isCoatom
code: theorem isMaximal_iff_isCoatom : IsMaximal I ↔ IsCoatom I 
goal: I.IsMaximal ↔ IsCoatom I

full_name: Order.Ideal.bot_mem
code: @[simp]
theorem bot_mem (s : Ideal P) : ⊥ ∈ s 
goal: ⊥ ∈ s

full_name: Order.Ideal.top_of_top_mem
code: theorem top_of_top_mem (h : ⊤ ∈ I) : I = ⊤ 
goal: I = ⊤

full_name: Order.Ideal.IsProper.top_not_mem
code: theorem IsProper.top_not_mem (hI : IsProper I) : ⊤ ∉ I 
goal: ⊤ ∉ I

full_name: Order.Ideal.principal
code: /-- The smallest ideal containing a given element. -/
@[simps]
def principal (p : P) : Ideal P 
goal: Order.Ideal P

full_name: Order.Ideal.principal_toLowerSet
code: /-- The smallest ideal containing a given element. -/
@[simps]
def principal (p : P) : Ideal P 
goal: (Order.Ideal.principal p).toLowerSet = LowerSet.Iic p

full_name: Order.Ideal.instInhabited
code: instance [Inhabited P] : Inhabited (Ideal P) 
goal: Inhabited (Order.Ideal P)

full_name: Order.Ideal.principal_le_iff
code: @[simp]
theorem principal_le_iff : principal x ≤ I ↔ x ∈ I 
goal: Order.Ideal.principal x ≤ I ↔ x ∈ I

full_name: Order.Ideal.mem_principal
code: @[simp]
theorem mem_principal : x ∈ principal y ↔ x ≤ y 
goal: x ∈ Order.Ideal.principal y ↔ x ≤ y

full_name: Order.Ideal.mem_principal_self
code: lemma mem_principal_self : x ∈ principal x 
goal: x ∈ Order.Ideal.principal x

full_name: Order.Ideal.instOrderBot
code: /-- There is a bottom ideal when `P` has a bottom element. -/
instance : OrderBot (Ideal P) 
goal: OrderBot (Order.Ideal P)

full_name: Order.Ideal.principal_bot
code: @[simp]
theorem principal_bot : principal (⊥ : P) = ⊥ 
goal: Order.Ideal.principal ⊥ = ⊥

full_name: Order.Ideal.principal_top
code: @[simp]
theorem principal_top : principal (⊤ : P) = ⊤ 
goal: Order.Ideal.principal ⊤ = ⊤

full_name: Order.Ideal.sup_mem
code: /-- A specific witness of `I.directed` when `P` has joins. -/
theorem sup_mem (hx : x ∈ s) (hy : y ∈ s) : x ⊔ y ∈ s 
goal: x ⊔ y ∈ s

full_name: Order.Ideal.sup_mem_iff
code: @[simp]
theorem sup_mem_iff : x ⊔ y ∈ I ↔ x ∈ I ∧ y ∈ I 
goal: x ⊔ y ∈ I ↔ x ∈ I ∧ y ∈ I

full_name: Order.Ideal.instInf
code: /-- The infimum of two ideals of a co-directed order is their intersection. -/
instance : Inf (Ideal P) 
goal: Inf (Order.Ideal P)

full_name: Order.Ideal.instSup
code: /-- The supremum of two ideals of a co-directed order is the union of the down sets of the pointwise
supremum of `I` and `J`. -/
instance : Sup (Ideal P) 
goal: Sup (Order.Ideal P)

full_name: Order.Ideal.instLattice
code: instance : Lattice (Ideal P) 
goal: Lattice (Order.Ideal P)

full_name: Order.Ideal.coe_sup
code: @[simp]
theorem coe_sup : ↑(s ⊔ t) = { x | ∃ a ∈ s, ∃ b ∈ t, x ≤ a ⊔ b } 
goal: ↑(s ⊔ t) = {x | ∃ a ∈ s, ∃ b ∈ t, x ≤ a ⊔ b}

full_name: Order.Ideal.coe_inf
code: @[simp]
theorem coe_inf : (↑(s ⊓ t) : Set P) = ↑s ∩ ↑t 
goal: ↑(s ⊓ t) = ↑s ∩ ↑t

full_name: Order.Ideal.mem_inf
code: @[simp]
theorem mem_inf : x ∈ I ⊓ J ↔ x ∈ I ∧ x ∈ J 
goal: x ∈ I ⊓ J ↔ x ∈ I ∧ x ∈ J

full_name: Order.Ideal.mem_sup
code: @[simp]
theorem mem_sup : x ∈ I ⊔ J ↔ ∃ i ∈ I, ∃ j ∈ J, x ≤ i ⊔ j 
goal: x ∈ I ⊔ J ↔ ∃ i ∈ I, ∃ j ∈ J, x ≤ i ⊔ j

full_name: Order.Ideal.lt_sup_principal_of_not_mem
code: theorem lt_sup_principal_of_not_mem (hx : x ∉ I) : I < I ⊔ principal x 
goal: I < I ⊔ Order.Ideal.principal x

full_name: Order.Ideal.instInfSet
code: instance : InfSet (Ideal P) 
goal: InfSet (Order.Ideal P)

full_name: Order.Ideal.coe_sInf
code: @[simp]
theorem coe_sInf : (↑(sInf S) : Set P) = ⋂ s ∈ S, ↑s 
goal: ↑(sInf S) = ⋂ s ∈ S, ↑s

full_name: Order.Ideal.mem_sInf
code: @[simp]
theorem mem_sInf : x ∈ sInf S ↔ ∀ s ∈ S, x ∈ s 
goal: x ∈ sInf S ↔ ∀ s ∈ S, x ∈ s

full_name: Order.Ideal.instCompleteLattice
code: instance : CompleteLattice (Ideal P) 
goal: CompleteLattice (Order.Ideal P)

full_name: Order.Ideal.eq_sup_of_le_sup
code: theorem eq_sup_of_le_sup {x i j : P} (hi : i ∈ I) (hj : j ∈ J) (hx : x ≤ i ⊔ j) :
    ∃ i' ∈ I, ∃ j' ∈ J, x = i' ⊔ j' 
goal: ∃ i' ∈ I, ∃ j' ∈ J, x = i' ⊔ j'

full_name: Order.Ideal.coe_sup_eq
code: theorem coe_sup_eq : ↑(I ⊔ J) = { x | ∃ i ∈ I, ∃ j ∈ J, x = i ⊔ j } 
goal: ↑(I ⊔ J) = {x | ∃ i ∈ I, ∃ j ∈ J, x = i ⊔ j}

full_name: Order.Ideal.IsProper.not_mem_of_compl_mem
code: theorem IsProper.not_mem_of_compl_mem (hI : IsProper I) (hxc : xᶜ ∈ I) : x ∉ I 
goal: x ∉ I

full_name: Order.Ideal.IsProper.not_mem_or_compl_not_mem
code: theorem IsProper.not_mem_or_compl_not_mem (hI : IsProper I) : x ∉ I ∨ xᶜ ∉ I 
goal: x ∉ I ∨ xᶜ ∉ I

full_name: Order.Cofinal.mem_gt
code: /-- For a preorder `P`, `Cofinal P` is the type of subsets of `P`
  containing arbitrarily large elements. They are the dense sets in
  the topology whose open sets are terminal segments. -/
structure Cofinal (P) [Preorder P] where
  /-- The carrier of a `Cofinal` is the underlying set. -/
  carrier : Set P
  /-- The `Cofinal` contains arbitrarily large elements. -/
  mem_gt : ∀ x : P, ∃ y ∈ carrier, x ≤ y
goal: ∃ y ∈ self.carrier, x ≤ y

full_name: Order.Cofinal.carrier
code: /-- For a preorder `P`, `Cofinal P` is the type of subsets of `P`
  containing arbitrarily large elements. They are the dense sets in
  the topology whose open sets are terminal segments. -/
structure Cofinal (P) [Preorder P] where
  /-- The carrier of a `Cofinal` is the underlying set. -/
  carrier : Set P
  /-- The `Cofinal` contains arbitrarily large elements. -/
  mem_gt : ∀ x : P, ∃ y ∈ carrier, x ≤ y
goal: Set P

full_name: Order.Cofinal
code: /-- For a preorder `P`, `Cofinal P` is the type of subsets of `P`
  containing arbitrarily large elements. They are the dense sets in
  the topology whose open sets are terminal segments. -/
structure Cofinal (P) [Preorder P] where
  /-- The carrier of a `Cofinal` is the underlying set. -/
  carrier : Set P
  /-- The `Cofinal` contains arbitrarily large elements. -/
  mem_gt : ∀ x : P, ∃ y ∈ carrier, x ≤ y
goal: Type u_2

full_name: Order.Cofinal.instInhabited
code: instance : Inhabited (Cofinal P) 
goal: Inhabited (Order.Cofinal P)

full_name: Order.Cofinal.instMembership
code: instance : Membership P (Cofinal P) 
goal: Membership P (Order.Cofinal P)

full_name: Order.Cofinal.above
code: /-- A (noncomputable) element of a cofinal set lying above a given element. -/
noncomputable def above : P 
goal: P

full_name: Order.Cofinal.above_mem
code: theorem above_mem : D.above x ∈ D 
goal: D.above x ∈ D

full_name: Order.Cofinal.le_above
code: theorem le_above : x ≤ D.above x 
goal: x ≤ D.above x

full_name: Order.sequenceOfCofinals
code: /-- Given a starting point, and a countable family of cofinal sets,
  this is an increasing sequence that intersects each cofinal set. -/
noncomputable def sequenceOfCofinals : ℕ → P
  
goal: ℕ → P

full_name: Order.sequenceOfCofinals.monotone
code: theorem sequenceOfCofinals.monotone : Monotone (sequenceOfCofinals p 𝒟) 
goal: Monotone (Order.sequenceOfCofinals p 𝒟)

full_name: Order.sequenceOfCofinals.encode_mem
code: theorem sequenceOfCofinals.encode_mem (i : ι) :
    sequenceOfCofinals p 𝒟 (Encodable.encode i + 1) ∈ 𝒟 i 
goal: Order.sequenceOfCofinals p 𝒟 (Encodable.encode i + 1) ∈ 𝒟 i

full_name: Order.idealOfCofinals
code: /-- Given an element `p : P` and a family `𝒟` of cofinal subsets of a preorder `P`,
  indexed by a countable type, `idealOfCofinals p 𝒟` is an ideal in `P` which
  - contains `p`, according to `mem_idealOfCofinals p 𝒟`, and
  - intersects every set in `𝒟`, according to `cofinal_meets_idealOfCofinals p 𝒟`.

  This proves the Rasiowa–Sikorski lemma. -/
def idealOfCofinals : Ideal P 
goal: Order.Ideal P

full_name: Order.mem_idealOfCofinals
code: theorem mem_idealOfCofinals : p ∈ idealOfCofinals p 𝒟 
goal: p ∈ Order.idealOfCofinals p 𝒟

full_name: Order.cofinal_meets_idealOfCofinals
code: /-- `idealOfCofinals p 𝒟` is `𝒟`-generic. -/
theorem cofinal_meets_idealOfCofinals (i : ι) : ∃ x : P, x ∈ 𝒟 i ∧ x ∈ idealOfCofinals p 𝒟 
goal: ∃ x ∈ 𝒟 i, x ∈ Order.idealOfCofinals p 𝒟

full_name: Order.isIdeal_sUnion_of_directedOn
code: /-- A non-empty directed union of ideals of sets in a preorder is an ideal. -/
lemma isIdeal_sUnion_of_directedOn {C : Set (Set P)} (hidl : ∀ I ∈ C, IsIdeal I)
    (hD : DirectedOn (· ⊆ ·) C) (hNe : C.Nonempty) : IsIdeal C.sUnion 
goal: Order.IsIdeal (⋃₀ C)

full_name: Order.isIdeal_sUnion_of_isChain
code: /-- A union of a nonempty chain of ideals of sets is an ideal. -/
lemma isIdeal_sUnion_of_isChain {C : Set (Set P)} (hidl : ∀ I ∈ C, IsIdeal I)
    (hC : IsChain (· ⊆ ·) C) (hNe : C.Nonempty) : IsIdeal C.sUnion 
goal: Order.IsIdeal (⋃₀ C)