fact stringlengths 6 3.84k | type stringclasses 11
values | library stringclasses 32
values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
IsCoatom.ne_top_iff_eq (ha : IsCoatom a) (hab : a ≤ b) : b ≠ ⊤ ↔ b = a :=
(ha.ne_iff_eq_top hab).not_right.symm | lemma | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | IsCoatom.ne_top_iff_eq | null |
IsCoatom.Ici_eq (h : IsCoatom a) : Set.Ici a = {⊤, a} :=
h.dual.Iic_eq
@[simp] | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | IsCoatom.Ici_eq | null |
covBy_top_iff : a ⋖ ⊤ ↔ IsCoatom a :=
toDual_covBy_toDual_iff.symm.trans bot_covBy_iff
alias ⟨CovBy.isCoatom, IsCoatom.covBy_top⟩ := covBy_top_iff | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | covBy_top_iff | null |
isAtom_iff [OrderBot A] {K : A} :
IsAtom K ↔ K ≠ ⊥ ∧ ∀ H g, H ≤ K → g ∉ H → g ∈ K → H = ⊥ := by
simp_rw [IsAtom, lt_iff_le_not_ge, SetLike.not_le_iff_exists,
and_comm (a := _ ≤ _), and_imp, exists_imp, ← and_imp, and_comm] | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | isAtom_iff | null |
isCoatom_iff [OrderTop A] {K : A} :
IsCoatom K ↔ K ≠ ⊤ ∧ ∀ H g, K ≤ H → g ∉ K → g ∈ H → H = ⊤ := by
simp_rw [IsCoatom, lt_iff_le_not_ge, SetLike.not_le_iff_exists,
and_comm (a := _ ≤ _), and_imp, exists_imp, ← and_imp, and_comm] | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | isCoatom_iff | null |
covBy_iff {K L : A} :
K ⋖ L ↔ K < L ∧ ∀ H g, K ≤ H → H ≤ L → g ∉ K → g ∈ H → H = L := by
refine and_congr_right fun _ ↦ forall_congr' fun H ↦ not_iff_not.mp ?_
push_neg
rw [lt_iff_le_not_ge, lt_iff_le_and_ne, and_and_and_comm]
simp_rw [exists_and_left, and_assoc, and_congr_right_iff, ← and_assoc, and_comm, ... | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | covBy_iff | null |
covBy_iff' {K L : A} :
K ⋖ L ↔ K < L ∧ ∀ H g, K ≤ H → H ≤ L → g ∉ H → g ∈ L → H = K := by
refine and_congr_right fun _ ↦ forall_congr' fun H ↦ not_iff_not.mp ?_
push_neg
rw [lt_iff_le_and_ne, lt_iff_le_not_ge, and_and_and_comm]
simp_rw [exists_and_left, and_assoc, and_congr_right_iff, ← and_assoc, and_comm,... | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | covBy_iff' | Dual variant of `SetLike.covBy_iff` |
protected IsCoatom.iInf_le (ha : IsCoatom a) : iInf f ≤ a ↔ ∃ i, f i ≤ a :=
IsAtom.le_iSup (α := αᵒᵈ) ha
@[deprecated (since := "2025-07-11")] alias iInf_le_coatom := IsCoatom.iInf_le | lemma | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | IsCoatom.iInf_le | null |
protected IsCoatom.sInf_le (ha : IsCoatom a) : sInf s ≤ a ↔ ∃ b ∈ s, b ≤ a := by
simp [sInf_eq_iInf', ha.iInf_le] | lemma | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | IsCoatom.sInf_le | null |
@[simp]
Set.Ici.isAtom_iff {b : Set.Ici a} : IsAtom b ↔ a ⋖ b := by
rw [← bot_covBy_iff]
refine (Set.OrdConnected.apply_covBy_apply_iff (OrderEmbedding.subtype fun c => a ≤ c) ?_).symm
simpa only [OrderEmbedding.coe_subtype, Subtype.range_coe_subtype] using Set.ordConnected_Ici
@[simp] | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | Set.Ici.isAtom_iff | null |
Set.Iic.isCoatom_iff {a : Set.Iic b} : IsCoatom a ↔ ↑a ⋖ b := by
rw [← covBy_top_iff]
refine (Set.OrdConnected.apply_covBy_apply_iff (OrderEmbedding.subtype fun c => c ≤ b) ?_).symm
simpa only [OrderEmbedding.coe_subtype, Subtype.range_coe_subtype] using Set.ordConnected_Iic | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | Set.Iic.isCoatom_iff | null |
covBy_iff_atom_Ici (h : a ≤ b) : a ⋖ b ↔ IsAtom (⟨b, h⟩ : Set.Ici a) := by simp | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | covBy_iff_atom_Ici | null |
covBy_iff_coatom_Iic (h : a ≤ b) : a ⋖ b ↔ IsCoatom (⟨a, h⟩ : Set.Iic b) := by simp | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | covBy_iff_coatom_Iic | null |
IsAtom.not_disjoint_iff_le (ha : IsAtom a) : ¬ Disjoint a b ↔ a ≤ b := by
rw [disjoint_iff, ← inf_eq_left]; exact ha.ne_bot_iff_eq inf_le_left | lemma | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | IsAtom.not_disjoint_iff_le | null |
IsAtom.not_le_iff_disjoint (ha : IsAtom a) : ¬ a ≤ b ↔ Disjoint a b :=
ha.not_disjoint_iff_le.not_right.symm | lemma | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | IsAtom.not_le_iff_disjoint | null |
IsAtom.disjoint_of_ne (ha : IsAtom a) (hb : IsAtom b) (hab : a ≠ b) : Disjoint a b := by
simp [← ha.not_le_iff_disjoint, hb.le_iff, hab, ha.ne_bot]
@[deprecated disjoint_of_ne (since := "2025-07-11")] | lemma | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | IsAtom.disjoint_of_ne | null |
IsAtom.inf_eq_bot_of_ne (ha : IsAtom a) (hb : IsAtom b) (hab : a ≠ b) : a ⊓ b = ⊥ :=
hab.not_le_or_not_ge.elim (ha.lt_iff.1 ∘ inf_lt_left.2) (hb.lt_iff.1 ∘ inf_lt_right.2)
@[deprecated not_le_iff_disjoint (since := "2025-07-11")] | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | IsAtom.inf_eq_bot_of_ne | null |
IsAtom.inf_eq_bot_iff (ha : IsAtom a) : a ⊓ b = ⊥ ↔ ¬ a ≤ b := by
by_cases hb : b = ⊥
· simpa [hb] using ha.1
· exact ⟨fun h ↦ inf_lt_left.mp (h ▸ bot_lt ha), fun h ↦ ha.2 _ (inf_lt_left.mpr h)⟩ | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | IsAtom.inf_eq_bot_iff | null |
IsCoatom.not_codisjoint_iff_le (ha : IsCoatom a) : ¬ Codisjoint a b ↔ b ≤ a := by
rw [codisjoint_iff, ← sup_eq_left]; exact ha.ne_top_iff_eq le_sup_left | lemma | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | IsCoatom.not_codisjoint_iff_le | null |
IsCoatom.not_le_iff_codisjoint (ha : IsCoatom a) : ¬ b ≤ a ↔ Codisjoint a b :=
ha.not_codisjoint_iff_le.not_right.symm | lemma | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | IsCoatom.not_le_iff_codisjoint | null |
IsCoatom.codisjoint_of_ne (ha : IsCoatom a) (hb : IsCoatom b) (hab : a ≠ b) :
Codisjoint a b := by
simp [← ha.not_le_iff_codisjoint, hb.le_iff, hab, ha.ne_top] | lemma | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | IsCoatom.codisjoint_of_ne | null |
IsCoatom.sup_eq_top_of_ne (ha : IsCoatom a) (hb : IsCoatom b) (hab : a ≠ b) : a ⊔ b = ⊤ :=
codisjoint_iff.1 <| ha.codisjoint_of_ne hb hab
set_option linter.deprecated false in
@[deprecated not_le_iff_codisjoint (since := "2025-07-11")] | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | IsCoatom.sup_eq_top_of_ne | null |
IsCoatom.sup_eq_top_iff (ha : IsCoatom a) : a ⊔ b = ⊤ ↔ ¬ b ≤ a :=
ha.dual.inf_eq_bot_iff | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | IsCoatom.sup_eq_top_iff | null |
@[mk_iff]
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 | class | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | IsAtomic | A lattice is atomic iff every element other than `⊥` has an atom below it. |
@[mk_iff]
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
export IsAtomic (eq_bot_or_exists_atom_le)
export IsCoatomic (eq_top_or_exists_le_coatom) | class | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | IsCoatomic | A lattice is coatomic iff every element other than `⊤` has a coatom above it. |
IsAtomic.exists_atom [OrderBot α] [Nontrivial α] [IsAtomic α] : ∃ a : α, IsAtom a :=
have ⟨b, hb⟩ := exists_ne (⊥ : α)
have ⟨a, ha⟩ := (eq_bot_or_exists_atom_le b).resolve_left hb
⟨a, ha.1⟩ | lemma | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | IsAtomic.exists_atom | null |
IsCoatomic.exists_coatom [OrderTop α] [Nontrivial α] [IsCoatomic α] : ∃ a : α, IsCoatom a :=
have ⟨b, hb⟩ := exists_ne (⊤ : α)
have ⟨a, ha⟩ := (eq_top_or_exists_le_coatom b).resolve_left hb
⟨a, ha.1⟩
variable {α}
@[simp] | lemma | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | IsCoatomic.exists_coatom | null |
isCoatomic_dual_iff_isAtomic [OrderBot α] : IsCoatomic αᵒᵈ ↔ IsAtomic α :=
⟨fun h => ⟨fun b => by apply h.eq_top_or_exists_le_coatom⟩, fun h =>
⟨fun b => by apply h.eq_bot_or_exists_atom_le⟩⟩
@[simp] | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | isCoatomic_dual_iff_isAtomic | null |
isAtomic_dual_iff_isCoatomic [OrderTop α] : IsAtomic αᵒᵈ ↔ IsCoatomic α :=
⟨fun h => ⟨fun b => by apply h.eq_bot_or_exists_atom_le⟩, fun h =>
⟨fun b => by apply h.eq_top_or_exists_le_coatom⟩⟩ | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | isAtomic_dual_iff_isCoatomic | null |
_root_.OrderDual.instIsCoatomic : IsCoatomic αᵒᵈ :=
isCoatomic_dual_iff_isAtomic.2 ‹IsAtomic α› | instance | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | _root_.OrderDual.instIsCoatomic | null |
Set.Iic.isAtomic {x : α} : IsAtomic (Set.Iic x) :=
⟨fun ⟨y, hy⟩ =>
(eq_bot_or_exists_atom_le y).imp Subtype.mk_eq_mk.2 fun ⟨a, ha, hay⟩ =>
⟨⟨a, hay.trans hy⟩, ha.Iic (hay.trans hy), hay⟩⟩ | instance | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | Set.Iic.isAtomic | null |
_root_.OrderDual.instIsAtomic : IsAtomic αᵒᵈ :=
isAtomic_dual_iff_isCoatomic.2 ‹IsCoatomic α› | instance | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | _root_.OrderDual.instIsAtomic | null |
Set.Ici.isCoatomic {x : α} : IsCoatomic (Set.Ici x) :=
⟨fun ⟨y, hy⟩ =>
(eq_top_or_exists_le_coatom y).imp Subtype.mk_eq_mk.2 fun ⟨a, ha, hay⟩ =>
⟨⟨a, le_trans hy hay⟩, ha.Ici (le_trans hy hay), hay⟩⟩ | instance | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | Set.Ici.isCoatomic | null |
isAtomic_iff_forall_isAtomic_Iic [OrderBot α] :
IsAtomic α ↔ ∀ x : α, IsAtomic (Set.Iic x) :=
⟨@IsAtomic.Set.Iic.isAtomic _ _ _, fun h =>
⟨fun x =>
((@eq_bot_or_exists_atom_le _ _ _ (h x)) (⊤ : Set.Iic x)).imp Subtype.mk_eq_mk.1
(Exists.imp' (↑) fun ⟨_, _⟩ => And.imp_left IsAtom.of_isAtom_coe_Ii... | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | isAtomic_iff_forall_isAtomic_Iic | null |
isCoatomic_iff_forall_isCoatomic_Ici [OrderTop α] :
IsCoatomic α ↔ ∀ x : α, IsCoatomic (Set.Ici x) :=
isAtomic_dual_iff_isCoatomic.symm.trans <|
isAtomic_iff_forall_isAtomic_Iic.trans <|
forall_congr' fun _ => isCoatomic_dual_iff_isAtomic.symm.trans Iff.rfl | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | isCoatomic_iff_forall_isCoatomic_Ici | null |
@[mk_iff]
IsStronglyAtomic (α : Type*) [Preorder α] : Prop where
exists_covBy_le_of_lt : ∀ (a b : α), a < b → ∃ x, a ⋖ x ∧ x ≤ b | class | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | IsStronglyAtomic | An order is strongly atomic if every nontrivial interval `[a, b]`
contains an element covering `a`. |
exists_covBy_le_of_lt [IsStronglyAtomic α] (h : a < b) : ∃ x, a ⋖ x ∧ x ≤ b :=
IsStronglyAtomic.exists_covBy_le_of_lt a b h
alias LT.lt.exists_covby_le := exists_covBy_le_of_lt | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | exists_covBy_le_of_lt | null |
@[mk_iff]
IsStronglyCoatomic (α : Type*) [Preorder α] : Prop where
(exists_le_covBy_of_lt : ∀ (a b : α), a < b → ∃ x, a ≤ x ∧ x ⋖ b) | class | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | IsStronglyCoatomic | An order is strongly coatomic if every nontrivial interval `[a, b]`
contains an element covered by `b`. |
exists_le_covBy_of_lt [IsStronglyCoatomic α] (h : a < b) : ∃ x, a ≤ x ∧ x ⋖ b :=
IsStronglyCoatomic.exists_le_covBy_of_lt a b h
alias LT.lt.exists_le_covby := exists_le_covBy_of_lt | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | exists_le_covBy_of_lt | null |
isStronglyAtomic_dual_iff_is_stronglyCoatomic :
IsStronglyAtomic αᵒᵈ ↔ IsStronglyCoatomic α := by
simpa [isStronglyAtomic_iff, OrderDual.exists, OrderDual.forall,
OrderDual.toDual_le_toDual, and_comm, isStronglyCoatomic_iff] using forall_comm
@[simp] theorem isStronglyCoatomic_dual_iff_is_stronglyAtomic :
... | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | isStronglyAtomic_dual_iff_is_stronglyCoatomic | null |
OrderDual.instIsStronglyCoatomic [IsStronglyAtomic α] : IsStronglyCoatomic αᵒᵈ := by
rwa [isStronglyCoatomic_dual_iff_is_stronglyAtomic] | instance | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | OrderDual.instIsStronglyCoatomic | null |
IsStronglyAtomic.isAtomic (α : Type*) [PartialOrder α] [OrderBot α] [IsStronglyAtomic α] :
IsAtomic α where
eq_bot_or_exists_atom_le a := by
rw [or_iff_not_imp_left, ← Ne, ← bot_lt_iff_ne_bot]
refine fun hlt ↦ ?_
obtain ⟨x, hx, hxa⟩ := hlt.exists_covby_le
exact ⟨x, bot_covBy_iff.1 hx, hxa⟩ | instance | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | IsStronglyAtomic.isAtomic | null |
IsStronglyCoatomic.toIsCoatomic (α : Type*) [PartialOrder α] [OrderTop α]
[IsStronglyCoatomic α] : IsCoatomic α :=
isAtomic_dual_iff_isCoatomic.1 <| IsStronglyAtomic.isAtomic (α := αᵒᵈ) | instance | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | IsStronglyCoatomic.toIsCoatomic | null |
Set.OrdConnected.isStronglyAtomic [IsStronglyAtomic α] {s : Set α}
(h : Set.OrdConnected s) : IsStronglyAtomic s where
exists_covBy_le_of_lt := by
rintro ⟨c, hc⟩ ⟨d, hd⟩ hcd
obtain ⟨x, hcx, hxd⟩ := (Subtype.mk_lt_mk.1 hcd).exists_covby_le
exact ⟨⟨x, h.out' hc hd ⟨hcx.le, hxd⟩⟩,
⟨by simpa using h... | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | Set.OrdConnected.isStronglyAtomic | null |
Set.OrdConnected.isStronglyCoatomic [IsStronglyCoatomic α] {s : Set α}
(h : Set.OrdConnected s) : IsStronglyCoatomic s :=
isStronglyAtomic_dual_iff_is_stronglyCoatomic.1 h.dual.isStronglyAtomic | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | Set.OrdConnected.isStronglyCoatomic | null |
SuccOrder.toIsStronglyAtomic [SuccOrder α] : IsStronglyAtomic α where
exists_covBy_le_of_lt a _ hab :=
⟨SuccOrder.succ a, Order.covBy_succ_of_not_isMax fun ha ↦ ha.not_lt hab,
SuccOrder.succ_le_of_lt hab⟩ | instance | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | SuccOrder.toIsStronglyAtomic | null |
IsStronglyAtomic.of_wellFounded_lt (h : WellFounded ((· < ·) : α → α → Prop)) :
IsStronglyAtomic α where
exists_covBy_le_of_lt a b hab := by
refine ⟨WellFounded.min h (Set.Ioc a b) ⟨b, hab,rfl.le⟩, ?_⟩
have hmem := (WellFounded.min_mem h (Set.Ioc a b) ⟨b, hab,rfl.le⟩)
exact ⟨⟨hmem.1,fun c hac hlt ↦ We... | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | IsStronglyAtomic.of_wellFounded_lt | null |
IsStronglyCoatomic.of_wellFounded_gt (h : WellFounded ((· > ·) : α → α → Prop)) :
IsStronglyCoatomic α :=
isStronglyAtomic_dual_iff_is_stronglyCoatomic.1 <| IsStronglyAtomic.of_wellFounded_lt (α := αᵒᵈ) h | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | IsStronglyCoatomic.of_wellFounded_gt | null |
isAtomic_of_orderBot_wellFounded_lt [OrderBot α]
(h : WellFounded ((· < ·) : α → α → Prop)) : IsAtomic α :=
(IsStronglyAtomic.of_wellFounded_lt h).isAtomic | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | isAtomic_of_orderBot_wellFounded_lt | null |
isCoatomic_of_orderTop_gt_wellFounded [OrderTop α]
(h : WellFounded ((· > ·) : α → α → Prop)) : IsCoatomic α :=
isAtomic_dual_iff_isCoatomic.1 (@isAtomic_of_orderBot_wellFounded_lt αᵒᵈ _ _ h) | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | isCoatomic_of_orderTop_gt_wellFounded | null |
le_iff_atom_le_imp {α} [BooleanAlgebra α] [IsAtomic α] {x y : α} :
x ≤ y ↔ ∀ a, IsAtom a → a ≤ x → a ≤ y := by
refine ⟨fun h a _ => (le_trans · h), fun h => ?_⟩
have : x ⊓ yᶜ = ⊥ := of_not_not fun hbot =>
have ⟨a, ha, hle⟩ := (eq_bot_or_exists_atom_le _).resolve_left hbot
have ⟨hx, hy'⟩ := le_inf_iff.1 ... | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | le_iff_atom_le_imp | null |
eq_iff_atom_le_iff {α} [BooleanAlgebra α] [IsAtomic α] {x y : α} :
x = y ↔ ∀ a, IsAtom a → (a ≤ x ↔ a ≤ y) := by
refine ⟨fun h => h ▸ by simp, fun h => ?_⟩
exact le_antisymm (le_iff_atom_le_imp.2 fun a ha hx => (h a ha).1 hx)
(le_iff_atom_le_imp.2 fun a ha hy => (h a ha).2 hy) | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | eq_iff_atom_le_iff | null |
@[mk_iff]
IsAtomistic [OrderBot α] : Prop where
/-- Every element is a `sSup` of a set of atoms. -/
isLUB_atoms : ∀ b : α, ∃ s : Set α, IsLUB s b ∧ ∀ a, a ∈ s → IsAtom a | class | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | IsAtomistic | Every atomic complete Boolean algebra is completely atomic.
This is not made an instance to avoid typeclass loops. -/
-- See note [reducible non-instances]
abbrev toCompleteAtomicBooleanAlgebra {α} [CompleteBooleanAlgebra α] [IsAtomic α] :
CompleteAtomicBooleanAlgebra α where
__ := ‹CompleteBooleanAlgebra α›
i... |
@[mk_iff]
IsCoatomistic [OrderTop α] : Prop where
/-- Every element is a `sInf` of a set of coatoms. -/
isGLB_coatoms : ∀ b : α, ∃ s : Set α, IsGLB s b ∧ ∀ a, a ∈ s → IsCoatom a
export IsAtomistic (isLUB_atoms)
export IsCoatomistic (isGLB_coatoms)
variable {α}
@[simp] | class | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | IsCoatomistic | A lattice is coatomistic iff every element is an `sInf` of a set of coatoms. |
isCoatomistic_dual_iff_isAtomistic [OrderBot α] : IsCoatomistic αᵒᵈ ↔ IsAtomistic α :=
⟨fun h => ⟨fun b => by apply h.isGLB_coatoms⟩, fun h => ⟨fun b => by apply h.isLUB_atoms⟩⟩
@[simp] | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | isCoatomistic_dual_iff_isAtomistic | null |
isAtomistic_dual_iff_isCoatomistic [OrderTop α] : IsAtomistic αᵒᵈ ↔ IsCoatomistic α :=
⟨fun h => ⟨fun b => by apply h.isLUB_atoms⟩, fun h => ⟨fun b => by apply h.isGLB_coatoms⟩⟩ | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | isAtomistic_dual_iff_isCoatomistic | null |
_root_.OrderDual.instIsCoatomistic [OrderBot α] [h : IsAtomistic α] : IsCoatomistic αᵒᵈ :=
isCoatomistic_dual_iff_isAtomistic.2 h
variable [OrderBot α] [IsAtomistic α] | instance | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | _root_.OrderDual.instIsCoatomistic | null |
isLUB_atoms_le (b : α) : IsLUB { a : α | IsAtom a ∧ a ≤ b } b := by
rcases isLUB_atoms b with ⟨s, hsb, hs⟩
exact ⟨fun c hc ↦ hc.2, fun c hc ↦ hsb.2 fun i hi ↦ hc ⟨hs _ hi, hsb.1 hi⟩⟩ | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | isLUB_atoms_le | null |
isLUB_atoms_top [OrderTop α] : IsLUB { a : α | IsAtom a } ⊤ := by
simpa using isLUB_atoms_le (⊤ : α) | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | isLUB_atoms_top | null |
le_iff_atom_le_imp {a b : α} : a ≤ b ↔ ∀ c : α, IsAtom c → c ≤ a → c ≤ b :=
⟨fun hab _ _ hca ↦ hca.trans hab,
fun h ↦ (isLUB_atoms_le a).mono (isLUB_atoms_le b) fun _ ⟨h₁, h₂⟩ ↦ ⟨h₁, h _ h₁ h₂⟩⟩ | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | le_iff_atom_le_imp | null |
eq_iff_atom_le_iff {a b : α} : a = b ↔ ∀ c, IsAtom c → (c ≤ a ↔ c ≤ b) := by
refine ⟨fun h => by simp [h], fun h => ?_⟩
rw [le_antisymm_iff, le_iff_atom_le_imp, le_iff_atom_le_imp]
simp_all | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | eq_iff_atom_le_iff | null |
_root_.OrderDual.instIsAtomistic [h : IsCoatomistic α] : IsAtomistic αᵒᵈ :=
isAtomistic_dual_iff_isCoatomistic.2 h
variable [IsCoatomistic α] | instance | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | _root_.OrderDual.instIsAtomistic | null |
@[simp]
sSup_atoms_le_eq {α} [CompleteLattice α] [IsAtomistic α] (b : α) :
sSup { a : α | IsAtom a ∧ a ≤ b } = b :=
(isLUB_atoms_le b).sSup_eq
@[simp] | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | sSup_atoms_le_eq | null |
sSup_atoms_eq_top {α} [CompleteLattice α] [IsAtomistic α] :
sSup { a : α | IsAtom a } = ⊤ :=
isLUB_atoms_top.sSup_eq
nonrec lemma CompleteLattice.isAtomistic_iff {α} [CompleteLattice α] :
IsAtomistic α ↔ ∀ b : α, ∃ s : Set α, b = sSup s ∧ ∀ a ∈ s, IsAtom a := by
simp_rw [isAtomistic_iff, isLUB_iff_sSup_eq, ... | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | sSup_atoms_eq_top | null |
eq_sSup_atoms {α} [CompleteLattice α] [IsAtomistic α] (b : α) :
∃ s : Set α, b = sSup s ∧ ∀ a ∈ s, IsAtom a :=
CompleteLattice.isAtomistic_iff.1 ‹_› b
nonrec lemma CompleteLattice.isCoatomistic_iff {α} [CompleteLattice α] :
IsCoatomistic α ↔ ∀ b : α, ∃ s : Set α, b = sInf s ∧ ∀ a ∈ s, IsCoatom a := by
simp_... | lemma | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | eq_sSup_atoms | null |
eq_sInf_coatoms {α} [CompleteLattice α] [IsCoatomistic α] (b : α) :
∃ s : Set α, b = sInf s ∧ ∀ a ∈ s, IsCoatom a :=
CompleteLattice.isCoatomistic_iff.1 ‹_› b | lemma | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | eq_sInf_coatoms | null |
@[mk_iff]
IsSimpleOrder (α : Type*) [LE α] [BoundedOrder α] : Prop extends Nontrivial α where
/-- Every element is either `⊥` or `⊤` -/
eq_bot_or_eq_top : ∀ a : α, a = ⊥ ∨ a = ⊤
export IsSimpleOrder (eq_bot_or_eq_top) | class | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | IsSimpleOrder | An order is simple iff it has exactly two elements, `⊥` and `⊤`. |
IsSimpleOrder.of_forall_eq_top {α : Type*} [LE α] [BoundedOrder α] [Nontrivial α]
(h : ∀ a : α, a ≠ ⊥ → a = ⊤) :
IsSimpleOrder α where
eq_bot_or_eq_top a := or_iff_not_imp_left.mpr <| h a | lemma | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | IsSimpleOrder.of_forall_eq_top | null |
isSimpleOrder_iff_isSimpleOrder_orderDual [LE α] [BoundedOrder α] :
IsSimpleOrder α ↔ IsSimpleOrder αᵒᵈ := by
constructor <;> intro i
· exact
{ eq_bot_or_eq_top := fun a => Or.symm (eq_bot_or_eq_top (OrderDual.ofDual a) : _ ∨ _) }
· exact
{ exists_pair_ne := @exists_pair_ne αᵒᵈ _
eq_bot_or... | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | isSimpleOrder_iff_isSimpleOrder_orderDual | null |
IsSimpleOrder.bot_ne_top [LE α] [BoundedOrder α] [IsSimpleOrder α] : (⊥ : α) ≠ (⊤ : α) := by
obtain ⟨a, b, h⟩ := exists_pair_ne α
rcases eq_bot_or_eq_top a with (rfl | rfl) <;> rcases eq_bot_or_eq_top b with (rfl | rfl) <;>
first | simpa | simpa using h.symm | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | IsSimpleOrder.bot_ne_top | null |
OrderDual.instIsSimpleOrder {α} [LE α] [BoundedOrder α] [IsSimpleOrder α] :
IsSimpleOrder αᵒᵈ := isSimpleOrder_iff_isSimpleOrder_orderDual.1 (by infer_instance) | instance | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | OrderDual.instIsSimpleOrder | null |
protected IsSimpleOrder.preorder {α} [LE α] [BoundedOrder α] [IsSimpleOrder α] :
Preorder α where
le := (· ≤ ·)
le_refl a := by rcases eq_bot_or_eq_top a with (rfl | rfl) <;> simp
le_trans a b c := by
rcases eq_bot_or_eq_top a with (rfl | rfl)
· simp
· rcases eq_bot_or_eq_top b with (rfl | rfl)
... | def | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | IsSimpleOrder.preorder | A simple `BoundedOrder` induces a preorder. This is not an instance to prevent loops. |
protected IsSimpleOrder.linearOrder [DecidableEq α] : LinearOrder α :=
{ (inferInstance : PartialOrder α) with
le_total := fun a b => by rcases eq_bot_or_eq_top a with (rfl | rfl) <;> simp
toDecidableLE := fun a b =>
if ha : a = ⊥ then isTrue (ha.le.trans bot_le)
else
if hb : b = ⊤ then is... | def | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | IsSimpleOrder.linearOrder | A simple partial ordered `BoundedOrder` induces a linear order.
This is not an instance to prevent loops. |
isAtom_top : IsAtom (⊤ : α) :=
⟨top_ne_bot, fun a ha => Or.resolve_right (eq_bot_or_eq_top a) (ne_of_lt ha)⟩
@[simp] | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | isAtom_top | null |
isAtom_iff_eq_top {a : α} : IsAtom a ↔ a = ⊤ :=
⟨fun h ↦ (eq_bot_or_eq_top a).resolve_left h.1, (· ▸ isAtom_top)⟩ | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | isAtom_iff_eq_top | null |
isCoatom_bot : IsCoatom (⊥ : α) :=
isAtom_dual_iff_isCoatom.1 isAtom_top
@[simp] | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | isCoatom_bot | null |
isCoatom_iff_eq_bot {a : α} : IsCoatom a ↔ a = ⊥ :=
⟨fun h ↦ (eq_bot_or_eq_top a).resolve_right h.1, (· ▸ isCoatom_bot)⟩ | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | isCoatom_iff_eq_bot | null |
bot_covBy_top : (⊥ : α) ⋖ ⊤ :=
isAtom_top.bot_covBy | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | bot_covBy_top | null |
eq_bot_of_lt : a = ⊥ :=
(IsSimpleOrder.eq_bot_or_eq_top _).resolve_right h.ne_top | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | eq_bot_of_lt | null |
eq_top_of_lt : b = ⊤ :=
(IsSimpleOrder.eq_bot_or_eq_top _).resolve_left h.ne_bot
alias _root_.LT.lt.eq_bot := eq_bot_of_lt
alias _root_.LT.lt.eq_top := eq_top_of_lt | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | eq_top_of_lt | null |
protected lattice {α} [DecidableEq α] [PartialOrder α] [BoundedOrder α] [IsSimpleOrder α] :
Lattice α :=
@LinearOrder.toLattice α IsSimpleOrder.linearOrder | def | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | lattice | A simple partial ordered `BoundedOrder` induces a lattice.
This is not an instance to prevent loops |
protected distribLattice : DistribLattice α :=
{ (inferInstance : Lattice α) with
le_sup_inf := fun x y z => by rcases eq_bot_or_eq_top x with (rfl | rfl) <;> simp } | def | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | distribLattice | A lattice that is a `BoundedOrder` is a distributive lattice.
This is not an instance to prevent loops |
@[simps]
equivBool {α} [DecidableEq α] [LE α] [BoundedOrder α] [IsSimpleOrder α] : α ≃ Bool where
toFun x := x = ⊤
invFun x := x.casesOn ⊥ ⊤
left_inv x := by rcases eq_bot_or_eq_top x with (rfl | rfl) <;> simp [bot_ne_top]
right_inv x := by cases x <;> simp [bot_ne_top] | def | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | equivBool | Every simple lattice is isomorphic to `Bool`, regardless of order. |
orderIsoBool : α ≃o Bool :=
{ equivBool with
map_rel_iff' := @fun a b => by
rcases eq_bot_or_eq_top a with (rfl | rfl)
· simp
· rcases eq_bot_or_eq_top b with (rfl | rfl)
· simp [bot_ne_top.symm, Bool.false_lt_true]
· simp } | def | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | orderIsoBool | Every simple lattice over a partial order is order-isomorphic to `Bool`. |
protected booleanAlgebra {α} [DecidableEq α] [Lattice α] [BoundedOrder α] [IsSimpleOrder α] :
BooleanAlgebra α :=
{ inferInstanceAs (BoundedOrder α), IsSimpleOrder.distribLattice with
compl := fun x => if x = ⊥ then ⊤ else ⊥
sdiff := fun x y => if x = ⊤ ∧ y = ⊥ then ⊤ else ⊥
sdiff_eq := fun x y => by
... | def | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | booleanAlgebra | A simple `BoundedOrder` is also a `BooleanAlgebra`. |
protected noncomputable completeLattice : CompleteLattice α :=
{ (inferInstance : Lattice α),
(inferInstance : BoundedOrder α) with
sSup := fun s => if ⊤ ∈ s then ⊤ else ⊥
sInf := fun s => if ⊥ ∈ s then ⊥ else ⊤
le_sSup := fun s x h => by
rcases eq_bot_or_eq_top x with (rfl | rfl)
· exact ... | def | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | completeLattice | A simple `BoundedOrder` is also complete. |
protected noncomputable completeBooleanAlgebra : CompleteBooleanAlgebra α :=
{ __ := IsSimpleOrder.completeLattice
__ := IsSimpleOrder.booleanAlgebra } | def | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | completeBooleanAlgebra | A simple `BoundedOrder` is also a `CompleteBooleanAlgebra`. |
@[simp] bot_lt_iff_eq_top {a : α} : ⊥ < a ↔ a = ⊤ :=
⟨eq_top_of_lt, fun h ↦ h ▸ bot_lt_top⟩
@[simp] lemma lt_top_iff_eq_bot {a : α} : a < ⊤ ↔ a = ⊥ :=
⟨eq_bot_of_lt, fun h ↦ h ▸ bot_lt_top⟩ | lemma | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | bot_lt_iff_eq_top | null |
isSimpleOrder_iff_isAtom_top [PartialOrder α] [BoundedOrder α] :
IsSimpleOrder α ↔ IsAtom (⊤ : α) :=
⟨fun h => @isAtom_top _ _ _ h, fun h =>
{ exists_pair_ne := ⟨⊤, ⊥, h.1⟩
eq_bot_or_eq_top := fun a => ((eq_or_lt_of_le le_top).imp_right (h.2 a)).symm }⟩ | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | isSimpleOrder_iff_isAtom_top | null |
isSimpleOrder_iff_isCoatom_bot [PartialOrder α] [BoundedOrder α] :
IsSimpleOrder α ↔ IsCoatom (⊥ : α) :=
isSimpleOrder_iff_isSimpleOrder_orderDual.trans isSimpleOrder_iff_isAtom_top | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | isSimpleOrder_iff_isCoatom_bot | null |
isSimpleOrder_Iic_iff_isAtom [PartialOrder α] [OrderBot α] {a : α} :
IsSimpleOrder (Iic a) ↔ IsAtom a :=
isSimpleOrder_iff_isAtom_top.trans <|
and_congr (not_congr Subtype.mk_eq_mk)
⟨fun h b ab => Subtype.mk_eq_mk.1 (h ⟨b, le_of_lt ab⟩ ab), fun h ⟨b, _⟩ hbotb =>
Subtype.mk_eq_mk.2 (h b (Subtype.... | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | isSimpleOrder_Iic_iff_isAtom | null |
isSimpleOrder_Ici_iff_isCoatom [PartialOrder α] [OrderTop α] {a : α} :
IsSimpleOrder (Ici a) ↔ IsCoatom a :=
isSimpleOrder_iff_isCoatom_bot.trans <|
and_congr (not_congr Subtype.mk_eq_mk)
⟨fun h b ab => Subtype.mk_eq_mk.1 (h ⟨b, le_of_lt ab⟩ ab), fun h ⟨b, _⟩ hbotb =>
Subtype.mk_eq_mk.2 (h b (Su... | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | isSimpleOrder_Ici_iff_isCoatom | null |
isAtom_of_map_bot_of_image [OrderBot α] [OrderBot β] (f : β ↪o α) (hbot : f ⊥ = ⊥) {b : β}
(hb : IsAtom (f b)) : IsAtom b := by
simp only [← bot_covBy_iff] at hb ⊢
exact CovBy.of_image f (hbot.symm ▸ hb) | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | isAtom_of_map_bot_of_image | null |
isCoatom_of_map_top_of_image [OrderTop α] [OrderTop β] (f : β ↪o α) (htop : f ⊤ = ⊤)
{b : β} (hb : IsCoatom (f b)) : IsCoatom b :=
f.dual.isAtom_of_map_bot_of_image htop hb | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | isCoatom_of_map_top_of_image | null |
isAtom_of_u_bot [OrderBot α] [OrderBot β] {l : α → β} {u : β → α}
(gi : GaloisInsertion l u) (hbot : u ⊥ = ⊥) {b : β} (hb : IsAtom (u b)) : IsAtom b :=
OrderEmbedding.isAtom_of_map_bot_of_image
⟨⟨u, gi.u_injective⟩, @GaloisInsertion.u_le_u_iff _ _ _ _ _ _ gi⟩ hbot hb | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | isAtom_of_u_bot | null |
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 := by
refine ⟨fun hla => ?_, fun ha => gi.isAtom_of_u_bot hbot ((h_atom a ha).symm ▸ ha)⟩
obtain ⟨a', ha', hab'⟩ :=
... | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | isAtom_iff | null |
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 := by rw [← gi.isAtom_iff hbot h_atom, gi.l_u_eq] | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | isAtom_iff' | null |
isCoatom_of_image [OrderTop α] [OrderTop β] {l : α → β} {u : β → α}
(gi : GaloisInsertion l u) {b : β} (hb : IsCoatom (u b)) : IsCoatom b :=
OrderEmbedding.isCoatom_of_map_top_of_image
⟨⟨u, gi.u_injective⟩, @GaloisInsertion.u_le_u_iff _ _ _ _ _ _ gi⟩ gi.gc.u_top hb | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | isCoatom_of_image | null |
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 := by
refine ⟨fun hb => gi.isCoatom_of_image hb, fun hb => ?_⟩
obtain ⟨a, ha, hab⟩ :=
(eq_top_or_exists_le_coatom ... | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | isCoatom_iff | null |
isCoatom_of_l_top [OrderTop α] [OrderTop β] {l : α → β} {u : β → α}
(gi : GaloisCoinsertion l u) (hbot : l ⊤ = ⊤) {a : α} (hb : IsCoatom (l a)) : IsCoatom a :=
gi.dual.isAtom_of_u_bot hbot hb.dual | theorem | Order | [
"Mathlib.Data.Set.Lattice",
"Mathlib.Data.SetLike.Basic",
"Mathlib.Order.ModularLattice",
"Mathlib.Order.SuccPred.Basic",
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Nontriviality",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed"
] | Mathlib/Order/Atoms.lean | isCoatom_of_l_top | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.