File: Mathlib/Order/Atoms.lean

full_name: IsAtom
code: /-- An atom of an `OrderBot` is an element with no other element between it and `⊥`,
  which is not `⊥`. -/
def IsAtom (a : α) : Prop 
goal: Prop

full_name: IsAtom.Iic
code: theorem IsAtom.Iic (ha : IsAtom a) (hax : a ≤ x) : IsAtom (⟨a, hax⟩ : Set.Iic x) 
goal: IsAtom ⟨a, hax⟩

full_name: IsAtom.of_isAtom_coe_Iic
code: theorem IsAtom.of_isAtom_coe_Iic {a : Set.Iic x} (ha : IsAtom a) : IsAtom (a : α) 
goal: IsAtom ↑a

full_name: isAtom_iff_le_of_ge
code: theorem isAtom_iff_le_of_ge : IsAtom a ↔ a ≠ ⊥ ∧ ∀ b ≠ ⊥, b ≤ a → a ≤ b 
goal: IsAtom a ↔ a ≠ ⊥ ∧ ∀ (b : α), b ≠ ⊥ → b ≤ a → a ≤ b

full_name: IsAtom.lt_iff
code: theorem IsAtom.lt_iff (h : IsAtom a) : x < a ↔ x = ⊥ 
goal: x < a ↔ x = ⊥

full_name: IsAtom.le_iff
code: theorem IsAtom.le_iff (h : IsAtom a) : x ≤ a ↔ x = ⊥ ∨ x = a 
goal: x ≤ a ↔ x = ⊥ ∨ x = a

full_name: IsAtom.le_iff_eq
code: lemma IsAtom.le_iff_eq (ha : IsAtom a) (hb : b ≠ ⊥) : b ≤ a ↔ b = a 
goal: b ≤ a ↔ b = a

full_name: IsAtom.Iic_eq
code: theorem IsAtom.Iic_eq (h : IsAtom a) : Set.Iic a = {⊥, a} 
goal: Set.Iic a = {⊥, a}

full_name: bot_covBy_iff
code: @[simp]
theorem bot_covBy_iff : ⊥ ⋖ a ↔ IsAtom a 
goal: ⊥ ⋖ a ↔ IsAtom a

full_name: atom_le_iSup
code: theorem atom_le_iSup [Order.Frame α] {a : α} (ha : IsAtom a) {f : ι → α} :
    a ≤ iSup f ↔ ∃ i, a ≤ f i 
goal: a ≤ iSup f ↔ ∃ i, a ≤ f i

full_name: IsCoatom
code: /-- A coatom of an `OrderTop` is an element with no other element between it and `⊤`,
  which is not `⊤`. -/
def IsCoatom [OrderTop α] (a : α) : Prop 
goal: Prop

full_name: isCoatom_dual_iff_isAtom
code: @[simp]
theorem isCoatom_dual_iff_isAtom [OrderBot α] {a : α} :
    IsCoatom (OrderDual.toDual a) ↔ IsAtom a 
goal: IsCoatom (OrderDual.toDual a) ↔ IsAtom a

full_name: isAtom_dual_iff_isCoatom
code: @[simp]
theorem isAtom_dual_iff_isCoatom [OrderTop α] {a : α} :
    IsAtom (OrderDual.toDual a) ↔ IsCoatom a 
goal: IsAtom (OrderDual.toDual a) ↔ IsCoatom a

full_name: IsCoatom.Ici
code: theorem IsCoatom.Ici (ha : IsCoatom a) (hax : x ≤ a) : IsCoatom (⟨a, hax⟩ : Set.Ici x) 
goal: IsCoatom ⟨a, hax⟩

full_name: IsCoatom.of_isCoatom_coe_Ici
code: theorem IsCoatom.of_isCoatom_coe_Ici {a : Set.Ici x} (ha : IsCoatom a) : IsCoatom (a : α) 
goal: IsCoatom ↑a

full_name: isCoatom_iff_ge_of_le
code: theorem isCoatom_iff_ge_of_le : IsCoatom a ↔ a ≠ ⊤ ∧ ∀ b ≠ ⊤, a ≤ b → b ≤ a 
goal: IsCoatom a ↔ a ≠ ⊤ ∧ ∀ (b : α), b ≠ ⊤ → a ≤ b → b ≤ a

full_name: IsCoatom.lt_iff
code: theorem IsCoatom.lt_iff (h : IsCoatom a) : a < x ↔ x = ⊤ 
goal: a < x ↔ x = ⊤

full_name: IsCoatom.le_iff
code: theorem IsCoatom.le_iff (h : IsCoatom a) : a ≤ x ↔ x = ⊤ ∨ x = a 
goal: a ≤ x ↔ x = ⊤ ∨ x = a

full_name: IsCoatom.le_iff_eq
code: lemma IsCoatom.le_iff_eq (ha : IsCoatom a) (hb : b ≠ ⊤) : a ≤ b ↔ b = a 
goal: a ≤ b ↔ b = a

full_name: IsCoatom.Ici_eq
code: theorem IsCoatom.Ici_eq (h : IsCoatom a) : Set.Ici a = {⊤, a} 
goal: Set.Ici a = {⊤, a}

full_name: covBy_top_iff
code: @[simp]
theorem covBy_top_iff : a ⋖ ⊤ ↔ IsCoatom a 
goal: a ⋖ ⊤ ↔ IsCoatom a

full_name: iInf_le_coatom
code: theorem iInf_le_coatom [Order.Coframe α] {a : α} (ha : IsCoatom a) {f : ι → α} :
    iInf f ≤ a ↔ ∃ i, f i ≤ a 
goal: iInf f ≤ a ↔ ∃ i, f i ≤ a

full_name: Set.Ici.isAtom_iff
code: @[simp]
theorem Set.Ici.isAtom_iff {b : Set.Ici a} : IsAtom b ↔ a ⋖ b 
goal: IsAtom b ↔ a ⋖ ↑b

full_name: Set.Iic.isCoatom_iff
code: @[simp]
theorem Set.Iic.isCoatom_iff {a : Set.Iic b} : IsCoatom a ↔ ↑a ⋖ b 
goal: IsCoatom a ↔ ↑a ⋖ b

full_name: covBy_iff_atom_Ici
code: theorem covBy_iff_atom_Ici (h : a ≤ b) : a ⋖ b ↔ IsAtom (⟨b, h⟩ : Set.Ici a) 
goal: a ⋖ b ↔ IsAtom ⟨b, h⟩

full_name: covBy_iff_coatom_Iic
code: theorem covBy_iff_coatom_Iic (h : a ≤ b) : a ⋖ b ↔ IsCoatom (⟨a, h⟩ : Set.Iic b) 
goal: a ⋖ b ↔ IsCoatom ⟨a, h⟩

full_name: IsAtom.inf_eq_bot_of_ne
code: theorem IsAtom.inf_eq_bot_of_ne [SemilatticeInf α] [OrderBot α] {a b : α} (ha : IsAtom a)
    (hb : IsAtom b) (hab : a ≠ b) : a ⊓ b = ⊥ 
goal: a ⊓ b = ⊥

full_name: IsAtom.disjoint_of_ne
code: theorem IsAtom.disjoint_of_ne [SemilatticeInf α] [OrderBot α] {a b : α} (ha : IsAtom a)
    (hb : IsAtom b) (hab : a ≠ b) : Disjoint a b 
goal: Disjoint a b

full_name: IsCoatom.sup_eq_top_of_ne
code: theorem IsCoatom.sup_eq_top_of_ne [SemilatticeSup α] [OrderTop α] {a b : α} (ha : IsCoatom a)
    (hb : IsCoatom b) (hab : a ≠ b) : a ⊔ b = ⊤ 
goal: a ⊔ b = ⊤

full_name: IsAtomic.eq_bot_or_exists_atom_le
code: /-- A lattice is atomic iff every element other than `⊥` has an atom below it. -/
@[mk_iff]
class IsAtomic [OrderBot α] : Prop where
  /-- Every element other than `⊥` has an atom below it. -/
  eq_bot_or_exists_atom_le : ∀ b : α, b = ⊥ ∨ ∃ a : α, IsAtom a ∧ a ≤ b
goal: b = ⊥ ∨ ∃ a, IsAtom a ∧ a ≤ b

full_name: isAtomic_iff
code: /-- A lattice is atomic iff every element other than `⊥` has an atom below it. -/
@[mk_iff]
class IsAtomic [OrderBot α] : Prop where
  /-- Every element other than `⊥` has an atom below it. -/
  eq_bot_or_exists_atom_le : ∀ b : α, b = ⊥ ∨ ∃ a : α, IsAtom a ∧ a ≤ b
goal: IsAtomic α ↔ ∀ (b : α), b = ⊥ ∨ ∃ a, IsAtom a ∧ a ≤ b

full_name: IsAtomic
code: /-- A lattice is atomic iff every element other than `⊥` has an atom below it. -/
@[mk_iff]
class IsAtomic [OrderBot α] : Prop where
  /-- Every element other than `⊥` has an atom below it. -/
  eq_bot_or_exists_atom_le : ∀ b : α, b = ⊥ ∨ ∃ a : α, IsAtom a ∧ a ≤ b
goal: Prop

full_name: IsCoatomic.eq_top_or_exists_le_coatom
code: /-- A lattice is coatomic iff every element other than `⊤` has a coatom above it. -/
@[mk_iff]
class IsCoatomic [OrderTop α] : Prop where
  /-- Every element other than `⊤` has an atom above it. -/
  eq_top_or_exists_le_coatom : ∀ b : α, b = ⊤ ∨ ∃ a : α, IsCoatom a ∧ b ≤ a
goal: b = ⊤ ∨ ∃ a, IsCoatom a ∧ b ≤ a

full_name: isCoatomic_iff
code: /-- A lattice is coatomic iff every element other than `⊤` has a coatom above it. -/
@[mk_iff]
class IsCoatomic [OrderTop α] : Prop where
  /-- Every element other than `⊤` has an atom above it. -/
  eq_top_or_exists_le_coatom : ∀ b : α, b = ⊤ ∨ ∃ a : α, IsCoatom a ∧ b ≤ a
goal: IsCoatomic α ↔ ∀ (b : α), b = ⊤ ∨ ∃ a, IsCoatom a ∧ b ≤ a

full_name: IsCoatomic
code: /-- A lattice is coatomic iff every element other than `⊤` has a coatom above it. -/
@[mk_iff]
class IsCoatomic [OrderTop α] : Prop where
  /-- Every element other than `⊤` has an atom above it. -/
  eq_top_or_exists_le_coatom : ∀ b : α, b = ⊤ ∨ ∃ a : α, IsCoatom a ∧ b ≤ a
goal: Prop

full_name: IsAtomic.exists_atom
code: lemma IsAtomic.exists_atom [OrderBot α] [Nontrivial α] [IsAtomic α] : ∃ a : α, IsAtom a 
goal: ∃ a, IsAtom a

full_name: IsCoatomic.exists_coatom
code: lemma IsCoatomic.exists_coatom [OrderTop α] [Nontrivial α] [IsCoatomic α] : ∃ a : α, IsCoatom a 
goal: ∃ a, IsCoatom a

full_name: isCoatomic_dual_iff_isAtomic
code: @[simp]
theorem isCoatomic_dual_iff_isAtomic [OrderBot α] : IsCoatomic αᵒᵈ ↔ IsAtomic α 
goal: IsCoatomic αᵒᵈ ↔ IsAtomic α

full_name: isAtomic_dual_iff_isCoatomic
code: @[simp]
theorem isAtomic_dual_iff_isCoatomic [OrderTop α] : IsAtomic αᵒᵈ ↔ IsCoatomic α 
goal: IsAtomic αᵒᵈ ↔ IsCoatomic α

full_name: OrderDual.instIsCoatomic
code: instance _root_.OrderDual.instIsCoatomic : IsCoatomic αᵒᵈ 
goal: IsCoatomic αᵒᵈ

full_name: IsAtomic.Set.Iic.isAtomic
code: instance Set.Iic.isAtomic {x : α} : IsAtomic (Set.Iic x) 
goal: IsAtomic ↑(Set.Iic x)

full_name: OrderDual.instIsAtomic
code: instance _root_.OrderDual.instIsAtomic : IsAtomic αᵒᵈ 
goal: IsAtomic αᵒᵈ

full_name: IsCoatomic.Set.Ici.isCoatomic
code: instance Set.Ici.isCoatomic {x : α} : IsCoatomic (Set.Ici x) 
goal: IsCoatomic ↑(Set.Ici x)

full_name: isAtomic_iff_forall_isAtomic_Iic
code: theorem isAtomic_iff_forall_isAtomic_Iic [OrderBot α] :
    IsAtomic α ↔ ∀ x : α, IsAtomic (Set.Iic x) 
goal: IsAtomic α ↔ ∀ (x : α), IsAtomic ↑(Set.Iic x)

full_name: isCoatomic_iff_forall_isCoatomic_Ici
code: theorem isCoatomic_iff_forall_isCoatomic_Ici [OrderTop α] :
    IsCoatomic α ↔ ∀ x : α, IsCoatomic (Set.Ici x) 
goal: IsCoatomic α ↔ ∀ (x : α), IsCoatomic ↑(Set.Ici x)

full_name: IsStronglyAtomic.exists_covBy_le_of_lt
code: /-- An order is strongly atomic if every nontrivial interval `[a, b]`
contains an element covering `a`. -/
@[mk_iff]
class IsStronglyAtomic (α : Type*) [Preorder α] : Prop where
  exists_covBy_le_of_lt : ∀ (a b : α), a < b → ∃ x, a ⋖ x ∧ x ≤ b
goal: a < b → ∃ x, a ⋖ x ∧ x ≤ b

full_name: IsStronglyAtomic
code: /-- An order is strongly atomic if every nontrivial interval `[a, b]`
contains an element covering `a`. -/
@[mk_iff]
class IsStronglyAtomic (α : Type*) [Preorder α] : Prop where
  exists_covBy_le_of_lt : ∀ (a b : α), a < b → ∃ x, a ⋖ x ∧ x ≤ b
goal: Prop

full_name: isStronglyAtomic_iff
code: /-- An order is strongly atomic if every nontrivial interval `[a, b]`
contains an element covering `a`. -/
@[mk_iff]
class IsStronglyAtomic (α : Type*) [Preorder α] : Prop where
  exists_covBy_le_of_lt : ∀ (a b : α), a < b → ∃ x, a ⋖ x ∧ x ≤ b
goal: IsStronglyAtomic α ↔ ∀ (a b : α), a < b → ∃ x, a ⋖ x ∧ x ≤ b

full_name: exists_covBy_le_of_lt
code: theorem exists_covBy_le_of_lt [IsStronglyAtomic α] (h : a < b) : ∃ x, a ⋖ x ∧ x ≤ b 
goal: ∃ x, a ⋖ x ∧ x ≤ b

full_name: isStronglyCoatomic_iff
code: /-- An order is strongly coatomic if every nontrivial interval `[a, b]`
contains an element covered by `b`. -/
@[mk_iff]
class IsStronglyCoatomic (α : Type*) [Preorder α] : Prop where
  (exists_le_covBy_of_lt : ∀ (a b : α), a < b → ∃ x, a ≤ x ∧ x ⋖ b)
goal: IsStronglyCoatomic α ↔ ∀ (a b : α), a < b → ∃ x, a ≤ x ∧ x ⋖ b

full_name: IsStronglyCoatomic
code: /-- An order is strongly coatomic if every nontrivial interval `[a, b]`
contains an element covered by `b`. -/
@[mk_iff]
class IsStronglyCoatomic (α : Type*) [Preorder α] : Prop where
  (exists_le_covBy_of_lt : ∀ (a b : α), a < b → ∃ x, a ≤ x ∧ x ⋖ b)
goal: Prop

full_name: IsStronglyCoatomic.exists_le_covBy_of_lt
code: /-- An order is strongly coatomic if every nontrivial interval `[a, b]`
contains an element covered by `b`. -/
@[mk_iff]
class IsStronglyCoatomic (α : Type*) [Preorder α] : Prop where
  (exists_le_covBy_of_lt : ∀ (a b : α), a < b → ∃ x, a ≤ x ∧ x ⋖ b)
goal: a < b → ∃ x, a ≤ x ∧ x ⋖ b

full_name: exists_le_covBy_of_lt
code: theorem exists_le_covBy_of_lt [IsStronglyCoatomic α] (h : a < b) : ∃ x, a ≤ x ∧ x ⋖ b 
goal: ∃ x, a ≤ x ∧ x ⋖ b

full_name: isStronglyAtomic_dual_iff_is_stronglyCoatomic
code: theorem isStronglyAtomic_dual_iff_is_stronglyCoatomic :
    IsStronglyAtomic αᵒᵈ ↔ IsStronglyCoatomic α 
goal: IsStronglyAtomic αᵒᵈ ↔ IsStronglyCoatomic α

full_name: isStronglyCoatomic_dual_iff_is_stronglyAtomic
code: @[simp] theorem isStronglyCoatomic_dual_iff_is_stronglyAtomic :
    IsStronglyCoatomic αᵒᵈ ↔ IsStronglyAtomic α 
goal: IsStronglyCoatomic αᵒᵈ ↔ IsStronglyAtomic α

full_name: OrderDual.instIsStronglyCoatomic
code: instance OrderDual.instIsStronglyCoatomic [IsStronglyAtomic α] : IsStronglyCoatomic αᵒᵈ 
goal: IsStronglyCoatomic αᵒᵈ

full_name: instIsStronglyAtomicOrderDualOfIsStronglyCoatomic
code: instance [IsStronglyCoatomic α] : IsStronglyAtomic αᵒᵈ 
goal: IsStronglyAtomic αᵒᵈ

full_name: IsStronglyAtomic.isAtomic
code: instance IsStronglyAtomic.isAtomic (α : Type*) [PartialOrder α] [OrderBot α] [IsStronglyAtomic α] :
    IsAtomic α 
goal: IsAtomic α

full_name: IsStronglyCoatomic.toIsCoatomic
code: instance IsStronglyCoatomic.toIsCoatomic (α : Type*) [PartialOrder α] [OrderTop α]
    [IsStronglyCoatomic α] : IsCoatomic α 
goal: IsCoatomic α

full_name: Set.OrdConnected.isStronglyAtomic
code: theorem Set.OrdConnected.isStronglyAtomic [IsStronglyAtomic α] {s : Set α}
    (h : Set.OrdConnected s) : IsStronglyAtomic s 
goal: IsStronglyAtomic ↑s

full_name: Set.OrdConnected.isStronglyCoatomic
code: theorem Set.OrdConnected.isStronglyCoatomic [IsStronglyCoatomic α] {s : Set α}
    (h : Set.OrdConnected s) : IsStronglyCoatomic s 
goal: IsStronglyCoatomic ↑s

full_name: instIsStronglyAtomicElemOfOrdConnected
code: instance [IsStronglyAtomic α] {s : Set α} [Set.OrdConnected s] : IsStronglyAtomic s 
goal: IsStronglyAtomic ↑s

full_name: instIsStronglyCoatomicElemOfOrdConnected
code: instance [IsStronglyCoatomic α] {s : Set α} [h : Set.OrdConnected s] : IsStronglyCoatomic s 
goal: IsStronglyCoatomic ↑s

full_name: SuccOrder.toIsStronglyAtomic
code: instance SuccOrder.toIsStronglyAtomic [SuccOrder α] : IsStronglyAtomic α 
goal: IsStronglyAtomic α

full_name: instIsStronglyCoatomicOfPredOrder
code: instance [PredOrder α] : IsStronglyCoatomic α 
goal: IsStronglyCoatomic α

full_name: IsStronglyAtomic.of_wellFounded_lt
code: theorem IsStronglyAtomic.of_wellFounded_lt (h : WellFounded ((· < ·) : α → α → Prop)) :
    IsStronglyAtomic α 
goal: IsStronglyAtomic α

full_name: IsStronglyCoatomic.of_wellFounded_gt
code: theorem IsStronglyCoatomic.of_wellFounded_gt (h : WellFounded ((· > ·) : α → α → Prop)) :
    IsStronglyCoatomic α 
goal: IsStronglyCoatomic α

full_name: instIsStronglyAtomicOfWellFoundedLT
code: instance [WellFoundedLT α] : IsStronglyAtomic α 
goal: IsStronglyAtomic α

full_name: instIsStronglyCoatomicOfWellFoundedGT
code: instance [WellFoundedGT α] : IsStronglyCoatomic α 
goal: IsStronglyCoatomic α

full_name: isAtomic_of_orderBot_wellFounded_lt
code: theorem isAtomic_of_orderBot_wellFounded_lt [OrderBot α]
    (h : WellFounded ((· < ·) : α → α → Prop)) : IsAtomic α 
goal: IsAtomic α

full_name: isCoatomic_of_orderTop_gt_wellFounded
code: theorem isCoatomic_of_orderTop_gt_wellFounded [OrderTop α]
    (h : WellFounded ((· > ·) : α → α → Prop)) : IsCoatomic α 
goal: IsCoatomic α

full_name: BooleanAlgebra.le_iff_atom_le_imp
code: theorem le_iff_atom_le_imp {α} [BooleanAlgebra α] [IsAtomic α] {x y : α} :
    x ≤ y ↔ ∀ a, IsAtom a → a ≤ x → a ≤ y 
goal: x ≤ y ↔ ∀ (a : α), IsAtom a → a ≤ x → a ≤ y

full_name: BooleanAlgebra.eq_iff_atom_le_iff
code: theorem eq_iff_atom_le_iff {α} [BooleanAlgebra α] [IsAtomic α] {x y : α} :
    x = y ↔ ∀ a, IsAtom a → (a ≤ x ↔ a ≤ y) 
goal: x = y ↔ ∀ (a : α), IsAtom a → (a ≤ x ↔ a ≤ y)

full_name: CompleteBooleanAlgebra.toCompleteAtomicBooleanAlgebra
code: abbrev toCompleteAtomicBooleanAlgebra {α} [CompleteBooleanAlgebra α] [IsAtomic α] :
    CompleteAtomicBooleanAlgebra α 
goal: CompleteAtomicBooleanAlgebra α

full_name: IsAtomistic.eq_sSup_atoms
code: /-- A lattice is atomistic iff every element is a `sSup` of a set of atoms. -/
class IsAtomistic : Prop where
  /-- Every element is a `sSup` of a set of atoms. -/
  eq_sSup_atoms : ∀ b : α, ∃ s : Set α, b = sSup s ∧ ∀ a, a ∈ s → IsAtom a
goal: ∃ s, b = sSup s ∧ ∀ a ∈ s, IsAtom a

full_name: IsAtomistic
code: /-- A lattice is atomistic iff every element is a `sSup` of a set of atoms. -/
class IsAtomistic : Prop where
  /-- Every element is a `sSup` of a set of atoms. -/
  eq_sSup_atoms : ∀ b : α, ∃ s : Set α, b = sSup s ∧ ∀ a, a ∈ s → IsAtom a
goal: Prop

full_name: IsCoatomistic.eq_sInf_coatoms
code: /-- A lattice is coatomistic iff every element is an `sInf` of a set of coatoms. -/
class IsCoatomistic : Prop where
  /-- Every element is a `sInf` of a set of coatoms. -/
  eq_sInf_coatoms : ∀ b : α, ∃ s : Set α, b = sInf s ∧ ∀ a, a ∈ s → IsCoatom a
goal: ∃ s, b = sInf s ∧ ∀ a ∈ s, IsCoatom a

full_name: IsCoatomistic
code: /-- A lattice is coatomistic iff every element is an `sInf` of a set of coatoms. -/
class IsCoatomistic : Prop where
  /-- Every element is a `sInf` of a set of coatoms. -/
  eq_sInf_coatoms : ∀ b : α, ∃ s : Set α, b = sInf s ∧ ∀ a, a ∈ s → IsCoatom a
goal: Prop

full_name: isCoatomistic_dual_iff_isAtomistic
code: @[simp]
theorem isCoatomistic_dual_iff_isAtomistic : IsCoatomistic αᵒᵈ ↔ IsAtomistic α 
goal: IsCoatomistic αᵒᵈ ↔ IsAtomistic α

full_name: isAtomistic_dual_iff_isCoatomistic
code: @[simp]
theorem isAtomistic_dual_iff_isCoatomistic : IsAtomistic αᵒᵈ ↔ IsCoatomistic α 
goal: IsAtomistic αᵒᵈ ↔ IsCoatomistic α

full_name: OrderDual.instIsCoatomistic
code: instance _root_.OrderDual.instIsCoatomistic [h : IsAtomistic α] : IsCoatomistic αᵒᵈ 
goal: IsCoatomistic αᵒᵈ

full_name: IsAtomistic.instIsAtomic
code: instance (priority := 100) : IsAtomic α 
goal: IsAtomic α

full_name: sSup_atoms_le_eq
code: @[simp]
theorem sSup_atoms_le_eq (b : α) : sSup { a : α | IsAtom a ∧ a ≤ b } = b 
goal: sSup {a | IsAtom a ∧ a ≤ b} = b

full_name: sSup_atoms_eq_top
code: @[simp]
theorem sSup_atoms_eq_top : sSup { a : α | IsAtom a } = ⊤ 
goal: sSup {a | IsAtom a} = ⊤

full_name: le_iff_atom_le_imp
code: theorem le_iff_atom_le_imp {a b : α} : a ≤ b ↔ ∀ c : α, IsAtom c → c ≤ a → c ≤ b 
goal: a ≤ b ↔ ∀ (c : α), IsAtom c → c ≤ a → c ≤ b

full_name: eq_iff_atom_le_iff
code: theorem eq_iff_atom_le_iff {a b : α} : a = b ↔ ∀ c, IsAtom c → (c ≤ a ↔ c ≤ b) 
goal: a = b ↔ ∀ (c : α), IsAtom c → (c ≤ a ↔ c ≤ b)

full_name: OrderDual.instIsAtomistic
code: instance _root_.OrderDual.instIsAtomistic [h : IsCoatomistic α] : IsAtomistic αᵒᵈ 
goal: IsAtomistic αᵒᵈ

full_name: IsCoatomistic.instIsCoatomic
code: instance (priority := 100) : IsCoatomic α 
goal: IsCoatomic α

full_name: CompleteAtomicBooleanAlgebra.instIsAtomistic
code: instance {α} [CompleteAtomicBooleanAlgebra α] : IsAtomistic α 
goal: IsAtomistic α

full_name: CompleteAtomicBooleanAlgebra.instIsCoatomistic
code: instance {α} [CompleteAtomicBooleanAlgebra α] : IsCoatomistic α 
goal: IsCoatomistic α

full_name: IsSimpleOrder
code: /-- An order is simple iff it has exactly two elements, `⊥` and `⊤`. -/
class IsSimpleOrder (α : Type*) [LE α] [BoundedOrder α] extends Nontrivial α : Prop where
  /-- Every element is either `⊥` or `⊤` -/
  eq_bot_or_eq_top : ∀ a : α, a = ⊥ ∨ a = ⊤
goal: Prop

full_name: IsSimpleOrder.eq_bot_or_eq_top
code: /-- An order is simple iff it has exactly two elements, `⊥` and `⊤`. -/
class IsSimpleOrder (α : Type*) [LE α] [BoundedOrder α] extends Nontrivial α : Prop where
  /-- Every element is either `⊥` or `⊤` -/
  eq_bot_or_eq_top : ∀ a : α, a = ⊥ ∨ a = ⊤
goal: a = ⊥ ∨ a = ⊤

full_name: isSimpleOrder_iff_isSimpleOrder_orderDual
code: theorem isSimpleOrder_iff_isSimpleOrder_orderDual [LE α] [BoundedOrder α] :
    IsSimpleOrder α ↔ IsSimpleOrder αᵒᵈ 
goal: IsSimpleOrder α ↔ IsSimpleOrder αᵒᵈ

full_name: IsSimpleOrder.bot_ne_top
code: theorem IsSimpleOrder.bot_ne_top [LE α] [BoundedOrder α] [IsSimpleOrder α] : (⊥ : α) ≠ (⊤ : α) 
goal: ⊥ ≠ ⊤

full_name: OrderDual.instIsSimpleOrder
code: instance OrderDual.instIsSimpleOrder {α} [LE α] [BoundedOrder α] [IsSimpleOrder α] :
    IsSimpleOrder αᵒᵈ 
goal: IsSimpleOrder αᵒᵈ

full_name: IsSimpleOrder.preorder
code: /-- A simple `BoundedOrder` induces a preorder. This is not an instance to prevent loops. -/
protected def IsSimpleOrder.preorder {α} [LE α] [BoundedOrder α] [IsSimpleOrder α] :
    Preorder α 
goal: Preorder α

full_name: IsSimpleOrder.linearOrder
code: /-- A simple partial ordered `BoundedOrder` induces a linear order.
This is not an instance to prevent loops. -/
protected def IsSimpleOrder.linearOrder [DecidableEq α] : LinearOrder α 
goal: LinearOrder α

full_name: isAtom_top
code: @[simp]
theorem isAtom_top : IsAtom (⊤ : α) 
goal: IsAtom ⊤

full_name: isCoatom_bot
code: @[simp]
theorem isCoatom_bot : IsCoatom (⊥ : α) 
goal: IsCoatom ⊥

full_name: bot_covBy_top
code: theorem bot_covBy_top : (⊥ : α) ⋖ ⊤ 
goal: ⊥ ⋖ ⊤

full_name: IsSimpleOrder.eq_bot_of_lt
code: theorem eq_bot_of_lt : a = ⊥ 
goal: a = ⊥

full_name: IsSimpleOrder.eq_top_of_lt
code: theorem eq_top_of_lt : b = ⊤ 
goal: b = ⊤

full_name: IsSimpleOrder.lattice
code: /-- A simple partial ordered `BoundedOrder` induces a lattice.
This is not an instance to prevent loops -/
protected def lattice {α} [DecidableEq α] [PartialOrder α] [BoundedOrder α] [IsSimpleOrder α] :
    Lattice α 
goal: Lattice α

full_name: IsSimpleOrder.distribLattice
code: /-- A lattice that is a `BoundedOrder` is a distributive lattice.
This is not an instance to prevent loops -/
protected def distribLattice : DistribLattice α 
goal: DistribLattice α

full_name: IsSimpleOrder.instIsAtomic
code: instance (priority := 100) : IsAtomic α 
goal: IsAtomic α

full_name: IsSimpleOrder.instIsCoatomic
code: instance (priority := 100) : IsCoatomic α 
goal: IsCoatomic α

full_name: IsSimpleOrder.equivBool_symm_apply
code: /-- Every simple lattice is isomorphic to `Bool`, regardless of order. -/
@[simps]
def equivBool {α} [DecidableEq α] [LE α] [BoundedOrder α] [IsSimpleOrder α] : α ≃ Bool 
goal: IsSimpleOrder.equivBool.symm x = Bool.casesOn x ⊥ ⊤

full_name: IsSimpleOrder.equivBool
code: /-- Every simple lattice is isomorphic to `Bool`, regardless of order. -/
@[simps]
def equivBool {α} [DecidableEq α] [LE α] [BoundedOrder α] [IsSimpleOrder α] : α ≃ Bool 
goal: α ≃ Bool

full_name: IsSimpleOrder.equivBool_apply
code: /-- Every simple lattice is isomorphic to `Bool`, regardless of order. -/
@[simps]
def equivBool {α} [DecidableEq α] [LE α] [BoundedOrder α] [IsSimpleOrder α] : α ≃ Bool 
goal: IsSimpleOrder.equivBool x = decide (x = ⊤)

full_name: IsSimpleOrder.orderIsoBool
code: /-- Every simple lattice over a partial order is order-isomorphic to `Bool`. -/
def orderIsoBool : α ≃o Bool 
goal: α ≃o Bool

full_name: IsSimpleOrder.booleanAlgebra
code: /-- A simple `BoundedOrder` is also a `BooleanAlgebra`. -/
protected def booleanAlgebra {α} [DecidableEq α] [Lattice α] [BoundedOrder α] [IsSimpleOrder α] :
    BooleanAlgebra α 
goal: BooleanAlgebra α

full_name: IsSimpleOrder.completeLattice
code: /-- A simple `BoundedOrder` is also complete. -/
protected noncomputable def completeLattice : CompleteLattice α 
goal: CompleteLattice α

full_name: IsSimpleOrder.completeBooleanAlgebra
code: /-- A simple `BoundedOrder` is also a `CompleteBooleanAlgebra`. -/
protected noncomputable def completeBooleanAlgebra : CompleteBooleanAlgebra α 
goal: CompleteBooleanAlgebra α

full_name: IsSimpleOrder.instComplementedLattice
code: instance : ComplementedLattice α 
goal: ComplementedLattice α

full_name: IsSimpleOrder.instIsAtomistic
code: instance (priority := 100) : IsAtomistic α 
goal: IsAtomistic α

full_name: IsSimpleOrder.instIsCoatomistic
code: instance : IsCoatomistic α 
goal: IsCoatomistic α

full_name: isSimpleOrder_iff_isAtom_top
code: theorem isSimpleOrder_iff_isAtom_top [PartialOrder α] [BoundedOrder α] :
    IsSimpleOrder α ↔ IsAtom (⊤ : α) 
goal: IsSimpleOrder α ↔ IsAtom ⊤

full_name: isSimpleOrder_iff_isCoatom_bot
code: theorem isSimpleOrder_iff_isCoatom_bot [PartialOrder α] [BoundedOrder α] :
    IsSimpleOrder α ↔ IsCoatom (⊥ : α) 
goal: IsSimpleOrder α ↔ IsCoatom ⊥

full_name: Set.isSimpleOrder_Iic_iff_isAtom
code: theorem isSimpleOrder_Iic_iff_isAtom [PartialOrder α] [OrderBot α] {a : α} :
    IsSimpleOrder (Iic a) ↔ IsAtom a 
goal: IsSimpleOrder ↑(Set.Iic a) ↔ IsAtom a

full_name: Set.isSimpleOrder_Ici_iff_isCoatom
code: theorem isSimpleOrder_Ici_iff_isCoatom [PartialOrder α] [OrderTop α] {a : α} :
    IsSimpleOrder (Ici a) ↔ IsCoatom a 
goal: IsSimpleOrder ↑(Set.Ici a) ↔ IsCoatom a

full_name: OrderEmbedding.isAtom_of_map_bot_of_image
code: theorem isAtom_of_map_bot_of_image [OrderBot α] [OrderBot β] (f : β ↪o α) (hbot : f ⊥ = ⊥) {b : β}
    (hb : IsAtom (f b)) : IsAtom b 
goal: IsAtom b

full_name: OrderEmbedding.isCoatom_of_map_top_of_image
code: theorem isCoatom_of_map_top_of_image [OrderTop α] [OrderTop β] (f : β ↪o α) (htop : f ⊤ = ⊤)
    {b : β} (hb : IsCoatom (f b)) : IsCoatom b 
goal: IsCoatom b

full_name: GaloisInsertion.isAtom_of_u_bot
code: theorem isAtom_of_u_bot [OrderBot α] [OrderBot β] {l : α → β} {u : β → α}
    (gi : GaloisInsertion l u) (hbot : u ⊥ = ⊥) {b : β} (hb : IsAtom (u b)) : IsAtom b 
goal: IsAtom b

full_name: GaloisInsertion.isAtom_iff
code: theorem isAtom_iff [OrderBot α] [IsAtomic α] [OrderBot β] {l : α → β} {u : β → α}
    (gi : GaloisInsertion l u) (hbot : u ⊥ = ⊥) (h_atom : ∀ a, IsAtom a → u (l a) = a) (a : α) :
    IsAtom (l a) ↔ IsAtom a 
goal: IsAtom (l a) ↔ IsAtom a

full_name: GaloisInsertion.isAtom_iff'
code: theorem isAtom_iff' [OrderBot α] [IsAtomic α] [OrderBot β] {l : α → β} {u : β → α}
    (gi : GaloisInsertion l u) (hbot : u ⊥ = ⊥) (h_atom : ∀ a, IsAtom a → u (l a) = a) (b : β) :
    IsAtom (u b) ↔ IsAtom b 
goal: IsAtom (u b) ↔ IsAtom b

full_name: GaloisInsertion.isCoatom_of_image
code: theorem isCoatom_of_image [OrderTop α] [OrderTop β] {l : α → β} {u : β → α}
    (gi : GaloisInsertion l u) {b : β} (hb : IsCoatom (u b)) : IsCoatom b 
goal: IsCoatom b

full_name: GaloisInsertion.isCoatom_iff
code: theorem isCoatom_iff [OrderTop α] [IsCoatomic α] [OrderTop β] {l : α → β} {u : β → α}
    (gi : GaloisInsertion l u) (h_coatom : ∀ a : α, IsCoatom a → u (l a) = a) (b : β) :
    IsCoatom (u b) ↔ IsCoatom b 
goal: IsCoatom (u b) ↔ IsCoatom b

full_name: GaloisCoinsertion.isCoatom_of_l_top
code: theorem isCoatom_of_l_top [OrderTop α] [OrderTop β] {l : α → β} {u : β → α}
    (gi : GaloisCoinsertion l u) (hbot : l ⊤ = ⊤) {a : α} (hb : IsCoatom (l a)) : IsCoatom a 
goal: IsCoatom a

full_name: GaloisCoinsertion.isCoatom_iff
code: theorem isCoatom_iff [OrderTop α] [OrderTop β] [IsCoatomic β] {l : α → β} {u : β → α}
    (gi : GaloisCoinsertion l u) (htop : l ⊤ = ⊤) (h_coatom : ∀ b, IsCoatom b → l (u b) = b)
    (b : β) : IsCoatom (u b) ↔ IsCoatom b 
goal: IsCoatom (u b) ↔ IsCoatom b

full_name: GaloisCoinsertion.isCoatom_iff'
code: theorem isCoatom_iff' [OrderTop α] [OrderTop β] [IsCoatomic β] {l : α → β} {u : β → α}
    (gi : GaloisCoinsertion l u) (htop : l ⊤ = ⊤) (h_coatom : ∀ b, IsCoatom b → l (u b) = b)
    (a : α) : IsCoatom (l a) ↔ IsCoatom a 
goal: IsCoatom (l a) ↔ IsCoatom a

full_name: GaloisCoinsertion.isAtom_of_image
code: theorem isAtom_of_image [OrderBot α] [OrderBot β] {l : α → β} {u : β → α}
    (gi : GaloisCoinsertion l u) {a : α} (hb : IsAtom (l a)) : IsAtom a 
goal: IsAtom a

full_name: GaloisCoinsertion.isAtom_iff
code: theorem isAtom_iff [OrderBot α] [OrderBot β] [IsAtomic β] {l : α → β} {u : β → α}
    (gi : GaloisCoinsertion l u) (h_atom : ∀ b, IsAtom b → l (u b) = b) (a : α) :
    IsAtom (l a) ↔ IsAtom a 
goal: IsAtom (l a) ↔ IsAtom a

full_name: OrderIso.isAtom_iff
code: @[simp]
theorem isAtom_iff [OrderBot α] [OrderBot β] (f : α ≃o β) (a : α) : IsAtom (f a) ↔ IsAtom a 
goal: IsAtom (f a) ↔ IsAtom a

full_name: OrderIso.isCoatom_iff
code: @[simp]
theorem isCoatom_iff [OrderTop α] [OrderTop β] (f : α ≃o β) (a : α) :
    IsCoatom (f a) ↔ IsCoatom a 
goal: IsCoatom (f a) ↔ IsCoatom a

full_name: OrderIso.isSimpleOrder_iff
code: theorem isSimpleOrder_iff [BoundedOrder α] [BoundedOrder β] (f : α ≃o β) :
    IsSimpleOrder α ↔ IsSimpleOrder β 
goal: IsSimpleOrder α ↔ IsSimpleOrder β

full_name: OrderIso.isSimpleOrder
code: theorem isSimpleOrder [BoundedOrder α] [BoundedOrder β] [h : IsSimpleOrder β] (f : α ≃o β) :
    IsSimpleOrder α 
goal: IsSimpleOrder α

full_name: OrderIso.isAtomic_iff
code: protected theorem isAtomic_iff [OrderBot α] [OrderBot β] (f : α ≃o β) :
    IsAtomic α ↔ IsAtomic β 
goal: IsAtomic α ↔ IsAtomic β

full_name: OrderIso.isCoatomic_iff
code: protected theorem isCoatomic_iff [OrderTop α] [OrderTop β] (f : α ≃o β) :
    IsCoatomic α ↔ IsCoatomic β 
goal: IsCoatomic α ↔ IsCoatomic β

full_name: CompleteLattice.isStronglyAtomic
code: /-- A complete upper-modular lattice that is atomistic is strongly atomic.
Not an instance to prevent loops. -/
theorem CompleteLattice.isStronglyAtomic [IsUpperModularLattice α] [IsAtomistic α] :
    IsStronglyAtomic α 
goal: IsStronglyAtomic α

full_name: CompleteLattice.isStronglyCoatomic
code: /-- A complete lower-modular lattice that is coatomistic is strongly coatomic.
Not an instance to prevent loops. -/
theorem CompleteLattice.isStronglyCoatomic [IsLowerModularLattice α] [IsCoatomistic α] :
    IsStronglyCoatomic α 
goal: IsStronglyCoatomic α

full_name: IsCompl.isAtom_iff_isCoatom
code: theorem isAtom_iff_isCoatom : IsAtom a ↔ IsCoatom b 
goal: IsAtom a ↔ IsCoatom b

full_name: IsCompl.isCoatom_iff_isAtom
code: theorem isCoatom_iff_isAtom : IsCoatom a ↔ IsAtom b 
goal: IsCoatom a ↔ IsAtom b

full_name: isCoatomic_of_isAtomic_of_complementedLattice_of_isModular
code: theorem isCoatomic_of_isAtomic_of_complementedLattice_of_isModular [IsAtomic α] :
    IsCoatomic α 
goal: IsCoatomic α

full_name: isAtomic_of_isCoatomic_of_complementedLattice_of_isModular
code: theorem isAtomic_of_isCoatomic_of_complementedLattice_of_isModular [IsCoatomic α] :
    IsAtomic α 
goal: IsAtomic α

full_name: isAtomic_iff_isCoatomic
code: theorem isAtomic_iff_isCoatomic : IsAtomic α ↔ IsCoatomic α 
goal: IsAtomic α ↔ IsCoatomic α

full_name: ComplementedLattice.isStronglyAtomic
code: /-- A complemented modular atomic lattice is strongly atomic.
Not an instance to prevent loops. -/
theorem ComplementedLattice.isStronglyAtomic [IsAtomic α] : IsStronglyAtomic α 
goal: IsStronglyAtomic α

full_name: ComplementedLattice.isStronglyCoatomic
code: /-- A complemented modular coatomic lattice is strongly coatomic.
Not an instance to prevent loops. -/
theorem ComplementedLattice.isStronglyCoatomic [IsCoatomic α] : IsStronglyCoatomic α 
goal: IsStronglyCoatomic α

full_name: ComplementedLattice.isStronglyAtomic'
code: /-- A complemented modular atomic lattice is strongly coatomic.
Not an instance to prevent loops. -/
theorem ComplementedLattice.isStronglyAtomic' [h : IsAtomic α] : IsStronglyCoatomic α 
goal: IsStronglyCoatomic α

full_name: ComplementedLattice.isStronglyCoatomic'
code: /-- A complemented modular coatomic lattice is strongly atomic.
Not an instance to prevent loops. -/
theorem ComplementedLattice.isStronglyCoatomic' [h : IsCoatomic α] : IsStronglyAtomic α 
goal: IsStronglyAtomic α

full_name: Prop.isAtom_iff
code: @[simp] theorem isAtom_iff {p : Prop} : IsAtom p ↔ p 
goal: IsAtom p ↔ p

full_name: Prop.isCoatom_iff
code: @[simp] theorem isCoatom_iff {p : Prop} : IsCoatom p ↔ ¬ p 
goal: IsCoatom p ↔ ¬p

full_name: Prop.instIsSimpleOrderProp
code: instance : IsSimpleOrder Prop 
goal: IsSimpleOrder Prop

full_name: Pi.eq_bot_iff
code: protected theorem eq_bot_iff [∀ i, Bot (π i)] {f : ∀ i, π i} : f = ⊥ ↔ ∀ i, f i = ⊥ 
goal: f = ⊥ ↔ ∀ (i : ι), f i = ⊥

full_name: Pi.isAtom_iff
code: theorem isAtom_iff {f : ∀ i, π i} [∀ i, PartialOrder (π i)] [∀ i, OrderBot (π i)] :
    IsAtom f ↔ ∃ i, IsAtom (f i) ∧ ∀ j, j ≠ i → f j = ⊥ 
goal: IsAtom f ↔ ∃ i, IsAtom (f i) ∧ ∀ (j : ι), j ≠ i → f j = ⊥

full_name: Pi.isAtom_single
code: theorem isAtom_single {i : ι} [DecidableEq ι] [∀ i, PartialOrder (π i)] [∀ i, OrderBot (π i)]
    {a : π i} (h : IsAtom a) : IsAtom (Function.update (⊥ : ∀ i, π i) i a) 
goal: IsAtom (Function.update ⊥ i a)

full_name: Pi.isAtom_iff_eq_single
code: theorem isAtom_iff_eq_single [DecidableEq ι] [∀ i, PartialOrder (π i)]
    [∀ i, OrderBot (π i)] {f : ∀ i, π i} :
    IsAtom f ↔ ∃ i a, IsAtom a ∧ f = Function.update ⊥ i a 
goal: IsAtom f ↔ ∃ i a, IsAtom a ∧ f = Function.update ⊥ i a

full_name: Pi.isAtomic
code: instance isAtomic [∀ i, PartialOrder (π i)] [∀ i, OrderBot (π i)] [∀ i, IsAtomic (π i)] :
    IsAtomic (∀ i, π i) 
goal: IsAtomic ((i : ι) → π i)

full_name: Pi.isCoatomic
code: instance isCoatomic [∀ i, PartialOrder (π i)] [∀ i, OrderTop (π i)] [∀ i, IsCoatomic (π i)] :
    IsCoatomic (∀ i, π i) 
goal: IsCoatomic ((i : ι) → π i)

full_name: Pi.isAtomistic
code: instance isAtomistic [∀ i, CompleteLattice (π i)] [∀ i, IsAtomistic (π i)] :
    IsAtomistic (∀ i, π i) 
goal: IsAtomistic ((i : ι) → π i)

full_name: Pi.isCoatomistic
code: instance isCoatomistic [∀ i, CompleteLattice (π i)] [∀ i, IsCoatomistic (π i)] :
    IsCoatomistic (∀ i, π i) 
goal: IsCoatomistic ((i : ι) → π i)

full_name: isAtom_compl
code: @[simp] lemma isAtom_compl : IsAtom aᶜ ↔ IsCoatom a 
goal: IsAtom aᶜ ↔ IsCoatom a

full_name: isCoatom_compl
code: @[simp] lemma isCoatom_compl : IsCoatom aᶜ ↔ IsAtom a 
goal: IsCoatom aᶜ ↔ IsAtom a

full_name: Set.isAtom_singleton
code: theorem isAtom_singleton (x : α) : IsAtom ({x} : Set α) 
goal: IsAtom {x}

full_name: Set.isAtom_iff
code: theorem isAtom_iff {s : Set α} : IsAtom s ↔ ∃ x, s = {x} 
goal: IsAtom s ↔ ∃ x, s = {x}

full_name: Set.isCoatom_iff
code: theorem isCoatom_iff (s : Set α) : IsCoatom s ↔ ∃ x, s = {x}ᶜ 
goal: IsCoatom s ↔ ∃ x, s = {x}ᶜ

full_name: Set.isCoatom_singleton_compl
code: theorem isCoatom_singleton_compl (x : α) : IsCoatom ({x}ᶜ : Set α) 
goal: IsCoatom {x}ᶜ

full_name: Set.instIsAtomistic
code: instance : IsAtomistic (Set α) 
goal: IsAtomistic (Set α)

full_name: Set.instIsCoatomistic
code: instance : IsCoatomistic (Set α) 
goal: IsCoatomistic (Set α)