File: Mathlib/Order/UpperLower/Basic.lean

full_name: IsUpperSet
code: /-- An upper set in an order `α` is a set such that any element greater than one of its members is
also a member. Also called up-set, upward-closed set. -/
@[aesop norm unfold]
def IsUpperSet (s : Set α) : Prop 
goal: Prop

full_name: IsLowerSet
code: /-- A lower set in an order `α` is a set such that any element less than one of its members is also
a member. Also called down-set, downward-closed set. -/
@[aesop norm unfold]
def IsLowerSet (s : Set α) : Prop 
goal: Prop

full_name: isUpperSet_empty
code: theorem isUpperSet_empty : IsUpperSet (∅ : Set α) 
goal: IsUpperSet ∅

full_name: isLowerSet_empty
code: theorem isLowerSet_empty : IsLowerSet (∅ : Set α) 
goal: IsLowerSet ∅

full_name: isUpperSet_univ
code: theorem isUpperSet_univ : IsUpperSet (univ : Set α) 
goal: IsUpperSet Set.univ

full_name: isLowerSet_univ
code: theorem isLowerSet_univ : IsLowerSet (univ : Set α) 
goal: IsLowerSet Set.univ

full_name: IsUpperSet.compl
code: theorem IsUpperSet.compl (hs : IsUpperSet s) : IsLowerSet sᶜ 
goal: IsLowerSet sᶜ

full_name: IsLowerSet.compl
code: theorem IsLowerSet.compl (hs : IsLowerSet s) : IsUpperSet sᶜ 
goal: IsUpperSet sᶜ

full_name: isUpperSet_compl
code: @[simp]
theorem isUpperSet_compl : IsUpperSet sᶜ ↔ IsLowerSet s 
goal: IsUpperSet sᶜ ↔ IsLowerSet s

full_name: isLowerSet_compl
code: @[simp]
theorem isLowerSet_compl : IsLowerSet sᶜ ↔ IsUpperSet s 
goal: IsLowerSet sᶜ ↔ IsUpperSet s

full_name: IsUpperSet.union
code: theorem IsUpperSet.union (hs : IsUpperSet s) (ht : IsUpperSet t) : IsUpperSet (s ∪ t) 
goal: IsUpperSet (s ∪ t)

full_name: IsLowerSet.union
code: theorem IsLowerSet.union (hs : IsLowerSet s) (ht : IsLowerSet t) : IsLowerSet (s ∪ t) 
goal: IsLowerSet (s ∪ t)

full_name: IsUpperSet.inter
code: theorem IsUpperSet.inter (hs : IsUpperSet s) (ht : IsUpperSet t) : IsUpperSet (s ∩ t) 
goal: IsUpperSet (s ∩ t)

full_name: IsLowerSet.inter
code: theorem IsLowerSet.inter (hs : IsLowerSet s) (ht : IsLowerSet t) : IsLowerSet (s ∩ t) 
goal: IsLowerSet (s ∩ t)

full_name: isUpperSet_sUnion
code: theorem isUpperSet_sUnion {S : Set (Set α)} (hf : ∀ s ∈ S, IsUpperSet s) : IsUpperSet (⋃₀ S) 
goal: IsUpperSet (⋃₀ S)

full_name: isLowerSet_sUnion
code: theorem isLowerSet_sUnion {S : Set (Set α)} (hf : ∀ s ∈ S, IsLowerSet s) : IsLowerSet (⋃₀ S) 
goal: IsLowerSet (⋃₀ S)

full_name: isUpperSet_iUnion
code: theorem isUpperSet_iUnion {f : ι → Set α} (hf : ∀ i, IsUpperSet (f i)) : IsUpperSet (⋃ i, f i) 
goal: IsUpperSet (⋃ i, f i)

full_name: isLowerSet_iUnion
code: theorem isLowerSet_iUnion {f : ι → Set α} (hf : ∀ i, IsLowerSet (f i)) : IsLowerSet (⋃ i, f i) 
goal: IsLowerSet (⋃ i, f i)

full_name: isUpperSet_iUnion₂
code: theorem isUpperSet_iUnion₂ {f : ∀ i, κ i → Set α} (hf : ∀ i j, IsUpperSet (f i j)) :
    IsUpperSet (⋃ (i) (j), f i j) 
goal: IsUpperSet (⋃ i, ⋃ j, f i j)

full_name: isLowerSet_iUnion₂
code: theorem isLowerSet_iUnion₂ {f : ∀ i, κ i → Set α} (hf : ∀ i j, IsLowerSet (f i j)) :
    IsLowerSet (⋃ (i) (j), f i j) 
goal: IsLowerSet (⋃ i, ⋃ j, f i j)

full_name: isUpperSet_sInter
code: theorem isUpperSet_sInter {S : Set (Set α)} (hf : ∀ s ∈ S, IsUpperSet s) : IsUpperSet (⋂₀ S) 
goal: IsUpperSet (⋂₀ S)

full_name: isLowerSet_sInter
code: theorem isLowerSet_sInter {S : Set (Set α)} (hf : ∀ s ∈ S, IsLowerSet s) : IsLowerSet (⋂₀ S) 
goal: IsLowerSet (⋂₀ S)

full_name: isUpperSet_iInter
code: theorem isUpperSet_iInter {f : ι → Set α} (hf : ∀ i, IsUpperSet (f i)) : IsUpperSet (⋂ i, f i) 
goal: IsUpperSet (⋂ i, f i)

full_name: isLowerSet_iInter
code: theorem isLowerSet_iInter {f : ι → Set α} (hf : ∀ i, IsLowerSet (f i)) : IsLowerSet (⋂ i, f i) 
goal: IsLowerSet (⋂ i, f i)

full_name: isUpperSet_iInter₂
code: theorem isUpperSet_iInter₂ {f : ∀ i, κ i → Set α} (hf : ∀ i j, IsUpperSet (f i j)) :
    IsUpperSet (⋂ (i) (j), f i j) 
goal: IsUpperSet (⋂ i, ⋂ j, f i j)

full_name: isLowerSet_iInter₂
code: theorem isLowerSet_iInter₂ {f : ∀ i, κ i → Set α} (hf : ∀ i j, IsLowerSet (f i j)) :
    IsLowerSet (⋂ (i) (j), f i j) 
goal: IsLowerSet (⋂ i, ⋂ j, f i j)

full_name: isLowerSet_preimage_ofDual_iff
code: @[simp]
theorem isLowerSet_preimage_ofDual_iff : IsLowerSet (ofDual ⁻¹' s) ↔ IsUpperSet s 
goal: IsLowerSet (⇑OrderDual.ofDual ⁻¹' s) ↔ IsUpperSet s

full_name: isUpperSet_preimage_ofDual_iff
code: @[simp]
theorem isUpperSet_preimage_ofDual_iff : IsUpperSet (ofDual ⁻¹' s) ↔ IsLowerSet s 
goal: IsUpperSet (⇑OrderDual.ofDual ⁻¹' s) ↔ IsLowerSet s

full_name: isLowerSet_preimage_toDual_iff
code: @[simp]
theorem isLowerSet_preimage_toDual_iff {s : Set αᵒᵈ} : IsLowerSet (toDual ⁻¹' s) ↔ IsUpperSet s 
goal: IsLowerSet (⇑OrderDual.toDual ⁻¹' s) ↔ IsUpperSet s

full_name: isUpperSet_preimage_toDual_iff
code: @[simp]
theorem isUpperSet_preimage_toDual_iff {s : Set αᵒᵈ} : IsUpperSet (toDual ⁻¹' s) ↔ IsLowerSet s 
goal: IsUpperSet (⇑OrderDual.toDual ⁻¹' s) ↔ IsLowerSet s

full_name: IsUpperSet.isLowerSet_preimage_coe
code: lemma IsUpperSet.isLowerSet_preimage_coe (hs : IsUpperSet s) :
    IsLowerSet ((↑) ⁻¹' t : Set s) ↔ ∀ b ∈ s, ∀ c ∈ t, b ≤ c → b ∈ t 
goal: IsLowerSet (Subtype.val ⁻¹' t) ↔ ∀ b ∈ s, ∀ c ∈ t, b ≤ c → b ∈ t

full_name: IsLowerSet.isUpperSet_preimage_coe
code: lemma IsLowerSet.isUpperSet_preimage_coe (hs : IsLowerSet s) :
    IsUpperSet ((↑) ⁻¹' t : Set s) ↔ ∀ b ∈ s, ∀ c ∈ t, c ≤ b → b ∈ t 
goal: IsUpperSet (Subtype.val ⁻¹' t) ↔ ∀ b ∈ s, ∀ c ∈ t, c ≤ b → b ∈ t

full_name: IsUpperSet.sdiff
code: lemma IsUpperSet.sdiff (hs : IsUpperSet s) (ht : ∀ b ∈ s, ∀ c ∈ t, b ≤ c → b ∈ t) :
    IsUpperSet (s \ t) 
goal: IsUpperSet (s \ t)

full_name: IsLowerSet.sdiff
code: lemma IsLowerSet.sdiff (hs : IsLowerSet s) (ht : ∀ b ∈ s, ∀ c ∈ t, c ≤ b → b ∈ t) :
    IsLowerSet (s \ t) 
goal: IsLowerSet (s \ t)

full_name: IsUpperSet.sdiff_of_isLowerSet
code: lemma IsUpperSet.sdiff_of_isLowerSet (hs : IsUpperSet s) (ht : IsLowerSet t) : IsUpperSet (s \ t) 
goal: IsUpperSet (s \ t)

full_name: IsLowerSet.sdiff_of_isUpperSet
code: lemma IsLowerSet.sdiff_of_isUpperSet (hs : IsLowerSet s) (ht : IsUpperSet t) : IsLowerSet (s \ t) 
goal: IsLowerSet (s \ t)

full_name: IsUpperSet.erase
code: lemma IsUpperSet.erase (hs : IsUpperSet s) (has : ∀ b ∈ s, b ≤ a → b = a) : IsUpperSet (s \ {a}) 
goal: IsUpperSet (s \ {a})

full_name: IsLowerSet.erase
code: lemma IsLowerSet.erase (hs : IsLowerSet s) (has : ∀ b ∈ s, a ≤ b → b = a) : IsLowerSet (s \ {a}) 
goal: IsLowerSet (s \ {a})

full_name: isUpperSet_Ici
code: theorem isUpperSet_Ici : IsUpperSet (Ici a) 
goal: IsUpperSet (Set.Ici a)

full_name: isLowerSet_Iic
code: theorem isLowerSet_Iic : IsLowerSet (Iic a) 
goal: IsLowerSet (Set.Iic a)

full_name: isUpperSet_Ioi
code: theorem isUpperSet_Ioi : IsUpperSet (Ioi a) 
goal: IsUpperSet (Set.Ioi a)

full_name: isLowerSet_Iio
code: theorem isLowerSet_Iio : IsLowerSet (Iio a) 
goal: IsLowerSet (Set.Iio a)

full_name: isUpperSet_iff_Ici_subset
code: theorem isUpperSet_iff_Ici_subset : IsUpperSet s ↔ ∀ ⦃a⦄, a ∈ s → Ici a ⊆ s 
goal: IsUpperSet s ↔ ∀ ⦃a : α⦄, a ∈ s → Set.Ici a ⊆ s

full_name: isLowerSet_iff_Iic_subset
code: theorem isLowerSet_iff_Iic_subset : IsLowerSet s ↔ ∀ ⦃a⦄, a ∈ s → Iic a ⊆ s 
goal: IsLowerSet s ↔ ∀ ⦃a : α⦄, a ∈ s → Set.Iic a ⊆ s

full_name: IsUpperSet.Ioi_subset
code: theorem IsUpperSet.Ioi_subset (h : IsUpperSet s) ⦃a⦄ (ha : a ∈ s) : Ioi a ⊆ s 
goal: Set.Ioi a ⊆ s

full_name: IsLowerSet.Iio_subset
code: theorem IsLowerSet.Iio_subset (h : IsLowerSet s) ⦃a⦄ (ha : a ∈ s) : Iio a ⊆ s 
goal: Set.Iio a ⊆ s

full_name: IsUpperSet.ordConnected
code: theorem IsUpperSet.ordConnected (h : IsUpperSet s) : s.OrdConnected 
goal: s.OrdConnected

full_name: IsLowerSet.ordConnected
code: theorem IsLowerSet.ordConnected (h : IsLowerSet s) : s.OrdConnected 
goal: s.OrdConnected

full_name: IsUpperSet.preimage
code: theorem IsUpperSet.preimage (hs : IsUpperSet s) {f : β → α} (hf : Monotone f) :
    IsUpperSet (f ⁻¹' s : Set β) 
goal: IsUpperSet (f ⁻¹' s)

full_name: IsLowerSet.preimage
code: theorem IsLowerSet.preimage (hs : IsLowerSet s) {f : β → α} (hf : Monotone f) :
    IsLowerSet (f ⁻¹' s : Set β) 
goal: IsLowerSet (f ⁻¹' s)

full_name: IsUpperSet.image
code: theorem IsUpperSet.image (hs : IsUpperSet s) (f : α ≃o β) : IsUpperSet (f '' s : Set β) 
goal: IsUpperSet (⇑f '' s)

full_name: IsLowerSet.image
code: theorem IsLowerSet.image (hs : IsLowerSet s) (f : α ≃o β) : IsLowerSet (f '' s : Set β) 
goal: IsLowerSet (⇑f '' s)

full_name: OrderEmbedding.image_Ici
code: theorem OrderEmbedding.image_Ici (e : α ↪o β) (he : IsUpperSet (range e)) (a : α) :
    e '' Ici a = Ici (e a) 
goal: ⇑e '' Set.Ici a = Set.Ici (e a)

full_name: OrderEmbedding.image_Iic
code: theorem OrderEmbedding.image_Iic (e : α ↪o β) (he : IsLowerSet (range e)) (a : α) :
    e '' Iic a = Iic (e a) 
goal: ⇑e '' Set.Iic a = Set.Iic (e a)

full_name: OrderEmbedding.image_Ioi
code: theorem OrderEmbedding.image_Ioi (e : α ↪o β) (he : IsUpperSet (range e)) (a : α) :
    e '' Ioi a = Ioi (e a) 
goal: ⇑e '' Set.Ioi a = Set.Ioi (e a)

full_name: OrderEmbedding.image_Iio
code: theorem OrderEmbedding.image_Iio (e : α ↪o β) (he : IsLowerSet (range e)) (a : α) :
    e '' Iio a = Iio (e a) 
goal: ⇑e '' Set.Iio a = Set.Iio (e a)

full_name: Set.monotone_mem
code: @[simp]
theorem Set.monotone_mem : Monotone (· ∈ s) ↔ IsUpperSet s 
goal: (Monotone fun x => x ∈ s) ↔ IsUpperSet s

full_name: Set.antitone_mem
code: @[simp]
theorem Set.antitone_mem : Antitone (· ∈ s) ↔ IsLowerSet s 
goal: (Antitone fun x => x ∈ s) ↔ IsLowerSet s

full_name: isUpperSet_setOf
code: @[simp]
theorem isUpperSet_setOf : IsUpperSet { a | p a } ↔ Monotone p 
goal: IsUpperSet {a | p a} ↔ Monotone p

full_name: isLowerSet_setOf
code: @[simp]
theorem isLowerSet_setOf : IsLowerSet { a | p a } ↔ Antitone p 
goal: IsLowerSet {a | p a} ↔ Antitone p

full_name: IsUpperSet.upperBounds_subset
code: lemma IsUpperSet.upperBounds_subset (hs : IsUpperSet s) : s.Nonempty → upperBounds s ⊆ s 
goal: s.Nonempty → upperBounds s ⊆ s

full_name: IsLowerSet.lowerBounds_subset
code: lemma IsLowerSet.lowerBounds_subset (hs : IsLowerSet s) : s.Nonempty → lowerBounds s ⊆ s 
goal: s.Nonempty → lowerBounds s ⊆ s

full_name: IsLowerSet.top_mem
code: theorem IsLowerSet.top_mem (hs : IsLowerSet s) : ⊤ ∈ s ↔ s = univ 
goal: ⊤ ∈ s ↔ s = Set.univ

full_name: IsUpperSet.top_mem
code: theorem IsUpperSet.top_mem (hs : IsUpperSet s) : ⊤ ∈ s ↔ s.Nonempty 
goal: ⊤ ∈ s ↔ s.Nonempty

full_name: IsUpperSet.not_top_mem
code: theorem IsUpperSet.not_top_mem (hs : IsUpperSet s) : ⊤ ∉ s ↔ s = ∅ 
goal: ⊤ ∉ s ↔ s = ∅

full_name: IsUpperSet.bot_mem
code: theorem IsUpperSet.bot_mem (hs : IsUpperSet s) : ⊥ ∈ s ↔ s = univ 
goal: ⊥ ∈ s ↔ s = Set.univ

full_name: IsLowerSet.bot_mem
code: theorem IsLowerSet.bot_mem (hs : IsLowerSet s) : ⊥ ∈ s ↔ s.Nonempty 
goal: ⊥ ∈ s ↔ s.Nonempty

full_name: IsLowerSet.not_bot_mem
code: theorem IsLowerSet.not_bot_mem (hs : IsLowerSet s) : ⊥ ∉ s ↔ s = ∅ 
goal: ⊥ ∉ s ↔ s = ∅

full_name: IsUpperSet.not_bddAbove
code: theorem IsUpperSet.not_bddAbove (hs : IsUpperSet s) : s.Nonempty → ¬BddAbove s 
goal: s.Nonempty → ¬BddAbove s

full_name: not_bddAbove_Ici
code: theorem not_bddAbove_Ici : ¬BddAbove (Ici a) 
goal: ¬BddAbove (Set.Ici a)

full_name: not_bddAbove_Ioi
code: theorem not_bddAbove_Ioi : ¬BddAbove (Ioi a) 
goal: ¬BddAbove (Set.Ioi a)

full_name: IsLowerSet.not_bddBelow
code: theorem IsLowerSet.not_bddBelow (hs : IsLowerSet s) : s.Nonempty → ¬BddBelow s 
goal: s.Nonempty → ¬BddBelow s

full_name: not_bddBelow_Iic
code: theorem not_bddBelow_Iic : ¬BddBelow (Iic a) 
goal: ¬BddBelow (Set.Iic a)

full_name: not_bddBelow_Iio
code: theorem not_bddBelow_Iio : ¬BddBelow (Iio a) 
goal: ¬BddBelow (Set.Iio a)

full_name: isUpperSet_iff_forall_lt
code: theorem isUpperSet_iff_forall_lt : IsUpperSet s ↔ ∀ ⦃a b : α⦄, a < b → a ∈ s → b ∈ s 
goal: IsUpperSet s ↔ ∀ ⦃a b : α⦄, a < b → a ∈ s → b ∈ s

full_name: isLowerSet_iff_forall_lt
code: theorem isLowerSet_iff_forall_lt : IsLowerSet s ↔ ∀ ⦃a b : α⦄, b < a → a ∈ s → b ∈ s 
goal: IsLowerSet s ↔ ∀ ⦃a b : α⦄, b < a → a ∈ s → b ∈ s

full_name: isUpperSet_iff_Ioi_subset
code: theorem isUpperSet_iff_Ioi_subset : IsUpperSet s ↔ ∀ ⦃a⦄, a ∈ s → Ioi a ⊆ s 
goal: IsUpperSet s ↔ ∀ ⦃a : α⦄, a ∈ s → Set.Ioi a ⊆ s

full_name: isLowerSet_iff_Iio_subset
code: theorem isLowerSet_iff_Iio_subset : IsLowerSet s ↔ ∀ ⦃a⦄, a ∈ s → Iio a ⊆ s 
goal: IsLowerSet s ↔ ∀ ⦃a : α⦄, a ∈ s → Set.Iio a ⊆ s

full_name: Relation.Fibration.isLowerSet_image
code: lemma Fibration.isLowerSet_image [LE α] [LE β] (hf : Fibration (· ≤ ·) (· ≤ ·) f)
    {s : Set α} (hs : IsLowerSet s) : IsLowerSet (f '' s) 
goal: IsLowerSet (f '' s)

full_name: Relation.fibration_iff_isLowerSet_image_Iic
code: lemma fibration_iff_isLowerSet_image_Iic [Preorder α] [LE β] :
    Fibration (· ≤ ·) (· ≤ ·) f ↔ ∀ x, IsLowerSet (f '' Iic x) 
goal: Relation.Fibration (fun x x_1 => x ≤ x_1) (fun x x_1 => x ≤ x_1) f ↔ ∀ (x : α), IsLowerSet (f '' Set.Iic x)

full_name: Relation.fibration_iff_isLowerSet_image
code: lemma fibration_iff_isLowerSet_image [Preorder α] [LE β] :
    Fibration (· ≤ ·) (· ≤ ·) f ↔ ∀ s, IsLowerSet s → IsLowerSet (f '' s) 
goal: Relation.Fibration (fun x x_1 => x ≤ x_1) (fun x x_1 => x ≤ x_1) f ↔ ∀ (s : Set α), IsLowerSet s → IsLowerSet (f '' s)

full_name: Relation.fibration_iff_image_Iic
code: lemma fibration_iff_image_Iic [Preorder α] [Preorder β] (hf : Monotone f) :
    Fibration (· ≤ ·) (· ≤ ·) f ↔ ∀ x, f '' Iic x = Iic (f x) 
goal: Relation.Fibration (fun x x_1 => x ≤ x_1) (fun x x_1 => x ≤ x_1) f ↔ ∀ (x : α), f '' Set.Iic x = Set.Iic (f x)

full_name: Relation.Fibration.isUpperSet_image
code: lemma Fibration.isUpperSet_image [LE α] [LE β] (hf : Fibration (· ≥ ·) (· ≥ ·) f)
    {s : Set α} (hs : IsUpperSet s) : IsUpperSet (f '' s) 
goal: IsUpperSet (f '' s)

full_name: Relation.fibration_iff_isUpperSet_image_Ici
code: lemma fibration_iff_isUpperSet_image_Ici [Preorder α] [LE β] :
    Fibration (· ≥ ·) (· ≥ ·) f ↔ ∀ x, IsUpperSet (f '' Ici x) 
goal: Relation.Fibration (fun x x_1 => x ≥ x_1) (fun x x_1 => x ≥ x_1) f ↔ ∀ (x : α), IsUpperSet (f '' Set.Ici x)

full_name: Relation.fibration_iff_isUpperSet_image
code: lemma fibration_iff_isUpperSet_image [Preorder α] [LE β] :
    Fibration (· ≥ ·) (· ≥ ·) f ↔ ∀ s, IsUpperSet s → IsUpperSet (f '' s) 
goal: Relation.Fibration (fun x x_1 => x ≥ x_1) (fun x x_1 => x ≥ x_1) f ↔ ∀ (s : Set α), IsUpperSet s → IsUpperSet (f '' s)

full_name: Relation.fibration_iff_image_Ici
code: lemma fibration_iff_image_Ici [Preorder α] [Preorder β] (hf : Monotone f) :
    Fibration (· ≥ ·) (· ≥ ·) f ↔ ∀ x, f '' Ici x = Ici (f x) 
goal: Relation.Fibration (fun x x_1 => x ≥ x_1) (fun x x_1 => x ≥ x_1) f ↔ ∀ (x : α), f '' Set.Ici x = Set.Ici (f x)

full_name: IsUpperSet.total
code: theorem IsUpperSet.total (hs : IsUpperSet s) (ht : IsUpperSet t) : s ⊆ t ∨ t ⊆ s 
goal: s ⊆ t ∨ t ⊆ s

full_name: IsLowerSet.total
code: theorem IsLowerSet.total (hs : IsLowerSet s) (ht : IsLowerSet t) : s ⊆ t ∨ t ⊆ s 
goal: s ⊆ t ∨ t ⊆ s

full_name: UpperSet
code: @[inherit_doc IsUpperSet]
structure UpperSet (α : Type*) [LE α] where
  /-- The carrier of an `UpperSet`. -/
  carrier : Set α
  /-- The carrier of an `UpperSet` is an upper set. -/
  upper' : IsUpperSet carrier
goal: Type u_6

full_name: UpperSet.carrier
code: @[inherit_doc IsUpperSet]
structure UpperSet (α : Type*) [LE α] where
  /-- The carrier of an `UpperSet`. -/
  carrier : Set α
  /-- The carrier of an `UpperSet` is an upper set. -/
  upper' : IsUpperSet carrier
goal: Set α

full_name: UpperSet.upper'
code: @[inherit_doc IsUpperSet]
structure UpperSet (α : Type*) [LE α] where
  /-- The carrier of an `UpperSet`. -/
  carrier : Set α
  /-- The carrier of an `UpperSet` is an upper set. -/
  upper' : IsUpperSet carrier
goal: IsUpperSet self.carrier

full_name: LowerSet.lower'
code: @[inherit_doc IsLowerSet]
structure LowerSet (α : Type*) [LE α] where
  /-- The carrier of a `LowerSet`. -/
  carrier : Set α
  /-- The carrier of a `LowerSet` is a lower set. -/
  lower' : IsLowerSet carrier
goal: IsLowerSet self.carrier

full_name: LowerSet.carrier
code: @[inherit_doc IsLowerSet]
structure LowerSet (α : Type*) [LE α] where
  /-- The carrier of a `LowerSet`. -/
  carrier : Set α
  /-- The carrier of a `LowerSet` is a lower set. -/
  lower' : IsLowerSet carrier
goal: Set α

full_name: LowerSet
code: @[inherit_doc IsLowerSet]
structure LowerSet (α : Type*) [LE α] where
  /-- The carrier of a `LowerSet`. -/
  carrier : Set α
  /-- The carrier of a `LowerSet` is a lower set. -/
  lower' : IsLowerSet carrier
goal: Type u_6

full_name: UpperSet.instSetLike
code: instance : SetLike (UpperSet α) α 
goal: SetLike (UpperSet α) α

full_name: UpperSet.Simps.coe
code: /-- See Note [custom simps projection]. -/
def Simps.coe (s : UpperSet α) : Set α 
goal: Set α

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

full_name: UpperSet.carrier_eq_coe
code: @[simp]
theorem carrier_eq_coe (s : UpperSet α) : s.carrier = s 
goal: s.carrier = ↑s

full_name: UpperSet.upper
code: @[simp] protected lemma upper (s : UpperSet α) : IsUpperSet (s : Set α) 
goal: IsUpperSet ↑s

full_name: UpperSet.coe_mk
code: @[simp, norm_cast] lemma coe_mk (s : Set α) (hs) : mk s hs = s 
goal: ↑{ carrier := s, upper' := hs } = s

full_name: UpperSet.mem_mk
code: @[simp] lemma mem_mk {s : Set α} (hs) {a : α} : a ∈ mk s hs ↔ a ∈ s 
goal: a ∈ { carrier := s, upper' := hs } ↔ a ∈ s

full_name: LowerSet.instSetLike
code: instance : SetLike (LowerSet α) α 
goal: SetLike (LowerSet α) α

full_name: LowerSet.Simps.coe
code: /-- See Note [custom simps projection]. -/
def Simps.coe (s : LowerSet α) : Set α 
goal: Set α

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

full_name: LowerSet.carrier_eq_coe
code: @[simp]
theorem carrier_eq_coe (s : LowerSet α) : s.carrier = s 
goal: s.carrier = ↑s

full_name: LowerSet.lower
code: @[simp] protected lemma lower (s : LowerSet α) : IsLowerSet (s : Set α) 
goal: IsLowerSet ↑s

full_name: LowerSet.coe_mk
code: @[simp, norm_cast] lemma coe_mk (s : Set α) (hs) : mk s hs = s 
goal: ↑{ carrier := s, lower' := hs } = s

full_name: LowerSet.mem_mk
code: @[simp] lemma mem_mk {s : Set α} (hs) {a : α} : a ∈ mk s hs ↔ a ∈ s 
goal: a ∈ { carrier := s, lower' := hs } ↔ a ∈ s

full_name: UpperSet.instSup
code: instance : Sup (UpperSet α) 
goal: Sup (UpperSet α)

full_name: UpperSet.instInf
code: instance : Inf (UpperSet α) 
goal: Inf (UpperSet α)

full_name: UpperSet.instTop
code: instance : Top (UpperSet α) 
goal: Top (UpperSet α)

full_name: UpperSet.instBot
code: instance : Bot (UpperSet α) 
goal: Bot (UpperSet α)

full_name: UpperSet.instSupSet
code: instance : SupSet (UpperSet α) 
goal: SupSet (UpperSet α)

full_name: UpperSet.instInfSet
code: instance : InfSet (UpperSet α) 
goal: InfSet (UpperSet α)

full_name: UpperSet.completeLattice
code: instance completeLattice : CompleteLattice (UpperSet α) 
goal: CompleteLattice (UpperSet α)

full_name: UpperSet.completelyDistribLattice
code: instance completelyDistribLattice : CompletelyDistribLattice (UpperSet α) 
goal: CompletelyDistribLattice (UpperSet α)

full_name: UpperSet.instInhabited
code: instance : Inhabited (UpperSet α) 
goal: Inhabited (UpperSet α)

full_name: UpperSet.coe_subset_coe
code: @[simp 1100, norm_cast]
theorem coe_subset_coe : (s : Set α) ⊆ t ↔ t ≤ s 
goal: ↑s ⊆ ↑t ↔ t ≤ s

full_name: UpperSet.coe_ssubset_coe
code: @[simp 1100, norm_cast] lemma coe_ssubset_coe : (s : Set α) ⊂ t ↔ t < s 
goal: ↑s ⊂ ↑t ↔ t < s

full_name: UpperSet.coe_top
code: @[simp, norm_cast]
theorem coe_top : ((⊤ : UpperSet α) : Set α) = ∅ 
goal: ↑⊤ = ∅

full_name: UpperSet.coe_bot
code: @[simp, norm_cast]
theorem coe_bot : ((⊥ : UpperSet α) : Set α) = univ 
goal: ↑⊥ = Set.univ

full_name: UpperSet.coe_eq_univ
code: @[simp, norm_cast]
theorem coe_eq_univ : (s : Set α) = univ ↔ s = ⊥ 
goal: ↑s = Set.univ ↔ s = ⊥

full_name: UpperSet.coe_eq_empty
code: @[simp, norm_cast]
theorem coe_eq_empty : (s : Set α) = ∅ ↔ s = ⊤ 
goal: ↑s = ∅ ↔ s = ⊤

full_name: UpperSet.coe_nonempty
code: @[simp, norm_cast] lemma coe_nonempty : (s : Set α).Nonempty ↔ s ≠ ⊤ 
goal: (↑s).Nonempty ↔ s ≠ ⊤

full_name: UpperSet.coe_sup
code: @[simp, norm_cast]
theorem coe_sup (s t : UpperSet α) : (↑(s ⊔ t) : Set α) = (s : Set α) ∩ t 
goal: ↑(s ⊔ t) = ↑s ∩ ↑t

full_name: UpperSet.coe_inf
code: @[simp, norm_cast]
theorem coe_inf (s t : UpperSet α) : (↑(s ⊓ t) : Set α) = (s : Set α) ∪ t 
goal: ↑(s ⊓ t) = ↑s ∪ ↑t

full_name: UpperSet.coe_sSup
code: @[simp, norm_cast]
theorem coe_sSup (S : Set (UpperSet α)) : (↑(sSup S) : Set α) = ⋂ s ∈ S, ↑s 
goal: ↑(sSup S) = ⋂ s ∈ S, ↑s

full_name: UpperSet.coe_sInf
code: @[simp, norm_cast]
theorem coe_sInf (S : Set (UpperSet α)) : (↑(sInf S) : Set α) = ⋃ s ∈ S, ↑s 
goal: ↑(sInf S) = ⋃ s ∈ S, ↑s

full_name: UpperSet.coe_iSup
code: @[simp, norm_cast]
theorem coe_iSup (f : ι → UpperSet α) : (↑(⨆ i, f i) : Set α) = ⋂ i, f i 
goal: ↑(⨆ i, f i) = ⋂ i, ↑(f i)

full_name: UpperSet.coe_iInf
code: @[simp, norm_cast]
theorem coe_iInf (f : ι → UpperSet α) : (↑(⨅ i, f i) : Set α) = ⋃ i, f i 
goal: ↑(⨅ i, f i) = ⋃ i, ↑(f i)

full_name: UpperSet.coe_iSup₂
code: @[norm_cast] -- Porting note: no longer a `simp`
theorem coe_iSup₂ (f : ∀ i, κ i → UpperSet α) :
    (↑(⨆ (i) (j), f i j) : Set α) = ⋂ (i) (j), f i j 
goal: ↑(⨆ i, ⨆ j, f i j) = ⋂ i, ⋂ j, ↑(f i j)

full_name: UpperSet.coe_iInf₂
code: @[norm_cast] -- Porting note: no longer a `simp`
theorem coe_iInf₂ (f : ∀ i, κ i → UpperSet α) :
    (↑(⨅ (i) (j), f i j) : Set α) = ⋃ (i) (j), f i j 
goal: ↑(⨅ i, ⨅ j, f i j) = ⋃ i, ⋃ j, ↑(f i j)

full_name: UpperSet.not_mem_top
code: @[simp]
theorem not_mem_top : a ∉ (⊤ : UpperSet α) 
goal: a ∉ ⊤

full_name: UpperSet.mem_bot
code: @[simp]
theorem mem_bot : a ∈ (⊥ : UpperSet α) 
goal: a ∈ ⊥

full_name: UpperSet.mem_sup_iff
code: @[simp]
theorem mem_sup_iff : a ∈ s ⊔ t ↔ a ∈ s ∧ a ∈ t 
goal: a ∈ s ⊔ t ↔ a ∈ s ∧ a ∈ t

full_name: UpperSet.mem_inf_iff
code: @[simp]
theorem mem_inf_iff : a ∈ s ⊓ t ↔ a ∈ s ∨ a ∈ t 
goal: a ∈ s ⊓ t ↔ a ∈ s ∨ a ∈ t

full_name: UpperSet.mem_sSup_iff
code: @[simp]
theorem mem_sSup_iff : a ∈ sSup S ↔ ∀ s ∈ S, a ∈ s 
goal: a ∈ sSup S ↔ ∀ s ∈ S, a ∈ s

full_name: UpperSet.mem_sInf_iff
code: @[simp]
theorem mem_sInf_iff : a ∈ sInf S ↔ ∃ s ∈ S, a ∈ s 
goal: a ∈ sInf S ↔ ∃ s ∈ S, a ∈ s

full_name: UpperSet.mem_iSup_iff
code: @[simp]
theorem mem_iSup_iff {f : ι → UpperSet α} : (a ∈ ⨆ i, f i) ↔ ∀ i, a ∈ f i 
goal: a ∈ ⨆ i, f i ↔ ∀ (i : ι), a ∈ f i

full_name: UpperSet.mem_iInf_iff
code: @[simp]
theorem mem_iInf_iff {f : ι → UpperSet α} : (a ∈ ⨅ i, f i) ↔ ∃ i, a ∈ f i 
goal: a ∈ ⨅ i, f i ↔ ∃ i, a ∈ f i

full_name: UpperSet.mem_iSup₂_iff
code: theorem mem_iSup₂_iff {f : ∀ i, κ i → UpperSet α} : (a ∈ ⨆ (i) (j), f i j) ↔ ∀ i j, a ∈ f i j 
goal: a ∈ ⨆ i, ⨆ j, f i j ↔ ∀ (i : ι) (j : κ i), a ∈ f i j

full_name: UpperSet.mem_iInf₂_iff
code: theorem mem_iInf₂_iff {f : ∀ i, κ i → UpperSet α} : (a ∈ ⨅ (i) (j), f i j) ↔ ∃ i j, a ∈ f i j 
goal: a ∈ ⨅ i, ⨅ j, f i j ↔ ∃ i j, a ∈ f i j

full_name: UpperSet.codisjoint_coe
code: @[simp, norm_cast]
theorem codisjoint_coe : Codisjoint (s : Set α) t ↔ Disjoint s t 
goal: Codisjoint ↑s ↑t ↔ Disjoint s t

full_name: LowerSet.instSup
code: instance : Sup (LowerSet α) 
goal: Sup (LowerSet α)

full_name: LowerSet.instInf
code: instance : Inf (LowerSet α) 
goal: Inf (LowerSet α)

full_name: LowerSet.instTop
code: instance : Top (LowerSet α) 
goal: Top (LowerSet α)

full_name: LowerSet.instBot
code: instance : Bot (LowerSet α) 
goal: Bot (LowerSet α)

full_name: LowerSet.instSupSet
code: instance : SupSet (LowerSet α) 
goal: SupSet (LowerSet α)

full_name: LowerSet.instInfSet
code: instance : InfSet (LowerSet α) 
goal: InfSet (LowerSet α)

full_name: LowerSet.completeLattice
code: instance completeLattice : CompleteLattice (LowerSet α) 
goal: CompleteLattice (LowerSet α)

full_name: LowerSet.completelyDistribLattice
code: instance completelyDistribLattice : CompletelyDistribLattice (LowerSet α) 
goal: CompletelyDistribLattice (LowerSet α)

full_name: LowerSet.instInhabited
code: instance : Inhabited (LowerSet α) 
goal: Inhabited (LowerSet α)

full_name: LowerSet.coe_subset_coe
code: @[norm_cast] lemma coe_subset_coe : (s : Set α) ⊆ t ↔ s ≤ t 
goal: ↑s ⊆ ↑t ↔ s ≤ t

full_name: LowerSet.coe_ssubset_coe
code: @[norm_cast] lemma coe_ssubset_coe : (s : Set α) ⊂ t ↔ s < t 
goal: ↑s ⊂ ↑t ↔ s < t

full_name: LowerSet.coe_top
code: @[simp, norm_cast]
theorem coe_top : ((⊤ : LowerSet α) : Set α) = univ 
goal: ↑⊤ = Set.univ

full_name: LowerSet.coe_bot
code: @[simp, norm_cast]
theorem coe_bot : ((⊥ : LowerSet α) : Set α) = ∅ 
goal: ↑⊥ = ∅

full_name: LowerSet.coe_eq_univ
code: @[simp, norm_cast]
theorem coe_eq_univ : (s : Set α) = univ ↔ s = ⊤ 
goal: ↑s = Set.univ ↔ s = ⊤

full_name: LowerSet.coe_eq_empty
code: @[simp, norm_cast]
theorem coe_eq_empty : (s : Set α) = ∅ ↔ s = ⊥ 
goal: ↑s = ∅ ↔ s = ⊥

full_name: LowerSet.coe_nonempty
code: @[simp, norm_cast] lemma coe_nonempty : (s : Set α).Nonempty ↔ s ≠ ⊥ 
goal: (↑s).Nonempty ↔ s ≠ ⊥

full_name: LowerSet.coe_sup
code: @[simp, norm_cast]
theorem coe_sup (s t : LowerSet α) : (↑(s ⊔ t) : Set α) = (s : Set α) ∪ t 
goal: ↑(s ⊔ t) = ↑s ∪ ↑t

full_name: LowerSet.coe_inf
code: @[simp, norm_cast]
theorem coe_inf (s t : LowerSet α) : (↑(s ⊓ t) : Set α) = (s : Set α) ∩ t 
goal: ↑(s ⊓ t) = ↑s ∩ ↑t

full_name: LowerSet.coe_sSup
code: @[simp, norm_cast]
theorem coe_sSup (S : Set (LowerSet α)) : (↑(sSup S) : Set α) = ⋃ s ∈ S, ↑s 
goal: ↑(sSup S) = ⋃ s ∈ S, ↑s

full_name: LowerSet.coe_sInf
code: @[simp, norm_cast]
theorem coe_sInf (S : Set (LowerSet α)) : (↑(sInf S) : Set α) = ⋂ s ∈ S, ↑s 
goal: ↑(sInf S) = ⋂ s ∈ S, ↑s

full_name: LowerSet.coe_iSup
code: @[simp, norm_cast]
theorem coe_iSup (f : ι → LowerSet α) : (↑(⨆ i, f i) : Set α) = ⋃ i, f i 
goal: ↑(⨆ i, f i) = ⋃ i, ↑(f i)

full_name: LowerSet.coe_iInf
code: @[simp, norm_cast]
theorem coe_iInf (f : ι → LowerSet α) : (↑(⨅ i, f i) : Set α) = ⋂ i, f i 
goal: ↑(⨅ i, f i) = ⋂ i, ↑(f i)

full_name: LowerSet.coe_iSup₂
code: @[norm_cast] -- Porting note: no longer a `simp`
theorem coe_iSup₂ (f : ∀ i, κ i → LowerSet α) :
    (↑(⨆ (i) (j), f i j) : Set α) = ⋃ (i) (j), f i j 
goal: ↑(⨆ i, ⨆ j, f i j) = ⋃ i, ⋃ j, ↑(f i j)

full_name: LowerSet.coe_iInf₂
code: @[norm_cast] -- Porting note: no longer a `simp`
theorem coe_iInf₂ (f : ∀ i, κ i → LowerSet α) :
    (↑(⨅ (i) (j), f i j) : Set α) = ⋂ (i) (j), f i j 
goal: ↑(⨅ i, ⨅ j, f i j) = ⋂ i, ⋂ j, ↑(f i j)

full_name: LowerSet.mem_top
code: @[simp]
theorem mem_top : a ∈ (⊤ : LowerSet α) 
goal: a ∈ ⊤

full_name: LowerSet.not_mem_bot
code: @[simp]
theorem not_mem_bot : a ∉ (⊥ : LowerSet α) 
goal: a ∉ ⊥

full_name: LowerSet.mem_sup_iff
code: @[simp]
theorem mem_sup_iff : a ∈ s ⊔ t ↔ a ∈ s ∨ a ∈ t 
goal: a ∈ s ⊔ t ↔ a ∈ s ∨ a ∈ t

full_name: LowerSet.mem_inf_iff
code: @[simp]
theorem mem_inf_iff : a ∈ s ⊓ t ↔ a ∈ s ∧ a ∈ t 
goal: a ∈ s ⊓ t ↔ a ∈ s ∧ a ∈ t

full_name: LowerSet.mem_sSup_iff
code: @[simp]
theorem mem_sSup_iff : a ∈ sSup S ↔ ∃ s ∈ S, a ∈ s 
goal: a ∈ sSup S ↔ ∃ s ∈ S, a ∈ s

full_name: LowerSet.mem_sInf_iff
code: @[simp]
theorem mem_sInf_iff : a ∈ sInf S ↔ ∀ s ∈ S, a ∈ s 
goal: a ∈ sInf S ↔ ∀ s ∈ S, a ∈ s

full_name: LowerSet.mem_iSup_iff
code: @[simp]
theorem mem_iSup_iff {f : ι → LowerSet α} : (a ∈ ⨆ i, f i) ↔ ∃ i, a ∈ f i 
goal: a ∈ ⨆ i, f i ↔ ∃ i, a ∈ f i

full_name: LowerSet.mem_iInf_iff
code: @[simp]
theorem mem_iInf_iff {f : ι → LowerSet α} : (a ∈ ⨅ i, f i) ↔ ∀ i, a ∈ f i 
goal: a ∈ ⨅ i, f i ↔ ∀ (i : ι), a ∈ f i

full_name: LowerSet.mem_iSup₂_iff
code: theorem mem_iSup₂_iff {f : ∀ i, κ i → LowerSet α} : (a ∈ ⨆ (i) (j), f i j) ↔ ∃ i j, a ∈ f i j 
goal: a ∈ ⨆ i, ⨆ j, f i j ↔ ∃ i j, a ∈ f i j

full_name: LowerSet.mem_iInf₂_iff
code: theorem mem_iInf₂_iff {f : ∀ i, κ i → LowerSet α} : (a ∈ ⨅ (i) (j), f i j) ↔ ∀ i j, a ∈ f i j 
goal: a ∈ ⨅ i, ⨅ j, f i j ↔ ∀ (i : ι) (j : κ i), a ∈ f i j

full_name: LowerSet.disjoint_coe
code: @[simp, norm_cast]
theorem disjoint_coe : Disjoint (s : Set α) t ↔ Disjoint s t 
goal: Disjoint ↑s ↑t ↔ Disjoint s t

full_name: UpperSet.compl
code: /-- The complement of a lower set as an upper set. -/
def UpperSet.compl (s : UpperSet α) : LowerSet α 
goal: LowerSet α

full_name: LowerSet.compl
code: /-- The complement of a lower set as an upper set. -/
def LowerSet.compl (s : LowerSet α) : UpperSet α 
goal: UpperSet α

full_name: UpperSet.coe_compl
code: @[simp]
theorem coe_compl (s : UpperSet α) : (s.compl : Set α) = (↑s)ᶜ 
goal: ↑s.compl = (↑s)ᶜ

full_name: UpperSet.mem_compl_iff
code: @[simp]
theorem mem_compl_iff : a ∈ s.compl ↔ a ∉ s 
goal: a ∈ s.compl ↔ a ∉ s

full_name: UpperSet.compl_compl
code: @[simp]
nonrec theorem compl_compl (s : UpperSet α) : s.compl.compl = s 
goal: s.compl.compl = s

full_name: UpperSet.compl_le_compl
code: @[simp]
theorem compl_le_compl : s.compl ≤ t.compl ↔ s ≤ t 
goal: s.compl ≤ t.compl ↔ s ≤ t

full_name: UpperSet.compl_sup
code: @[simp]
protected theorem compl_sup (s t : UpperSet α) : (s ⊔ t).compl = s.compl ⊔ t.compl 
goal: (s ⊔ t).compl = s.compl ⊔ t.compl

full_name: UpperSet.compl_inf
code: @[simp]
protected theorem compl_inf (s t : UpperSet α) : (s ⊓ t).compl = s.compl ⊓ t.compl 
goal: (s ⊓ t).compl = s.compl ⊓ t.compl

full_name: UpperSet.compl_top
code: @[simp]
protected theorem compl_top : (⊤ : UpperSet α).compl = ⊤ 
goal: ⊤.compl = ⊤

full_name: UpperSet.compl_bot
code: @[simp]
protected theorem compl_bot : (⊥ : UpperSet α).compl = ⊥ 
goal: ⊥.compl = ⊥

full_name: UpperSet.compl_sSup
code: @[simp]
protected theorem compl_sSup (S : Set (UpperSet α)) : (sSup S).compl = ⨆ s ∈ S, UpperSet.compl s 
goal: (sSup S).compl = ⨆ s ∈ S, s.compl

full_name: UpperSet.compl_sInf
code: @[simp]
protected theorem compl_sInf (S : Set (UpperSet α)) : (sInf S).compl = ⨅ s ∈ S, UpperSet.compl s 
goal: (sInf S).compl = ⨅ s ∈ S, s.compl

full_name: UpperSet.compl_iSup
code: @[simp]
protected theorem compl_iSup (f : ι → UpperSet α) : (⨆ i, f i).compl = ⨆ i, (f i).compl 
goal: (⨆ i, f i).compl = ⨆ i, (f i).compl

full_name: UpperSet.compl_iInf
code: @[simp]
protected theorem compl_iInf (f : ι → UpperSet α) : (⨅ i, f i).compl = ⨅ i, (f i).compl 
goal: (⨅ i, f i).compl = ⨅ i, (f i).compl

full_name: UpperSet.compl_iSup₂
code: theorem compl_iSup₂ (f : ∀ i, κ i → UpperSet α) :
    (⨆ (i) (j), f i j).compl = ⨆ (i) (j), (f i j).compl 
goal: (⨆ i, ⨆ j, f i j).compl = ⨆ i, ⨆ j, (f i j).compl

full_name: UpperSet.compl_iInf₂
code: theorem compl_iInf₂ (f : ∀ i, κ i → UpperSet α) :
    (⨅ (i) (j), f i j).compl = ⨅ (i) (j), (f i j).compl 
goal: (⨅ i, ⨅ j, f i j).compl = ⨅ i, ⨅ j, (f i j).compl

full_name: LowerSet.coe_compl
code: @[simp]
theorem coe_compl (s : LowerSet α) : (s.compl : Set α) = (↑s)ᶜ 
goal: ↑s.compl = (↑s)ᶜ

full_name: LowerSet.mem_compl_iff
code: @[simp]
theorem mem_compl_iff : a ∈ s.compl ↔ a ∉ s 
goal: a ∈ s.compl ↔ a ∉ s

full_name: LowerSet.compl_compl
code: @[simp]
nonrec theorem compl_compl (s : LowerSet α) : s.compl.compl = s 
goal: s.compl.compl = s

full_name: LowerSet.compl_le_compl
code: @[simp]
theorem compl_le_compl : s.compl ≤ t.compl ↔ s ≤ t 
goal: s.compl ≤ t.compl ↔ s ≤ t

full_name: LowerSet.compl_sup
code: protected theorem compl_sup (s t : LowerSet α) : (s ⊔ t).compl = s.compl ⊔ t.compl 
goal: (s ⊔ t).compl = s.compl ⊔ t.compl

full_name: LowerSet.compl_inf
code: protected theorem compl_inf (s t : LowerSet α) : (s ⊓ t).compl = s.compl ⊓ t.compl 
goal: (s ⊓ t).compl = s.compl ⊓ t.compl

full_name: LowerSet.compl_top
code: protected theorem compl_top : (⊤ : LowerSet α).compl = ⊤ 
goal: ⊤.compl = ⊤

full_name: LowerSet.compl_bot
code: protected theorem compl_bot : (⊥ : LowerSet α).compl = ⊥ 
goal: ⊥.compl = ⊥

full_name: LowerSet.compl_sSup
code: protected theorem compl_sSup (S : Set (LowerSet α)) : (sSup S).compl = ⨆ s ∈ S, LowerSet.compl s 
goal: (sSup S).compl = ⨆ s ∈ S, s.compl

full_name: LowerSet.compl_sInf
code: protected theorem compl_sInf (S : Set (LowerSet α)) : (sInf S).compl = ⨅ s ∈ S, LowerSet.compl s 
goal: (sInf S).compl = ⨅ s ∈ S, s.compl

full_name: LowerSet.compl_iSup
code: protected theorem compl_iSup (f : ι → LowerSet α) : (⨆ i, f i).compl = ⨆ i, (f i).compl 
goal: (⨆ i, f i).compl = ⨆ i, (f i).compl

full_name: LowerSet.compl_iInf
code: protected theorem compl_iInf (f : ι → LowerSet α) : (⨅ i, f i).compl = ⨅ i, (f i).compl 
goal: (⨅ i, f i).compl = ⨅ i, (f i).compl

full_name: LowerSet.compl_iSup₂
code: @[simp]
theorem compl_iSup₂ (f : ∀ i, κ i → LowerSet α) :
    (⨆ (i) (j), f i j).compl = ⨆ (i) (j), (f i j).compl 
goal: (⨆ i, ⨆ j, f i j).compl = ⨆ i, ⨆ j, (f i j).compl

full_name: LowerSet.compl_iInf₂
code: @[simp]
theorem compl_iInf₂ (f : ∀ i, κ i → LowerSet α) :
    (⨅ (i) (j), f i j).compl = ⨅ (i) (j), (f i j).compl 
goal: (⨅ i, ⨅ j, f i j).compl = ⨅ i, ⨅ j, (f i j).compl

full_name: upperSetIsoLowerSet_symm_apply
code: /-- Upper sets are order-isomorphic to lower sets under complementation. -/
@[simps]
def upperSetIsoLowerSet : UpperSet α ≃o LowerSet α 
goal: (RelIso.symm upperSetIsoLowerSet) s = s.compl

full_name: upperSetIsoLowerSet
code: /-- Upper sets are order-isomorphic to lower sets under complementation. -/
@[simps]
def upperSetIsoLowerSet : UpperSet α ≃o LowerSet α 
goal: UpperSet α ≃o LowerSet α

full_name: upperSetIsoLowerSet_apply
code: /-- Upper sets are order-isomorphic to lower sets under complementation. -/
@[simps]
def upperSetIsoLowerSet : UpperSet α ≃o LowerSet α 
goal: upperSetIsoLowerSet s = s.compl

full_name: UpperSet.isTotal_le
code: instance UpperSet.isTotal_le : IsTotal (UpperSet α) (· ≤ ·) 
goal: IsTotal (UpperSet α) fun x x_1 => x ≤ x_1

full_name: LowerSet.isTotal_le
code: instance LowerSet.isTotal_le : IsTotal (LowerSet α) (· ≤ ·) 
goal: IsTotal (LowerSet α) fun x x_1 => x ≤ x_1

full_name: UpperSet.instLinearOrder
code: noncomputable instance UpperSet.instLinearOrder : LinearOrder (UpperSet α) 
goal: LinearOrder (UpperSet α)

full_name: LowerSet.instLinearOrder
code: noncomputable instance LowerSet.instLinearOrder : LinearOrder (LowerSet α) 
goal: LinearOrder (LowerSet α)

full_name: UpperSet.instCompleteLinearOrder
code: noncomputable instance UpperSet.instCompleteLinearOrder : CompleteLinearOrder (UpperSet α) 
goal: CompleteLinearOrder (UpperSet α)

full_name: LowerSet.instCompleteLinearOrder
code: noncomputable instance LowerSet.instCompleteLinearOrder : CompleteLinearOrder (LowerSet α) 
goal: CompleteLinearOrder (LowerSet α)

full_name: UpperSet.map
code: /-- An order isomorphism of Preorders induces an order isomorphism of their upper sets. -/
def map (f : α ≃o β) : UpperSet α ≃o UpperSet β 
goal: UpperSet α ≃o UpperSet β

full_name: UpperSet.symm_map
code: @[simp]
theorem symm_map (f : α ≃o β) : (map f).symm = map f.symm 
goal: (UpperSet.map f).symm = UpperSet.map f.symm

full_name: UpperSet.mem_map
code: @[simp]
theorem mem_map : b ∈ map f s ↔ f.symm b ∈ s 
goal: b ∈ (UpperSet.map f) s ↔ f.symm b ∈ s

full_name: UpperSet.map_refl
code: @[simp]
theorem map_refl : map (OrderIso.refl α) = OrderIso.refl _ 
goal: UpperSet.map (OrderIso.refl α) = OrderIso.refl (UpperSet α)

full_name: UpperSet.map_map
code: @[simp]
theorem map_map (g : β ≃o γ) (f : α ≃o β) : map g (map f s) = map (f.trans g) s 
goal: (UpperSet.map g) ((UpperSet.map f) s) = (UpperSet.map (f.trans g)) s

full_name: UpperSet.coe_map
code: @[simp, norm_cast]
theorem coe_map : (map f s : Set β) = f '' s 
goal: ↑((UpperSet.map f) s) = ⇑f '' ↑s

full_name: LowerSet.map
code: /-- An order isomorphism of Preorders induces an order isomorphism of their lower sets. -/
def map (f : α ≃o β) : LowerSet α ≃o LowerSet β 
goal: LowerSet α ≃o LowerSet β

full_name: LowerSet.symm_map
code: @[simp]
theorem symm_map (f : α ≃o β) : (map f).symm = map f.symm 
goal: (LowerSet.map f).symm = LowerSet.map f.symm

full_name: LowerSet.mem_map
code: @[simp]
theorem mem_map {f : α ≃o β} {b : β} : b ∈ map f s ↔ f.symm b ∈ s 
goal: b ∈ (LowerSet.map f) s ↔ f.symm b ∈ s

full_name: LowerSet.map_refl
code: @[simp]
theorem map_refl : map (OrderIso.refl α) = OrderIso.refl _ 
goal: LowerSet.map (OrderIso.refl α) = OrderIso.refl (LowerSet α)

full_name: LowerSet.map_map
code: @[simp]
theorem map_map (g : β ≃o γ) (f : α ≃o β) : map g (map f s) = map (f.trans g) s 
goal: (LowerSet.map g) ((LowerSet.map f) s) = (LowerSet.map (f.trans g)) s

full_name: LowerSet.coe_map
code: @[simp, norm_cast]
theorem coe_map : (map f s : Set β) = f '' s 
goal: ↑((LowerSet.map f) s) = ⇑f '' ↑s

full_name: UpperSet.compl_map
code: @[simp]
theorem compl_map (f : α ≃o β) (s : UpperSet α) : (map f s).compl = LowerSet.map f s.compl 
goal: ((UpperSet.map f) s).compl = (LowerSet.map f) s.compl

full_name: LowerSet.compl_map
code: @[simp]
theorem compl_map (f : α ≃o β) (s : LowerSet α) : (map f s).compl = UpperSet.map f s.compl 
goal: ((LowerSet.map f) s).compl = (UpperSet.map f) s.compl

full_name: UpperSet.Ici
code: /-- The smallest upper set containing a given element. -/
nonrec def Ici (a : α) : UpperSet α 
goal: UpperSet α

full_name: UpperSet.Ioi
code: /-- The smallest upper set containing a given element. -/
nonrec def Ioi (a : α) : UpperSet α 
goal: UpperSet α

full_name: UpperSet.coe_Ici
code: @[simp]
theorem coe_Ici (a : α) : ↑(Ici a) = Set.Ici a 
goal: ↑(UpperSet.Ici a) = Set.Ici a

full_name: UpperSet.coe_Ioi
code: @[simp]
theorem coe_Ioi (a : α) : ↑(Ioi a) = Set.Ioi a 
goal: ↑(UpperSet.Ioi a) = Set.Ioi a

full_name: UpperSet.mem_Ici_iff
code: @[simp]
theorem mem_Ici_iff : b ∈ Ici a ↔ a ≤ b 
goal: b ∈ UpperSet.Ici a ↔ a ≤ b

full_name: UpperSet.mem_Ioi_iff
code: @[simp]
theorem mem_Ioi_iff : b ∈ Ioi a ↔ a < b 
goal: b ∈ UpperSet.Ioi a ↔ a < b

full_name: UpperSet.map_Ici
code: @[simp]
theorem map_Ici (f : α ≃o β) (a : α) : map f (Ici a) = Ici (f a) 
goal: (UpperSet.map f) (UpperSet.Ici a) = UpperSet.Ici (f a)

full_name: UpperSet.map_Ioi
code: @[simp]
theorem map_Ioi (f : α ≃o β) (a : α) : map f (Ioi a) = Ioi (f a) 
goal: (UpperSet.map f) (UpperSet.Ioi a) = UpperSet.Ioi (f a)

full_name: UpperSet.Ici_le_Ioi
code: theorem Ici_le_Ioi (a : α) : Ici a ≤ Ioi a 
goal: UpperSet.Ici a ≤ UpperSet.Ioi a

full_name: UpperSet.Ici_bot
code: @[simp]
nonrec theorem Ici_bot [OrderBot α] : Ici (⊥ : α) = ⊥ 
goal: UpperSet.Ici ⊥ = ⊥

full_name: UpperSet.Ioi_top
code: @[simp]
nonrec theorem Ioi_top [OrderTop α] : Ioi (⊤ : α) = ⊤ 
goal: UpperSet.Ioi ⊤ = ⊤

full_name: UpperSet.Ici_ne_top
code: @[simp] lemma Ici_ne_top : Ici a ≠ ⊤ 
goal: UpperSet.Ici a ≠ ⊤

full_name: UpperSet.Ici_lt_top
code: @[simp] lemma Ici_lt_top : Ici a < ⊤ 
goal: UpperSet.Ici a < ⊤

full_name: UpperSet.le_Ici
code: @[simp] lemma le_Ici : s ≤ Ici a ↔ a ∈ s 
goal: s ≤ UpperSet.Ici a ↔ a ∈ s

full_name: UpperSet.Ici_injective
code: nonrec lemma Ici_injective : Injective (Ici : α → UpperSet α) 
goal: Function.Injective UpperSet.Ici

full_name: UpperSet.Ici_inj
code: @[simp] lemma Ici_inj : Ici a = Ici b ↔ a = b 
goal: UpperSet.Ici a = UpperSet.Ici b ↔ a = b

full_name: UpperSet.Ici_ne_Ici
code: lemma Ici_ne_Ici : Ici a ≠ Ici b ↔ a ≠ b 
goal: UpperSet.Ici a ≠ UpperSet.Ici b ↔ a ≠ b

full_name: UpperSet.Ici_sup
code: @[simp]
theorem Ici_sup [SemilatticeSup α] (a b : α) : Ici (a ⊔ b) = Ici a ⊔ Ici b 
goal: UpperSet.Ici (a ⊔ b) = UpperSet.Ici a ⊔ UpperSet.Ici b

full_name: UpperSet.Ici_sSup
code: @[simp]
theorem Ici_sSup (S : Set α) : Ici (sSup S) = ⨆ a ∈ S, Ici a 
goal: UpperSet.Ici (sSup S) = ⨆ a ∈ S, UpperSet.Ici a

full_name: UpperSet.Ici_iSup
code: @[simp]
theorem Ici_iSup (f : ι → α) : Ici (⨆ i, f i) = ⨆ i, Ici (f i) 
goal: UpperSet.Ici (⨆ i, f i) = ⨆ i, UpperSet.Ici (f i)

full_name: UpperSet.Ici_iSup₂
code: theorem Ici_iSup₂ (f : ∀ i, κ i → α) : Ici (⨆ (i) (j), f i j) = ⨆ (i) (j), Ici (f i j) 
goal: UpperSet.Ici (⨆ i, ⨆ j, f i j) = ⨆ i, ⨆ j, UpperSet.Ici (f i j)

full_name: LowerSet.Iic
code: /-- Principal lower set. `Set.Iic` as a lower set. The smallest lower set containing a given
element. -/
nonrec def Iic (a : α) : LowerSet α 
goal: LowerSet α

full_name: LowerSet.Iio
code: /-- Strict principal lower set. `Set.Iio` as a lower set. -/
nonrec def Iio (a : α) : LowerSet α 
goal: LowerSet α

full_name: LowerSet.coe_Iic
code: @[simp]
theorem coe_Iic (a : α) : ↑(Iic a) = Set.Iic a 
goal: ↑(LowerSet.Iic a) = Set.Iic a

full_name: LowerSet.coe_Iio
code: @[simp]
theorem coe_Iio (a : α) : ↑(Iio a) = Set.Iio a 
goal: ↑(LowerSet.Iio a) = Set.Iio a

full_name: LowerSet.mem_Iic_iff
code: @[simp]
theorem mem_Iic_iff : b ∈ Iic a ↔ b ≤ a 
goal: b ∈ LowerSet.Iic a ↔ b ≤ a

full_name: LowerSet.mem_Iio_iff
code: @[simp]
theorem mem_Iio_iff : b ∈ Iio a ↔ b < a 
goal: b ∈ LowerSet.Iio a ↔ b < a

full_name: LowerSet.map_Iic
code: @[simp]
theorem map_Iic (f : α ≃o β) (a : α) : map f (Iic a) = Iic (f a) 
goal: (LowerSet.map f) (LowerSet.Iic a) = LowerSet.Iic (f a)

full_name: LowerSet.map_Iio
code: @[simp]
theorem map_Iio (f : α ≃o β) (a : α) : map f (Iio a) = Iio (f a) 
goal: (LowerSet.map f) (LowerSet.Iio a) = LowerSet.Iio (f a)

full_name: LowerSet.Ioi_le_Ici
code: theorem Ioi_le_Ici (a : α) : Ioi a ≤ Ici a 
goal: Set.Ioi a ≤ Set.Ici a

full_name: LowerSet.Iic_top
code: @[simp]
nonrec theorem Iic_top [OrderTop α] : Iic (⊤ : α) = ⊤ 
goal: LowerSet.Iic ⊤ = ⊤

full_name: LowerSet.Iio_bot
code: @[simp]
nonrec theorem Iio_bot [OrderBot α] : Iio (⊥ : α) = ⊥ 
goal: LowerSet.Iio ⊥ = ⊥

full_name: LowerSet.Iic_ne_bot
code: @[simp] lemma Iic_ne_bot : Iic a ≠ ⊥ 
goal: LowerSet.Iic a ≠ ⊥

full_name: LowerSet.bot_lt_Iic
code: @[simp] lemma bot_lt_Iic : ⊥ < Iic a 
goal: ⊥ < LowerSet.Iic a

full_name: LowerSet.Iic_le
code: @[simp] lemma Iic_le : Iic a ≤ s ↔ a ∈ s 
goal: LowerSet.Iic a ≤ s ↔ a ∈ s

full_name: LowerSet.Iic_injective
code: nonrec lemma Iic_injective : Injective (Iic : α → LowerSet α) 
goal: Function.Injective LowerSet.Iic

full_name: LowerSet.Iic_inj
code: @[simp] lemma Iic_inj : Iic a = Iic b ↔ a = b 
goal: LowerSet.Iic a = LowerSet.Iic b ↔ a = b

full_name: LowerSet.Iic_ne_Iic
code: lemma Iic_ne_Iic : Iic a ≠ Iic b ↔ a ≠ b 
goal: LowerSet.Iic a ≠ LowerSet.Iic b ↔ a ≠ b

full_name: LowerSet.Iic_inf
code: @[simp]
theorem Iic_inf [SemilatticeInf α] (a b : α) : Iic (a ⊓ b) = Iic a ⊓ Iic b 
goal: LowerSet.Iic (a ⊓ b) = LowerSet.Iic a ⊓ LowerSet.Iic b

full_name: LowerSet.Iic_sInf
code: @[simp]
theorem Iic_sInf (S : Set α) : Iic (sInf S) = ⨅ a ∈ S, Iic a 
goal: LowerSet.Iic (sInf S) = ⨅ a ∈ S, LowerSet.Iic a

full_name: LowerSet.Iic_iInf
code: @[simp]
theorem Iic_iInf (f : ι → α) : Iic (⨅ i, f i) = ⨅ i, Iic (f i) 
goal: LowerSet.Iic (⨅ i, f i) = ⨅ i, LowerSet.Iic (f i)

full_name: LowerSet.Iic_iInf₂
code: theorem Iic_iInf₂ (f : ∀ i, κ i → α) : Iic (⨅ (i) (j), f i j) = ⨅ (i) (j), Iic (f i j) 
goal: LowerSet.Iic (⨅ i, ⨅ j, f i j) = ⨅ i, ⨅ j, LowerSet.Iic (f i j)

full_name: upperClosure
code: /-- The greatest upper set containing a given set. -/
def upperClosure (s : Set α) : UpperSet α 
goal: UpperSet α

full_name: lowerClosure
code: /-- The least lower set containing a given set. -/
def lowerClosure (s : Set α) : LowerSet α 
goal: LowerSet α

full_name: mem_upperClosure
code: @[simp]
theorem mem_upperClosure : x ∈ upperClosure s ↔ ∃ a ∈ s, a ≤ x 
goal: x ∈ upperClosure s ↔ ∃ a ∈ s, a ≤ x

full_name: mem_lowerClosure
code: @[simp]
theorem mem_lowerClosure : x ∈ lowerClosure s ↔ ∃ a ∈ s, x ≤ a 
goal: x ∈ lowerClosure s ↔ ∃ a ∈ s, x ≤ a

full_name: coe_upperClosure
code: @[norm_cast]
theorem coe_upperClosure (s : Set α) : ↑(upperClosure s) = ⋃ a ∈ s, Ici a 
goal: ↑(upperClosure s) = ⋃ a ∈ s, Set.Ici a

full_name: coe_lowerClosure
code: @[norm_cast]
theorem coe_lowerClosure (s : Set α) : ↑(lowerClosure s) = ⋃ a ∈ s, Iic a 
goal: ↑(lowerClosure s) = ⋃ a ∈ s, Set.Iic a

full_name: instDecidablePredMemUpperClosure
code: instance instDecidablePredMemUpperClosure [DecidablePred (∃ a ∈ s, a ≤ ·)] :
    DecidablePred (· ∈ upperClosure s) 
goal: DecidablePred fun x => x ∈ upperClosure s

full_name: instDecidablePredMemLowerClosure
code: instance instDecidablePredMemLowerClosure [DecidablePred (∃ a ∈ s, · ≤ a)] :
    DecidablePred (· ∈ lowerClosure s) 
goal: DecidablePred fun x => x ∈ lowerClosure s

full_name: subset_upperClosure
code: theorem subset_upperClosure : s ⊆ upperClosure s 
goal: s ⊆ ↑(upperClosure s)

full_name: subset_lowerClosure
code: theorem subset_lowerClosure : s ⊆ lowerClosure s 
goal: s ⊆ ↑(lowerClosure s)

full_name: upperClosure_min
code: theorem upperClosure_min (h : s ⊆ t) (ht : IsUpperSet t) : ↑(upperClosure s) ⊆ t 
goal: ↑(upperClosure s) ⊆ t

full_name: lowerClosure_min
code: theorem lowerClosure_min (h : s ⊆ t) (ht : IsLowerSet t) : ↑(lowerClosure s) ⊆ t 
goal: ↑(lowerClosure s) ⊆ t

full_name: IsUpperSet.upperClosure
code: protected theorem IsUpperSet.upperClosure (hs : IsUpperSet s) : ↑(upperClosure s) = s 
goal: ↑(upperClosure s) = s

full_name: IsLowerSet.lowerClosure
code: protected theorem IsLowerSet.lowerClosure (hs : IsLowerSet s) : ↑(lowerClosure s) = s 
goal: ↑(lowerClosure s) = s

full_name: UpperSet.upperClosure
code: @[simp]
protected theorem UpperSet.upperClosure (s : UpperSet α) : upperClosure (s : Set α) = s 
goal: upperClosure ↑s = s

full_name: LowerSet.lowerClosure
code: @[simp]
protected theorem LowerSet.lowerClosure (s : LowerSet α) : lowerClosure (s : Set α) = s 
goal: lowerClosure ↑s = s

full_name: upperClosure_image
code: @[simp]
theorem upperClosure_image (f : α ≃o β) :
    upperClosure (f '' s) = UpperSet.map f (upperClosure s) 
goal: upperClosure (⇑f '' s) = (UpperSet.map f) (upperClosure s)

full_name: lowerClosure_image
code: @[simp]
theorem lowerClosure_image (f : α ≃o β) :
    lowerClosure (f '' s) = LowerSet.map f (lowerClosure s) 
goal: lowerClosure (⇑f '' s) = (LowerSet.map f) (lowerClosure s)

full_name: UpperSet.iInf_Ici
code: @[simp]
theorem UpperSet.iInf_Ici (s : Set α) : ⨅ a ∈ s, UpperSet.Ici a = upperClosure s 
goal: ⨅ a ∈ s, UpperSet.Ici a = upperClosure s

full_name: LowerSet.iSup_Iic
code: @[simp]
theorem LowerSet.iSup_Iic (s : Set α) : ⨆ a ∈ s, LowerSet.Iic a = lowerClosure s 
goal: ⨆ a ∈ s, LowerSet.Iic a = lowerClosure s

full_name: lowerClosure_le
code: @[simp] lemma lowerClosure_le {t : LowerSet α} : lowerClosure s ≤ t ↔ s ⊆ t 
goal: lowerClosure s ≤ t ↔ s ⊆ ↑t

full_name: le_upperClosure
code: @[simp] lemma le_upperClosure {s : UpperSet α} : s ≤ upperClosure t ↔ t ⊆ s 
goal: s ≤ upperClosure t ↔ t ⊆ ↑s

full_name: gc_upperClosure_coe
code: theorem gc_upperClosure_coe :
    GaloisConnection (toDual ∘ upperClosure : Set α → (UpperSet α)ᵒᵈ) ((↑) ∘ ofDual) 
goal: GaloisConnection (⇑OrderDual.toDual ∘ upperClosure) (SetLike.coe ∘ ⇑OrderDual.ofDual)

full_name: gc_lowerClosure_coe
code: theorem gc_lowerClosure_coe :
    GaloisConnection (lowerClosure : Set α → LowerSet α) (↑) 
goal: GaloisConnection lowerClosure SetLike.coe

full_name: giUpperClosureCoe
code: /-- `upperClosure` forms a reversed Galois insertion with the coercion from upper sets to sets. -/
def giUpperClosureCoe :
    GaloisInsertion (toDual ∘ upperClosure : Set α → (UpperSet α)ᵒᵈ) ((↑) ∘ ofDual) 
goal: GaloisInsertion (⇑OrderDual.toDual ∘ upperClosure) (SetLike.coe ∘ ⇑OrderDual.ofDual)

full_name: giLowerClosureCoe
code: /-- `lowerClosure` forms a Galois insertion with the coercion from lower sets to sets. -/
def giLowerClosureCoe : GaloisInsertion (lowerClosure : Set α → LowerSet α) (↑) 
goal: GaloisInsertion lowerClosure SetLike.coe

full_name: upperClosure_anti
code: theorem upperClosure_anti : Antitone (upperClosure : Set α → UpperSet α) 
goal: Antitone upperClosure

full_name: lowerClosure_mono
code: theorem lowerClosure_mono : Monotone (lowerClosure : Set α → LowerSet α) 
goal: Monotone lowerClosure

full_name: upperClosure_empty
code: @[simp]
theorem upperClosure_empty : upperClosure (∅ : Set α) = ⊤ 
goal: upperClosure ∅ = ⊤

full_name: lowerClosure_empty
code: @[simp]
theorem lowerClosure_empty : lowerClosure (∅ : Set α) = ⊥ 
goal: lowerClosure ∅ = ⊥

full_name: upperClosure_singleton
code: @[simp]
theorem upperClosure_singleton (a : α) : upperClosure ({a} : Set α) = UpperSet.Ici a 
goal: upperClosure {a} = UpperSet.Ici a

full_name: lowerClosure_singleton
code: @[simp]
theorem lowerClosure_singleton (a : α) : lowerClosure ({a} : Set α) = LowerSet.Iic a 
goal: lowerClosure {a} = LowerSet.Iic a

full_name: upperClosure_univ
code: @[simp]
theorem upperClosure_univ : upperClosure (univ : Set α) = ⊥ 
goal: upperClosure Set.univ = ⊥

full_name: lowerClosure_univ
code: @[simp]
theorem lowerClosure_univ : lowerClosure (univ : Set α) = ⊤ 
goal: lowerClosure Set.univ = ⊤

full_name: upperClosure_eq_top_iff
code: @[simp]
theorem upperClosure_eq_top_iff : upperClosure s = ⊤ ↔ s = ∅ 
goal: upperClosure s = ⊤ ↔ s = ∅

full_name: lowerClosure_eq_bot_iff
code: @[simp]
theorem lowerClosure_eq_bot_iff : lowerClosure s = ⊥ ↔ s = ∅ 
goal: lowerClosure s = ⊥ ↔ s = ∅

full_name: upperClosure_union
code: @[simp]
theorem upperClosure_union (s t : Set α) : upperClosure (s ∪ t) = upperClosure s ⊓ upperClosure t 
goal: upperClosure (s ∪ t) = upperClosure s ⊓ upperClosure t

full_name: lowerClosure_union
code: @[simp]
theorem lowerClosure_union (s t : Set α) : lowerClosure (s ∪ t) = lowerClosure s ⊔ lowerClosure t 
goal: lowerClosure (s ∪ t) = lowerClosure s ⊔ lowerClosure t

full_name: upperClosure_iUnion
code: @[simp]
theorem upperClosure_iUnion (f : ι → Set α) : upperClosure (⋃ i, f i) = ⨅ i, upperClosure (f i) 
goal: upperClosure (⋃ i, f i) = ⨅ i, upperClosure (f i)

full_name: lowerClosure_iUnion
code: @[simp]
theorem lowerClosure_iUnion (f : ι → Set α) : lowerClosure (⋃ i, f i) = ⨆ i, lowerClosure (f i) 
goal: lowerClosure (⋃ i, f i) = ⨆ i, lowerClosure (f i)

full_name: upperClosure_sUnion
code: @[simp]
theorem upperClosure_sUnion (S : Set (Set α)) : upperClosure (⋃₀ S) = ⨅ s ∈ S, upperClosure s 
goal: upperClosure (⋃₀ S) = ⨅ s ∈ S, upperClosure s

full_name: lowerClosure_sUnion
code: @[simp]
theorem lowerClosure_sUnion (S : Set (Set α)) : lowerClosure (⋃₀ S) = ⨆ s ∈ S, lowerClosure s 
goal: lowerClosure (⋃₀ S) = ⨆ s ∈ S, lowerClosure s

full_name: Set.OrdConnected.upperClosure_inter_lowerClosure
code: theorem Set.OrdConnected.upperClosure_inter_lowerClosure (h : s.OrdConnected) :
    ↑(upperClosure s) ∩ ↑(lowerClosure s) = s 
goal: ↑(upperClosure s) ∩ ↑(lowerClosure s) = s

full_name: ordConnected_iff_upperClosure_inter_lowerClosure
code: theorem ordConnected_iff_upperClosure_inter_lowerClosure :
    s.OrdConnected ↔ ↑(upperClosure s) ∩ ↑(lowerClosure s) = s 
goal: s.OrdConnected ↔ ↑(upperClosure s) ∩ ↑(lowerClosure s) = s

full_name: upperBounds_lowerClosure
code: @[simp]
theorem upperBounds_lowerClosure : upperBounds (lowerClosure s : Set α) = upperBounds s 
goal: upperBounds ↑(lowerClosure s) = upperBounds s

full_name: lowerBounds_upperClosure
code: @[simp]
theorem lowerBounds_upperClosure : lowerBounds (upperClosure s : Set α) = lowerBounds s 
goal: lowerBounds ↑(upperClosure s) = lowerBounds s

full_name: bddAbove_lowerClosure
code: @[simp]
theorem bddAbove_lowerClosure : BddAbove (lowerClosure s : Set α) ↔ BddAbove s 
goal: BddAbove ↑(lowerClosure s) ↔ BddAbove s

full_name: bddBelow_upperClosure
code: @[simp]
theorem bddBelow_upperClosure : BddBelow (upperClosure s : Set α) ↔ BddBelow s 
goal: BddBelow ↑(upperClosure s) ↔ BddBelow s

full_name: IsLowerSet.disjoint_upperClosure_left
code: @[simp] lemma IsLowerSet.disjoint_upperClosure_left (ht : IsLowerSet t) :
    Disjoint ↑(upperClosure s) t ↔ Disjoint s t 
goal: Disjoint (↑(upperClosure s)) t ↔ Disjoint s t

full_name: IsLowerSet.disjoint_upperClosure_right
code: @[simp] lemma IsLowerSet.disjoint_upperClosure_right (hs : IsLowerSet s) :
    Disjoint s (upperClosure t) ↔ Disjoint s t 
goal: Disjoint s ↑(upperClosure t) ↔ Disjoint s t

full_name: IsUpperSet.disjoint_lowerClosure_left
code: @[simp] lemma IsUpperSet.disjoint_lowerClosure_left (ht : IsUpperSet t) :
    Disjoint ↑(lowerClosure s) t ↔ Disjoint s t 
goal: Disjoint (↑(lowerClosure s)) t ↔ Disjoint s t

full_name: IsUpperSet.disjoint_lowerClosure_right
code: @[simp] lemma IsUpperSet.disjoint_lowerClosure_right (hs : IsUpperSet s) :
    Disjoint s (lowerClosure t) ↔ Disjoint s t 
goal: Disjoint s ↑(lowerClosure t) ↔ Disjoint s t

full_name: upperClosure_eq
code: @[simp] lemma upperClosure_eq :
    ↑(upperClosure s) = s ↔ IsUpperSet s 
goal: ↑(upperClosure s) = s ↔ IsUpperSet s

full_name: lowerClosure_eq
code: @[simp] lemma lowerClosure_eq :
    ↑(lowerClosure s) = s ↔ IsLowerSet s 
goal: ↑(lowerClosure s) = s ↔ IsLowerSet s

full_name: LowerSet.sdiff
code: /-- The biggest lower subset of a lower set `s` disjoint from a set `t`. -/
def sdiff (s : LowerSet α) (t : Set α) : LowerSet α 
goal: LowerSet α

full_name: LowerSet.erase
code: /-- The biggest lower subset of a lower set `s` not containing an element `a`. -/
def erase (s : LowerSet α) (a : α) : LowerSet α 
goal: LowerSet α

full_name: LowerSet.coe_sdiff
code: @[simp, norm_cast]
lemma coe_sdiff (s : LowerSet α) (t : Set α) : s.sdiff t = (s : Set α) \ upperClosure t 
goal: ↑(s.sdiff t) = ↑s \ ↑(upperClosure t)

full_name: LowerSet.coe_erase
code: @[simp, norm_cast]
lemma coe_erase (s : LowerSet α) (a : α) : s.erase a = (s : Set α) \ UpperSet.Ici a 
goal: ↑(s.erase a) = ↑s \ ↑(UpperSet.Ici a)

full_name: LowerSet.sdiff_singleton
code: @[simp] lemma sdiff_singleton (s : LowerSet α) (a : α) : s.sdiff {a} = s.erase a 
goal: s.sdiff {a} = s.erase a

full_name: LowerSet.sdiff_le_left
code: lemma sdiff_le_left : s.sdiff t ≤ s 
goal: s.sdiff t ≤ s

full_name: LowerSet.erase_le
code: lemma erase_le : s.erase a ≤ s 
goal: s.erase a ≤ s

full_name: LowerSet.sdiff_eq_left
code: @[simp] protected lemma sdiff_eq_left : s.sdiff t = s ↔ Disjoint ↑s t 
goal: s.sdiff t = s ↔ Disjoint (↑s) t

full_name: LowerSet.erase_eq
code: @[simp] lemma erase_eq : s.erase a = s ↔ a ∉ s 
goal: s.erase a = s ↔ a ∉ s

full_name: LowerSet.sdiff_lt_left
code: @[simp] lemma sdiff_lt_left : s.sdiff t < s ↔ ¬ Disjoint ↑s t 
goal: s.sdiff t < s ↔ ¬Disjoint (↑s) t

full_name: LowerSet.erase_lt
code: @[simp] lemma erase_lt : s.erase a < s ↔ a ∈ s 
goal: s.erase a < s ↔ a ∈ s

full_name: LowerSet.sdiff_idem
code: @[simp] protected lemma sdiff_idem (s : LowerSet α) (t : Set α) : (s.sdiff t).sdiff t = s.sdiff t 
goal: (s.sdiff t).sdiff t = s.sdiff t

full_name: LowerSet.erase_idem
code: @[simp] lemma erase_idem (s : LowerSet α) (a : α) : (s.erase a).erase a = s.erase a 
goal: (s.erase a).erase a = s.erase a

full_name: LowerSet.sdiff_sup_lowerClosure
code: lemma sdiff_sup_lowerClosure (hts : t ⊆ s) (hst : ∀ b ∈ s, ∀ c ∈ t, c ≤ b → b ∈ t) :
    s.sdiff t ⊔ lowerClosure t = s 
goal: s.sdiff t ⊔ lowerClosure t = s

full_name: LowerSet.lowerClosure_sup_sdiff
code: lemma lowerClosure_sup_sdiff (hts : t ⊆ s) (hst : ∀ b ∈ s, ∀ c ∈ t, c ≤ b → b ∈ t) :
    lowerClosure t ⊔ s.sdiff t = s 
goal: lowerClosure t ⊔ s.sdiff t = s

full_name: LowerSet.erase_sup_Iic
code: lemma erase_sup_Iic (ha : a ∈ s) (has : ∀ b ∈ s, a ≤ b → b = a) : s.erase a ⊔ Iic a = s 
goal: s.erase a ⊔ LowerSet.Iic a = s

full_name: LowerSet.Iic_sup_erase
code: lemma Iic_sup_erase (ha : a ∈ s) (has : ∀ b ∈ s, a ≤ b → b = a) : Iic a ⊔ s.erase a = s 
goal: LowerSet.Iic a ⊔ s.erase a = s

full_name: UpperSet.sdiff
code: /-- The biggest upper subset of a upper set `s` disjoint from a set `t`. -/
def sdiff (s : UpperSet α) (t : Set α) : UpperSet α 
goal: UpperSet α

full_name: UpperSet.erase
code: /-- The biggest upper subset of a upper set `s` not containing an element `a`. -/
def erase (s : UpperSet α) (a : α) : UpperSet α 
goal: UpperSet α

full_name: UpperSet.coe_sdiff
code: @[simp, norm_cast]
lemma coe_sdiff (s : UpperSet α) (t : Set α) : s.sdiff t = (s : Set α) \ lowerClosure t 
goal: ↑(s.sdiff t) = ↑s \ ↑(lowerClosure t)

full_name: UpperSet.coe_erase
code: @[simp, norm_cast]
lemma coe_erase (s : UpperSet α) (a : α) : s.erase a = (s : Set α) \ LowerSet.Iic a 
goal: ↑(s.erase a) = ↑s \ ↑(LowerSet.Iic a)

full_name: UpperSet.sdiff_singleton
code: @[simp] lemma sdiff_singleton (s : UpperSet α) (a : α) : s.sdiff {a} = s.erase a 
goal: s.sdiff {a} = s.erase a

full_name: UpperSet.le_sdiff_left
code: lemma le_sdiff_left : s ≤ s.sdiff t 
goal: s ≤ s.sdiff t

full_name: UpperSet.le_erase
code: lemma le_erase : s ≤ s.erase a 
goal: s ≤ s.erase a

full_name: UpperSet.sdiff_eq_left
code: @[simp] protected lemma sdiff_eq_left : s.sdiff t = s ↔ Disjoint ↑s t 
goal: s.sdiff t = s ↔ Disjoint (↑s) t

full_name: UpperSet.erase_eq
code: @[simp] lemma erase_eq : s.erase a = s ↔ a ∉ s 
goal: s.erase a = s ↔ a ∉ s

full_name: UpperSet.lt_sdiff_left
code: @[simp] lemma lt_sdiff_left : s < s.sdiff t ↔ ¬ Disjoint ↑s t 
goal: s < s.sdiff t ↔ ¬Disjoint (↑s) t

full_name: UpperSet.lt_erase
code: @[simp] lemma lt_erase : s < s.erase a ↔ a ∈ s 
goal: s < s.erase a ↔ a ∈ s

full_name: UpperSet.sdiff_idem
code: @[simp] protected lemma sdiff_idem (s : UpperSet α) (t : Set α) : (s.sdiff t).sdiff t = s.sdiff t 
goal: (s.sdiff t).sdiff t = s.sdiff t

full_name: UpperSet.erase_idem
code: @[simp] lemma erase_idem (s : UpperSet α) (a : α) : (s.erase a).erase a = s.erase a 
goal: (s.erase a).erase a = s.erase a

full_name: UpperSet.sdiff_inf_upperClosure
code: lemma sdiff_inf_upperClosure (hts : t ⊆ s) (hst : ∀ b ∈ s, ∀ c ∈ t, b ≤ c → b ∈ t) :
    s.sdiff t ⊓ upperClosure t = s 
goal: s.sdiff t ⊓ upperClosure t = s

full_name: UpperSet.upperClosure_inf_sdiff
code: lemma upperClosure_inf_sdiff (hts : t ⊆ s) (hst : ∀ b ∈ s, ∀ c ∈ t, b ≤ c → b ∈ t) :
    upperClosure t ⊓ s.sdiff t = s 
goal: upperClosure t ⊓ s.sdiff t = s

full_name: UpperSet.erase_inf_Ici
code: lemma erase_inf_Ici (ha : a ∈ s) (has : ∀ b ∈ s, b ≤ a → b = a) : s.erase a ⊓ Ici a = s 
goal: s.erase a ⊓ UpperSet.Ici a = s

full_name: UpperSet.Ici_inf_erase
code: lemma Ici_inf_erase (ha : a ∈ s) (has : ∀ b ∈ s, b ≤ a → b = a) : Ici a ⊓ s.erase a = s 
goal: UpperSet.Ici a ⊓ s.erase a = s

full_name: IsUpperSet.prod
code: theorem IsUpperSet.prod (hs : IsUpperSet s) (ht : IsUpperSet t) : IsUpperSet (s ×ˢ t) 
goal: IsUpperSet (s ×ˢ t)

full_name: IsLowerSet.prod
code: theorem IsLowerSet.prod (hs : IsLowerSet s) (ht : IsLowerSet t) : IsLowerSet (s ×ˢ t) 
goal: IsLowerSet (s ×ˢ t)

full_name: UpperSet.prod
code: /-- The product of two upper sets as an upper set. -/
def prod : UpperSet (α × β) 
goal: UpperSet (α × β)

full_name: UpperSet.instSProd
code: instance instSProd : SProd (UpperSet α) (UpperSet β) (UpperSet (α × β)) 
goal: SProd (UpperSet α) (UpperSet β) (UpperSet (α × β))

full_name: UpperSet.coe_prod
code: @[simp, norm_cast]
theorem coe_prod : ((s ×ˢ t : UpperSet (α × β)) : Set (α × β)) = (s : Set α) ×ˢ t 
goal: ↑(s ×ˢ t) = ↑s ×ˢ ↑t

full_name: UpperSet.mem_prod
code: @[simp]
theorem mem_prod {s : UpperSet α} {t : UpperSet β} : x ∈ s ×ˢ t ↔ x.1 ∈ s ∧ x.2 ∈ t 
goal: x ∈ s ×ˢ t ↔ x.1 ∈ s ∧ x.2 ∈ t

full_name: UpperSet.Ici_prod
code: theorem Ici_prod (x : α × β) : Ici x = Ici x.1 ×ˢ Ici x.2 
goal: UpperSet.Ici x = UpperSet.Ici x.1 ×ˢ UpperSet.Ici x.2

full_name: UpperSet.Ici_prod_Ici
code: @[simp]
theorem Ici_prod_Ici (a : α) (b : β) : Ici a ×ˢ Ici b = Ici (a, b) 
goal: UpperSet.Ici a ×ˢ UpperSet.Ici b = UpperSet.Ici (a, b)

full_name: UpperSet.prod_top
code: @[simp]
theorem prod_top : s ×ˢ (⊤ : UpperSet β) = ⊤ 
goal: s ×ˢ ⊤ = ⊤

full_name: UpperSet.top_prod
code: @[simp]
theorem top_prod : (⊤ : UpperSet α) ×ˢ t = ⊤ 
goal: ⊤ ×ˢ t = ⊤

full_name: UpperSet.bot_prod_bot
code: @[simp]
theorem bot_prod_bot : (⊥ : UpperSet α) ×ˢ (⊥ : UpperSet β) = ⊥ 
goal: ⊥ ×ˢ ⊥ = ⊥

full_name: UpperSet.sup_prod
code: @[simp]
theorem sup_prod : (s₁ ⊔ s₂) ×ˢ t = s₁ ×ˢ t ⊔ s₂ ×ˢ t 
goal: (s₁ ⊔ s₂) ×ˢ t = s₁ ×ˢ t ⊔ s₂ ×ˢ t

full_name: UpperSet.prod_sup
code: @[simp]
theorem prod_sup : s ×ˢ (t₁ ⊔ t₂) = s ×ˢ t₁ ⊔ s ×ˢ t₂ 
goal: s ×ˢ (t₁ ⊔ t₂) = s ×ˢ t₁ ⊔ s ×ˢ t₂

full_name: UpperSet.inf_prod
code: @[simp]
theorem inf_prod : (s₁ ⊓ s₂) ×ˢ t = s₁ ×ˢ t ⊓ s₂ ×ˢ t 
goal: (s₁ ⊓ s₂) ×ˢ t = s₁ ×ˢ t ⊓ s₂ ×ˢ t

full_name: UpperSet.prod_inf
code: @[simp]
theorem prod_inf : s ×ˢ (t₁ ⊓ t₂) = s ×ˢ t₁ ⊓ s ×ˢ t₂ 
goal: s ×ˢ (t₁ ⊓ t₂) = s ×ˢ t₁ ⊓ s ×ˢ t₂

full_name: UpperSet.prod_sup_prod
code: theorem prod_sup_prod : s₁ ×ˢ t₁ ⊔ s₂ ×ˢ t₂ = (s₁ ⊔ s₂) ×ˢ (t₁ ⊔ t₂) 
goal: s₁ ×ˢ t₁ ⊔ s₂ ×ˢ t₂ = (s₁ ⊔ s₂) ×ˢ (t₁ ⊔ t₂)

full_name: UpperSet.prod_mono
code: @[mono]
theorem prod_mono : s₁ ≤ s₂ → t₁ ≤ t₂ → s₁ ×ˢ t₁ ≤ s₂ ×ˢ t₂ 
goal: s₁ ≤ s₂ → t₁ ≤ t₂ → s₁ ×ˢ t₁ ≤ s₂ ×ˢ t₂

full_name: UpperSet.prod_mono_left
code: theorem prod_mono_left : s₁ ≤ s₂ → s₁ ×ˢ t ≤ s₂ ×ˢ t 
goal: s₁ ≤ s₂ → s₁ ×ˢ t ≤ s₂ ×ˢ t

full_name: UpperSet.prod_mono_right
code: theorem prod_mono_right : t₁ ≤ t₂ → s ×ˢ t₁ ≤ s ×ˢ t₂ 
goal: t₁ ≤ t₂ → s ×ˢ t₁ ≤ s ×ˢ t₂

full_name: UpperSet.prod_self_le_prod_self
code: @[simp]
theorem prod_self_le_prod_self : s₁ ×ˢ s₁ ≤ s₂ ×ˢ s₂ ↔ s₁ ≤ s₂ 
goal: s₁ ×ˢ s₁ ≤ s₂ ×ˢ s₂ ↔ s₁ ≤ s₂

full_name: UpperSet.prod_self_lt_prod_self
code: @[simp]
theorem prod_self_lt_prod_self : s₁ ×ˢ s₁ < s₂ ×ˢ s₂ ↔ s₁ < s₂ 
goal: s₁ ×ˢ s₁ < s₂ ×ˢ s₂ ↔ s₁ < s₂

full_name: UpperSet.prod_le_prod_iff
code: theorem prod_le_prod_iff : s₁ ×ˢ t₁ ≤ s₂ ×ˢ t₂ ↔ s₁ ≤ s₂ ∧ t₁ ≤ t₂ ∨ s₂ = ⊤ ∨ t₂ = ⊤ 
goal: s₁ ×ˢ t₁ ≤ s₂ ×ˢ t₂ ↔ s₁ ≤ s₂ ∧ t₁ ≤ t₂ ∨ s₂ = ⊤ ∨ t₂ = ⊤

full_name: UpperSet.prod_eq_top
code: @[simp]
theorem prod_eq_top : s ×ˢ t = ⊤ ↔ s = ⊤ ∨ t = ⊤ 
goal: s ×ˢ t = ⊤ ↔ s = ⊤ ∨ t = ⊤

full_name: UpperSet.codisjoint_prod
code: @[simp]
theorem codisjoint_prod :
    Codisjoint (s₁ ×ˢ t₁) (s₂ ×ˢ t₂) ↔ Codisjoint s₁ s₂ ∨ Codisjoint t₁ t₂ 
goal: Codisjoint (s₁ ×ˢ t₁) (s₂ ×ˢ t₂) ↔ Codisjoint s₁ s₂ ∨ Codisjoint t₁ t₂

full_name: LowerSet.prod
code: /-- The product of two lower sets as a lower set. -/
def prod : LowerSet (α × β) 
goal: LowerSet (α × β)

full_name: LowerSet.instSProd
code: instance instSProd : SProd (LowerSet α) (LowerSet β) (LowerSet (α × β)) 
goal: SProd (LowerSet α) (LowerSet β) (LowerSet (α × β))

full_name: LowerSet.coe_prod
code: @[simp, norm_cast]
theorem coe_prod : ((s ×ˢ t : LowerSet (α × β)) : Set (α × β)) = (s : Set α) ×ˢ t 
goal: ↑(s ×ˢ t) = ↑s ×ˢ ↑t

full_name: LowerSet.mem_prod
code: @[simp]
theorem mem_prod {s : LowerSet α} {t : LowerSet β} : x ∈ s ×ˢ t ↔ x.1 ∈ s ∧ x.2 ∈ t 
goal: x ∈ s ×ˢ t ↔ x.1 ∈ s ∧ x.2 ∈ t

full_name: LowerSet.Iic_prod
code: theorem Iic_prod (x : α × β) : Iic x = Iic x.1 ×ˢ Iic x.2 
goal: LowerSet.Iic x = LowerSet.Iic x.1 ×ˢ LowerSet.Iic x.2

full_name: LowerSet.Ici_prod_Ici
code: @[simp]
theorem Ici_prod_Ici (a : α) (b : β) : Iic a ×ˢ Iic b = Iic (a, b) 
goal: LowerSet.Iic a ×ˢ LowerSet.Iic b = LowerSet.Iic (a, b)

full_name: LowerSet.prod_bot
code: @[simp]
theorem prod_bot : s ×ˢ (⊥ : LowerSet β) = ⊥ 
goal: s ×ˢ ⊥ = ⊥

full_name: LowerSet.bot_prod
code: @[simp]
theorem bot_prod : (⊥ : LowerSet α) ×ˢ t = ⊥ 
goal: ⊥ ×ˢ t = ⊥

full_name: LowerSet.top_prod_top
code: @[simp]
theorem top_prod_top : (⊤ : LowerSet α) ×ˢ (⊤ : LowerSet β) = ⊤ 
goal: ⊤ ×ˢ ⊤ = ⊤

full_name: LowerSet.inf_prod
code: @[simp]
theorem inf_prod : (s₁ ⊓ s₂) ×ˢ t = s₁ ×ˢ t ⊓ s₂ ×ˢ t 
goal: (s₁ ⊓ s₂) ×ˢ t = s₁ ×ˢ t ⊓ s₂ ×ˢ t

full_name: LowerSet.prod_inf
code: @[simp]
theorem prod_inf : s ×ˢ (t₁ ⊓ t₂) = s ×ˢ t₁ ⊓ s ×ˢ t₂ 
goal: s ×ˢ (t₁ ⊓ t₂) = s ×ˢ t₁ ⊓ s ×ˢ t₂

full_name: LowerSet.sup_prod
code: @[simp]
theorem sup_prod : (s₁ ⊔ s₂) ×ˢ t = s₁ ×ˢ t ⊔ s₂ ×ˢ t 
goal: (s₁ ⊔ s₂) ×ˢ t = s₁ ×ˢ t ⊔ s₂ ×ˢ t

full_name: LowerSet.prod_sup
code: @[simp]
theorem prod_sup : s ×ˢ (t₁ ⊔ t₂) = s ×ˢ t₁ ⊔ s ×ˢ t₂ 
goal: s ×ˢ (t₁ ⊔ t₂) = s ×ˢ t₁ ⊔ s ×ˢ t₂

full_name: LowerSet.prod_inf_prod
code: theorem prod_inf_prod : s₁ ×ˢ t₁ ⊓ s₂ ×ˢ t₂ = (s₁ ⊓ s₂) ×ˢ (t₁ ⊓ t₂) 
goal: s₁ ×ˢ t₁ ⊓ s₂ ×ˢ t₂ = (s₁ ⊓ s₂) ×ˢ (t₁ ⊓ t₂)

full_name: LowerSet.prod_mono
code: theorem prod_mono : s₁ ≤ s₂ → t₁ ≤ t₂ → s₁ ×ˢ t₁ ≤ s₂ ×ˢ t₂ 
goal: s₁ ≤ s₂ → t₁ ≤ t₂ → s₁ ×ˢ t₁ ≤ s₂ ×ˢ t₂

full_name: LowerSet.prod_mono_left
code: theorem prod_mono_left : s₁ ≤ s₂ → s₁ ×ˢ t ≤ s₂ ×ˢ t 
goal: s₁ ≤ s₂ → s₁ ×ˢ t ≤ s₂ ×ˢ t

full_name: LowerSet.prod_mono_right
code: theorem prod_mono_right : t₁ ≤ t₂ → s ×ˢ t₁ ≤ s ×ˢ t₂ 
goal: t₁ ≤ t₂ → s ×ˢ t₁ ≤ s ×ˢ t₂

full_name: LowerSet.prod_self_le_prod_self
code: @[simp]
theorem prod_self_le_prod_self : s₁ ×ˢ s₁ ≤ s₂ ×ˢ s₂ ↔ s₁ ≤ s₂ 
goal: s₁ ×ˢ s₁ ≤ s₂ ×ˢ s₂ ↔ s₁ ≤ s₂

full_name: LowerSet.prod_self_lt_prod_self
code: @[simp]
theorem prod_self_lt_prod_self : s₁ ×ˢ s₁ < s₂ ×ˢ s₂ ↔ s₁ < s₂ 
goal: s₁ ×ˢ s₁ < s₂ ×ˢ s₂ ↔ s₁ < s₂

full_name: LowerSet.prod_le_prod_iff
code: theorem prod_le_prod_iff : s₁ ×ˢ t₁ ≤ s₂ ×ˢ t₂ ↔ s₁ ≤ s₂ ∧ t₁ ≤ t₂ ∨ s₁ = ⊥ ∨ t₁ = ⊥ 
goal: s₁ ×ˢ t₁ ≤ s₂ ×ˢ t₂ ↔ s₁ ≤ s₂ ∧ t₁ ≤ t₂ ∨ s₁ = ⊥ ∨ t₁ = ⊥

full_name: LowerSet.prod_eq_bot
code: @[simp]
theorem prod_eq_bot : s ×ˢ t = ⊥ ↔ s = ⊥ ∨ t = ⊥ 
goal: s ×ˢ t = ⊥ ↔ s = ⊥ ∨ t = ⊥

full_name: LowerSet.disjoint_prod
code: @[simp]
theorem disjoint_prod : Disjoint (s₁ ×ˢ t₁) (s₂ ×ˢ t₂) ↔ Disjoint s₁ s₂ ∨ Disjoint t₁ t₂ 
goal: Disjoint (s₁ ×ˢ t₁) (s₂ ×ˢ t₂) ↔ Disjoint s₁ s₂ ∨ Disjoint t₁ t₂

full_name: upperClosure_prod
code: @[simp]
theorem upperClosure_prod (s : Set α) (t : Set β) :
    upperClosure (s ×ˢ t) = upperClosure s ×ˢ upperClosure t 
goal: upperClosure (s ×ˢ t) = upperClosure s ×ˢ upperClosure t

full_name: lowerClosure_prod
code: @[simp]
theorem lowerClosure_prod (s : Set α) (t : Set β) :
    lowerClosure (s ×ˢ t) = lowerClosure s ×ˢ lowerClosure t 
goal: lowerClosure (s ×ˢ t) = lowerClosure s ×ˢ lowerClosure t