File: Mathlib/Order/SupClosed.lean

full_name: SupClosed
code: /-- A set `s` is *sup-closed* if `a ⊔ b ∈ s` for all `a ∈ s`, `b ∈ s`. -/
def SupClosed (s : Set α) : Prop 
goal: Prop

full_name: supClosed_empty
code: @[simp] lemma supClosed_empty : SupClosed (∅ : Set α) 
goal: SupClosed ∅

full_name: supClosed_singleton
code: @[simp] lemma supClosed_singleton : SupClosed ({a} : Set α) 
goal: SupClosed {a}

full_name: supClosed_univ
code: @[simp] lemma supClosed_univ : SupClosed (univ : Set α) 
goal: SupClosed Set.univ

full_name: SupClosed.inter
code: lemma SupClosed.inter (hs : SupClosed s) (ht : SupClosed t) : SupClosed (s ∩ t) 
goal: SupClosed (s ∩ t)

full_name: supClosed_sInter
code: lemma supClosed_sInter (hS : ∀ s ∈ S, SupClosed s) : SupClosed (⋂₀ S) 
goal: SupClosed (⋂₀ S)

full_name: supClosed_iInter
code: lemma supClosed_iInter (hf : ∀ i, SupClosed (f i)) : SupClosed (⋂ i, f i) 
goal: SupClosed (⋂ i, f i)

full_name: SupClosed.directedOn
code: lemma SupClosed.directedOn (hs : SupClosed s) : DirectedOn (· ≤ ·) s 
goal: DirectedOn (fun x x_1 => x ≤ x_1) s

full_name: IsUpperSet.supClosed
code: lemma IsUpperSet.supClosed (hs : IsUpperSet s) : SupClosed s 
goal: SupClosed s

full_name: SupClosed.preimage
code: lemma SupClosed.preimage [FunLike F β α] [SupHomClass F β α] (hs : SupClosed s) (f : F) :
    SupClosed (f ⁻¹' s) 
goal: SupClosed (⇑f ⁻¹' s)

full_name: SupClosed.image
code: lemma SupClosed.image [FunLike F α β] [SupHomClass F α β] (hs : SupClosed s) (f : F) :
    SupClosed (f '' s) 
goal: SupClosed (⇑f '' s)

full_name: supClosed_range
code: lemma supClosed_range [FunLike F α β] [SupHomClass F α β] (f : F) : SupClosed (Set.range f) 
goal: SupClosed (Set.range ⇑f)

full_name: SupClosed.prod
code: lemma SupClosed.prod {t : Set β} (hs : SupClosed s) (ht : SupClosed t) : SupClosed (s ×ˢ t) 
goal: SupClosed (s ×ˢ t)

full_name: supClosed_pi
code: lemma supClosed_pi {ι : Type*} {α : ι → Type*} [∀ i, SemilatticeSup (α i)] {s : Set ι}
    {t : ∀ i, Set (α i)} (ht : ∀ i ∈ s, SupClosed (t i)) : SupClosed (s.pi t) 
goal: SupClosed (s.pi t)

full_name: SupClosed.finsetSup'_mem
code: lemma SupClosed.finsetSup'_mem (hs : SupClosed s) (ht : t.Nonempty) :
    (∀ i ∈ t, f i ∈ s) → t.sup' ht f ∈ s 
goal: (∀ i ∈ t, f i ∈ s) → t.sup' ht f ∈ s

full_name: SupClosed.finsetSup_mem
code: lemma SupClosed.finsetSup_mem [OrderBot α] (hs : SupClosed s) (ht : t.Nonempty) :
    (∀ i ∈ t, f i ∈ s) → t.sup f ∈ s 
goal: (∀ i ∈ t, f i ∈ s) → t.sup f ∈ s

full_name: InfClosed
code: /-- A set `s` is *inf-closed* if `a ⊓ b ∈ s` for all `a ∈ s`, `b ∈ s`. -/
def InfClosed (s : Set α) : Prop 
goal: Prop

full_name: infClosed_empty
code: @[simp] lemma infClosed_empty : InfClosed (∅ : Set α) 
goal: InfClosed ∅

full_name: infClosed_singleton
code: @[simp] lemma infClosed_singleton : InfClosed ({a} : Set α) 
goal: InfClosed {a}

full_name: infClosed_univ
code: @[simp] lemma infClosed_univ : InfClosed (univ : Set α) 
goal: InfClosed Set.univ

full_name: InfClosed.inter
code: lemma InfClosed.inter (hs : InfClosed s) (ht : InfClosed t) : InfClosed (s ∩ t) 
goal: InfClosed (s ∩ t)

full_name: infClosed_sInter
code: lemma infClosed_sInter (hS : ∀ s ∈ S, InfClosed s) : InfClosed (⋂₀ S) 
goal: InfClosed (⋂₀ S)

full_name: infClosed_iInter
code: lemma infClosed_iInter (hf : ∀ i, InfClosed (f i)) : InfClosed (⋂ i, f i) 
goal: InfClosed (⋂ i, f i)

full_name: InfClosed.codirectedOn
code: lemma InfClosed.codirectedOn (hs : InfClosed s) : DirectedOn (· ≥ ·) s 
goal: DirectedOn (fun x x_1 => x ≥ x_1) s

full_name: IsLowerSet.infClosed
code: lemma IsLowerSet.infClosed (hs : IsLowerSet s) : InfClosed s 
goal: InfClosed s

full_name: InfClosed.preimage
code: lemma InfClosed.preimage [FunLike F β α] [InfHomClass F β α] (hs : InfClosed s) (f : F) :
    InfClosed (f ⁻¹' s) 
goal: InfClosed (⇑f ⁻¹' s)

full_name: InfClosed.image
code: lemma InfClosed.image [FunLike F α β] [InfHomClass F α β] (hs : InfClosed s) (f : F) :
    InfClosed (f '' s) 
goal: InfClosed (⇑f '' s)

full_name: infClosed_range
code: lemma infClosed_range [FunLike F α β] [InfHomClass F α β] (f : F) : InfClosed (Set.range f) 
goal: InfClosed (Set.range ⇑f)

full_name: InfClosed.prod
code: lemma InfClosed.prod {t : Set β} (hs : InfClosed s) (ht : InfClosed t) : InfClosed (s ×ˢ t) 
goal: InfClosed (s ×ˢ t)

full_name: infClosed_pi
code: lemma infClosed_pi {ι : Type*} {α : ι → Type*} [∀ i, SemilatticeInf (α i)] {s : Set ι}
    {t : ∀ i, Set (α i)} (ht : ∀ i ∈ s, InfClosed (t i)) : InfClosed (s.pi t) 
goal: InfClosed (s.pi t)

full_name: InfClosed.finsetInf'_mem
code: lemma InfClosed.finsetInf'_mem (hs : InfClosed s) (ht : t.Nonempty) :
    (∀ i ∈ t, f i ∈ s) → t.inf' ht f ∈ s 
goal: (∀ i ∈ t, f i ∈ s) → t.inf' ht f ∈ s

full_name: InfClosed.finsetInf_mem
code: lemma InfClosed.finsetInf_mem [OrderTop α] (hs : InfClosed s) (ht : t.Nonempty) :
    (∀ i ∈ t, f i ∈ s) → t.inf f ∈ s 
goal: (∀ i ∈ t, f i ∈ s) → t.inf f ∈ s

full_name: IsSublattice
code: /-- A set `s` is a *sublattice* if `a ⊔ b ∈ s` and `a ⊓ b ∈ s` for all `a ∈ s`, `b ∈ s`.
Note: This is not the preferred way to declare a sublattice. One should instead use `Sublattice`.
TODO: Define `Sublattice`. -/
structure IsSublattice (s : Set α) : Prop where
  supClosed : SupClosed s
  infClosed : InfClosed s
goal: Prop

full_name: IsSublattice.infClosed
code: /-- A set `s` is a *sublattice* if `a ⊔ b ∈ s` and `a ⊓ b ∈ s` for all `a ∈ s`, `b ∈ s`.
Note: This is not the preferred way to declare a sublattice. One should instead use `Sublattice`.
TODO: Define `Sublattice`. -/
structure IsSublattice (s : Set α) : Prop where
  supClosed : SupClosed s
  infClosed : InfClosed s
goal: InfClosed s

full_name: IsSublattice.supClosed
code: /-- A set `s` is a *sublattice* if `a ⊔ b ∈ s` and `a ⊓ b ∈ s` for all `a ∈ s`, `b ∈ s`.
Note: This is not the preferred way to declare a sublattice. One should instead use `Sublattice`.
TODO: Define `Sublattice`. -/
structure IsSublattice (s : Set α) : Prop where
  supClosed : SupClosed s
  infClosed : InfClosed s
goal: SupClosed s

full_name: isSublattice_empty
code: @[simp] lemma isSublattice_empty : IsSublattice (∅ : Set α) 
goal: IsSublattice ∅

full_name: isSublattice_singleton
code: @[simp] lemma isSublattice_singleton : IsSublattice ({a} : Set α) 
goal: IsSublattice {a}

full_name: isSublattice_univ
code: @[simp] lemma isSublattice_univ : IsSublattice (Set.univ : Set α) 
goal: IsSublattice Set.univ

full_name: IsSublattice.inter
code: lemma IsSublattice.inter (hs : IsSublattice s) (ht : IsSublattice t) : IsSublattice (s ∩ t) 
goal: IsSublattice (s ∩ t)

full_name: isSublattice_sInter
code: lemma isSublattice_sInter (hS : ∀ s ∈ S, IsSublattice s) : IsSublattice (⋂₀ S) 
goal: IsSublattice (⋂₀ S)

full_name: isSublattice_iInter
code: lemma isSublattice_iInter (hf : ∀ i, IsSublattice (f i)) : IsSublattice (⋂ i, f i) 
goal: IsSublattice (⋂ i, f i)

full_name: IsSublattice.preimage
code: lemma IsSublattice.preimage [FunLike F β α] [LatticeHomClass F β α]
    (hs : IsSublattice s) (f : F) :
    IsSublattice (f ⁻¹' s) 
goal: IsSublattice (⇑f ⁻¹' s)

full_name: IsSublattice.image
code: lemma IsSublattice.image [FunLike F α β] [LatticeHomClass F α β] (hs : IsSublattice s) (f : F) :
    IsSublattice (f '' s) 
goal: IsSublattice (⇑f '' s)

full_name: IsSublattice_range
code: lemma IsSublattice_range [FunLike F α β] [LatticeHomClass F α β] (f : F) :
    IsSublattice (Set.range f) 
goal: IsSublattice (Set.range ⇑f)

full_name: IsSublattice.prod
code: lemma IsSublattice.prod {t : Set β} (hs : IsSublattice s) (ht : IsSublattice t) :
    IsSublattice (s ×ˢ t) 
goal: IsSublattice (s ×ˢ t)

full_name: isSublattice_pi
code: lemma isSublattice_pi {ι : Type*} {α : ι → Type*} [∀ i, Lattice (α i)] {s : Set ι}
    {t : ∀ i, Set (α i)} (ht : ∀ i ∈ s, IsSublattice (t i)) : IsSublattice (s.pi t) 
goal: IsSublattice (s.pi t)

full_name: supClosed_preimage_toDual
code: @[simp] lemma supClosed_preimage_toDual {s : Set αᵒᵈ} :
    SupClosed (toDual ⁻¹' s) ↔ InfClosed s 
goal: SupClosed (⇑OrderDual.toDual ⁻¹' s) ↔ InfClosed s

full_name: infClosed_preimage_toDual
code: @[simp] lemma infClosed_preimage_toDual {s : Set αᵒᵈ} :
    InfClosed (toDual ⁻¹' s) ↔ SupClosed s 
goal: InfClosed (⇑OrderDual.toDual ⁻¹' s) ↔ SupClosed s

full_name: supClosed_preimage_ofDual
code: @[simp] lemma supClosed_preimage_ofDual {s : Set α} :
    SupClosed (ofDual ⁻¹' s) ↔ InfClosed s 
goal: SupClosed (⇑OrderDual.ofDual ⁻¹' s) ↔ InfClosed s

full_name: infClosed_preimage_ofDual
code: @[simp] lemma infClosed_preimage_ofDual {s : Set α} :
    InfClosed (ofDual ⁻¹' s) ↔ SupClosed s 
goal: InfClosed (⇑OrderDual.ofDual ⁻¹' s) ↔ SupClosed s

full_name: isSublattice_preimage_toDual
code: @[simp] lemma isSublattice_preimage_toDual {s : Set αᵒᵈ} :
    IsSublattice (toDual ⁻¹' s) ↔ IsSublattice s 
goal: IsSublattice (⇑OrderDual.toDual ⁻¹' s) ↔ IsSublattice s

full_name: isSublattice_preimage_ofDual
code: @[simp] lemma isSublattice_preimage_ofDual :
    IsSublattice (ofDual ⁻¹' s) ↔ IsSublattice s 
goal: IsSublattice (⇑OrderDual.ofDual ⁻¹' s) ↔ IsSublattice s

full_name: LinearOrder.supClosed
code: @[simp] protected lemma LinearOrder.supClosed (s : Set α) : SupClosed s 
goal: SupClosed s

full_name: LinearOrder.infClosed
code: @[simp] protected lemma LinearOrder.infClosed (s : Set α) : InfClosed s 
goal: InfClosed s

full_name: LinearOrder.isSublattice
code: @[simp] protected lemma LinearOrder.isSublattice (s : Set α) : IsSublattice s 
goal: IsSublattice s

full_name: supClosure_isClosed
code: /-- Every set in a join-semilattice generates a set closed under join. -/
@[simps! isClosed]
def supClosure : ClosureOperator (Set α) 
goal: supClosure.IsClosed s = SupClosed s

full_name: supClosure
code: /-- Every set in a join-semilattice generates a set closed under join. -/
@[simps! isClosed]
def supClosure : ClosureOperator (Set α) 
goal: ClosureOperator (Set α)

full_name: subset_supClosure
code: @[simp] lemma subset_supClosure {s : Set α} : s ⊆ supClosure s 
goal: s ⊆ supClosure s

full_name: supClosed_supClosure
code: @[simp] lemma supClosed_supClosure : SupClosed (supClosure s) 
goal: SupClosed (supClosure s)

full_name: supClosure_mono
code: lemma supClosure_mono : Monotone (supClosure : Set α → Set α) 
goal: Monotone ⇑supClosure

full_name: supClosure_eq_self
code: @[simp] lemma supClosure_eq_self : supClosure s = s ↔ SupClosed s 
goal: supClosure s = s ↔ SupClosed s

full_name: supClosure_idem
code: lemma supClosure_idem (s : Set α) : supClosure (supClosure s) = supClosure s 
goal: supClosure (supClosure s) = supClosure s

full_name: supClosure_empty
code: @[simp] lemma supClosure_empty : supClosure (∅ : Set α) = ∅ 
goal: supClosure ∅ = ∅

full_name: supClosure_singleton
code: @[simp] lemma supClosure_singleton : supClosure {a} = {a} 
goal: supClosure {a} = {a}

full_name: supClosure_univ
code: @[simp] lemma supClosure_univ : supClosure (Set.univ : Set α) = Set.univ 
goal: supClosure Set.univ = Set.univ

full_name: upperBounds_supClosure
code: @[simp] lemma upperBounds_supClosure (s : Set α) : upperBounds (supClosure s) = upperBounds s 
goal: upperBounds (supClosure s) = upperBounds s

full_name: isLUB_supClosure
code: @[simp] lemma isLUB_supClosure : IsLUB (supClosure s) a ↔ IsLUB s a 
goal: IsLUB (supClosure s) a ↔ IsLUB s a

full_name: sup_mem_supClosure
code: lemma sup_mem_supClosure (ha : a ∈ s) (hb : b ∈ s) : a ⊔ b ∈ supClosure s 
goal: a ⊔ b ∈ supClosure s

full_name: finsetSup'_mem_supClosure
code: lemma finsetSup'_mem_supClosure {ι : Type*} {t : Finset ι} (ht : t.Nonempty) {f : ι → α}
    (hf : ∀ i ∈ t, f i ∈ s) : t.sup' ht f ∈ supClosure s 
goal: t.sup' ht f ∈ supClosure s

full_name: supClosure_min
code: lemma supClosure_min : s ⊆ t → SupClosed t → supClosure s ⊆ t 
goal: s ⊆ t → SupClosed t → supClosure s ⊆ t

full_name: Set.Finite.supClosure
code: /-- The semilatice generated by a finite set is finite. -/
protected lemma Set.Finite.supClosure (hs : s.Finite) : (supClosure s).Finite 
goal: (supClosure s).Finite

full_name: supClosure_prod
code: @[simp] lemma supClosure_prod (s : Set α) (t : Set β) :
    supClosure (s ×ˢ t) = supClosure s ×ˢ supClosure t 
goal: supClosure (s ×ˢ t) = supClosure s ×ˢ supClosure t

full_name: infClosure
code: /-- Every set in a join-semilattice generates a set closed under join. -/
@[simps! isClosed]
def infClosure : ClosureOperator (Set α) 
goal: ClosureOperator (Set α)

full_name: infClosure_isClosed
code: /-- Every set in a join-semilattice generates a set closed under join. -/
@[simps! isClosed]
def infClosure : ClosureOperator (Set α) 
goal: infClosure.IsClosed s = InfClosed s

full_name: subset_infClosure
code: @[simp] lemma subset_infClosure {s : Set α} : s ⊆ infClosure s 
goal: s ⊆ infClosure s

full_name: infClosed_infClosure
code: @[simp] lemma infClosed_infClosure : InfClosed (infClosure s) 
goal: InfClosed (infClosure s)

full_name: infClosure_mono
code: lemma infClosure_mono : Monotone (infClosure : Set α → Set α) 
goal: Monotone ⇑infClosure

full_name: infClosure_eq_self
code: @[simp] lemma infClosure_eq_self : infClosure s = s ↔ InfClosed s 
goal: infClosure s = s ↔ InfClosed s

full_name: infClosure_idem
code: lemma infClosure_idem (s : Set α) : infClosure (infClosure s) = infClosure s 
goal: infClosure (infClosure s) = infClosure s

full_name: infClosure_empty
code: @[simp] lemma infClosure_empty : infClosure (∅ : Set α) = ∅ 
goal: infClosure ∅ = ∅

full_name: infClosure_singleton
code: @[simp] lemma infClosure_singleton : infClosure {a} = {a} 
goal: infClosure {a} = {a}

full_name: infClosure_univ
code: @[simp] lemma infClosure_univ : infClosure (Set.univ : Set α) = Set.univ 
goal: infClosure Set.univ = Set.univ

full_name: lowerBounds_infClosure
code: @[simp] lemma lowerBounds_infClosure (s : Set α) : lowerBounds (infClosure s) = lowerBounds s 
goal: lowerBounds (infClosure s) = lowerBounds s

full_name: isGLB_infClosure
code: @[simp] lemma isGLB_infClosure : IsGLB (infClosure s) a ↔ IsGLB s a 
goal: IsGLB (infClosure s) a ↔ IsGLB s a

full_name: inf_mem_infClosure
code: lemma inf_mem_infClosure (ha : a ∈ s) (hb : b ∈ s) : a ⊓ b ∈ infClosure s 
goal: a ⊓ b ∈ infClosure s

full_name: finsetInf'_mem_infClosure
code: lemma finsetInf'_mem_infClosure {ι : Type*} {t : Finset ι} (ht : t.Nonempty) {f : ι → α}
    (hf : ∀ i ∈ t, f i ∈ s) : t.inf' ht f ∈ infClosure s 
goal: t.inf' ht f ∈ infClosure s

full_name: infClosure_min
code: lemma infClosure_min : s ⊆ t → InfClosed t → infClosure s ⊆ t 
goal: s ⊆ t → InfClosed t → infClosure s ⊆ t

full_name: Set.Finite.infClosure
code: /-- The semilatice generated by a finite set is finite. -/
protected lemma Set.Finite.infClosure (hs : s.Finite) : (infClosure s).Finite 
goal: (infClosure s).Finite

full_name: infClosure_prod
code: @[simp] lemma infClosure_prod (s : Set α) (t : Set β) :
    infClosure (s ×ˢ t) = infClosure s ×ˢ infClosure t 
goal: infClosure (s ×ˢ t) = infClosure s ×ˢ infClosure t

full_name: latticeClosure_isClosed
code: /-- Every set in a join-semilattice generates a set closed under join. -/
@[simps! isClosed]
def latticeClosure : ClosureOperator (Set α) 
goal: latticeClosure.IsClosed s = IsSublattice s

full_name: latticeClosure
code: /-- Every set in a join-semilattice generates a set closed under join. -/
@[simps! isClosed]
def latticeClosure : ClosureOperator (Set α) 
goal: ClosureOperator (Set α)

full_name: subset_latticeClosure
code: @[simp] lemma subset_latticeClosure : s ⊆ latticeClosure s 
goal: s ⊆ latticeClosure s

full_name: isSublattice_latticeClosure
code: @[simp] lemma isSublattice_latticeClosure : IsSublattice (latticeClosure s) 
goal: IsSublattice (latticeClosure s)

full_name: latticeClosure_min
code: lemma latticeClosure_min : s ⊆ t → IsSublattice t → latticeClosure s ⊆ t 
goal: s ⊆ t → IsSublattice t → latticeClosure s ⊆ t

full_name: latticeClosure_mono
code: lemma latticeClosure_mono : Monotone (latticeClosure : Set α → Set α) 
goal: Monotone ⇑latticeClosure

full_name: latticeClosure_eq_self
code: @[simp] lemma latticeClosure_eq_self : latticeClosure s = s ↔ IsSublattice s 
goal: latticeClosure s = s ↔ IsSublattice s

full_name: latticeClosure_idem
code: lemma latticeClosure_idem (s : Set α) : latticeClosure (latticeClosure s) = latticeClosure s 
goal: latticeClosure (latticeClosure s) = latticeClosure s

full_name: latticeClosure_empty
code: @[simp] lemma latticeClosure_empty : latticeClosure (∅ : Set α) = ∅ 
goal: latticeClosure ∅ = ∅

full_name: latticeClosure_singleton
code: @[simp] lemma latticeClosure_singleton (a : α) : latticeClosure {a} = {a} 
goal: latticeClosure {a} = {a}

full_name: latticeClosure_univ
code: @[simp] lemma latticeClosure_univ : latticeClosure (Set.univ : Set α) = Set.univ 
goal: latticeClosure Set.univ = Set.univ

full_name: SupClosed.infClosure
code: protected lemma SupClosed.infClosure (hs : SupClosed s) : SupClosed (infClosure s) 
goal: SupClosed (infClosure s)

full_name: InfClosed.supClosure
code: protected lemma InfClosed.supClosure (hs : InfClosed s) : InfClosed (supClosure s) 
goal: InfClosed (supClosure s)

full_name: supClosure_infClosure
code: @[simp] lemma supClosure_infClosure (s : Set α) : supClosure (infClosure s) = latticeClosure s 
goal: supClosure (infClosure s) = latticeClosure s

full_name: infClosure_supClosure
code: @[simp] lemma infClosure_supClosure (s : Set α) : infClosure (supClosure s) = latticeClosure s 
goal: infClosure (supClosure s) = latticeClosure s

full_name: Set.Finite.latticeClosure
code: lemma Set.Finite.latticeClosure (hs : s.Finite) : (latticeClosure s).Finite 
goal: (latticeClosure s).Finite

full_name: latticeClosure_prod
code: @[simp] lemma latticeClosure_prod (s : Set α) (t : Set β) :
    latticeClosure (s ×ˢ t) = latticeClosure s ×ˢ latticeClosure t 
goal: latticeClosure (s ×ˢ t) = latticeClosure s ×ˢ latticeClosure t

full_name: SemilatticeSup.toCompleteSemilatticeSup
code: /-- A join-semilattice where every sup-closed set has a least upper bound is automatically complete.
-/
def SemilatticeSup.toCompleteSemilatticeSup [SemilatticeSup α] (sSup : Set α → α)
    (h : ∀ s, SupClosed s → IsLUB s (sSup s)) : CompleteSemilatticeSup α 
goal: CompleteSemilatticeSup α

full_name: SemilatticeInf.toCompleteSemilatticeInf
code: /-- A meet-semilattice where every inf-closed set has a greatest lower bound is automatically
complete. -/
def SemilatticeInf.toCompleteSemilatticeInf [SemilatticeInf α] (sInf : Set α → α)
    (h : ∀ s, InfClosed s → IsGLB s (sInf s)) : CompleteSemilatticeInf α 
goal: CompleteSemilatticeInf α