File: Mathlib/Order/CompactlyGenerated/Basic.lean

full_name: CompleteLattice.IsSupClosedCompact
code: /-- A compactness property for a complete lattice is that any `sup`-closed non-empty subset
contains its `sSup`. -/
def IsSupClosedCompact : Prop 
goal: Prop

full_name: CompleteLattice.IsSupFiniteCompact
code: /-- A compactness property for a complete lattice is that any subset has a finite subset with the
same `sSup`. -/
def IsSupFiniteCompact : Prop 
goal: Prop

full_name: CompleteLattice.IsCompactElement
code: /-- An element `k` of a complete lattice is said to be compact if any set with `sSup`
above `k` has a finite subset with `sSup` above `k`.  Such an element is also called
"finite" or "S-compact". -/
def IsCompactElement {α : Type*} [CompleteLattice α] (k : α) 
goal: Prop

full_name: CompleteLattice.isCompactElement_iff
code: theorem isCompactElement_iff.{u} {α : Type u} [CompleteLattice α] (k : α) :
    CompleteLattice.IsCompactElement k ↔
      ∀ (ι : Type u) (s : ι → α), k ≤ iSup s → ∃ t : Finset ι, k ≤ t.sup s 
goal: CompleteLattice.IsCompactElement k ↔ ∀ (ι : Type u) (s : ι → α), k ≤ iSup s → ∃ t, k ≤ t.sup s

full_name: CompleteLattice.isCompactElement_iff_le_of_directed_sSup_le
code: /-- An element `k` is compact if and only if any directed set with `sSup` above
`k` already got above `k` at some point in the set. -/
theorem isCompactElement_iff_le_of_directed_sSup_le (k : α) :
    IsCompactElement k ↔
      ∀ s : Set α, s.Nonempty → DirectedOn (· ≤ ·) s → k ≤ sSup s → ∃ x : α, x ∈ s ∧ k ≤ x 
goal: CompleteLattice.IsCompactElement k ↔
  ∀ (s : Set α), s.Nonempty → DirectedOn (fun x x_1 => x ≤ x_1) s → k ≤ sSup s → ∃ x ∈ s, k ≤ x

full_name: CompleteLattice.IsCompactElement.exists_finset_of_le_iSup
code: theorem IsCompactElement.exists_finset_of_le_iSup {k : α} (hk : IsCompactElement k) {ι : Type*}
    (f : ι → α) (h : k ≤ ⨆ i, f i) : ∃ s : Finset ι, k ≤ ⨆ i ∈ s, f i 
goal: ∃ s, k ≤ ⨆ i ∈ s, f i

full_name: CompleteLattice.IsCompactElement.directed_sSup_lt_of_lt
code: /-- A compact element `k` has the property that any directed set lying strictly below `k` has
its `sSup` strictly below `k`. -/
theorem IsCompactElement.directed_sSup_lt_of_lt {α : Type*} [CompleteLattice α] {k : α}
    (hk : IsCompactElement k) {s : Set α} (hemp : s.Nonempty) (hdir : DirectedOn (· ≤ ·) s)
    (hbelow : ∀ x ∈ s, x < k) : sSup s < k 
goal: sSup s < k

full_name: CompleteLattice.isCompactElement_finsetSup
code: theorem isCompactElement_finsetSup {α β : Type*} [CompleteLattice α] {f : β → α} (s : Finset β)
    (h : ∀ x ∈ s, IsCompactElement (f x)) : IsCompactElement (s.sup f) 
goal: CompleteLattice.IsCompactElement (s.sup f)

full_name: CompleteLattice.WellFounded.isSupFiniteCompact
code: theorem WellFounded.isSupFiniteCompact (h : WellFounded ((· > ·) : α → α → Prop)) :
    IsSupFiniteCompact α 
goal: CompleteLattice.IsSupFiniteCompact α

full_name: CompleteLattice.IsSupFiniteCompact.isSupClosedCompact
code: theorem IsSupFiniteCompact.isSupClosedCompact (h : IsSupFiniteCompact α) :
    IsSupClosedCompact α 
goal: CompleteLattice.IsSupClosedCompact α

full_name: CompleteLattice.IsSupClosedCompact.wellFounded
code: theorem IsSupClosedCompact.wellFounded (h : IsSupClosedCompact α) :
    WellFounded ((· > ·) : α → α → Prop) 
goal: WellFounded fun x x_1 => x > x_1

full_name: CompleteLattice.isSupFiniteCompact_iff_all_elements_compact
code: theorem isSupFiniteCompact_iff_all_elements_compact :
    IsSupFiniteCompact α ↔ ∀ k : α, IsCompactElement k 
goal: CompleteLattice.IsSupFiniteCompact α ↔ ∀ (k : α), CompleteLattice.IsCompactElement k

full_name: CompleteLattice.wellFounded_characterisations
code: theorem wellFounded_characterisations : List.TFAE
    [WellFounded ((· > ·) : α → α → Prop),
      IsSupFiniteCompact α, IsSupClosedCompact α, ∀ k : α, IsCompactElement k] 
goal: [WellFounded fun x x_1 => x > x_1, CompleteLattice.IsSupFiniteCompact α, CompleteLattice.IsSupClosedCompact α,
    ∀ (k : α), CompleteLattice.IsCompactElement k].TFAE

full_name: CompleteLattice.wellFounded_iff_isSupFiniteCompact
code: theorem wellFounded_iff_isSupFiniteCompact :
    WellFounded ((· > ·) : α → α → Prop) ↔ IsSupFiniteCompact α 
goal: (WellFounded fun x x_1 => x > x_1) ↔ CompleteLattice.IsSupFiniteCompact α

full_name: CompleteLattice.isSupFiniteCompact_iff_isSupClosedCompact
code: theorem isSupFiniteCompact_iff_isSupClosedCompact : IsSupFiniteCompact α ↔ IsSupClosedCompact α 
goal: CompleteLattice.IsSupFiniteCompact α ↔ CompleteLattice.IsSupClosedCompact α

full_name: CompleteLattice.isSupClosedCompact_iff_wellFounded
code: theorem isSupClosedCompact_iff_wellFounded :
    IsSupClosedCompact α ↔ WellFounded ((· > ·) : α → α → Prop) 
goal: CompleteLattice.IsSupClosedCompact α ↔ WellFounded fun x x_1 => x > x_1

full_name: CompleteLattice.WellFounded.finite_of_setIndependent
code: theorem WellFounded.finite_of_setIndependent (h : WellFounded ((· > ·) : α → α → Prop)) {s : Set α}
    (hs : SetIndependent s) : s.Finite 
goal: s.Finite

full_name: CompleteLattice.WellFounded.finite_ne_bot_of_independent
code: theorem WellFounded.finite_ne_bot_of_independent (hwf : WellFounded ((· > ·) : α → α → Prop))
    {ι : Type*} {t : ι → α} (ht : Independent t) : Set.Finite {i | t i ≠ ⊥} 
goal: {i | t i ≠ ⊥}.Finite

full_name: CompleteLattice.WellFounded.finite_of_independent
code: theorem WellFounded.finite_of_independent (hwf : WellFounded ((· > ·) : α → α → Prop)) {ι : Type*}
    {t : ι → α} (ht : Independent t) (h_ne_bot : ∀ i, t i ≠ ⊥) : Finite ι 
goal: Finite ι

full_name: IsCompactlyGenerated
code: /-- A complete lattice is said to be compactly generated if any
element is the `sSup` of compact elements. -/
class IsCompactlyGenerated (α : Type*) [CompleteLattice α] : Prop where
  /-- In a compactly generated complete lattice,
    every element is the `sSup` of some set of compact elements. -/
  exists_sSup_eq : ∀ x : α, ∃ s : Set α, (∀ x ∈ s, CompleteLattice.IsCompactElement x) ∧ sSup s = x
goal: Prop

full_name: IsCompactlyGenerated.exists_sSup_eq
code: /-- A complete lattice is said to be compactly generated if any
element is the `sSup` of compact elements. -/
class IsCompactlyGenerated (α : Type*) [CompleteLattice α] : Prop where
  /-- In a compactly generated complete lattice,
    every element is the `sSup` of some set of compact elements. -/
  exists_sSup_eq : ∀ x : α, ∃ s : Set α, (∀ x ∈ s, CompleteLattice.IsCompactElement x) ∧ sSup s = x
goal: ∃ s, (∀ x ∈ s, CompleteLattice.IsCompactElement x) ∧ sSup s = x

full_name: sSup_compact_le_eq
code: @[simp]
theorem sSup_compact_le_eq (b) :
    sSup { c : α | CompleteLattice.IsCompactElement c ∧ c ≤ b } = b 
goal: sSup {c | CompleteLattice.IsCompactElement c ∧ c ≤ b} = b

full_name: sSup_compact_eq_top
code: @[simp]
theorem sSup_compact_eq_top : sSup { a : α | CompleteLattice.IsCompactElement a } = ⊤ 
goal: sSup {a | CompleteLattice.IsCompactElement a} = ⊤

full_name: le_iff_compact_le_imp
code: theorem le_iff_compact_le_imp {a b : α} :
    a ≤ b ↔ ∀ c : α, CompleteLattice.IsCompactElement c → c ≤ a → c ≤ b 
goal: a ≤ b ↔ ∀ (c : α), CompleteLattice.IsCompactElement c → c ≤ a → c ≤ b

full_name: DirectedOn.inf_sSup_eq
code: /-- This property is sometimes referred to as `α` being upper continuous. -/
theorem DirectedOn.inf_sSup_eq (h : DirectedOn (· ≤ ·) s) : a ⊓ sSup s = ⨆ b ∈ s, a ⊓ b 
goal: a ⊓ sSup s = ⨆ b ∈ s, a ⊓ b

full_name: DirectedOn.sSup_inf_eq
code: /-- This property is sometimes referred to as `α` being upper continuous. -/
protected theorem DirectedOn.sSup_inf_eq (h : DirectedOn (· ≤ ·) s) :
    sSup s ⊓ a = ⨆ b ∈ s, b ⊓ a 
goal: sSup s ⊓ a = ⨆ b ∈ s, b ⊓ a

full_name: Directed.inf_iSup_eq
code: protected theorem Directed.inf_iSup_eq (h : Directed (· ≤ ·) f) :
    (a ⊓ ⨆ i, f i) = ⨆ i, a ⊓ f i 
goal: a ⊓ ⨆ i, f i = ⨆ i, a ⊓ f i

full_name: Directed.iSup_inf_eq
code: protected theorem Directed.iSup_inf_eq (h : Directed (· ≤ ·) f) :
    (⨆ i, f i) ⊓ a = ⨆ i, f i ⊓ a 
goal: (⨆ i, f i) ⊓ a = ⨆ i, f i ⊓ a

full_name: DirectedOn.disjoint_sSup_right
code: protected theorem DirectedOn.disjoint_sSup_right (h : DirectedOn (· ≤ ·) s) :
    Disjoint a (sSup s) ↔ ∀ ⦃b⦄, b ∈ s → Disjoint a b 
goal: Disjoint a (sSup s) ↔ ∀ ⦃b : α⦄, b ∈ s → Disjoint a b

full_name: DirectedOn.disjoint_sSup_left
code: protected theorem DirectedOn.disjoint_sSup_left (h : DirectedOn (· ≤ ·) s) :
    Disjoint (sSup s) a ↔ ∀ ⦃b⦄, b ∈ s → Disjoint b a 
goal: Disjoint (sSup s) a ↔ ∀ ⦃b : α⦄, b ∈ s → Disjoint b a

full_name: Directed.disjoint_iSup_right
code: protected theorem Directed.disjoint_iSup_right (h : Directed (· ≤ ·) f) :
    Disjoint a (⨆ i, f i) ↔ ∀ i, Disjoint a (f i) 
goal: Disjoint a (⨆ i, f i) ↔ ∀ (i : ι), Disjoint a (f i)

full_name: Directed.disjoint_iSup_left
code: protected theorem Directed.disjoint_iSup_left (h : Directed (· ≤ ·) f) :
    Disjoint (⨆ i, f i) a ↔ ∀ i, Disjoint (f i) a 
goal: Disjoint (⨆ i, f i) a ↔ ∀ (i : ι), Disjoint (f i) a

full_name: inf_sSup_eq_iSup_inf_sup_finset
code: /-- This property is equivalent to `α` being upper continuous. -/
theorem inf_sSup_eq_iSup_inf_sup_finset :
    a ⊓ sSup s = ⨆ (t : Finset α) (_ : ↑t ⊆ s), a ⊓ t.sup id 
goal: a ⊓ sSup s = ⨆ t, ⨆ (_ : ↑t ⊆ s), a ⊓ t.sup id

full_name: CompleteLattice.setIndependent_iff_finite
code: theorem CompleteLattice.setIndependent_iff_finite {s : Set α} :
    CompleteLattice.SetIndependent s ↔
      ∀ t : Finset α, ↑t ⊆ s → CompleteLattice.SetIndependent (↑t : Set α) 
goal: CompleteLattice.SetIndependent s ↔ ∀ (t : Finset α), ↑t ⊆ s → CompleteLattice.SetIndependent ↑t

full_name: CompleteLattice.independent_iff_supIndep_of_injOn
code: lemma CompleteLattice.independent_iff_supIndep_of_injOn {ι : Type*} {f : ι → α}
    (hf : InjOn f {i | f i ≠ ⊥}) :
    CompleteLattice.Independent f ↔ ∀ (s : Finset ι), s.SupIndep f 
goal: CompleteLattice.Independent f ↔ ∀ (s : Finset ι), s.SupIndep f

full_name: CompleteLattice.setIndependent_iUnion_of_directed
code: theorem CompleteLattice.setIndependent_iUnion_of_directed {η : Type*} {s : η → Set α}
    (hs : Directed (· ⊆ ·) s) (h : ∀ i, CompleteLattice.SetIndependent (s i)) :
    CompleteLattice.SetIndependent (⋃ i, s i) 
goal: CompleteLattice.SetIndependent (⋃ i, s i)

full_name: CompleteLattice.independent_sUnion_of_directed
code: theorem CompleteLattice.independent_sUnion_of_directed {s : Set (Set α)} (hs : DirectedOn (· ⊆ ·) s)
    (h : ∀ a ∈ s, CompleteLattice.SetIndependent a) : CompleteLattice.SetIndependent (⋃₀ s) 
goal: CompleteLattice.SetIndependent (⋃₀ s)

full_name: CompleteLattice.isCompactlyGenerated_of_wellFounded
code: theorem isCompactlyGenerated_of_wellFounded (h : WellFounded ((· > ·) : α → α → Prop)) :
    IsCompactlyGenerated α 
goal: IsCompactlyGenerated α

full_name: CompleteLattice.Iic_coatomic_of_compact_element
code: /-- A compact element `k` has the property that any `b < k` lies below a "maximal element below
`k`", which is to say `[⊥, k]` is coatomic. -/
theorem Iic_coatomic_of_compact_element {k : α} (h : IsCompactElement k) :
    IsCoatomic (Set.Iic k) 
goal: IsCoatomic ↑(Set.Iic k)

full_name: CompleteLattice.coatomic_of_top_compact
code: theorem coatomic_of_top_compact (h : IsCompactElement (⊤ : α)) : IsCoatomic α 
goal: IsCoatomic α

full_name: isAtomic_of_complementedLattice
code: instance (priority := 100) isAtomic_of_complementedLattice [ComplementedLattice α] : IsAtomic α 
goal: IsAtomic α

full_name: isAtomistic_of_complementedLattice
code: /-- See [Lemma 5.1][calugareanu]. -/
instance (priority := 100) isAtomistic_of_complementedLattice [ComplementedLattice α] :
    IsAtomistic α 
goal: IsAtomistic α

full_name: exists_setIndependent_isCompl_sSup_atoms
code: /-- In an atomic lattice, every element `b` has a complement of the form `sSup s`, where each
element of `s` is an atom. See also `complementedLattice_of_sSup_atoms_eq_top`. -/
theorem exists_setIndependent_isCompl_sSup_atoms (h : sSup { a : α | IsAtom a } = ⊤) (b : α) :
    ∃ s : Set α, CompleteLattice.SetIndependent s ∧
    IsCompl b (sSup s) ∧ ∀ ⦃a⦄, a ∈ s → IsAtom a 
goal: ∃ s, CompleteLattice.SetIndependent s ∧ IsCompl b (sSup s) ∧ ∀ ⦃a : α⦄, a ∈ s → IsAtom a

full_name: exists_setIndependent_of_sSup_atoms_eq_top
code: theorem exists_setIndependent_of_sSup_atoms_eq_top (h : sSup { a : α | IsAtom a } = ⊤) :
    ∃ s : Set α, CompleteLattice.SetIndependent s ∧ sSup s = ⊤ ∧ ∀ ⦃a⦄, a ∈ s → IsAtom a 
goal: ∃ s, CompleteLattice.SetIndependent s ∧ sSup s = ⊤ ∧ ∀ ⦃a : α⦄, a ∈ s → IsAtom a

full_name: complementedLattice_of_sSup_atoms_eq_top
code: /-- See [Theorem 6.6][calugareanu]. -/
theorem complementedLattice_of_sSup_atoms_eq_top (h : sSup { a : α | IsAtom a } = ⊤) :
    ComplementedLattice α 
goal: ComplementedLattice α

full_name: complementedLattice_of_isAtomistic
code: /-- See [Theorem 6.6][calugareanu]. -/
theorem complementedLattice_of_isAtomistic [IsAtomistic α] : ComplementedLattice α 
goal: ComplementedLattice α

full_name: complementedLattice_iff_isAtomistic
code: theorem complementedLattice_iff_isAtomistic : ComplementedLattice α ↔ IsAtomistic α 
goal: ComplementedLattice α ↔ IsAtomistic α