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_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 :=
gi.dual.isAtom_iff htop h_coatom b | 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_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 :=
gi.dual.isAtom_iff' htop h_coatom a | 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 |
isAtom_of_image [OrderBot α] [OrderBot β] {l : α → β} {u : β → α}
(gi : GaloisCoinsertion l u) {a : α} (hb : IsAtom (l a)) : IsAtom a :=
gi.dual.isCoatom_of_image 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 | isAtom_of_image | null |
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 :=
gi.dual.isCoatom_iff h_atom a | 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 |
@[simp]
isAtom_iff [OrderBot α] [OrderBot β] (f : α ≃o β) (a : α) : IsAtom (f a) ↔ IsAtom a :=
⟨f.toGaloisCoinsertion.isAtom_of_image, fun ha =>
f.toGaloisInsertion.isAtom_of_u_bot (map_bot f.symm) <| (f.symm_apply_apply a).symm ▸ 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_iff | null |
isCoatom_iff [OrderTop α] [OrderTop β] (f : α ≃o β) (a : α) :
IsCoatom (f a) ↔ IsCoatom a :=
f.dual.isAtom_iff a | 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 |
isSimpleOrder_iff [BoundedOrder α] [BoundedOrder β] (f : α ≃o β) :
IsSimpleOrder α ↔ IsSimpleOrder β := by
rw [isSimpleOrder_iff_isAtom_top, isSimpleOrder_iff_isAtom_top, ← f.isAtom_iff ⊤,
f.map_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 | null |
isSimpleOrder [BoundedOrder α] [BoundedOrder β] [h : IsSimpleOrder β] (f : α ≃o β) :
IsSimpleOrder α :=
f.isSimpleOrder_iff.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 | isSimpleOrder | null |
protected isAtomic_iff [OrderBot α] [OrderBot β] (f : α ≃o β) :
IsAtomic α ↔ IsAtomic β := by
simp only [isAtomic_iff, f.surjective.forall, f.surjective.exists, ← map_bot f, f.eq_iff_eq,
f.le_iff_le, f.isAtom_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 | isAtomic_iff | null |
protected isCoatomic_iff [OrderTop α] [OrderTop β] (f : α ≃o β) :
IsCoatomic α ↔ IsCoatomic β := by
simp only [← isAtomic_dual_iff_isCoatomic, f.dual.isAtomic_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 | isCoatomic_iff | null |
Lattice.isStronglyAtomic [OrderBot α] [IsUpperModularLattice α] [IsAtomistic α] :
IsStronglyAtomic α where
exists_covBy_le_of_lt a b hab := by
obtain ⟨s, hsb, h⟩ := isLUB_atoms b
refine by_contra fun hcon ↦ hab.not_ge <| (isLUB_le_iff hsb).2 fun x hx ↦ ?_
simp_rw [not_exists, and_comm (b := _ ≤ _), no... | 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 | Lattice.isStronglyAtomic | An upper-modular lattice that is atomistic is strongly atomic.
Not an instance to prevent loops. |
Lattice.isStronglyCoatomic [OrderTop α] [IsLowerModularLattice α]
[IsCoatomistic α] : IsStronglyCoatomic α := by
rw [← isStronglyAtomic_dual_iff_is_stronglyCoatomic]
exact Lattice.isStronglyAtomic
@[deprecated (since := "2025-03-13")] alias CompleteLattice.isStronglyCoatomic :=
Lattice.isStronglyCoatomic | 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 | Lattice.isStronglyCoatomic | A lower-modular lattice that is coatomistic is strongly coatomic.
Not an instance to prevent loops. |
isAtom_iff_isCoatom : IsAtom a ↔ IsCoatom b :=
Set.isSimpleOrder_Iic_iff_isAtom.symm.trans <|
hc.IicOrderIsoIci.isSimpleOrder_iff.trans Set.isSimpleOrder_Ici_iff_isCoatom | 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_isCoatom | null |
isCoatom_iff_isAtom : IsCoatom a ↔ IsAtom b :=
hc.symm.isAtom_iff_isCoatom.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 | isCoatom_iff_isAtom | null |
isCoatomic_of_isAtomic_of_complementedLattice_of_isModular [IsAtomic α] :
IsCoatomic α :=
⟨fun x => by
rcases exists_isCompl x with ⟨y, xy⟩
apply (eq_bot_or_exists_atom_le y).imp _ _
· rintro rfl
exact eq_top_of_isCompl_bot xy
· rintro ⟨a, ha, ay⟩
rcases exists_isCompl (xy.symm.IicOrde... | 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_isAtomic_of_complementedLattice_of_isModular | null |
isAtomic_of_isCoatomic_of_complementedLattice_of_isModular [IsCoatomic α] :
IsAtomic α :=
isCoatomic_dual_iff_isAtomic.1 isCoatomic_of_isAtomic_of_complementedLattice_of_isModular | 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_isCoatomic_of_complementedLattice_of_isModular | null |
isAtomic_iff_isCoatomic : IsAtomic α ↔ IsCoatomic α :=
⟨fun _ => isCoatomic_of_isAtomic_of_complementedLattice_of_isModular,
fun _ => isAtomic_of_isCoatomic_of_complementedLattice_of_isModular⟩ | 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_isCoatomic | null |
ComplementedLattice.isStronglyAtomic [IsAtomic α] : IsStronglyAtomic α where
exists_covBy_le_of_lt a b hab := by
obtain ⟨⟨a', ha'b : a' ≤ b⟩, ha'⟩ := exists_isCompl (α := Set.Iic b) ⟨a, hab.le⟩
obtain (rfl | ⟨d, hd⟩) := eq_bot_or_exists_atom_le a'
· obtain rfl : a = b := by simpa [codisjoint_bot, ← Subtyp... | 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 | ComplementedLattice.isStronglyAtomic | A complemented modular atomic lattice is strongly atomic.
Not an instance to prevent loops. |
ComplementedLattice.isStronglyCoatomic [IsCoatomic α] : IsStronglyCoatomic α :=
isStronglyAtomic_dual_iff_is_stronglyCoatomic.1 <| ComplementedLattice.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 | ComplementedLattice.isStronglyCoatomic | A complemented modular coatomic lattice is strongly coatomic.
Not an instance to prevent loops. |
ComplementedLattice.isStronglyAtomic' [h : IsAtomic α] : IsStronglyCoatomic α := by
rw [isAtomic_iff_isCoatomic] at h
exact isStronglyCoatomic | 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 | ComplementedLattice.isStronglyAtomic' | A complemented modular atomic lattice is strongly coatomic.
Not an instance to prevent loops. |
ComplementedLattice.isStronglyCoatomic' [h : IsCoatomic α] : IsStronglyAtomic α := by
rw [← isAtomic_iff_isCoatomic] at h
exact 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 | ComplementedLattice.isStronglyCoatomic' | A complemented modular coatomic lattice is strongly atomic.
Not an instance to prevent loops. |
isAtom_iff {p : Prop} : IsAtom p ↔ p := 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 | isAtom_iff | null |
isCoatom_iff {p : Prop} : IsCoatom p ↔ ¬ p := 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 | isCoatom_iff | null |
protected eq_bot_iff [∀ i, Bot (π i)] {f : ∀ i, π i} : f = ⊥ ↔ ∀ i, f i = ⊥ :=
funext_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 | eq_bot_iff | null |
isAtom_iff {f : ∀ i, π i} [∀ i, PartialOrder (π i)] [∀ i, OrderBot (π i)] :
IsAtom f ↔ ∃ i, IsAtom (f i) ∧ ∀ j, j ≠ i → f j = ⊥ := by
simp only [← bot_covBy_iff, Pi.covBy_iff, bot_apply, eq_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 |
isAtom_single {i : ι} [DecidableEq ι] [∀ i, PartialOrder (π i)] [∀ i, OrderBot (π i)]
{a : π i} (h : IsAtom a) : IsAtom (Function.update (⊥ : ∀ i, π i) i a) :=
isAtom_iff.2 ⟨i, by simpa, fun _ hji => Function.update_of_ne hji ..⟩ | 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_single | null |
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 := by
simp [← bot_covBy_iff, covBy_iff_exists_right_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_eq_single | null |
isAtomic [∀ i, PartialOrder (π i)] [∀ i, OrderBot (π i)] [∀ i, IsAtomic (π i)] :
IsAtomic (∀ i, π i) where
eq_bot_or_exists_atom_le b := or_iff_not_imp_left.2 fun h =>
have ⟨i, hi⟩ : ∃ i, b i ≠ ⊥ := not_forall.1 (h.imp Pi.eq_bot_iff.2)
have ⟨a, ha, hab⟩ := (eq_bot_or_exists_atom_le (b i)).resolve_left hi
... | 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 | isAtomic | null |
isCoatomic [∀ i, PartialOrder (π i)] [∀ i, OrderTop (π i)] [∀ i, IsCoatomic (π i)] :
IsCoatomic (∀ i, π i) :=
isAtomic_dual_iff_isCoatomic.1 <|
show IsAtomic (∀ i, (π i)ᵒᵈ) from inferInstance | 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 | isCoatomic | null |
isAtomistic [∀ i, PartialOrder (π i)] [∀ i, OrderBot (π i)] [∀ i, IsAtomistic (π i)] :
IsAtomistic (∀ i, π i) where
isLUB_atoms s := by
classical
refine ⟨{f | IsAtom f ∧ f ≤ s}, ?_, by simp +contextual⟩
rw [isLUB_pi]
intro i
simp_rw [isAtom_iff_eq_single]
refine ⟨?_, ?_⟩
· rintro _ ⟨_,... | 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 | isAtomistic | null |
isCoatomistic [∀ i, CompleteLattice (π i)] [∀ i, IsCoatomistic (π i)] :
IsCoatomistic (∀ i, π i) :=
isAtomistic_dual_iff_isCoatomistic.1 <|
show IsAtomistic (∀ i, (π i)ᵒᵈ) from inferInstance | 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 | isCoatomistic | null |
@[simp] isAtom_compl : IsAtom aᶜ ↔ IsCoatom a := isCompl_compl.symm.isAtom_iff_isCoatom
@[simp] lemma isCoatom_compl : IsCoatom aᶜ ↔ IsAtom a := isCompl_compl.symm.isCoatom_iff_isAtom
protected alias ⟨IsAtom.of_compl, IsCoatom.compl⟩ := isAtom_compl
protected alias ⟨IsCoatom.of_compl, IsAtom.compl⟩ := isCoatom_compl | 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_compl | null |
isAtom_singleton (x : α) : IsAtom ({x} : Set α) :=
⟨singleton_ne_empty _, fun _ hs => ssubset_singleton_iff.mp hs⟩ | 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_singleton | null |
isAtom_iff {s : Set α} : IsAtom s ↔ ∃ x, s = {x} := by
refine
⟨?_, by
rintro ⟨x, rfl⟩
exact isAtom_singleton x⟩
rw [isAtom_iff_le_of_ge, bot_eq_empty, ← nonempty_iff_ne_empty]
rintro ⟨⟨x, hx⟩, hs⟩
exact
⟨x, eq_singleton_iff_unique_mem.2
⟨hx, fun y hy => (hs {y} (singleton_ne_empty _)... | 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 (s : Set α) : IsCoatom s ↔ ∃ x, s = {x}ᶜ := by
rw [isCompl_compl.isCoatom_iff_isAtom, isAtom_iff]
simp_rw [@eq_comm _ s, compl_eq_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 |
isCoatom_singleton_compl (x : α) : IsCoatom ({x}ᶜ : Set α) :=
(isCoatom_iff {x}ᶜ).mpr ⟨x, 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 | isCoatom_singleton_compl | null |
protected LE.le.ge (h : a ≤ b) : b ≥ a := h | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | LE.le.ge | null |
protected GE.ge.le (h : a ≥ b) : b ≤ a := h | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | GE.ge.le | null |
le_of_le_of_eq' : b ≤ c → a = b → a ≤ c := flip le_of_eq_of_le | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | le_of_le_of_eq' | null |
le_of_eq_of_le' : b = c → a ≤ b → a ≤ c := flip le_of_le_of_eq
alias LE.le.trans_eq := le_of_le_of_eq
alias LE.le.trans_eq' := le_of_le_of_eq'
alias Eq.trans_le := le_of_eq_of_le
alias Eq.trans_ge := le_of_eq_of_le' | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | le_of_eq_of_le' | null |
protected LT.lt.gt (h : a < b) : b > a := h | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | LT.lt.gt | null |
protected GT.gt.lt (h : a > b) : b < a := h | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | GT.gt.lt | null |
lt_of_lt_of_eq' : b < c → a = b → a < c := flip lt_of_eq_of_lt | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | lt_of_lt_of_eq' | null |
lt_of_eq_of_lt' : b = c → a < b → a < c := flip lt_of_lt_of_eq
alias LT.lt.trans_eq := lt_of_lt_of_eq
alias LT.lt.trans_eq' := lt_of_lt_of_eq'
alias Eq.trans_lt := lt_of_eq_of_lt
alias Eq.trans_gt := lt_of_eq_of_lt' | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | lt_of_eq_of_lt' | null |
@[simp]
Order.Preimage (f : α → β) (s : β → β → Prop) (x y : α) : Prop := s (f x) (f y)
@[inherit_doc] infixl:80 " ⁻¹'o " => Order.Preimage | def | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | Order.Preimage | Given a relation `R` on `β` and a function `f : α → β`, the preimage relation on `α` is defined
by `x ≤ y ↔ f x ≤ f y`. It is the unique relation on `α` making `f` a `RelEmbedding` (assuming `f`
is injective). |
Order.Preimage.decidable (f : α → β) (s : β → β → Prop) [H : DecidableRel s] :
DecidableRel (f ⁻¹'o s) := fun _ _ ↦ H _ _
/-! ### Preorders -/ | instance | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | Order.Preimage.decidable | The preimage of a decidable order is decidable. |
not_lt_iff_not_le_or_ge : ¬a < b ↔ ¬a ≤ b ∨ b ≤ a := by
rw [lt_iff_le_not_ge, Classical.not_and_iff_not_or_not, Classical.not_not] | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | not_lt_iff_not_le_or_ge | null |
not_lt_iff_le_imp_ge : ¬ a < b ↔ (a ≤ b → b ≤ a) := by
simp [not_lt_iff_not_le_or_ge, or_iff_not_imp_left]
@[deprecated (since := "2025-05-11")] alias not_lt_iff_le_imp_le := not_lt_iff_le_imp_ge | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | not_lt_iff_le_imp_ge | null |
ge_of_eq (h : a = b) : b ≤ a := le_of_eq h.symm
@[simp] lemma lt_self_iff_false (x : α) : x < x ↔ False := ⟨lt_irrefl x, False.elim⟩
alias le_trans' := ge_trans
alias lt_trans' := gt_trans
alias LE.le.trans := le_trans
alias LE.le.trans' := le_trans'
alias LT.lt.trans := lt_trans
alias LT.lt.trans' := lt_trans'
alias L... | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | ge_of_eq | null |
ne_of_not_le (h : ¬a ≤ b) : a ≠ b := fun hab ↦ h (le_of_eq hab) | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | ne_of_not_le | null |
protected Eq.not_lt (hab : a = b) : ¬a < b := fun h' ↦ h'.ne hab | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | Eq.not_lt | null |
protected Eq.not_gt (hab : a = b) : ¬b < a := hab.symm.not_lt
@[simp] lemma le_of_subsingleton [Subsingleton α] : a ≤ b := (Subsingleton.elim a b).le
@[nontriviality] | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | Eq.not_gt | null |
not_lt_of_subsingleton [Subsingleton α] : ¬a < b := (Subsingleton.elim a b).not_lt | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | not_lt_of_subsingleton | null |
protected false : a < a → False := lt_irrefl a | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | false | null |
ne' (h : a < b) : b ≠ a := h.ne.symm | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | ne' | null |
le_of_forall_le (H : ∀ c, c ≤ a → c ≤ b) : a ≤ b := H _ le_rfl | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | le_of_forall_le | null |
le_of_forall_ge (H : ∀ c, a ≤ c → b ≤ c) : b ≤ a := H _ le_rfl | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | le_of_forall_ge | null |
forall_le_iff_le : (∀ ⦃c⦄, c ≤ a → c ≤ b) ↔ a ≤ b :=
⟨le_of_forall_le, fun h _ hca ↦ le_trans hca h⟩ | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | forall_le_iff_le | null |
forall_ge_iff_le : (∀ ⦃c⦄, a ≤ c → b ≤ c) ↔ b ≤ a :=
⟨le_of_forall_ge, fun h _ hca ↦ le_trans h hca⟩
@[deprecated (since := "2025-07-27")] alias forall_le_iff_ge := forall_ge_iff_le | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | forall_ge_iff_le | null |
@[gcongr] le_imp_le_of_le_of_le (h₁ : c ≤ a) (h₂ : b ≤ d) : a ≤ b → c ≤ d :=
fun hab ↦ (h₁.trans hab).trans h₂
@[deprecated (since := "2025-07-31")] alias le_implies_le_of_le_of_le := le_imp_le_of_le_of_le | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | le_imp_le_of_le_of_le | monotonicity of `≤` with respect to `→` |
@[gcongr] lt_imp_lt_of_le_of_le (h₁ : c ≤ a) (h₂ : b ≤ d) : a < b → c < d :=
fun hab ↦ (h₁.trans_lt hab).trans_le h₂ | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | lt_imp_lt_of_le_of_le | monotonicity of `<` with respect to `→` |
@[gcongr] gt_imp_gt (h₁ : a ≤ c) (h₂ : d ≤ b) : a > b → c > d := lt_imp_lt_of_le_of_le h₂ h₁ | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | gt_imp_gt | null |
@[gcongr_forward] exactLeOfLt : ForwardExt where
eval h goal := do goal.assignIfDefEq (← Lean.Meta.mkAppM ``le_of_lt #[h]) | def | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | exactLeOfLt | See if the term is `a < b` and the goal is `a ≤ b`. |
ge_antisymm : a ≤ b → b ≤ a → b = a :=
flip le_antisymm | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | ge_antisymm | null |
lt_of_le_of_ne' : a ≤ b → b ≠ a → a < b := fun h₁ h₂ ↦ lt_of_le_of_ne h₁ h₂.symm | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | lt_of_le_of_ne' | null |
Ne.lt_of_le : a ≠ b → a ≤ b → a < b :=
flip lt_of_le_of_ne | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | Ne.lt_of_le | null |
Ne.lt_of_le' : b ≠ a → a ≤ b → a < b :=
flip lt_of_le_of_ne'
alias LE.le.antisymm := le_antisymm
alias LE.le.antisymm' := ge_antisymm
alias LE.le.lt_of_ne := lt_of_le_of_ne
alias LE.le.lt_of_ne' := lt_of_le_of_ne' | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | Ne.lt_of_le' | null |
le_imp_eq_iff_le_imp_ge' : (a ≤ b → b = a) ↔ (a ≤ b → b ≤ a) where
mp h hab := (h hab).le
mpr h hab := (h hab).antisymm hab
@[deprecated (since := "2025-05-11")] alias le_imp_eq_iff_le_imp_le := le_imp_eq_iff_le_imp_ge' | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | le_imp_eq_iff_le_imp_ge' | null |
le_imp_eq_iff_le_imp_ge : (a ≤ b → a = b) ↔ (a ≤ b → b ≤ a) where
mp h hab := (h hab).ge
mpr h hab := hab.antisymm (h hab)
@[deprecated (since := "2025-05-11")] alias ge_imp_eq_iff_le_imp_le := le_imp_eq_iff_le_imp_ge | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | le_imp_eq_iff_le_imp_ge | null |
lt_iff_ne (h : a ≤ b) : a < b ↔ a ≠ b :=
⟨fun h ↦ h.ne, h.lt_of_ne⟩ | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | lt_iff_ne | null |
lt_iff_ne' (h : a ≤ b) : a < b ↔ b ≠ a :=
⟨fun h ↦ h.ne.symm, h.lt_of_ne'⟩ | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | lt_iff_ne' | null |
not_lt_iff_eq (h : a ≤ b) : ¬a < b ↔ a = b :=
h.lt_iff_ne.not_left | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | not_lt_iff_eq | null |
not_lt_iff_eq' (h : a ≤ b) : ¬a < b ↔ b = a :=
h.lt_iff_ne'.not_left | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | not_lt_iff_eq' | null |
ge_iff_eq (h : a ≤ b) : b ≤ a ↔ a = b :=
⟨h.antisymm, Eq.ge⟩ | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | ge_iff_eq | null |
ge_iff_eq' (h : a ≤ b) : b ≤ a ↔ b = a :=
⟨fun h' ↦ h'.antisymm h, Eq.le⟩
@[deprecated (since := "2025-06-08")] alias gt_iff_ne := lt_iff_ne'
@[deprecated (since := "2025-06-08")] alias le_iff_eq := ge_iff_eq'
@[deprecated (since := "2025-06-08")] alias not_gt_iff_eq := not_lt_iff_eq' | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | ge_iff_eq' | null |
protected Decidable.le_iff_eq_or_lt [DecidableLE α] : a ≤ b ↔ a = b ∨ a < b :=
Decidable.le_iff_lt_or_eq.trans or_comm | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | Decidable.le_iff_eq_or_lt | null |
le_iff_eq_or_lt : a ≤ b ↔ a = b ∨ a < b := le_iff_lt_or_eq.trans or_comm | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | le_iff_eq_or_lt | null |
lt_iff_le_and_ne : a < b ↔ a ≤ b ∧ a ≠ b :=
⟨fun h ↦ ⟨le_of_lt h, ne_of_lt h⟩, fun ⟨h1, h2⟩ ↦ h1.lt_of_ne h2⟩
@[deprecated LE.le.not_lt_iff_eq (since := "2025-06-08")] | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | lt_iff_le_and_ne | null |
eq_iff_not_lt_of_le (hab : a ≤ b) : a = b ↔ ¬ a < b := hab.not_lt_iff_eq.symm
@[deprecated (since := "2025-06-08")] alias LE.le.eq_iff_not_lt := eq_iff_not_lt_of_le | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | eq_iff_not_lt_of_le | null |
protected Decidable.eq_iff_le_not_lt [DecidableLE α] : a = b ↔ a ≤ b ∧ ¬a < b :=
⟨fun h ↦ ⟨h.le, h ▸ lt_irrefl _⟩, fun ⟨h₁, h₂⟩ ↦
h₁.antisymm <| Decidable.byContradiction fun h₃ ↦ h₂ (h₁.lt_of_not_ge h₃)⟩ | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | Decidable.eq_iff_le_not_lt | null |
eq_iff_le_not_lt : a = b ↔ a ≤ b ∧ ¬a < b := open scoped Classical in
Decidable.eq_iff_le_not_lt | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | eq_iff_le_not_lt | null |
protected Decidable.eq_or_lt_of_le [DecidableLE α] (h : a ≤ b) : a = b ∨ a < b :=
(Decidable.lt_or_eq_of_le h).symm | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | Decidable.eq_or_lt_of_le | null |
eq_or_lt_of_le (h : a ≤ b) : a = b ∨ a < b := (lt_or_eq_of_le h).symm | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | eq_or_lt_of_le | null |
eq_or_lt_of_le' (h : a ≤ b) : b = a ∨ a < b := (eq_or_lt_of_le h).imp Eq.symm id | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | eq_or_lt_of_le' | null |
lt_or_eq_of_le' (h : a ≤ b) : a < b ∨ b = a := (eq_or_lt_of_le' h).symm
alias LE.le.lt_or_eq_dec := Decidable.lt_or_eq_of_le
alias LE.le.eq_or_lt_dec := Decidable.eq_or_lt_of_le
alias LE.le.lt_or_eq := lt_or_eq_of_le
alias LE.le.eq_or_lt := eq_or_lt_of_le
alias LE.le.eq_or_lt' := eq_or_lt_of_le'
alias LE.le.lt_or_eq' :... | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | lt_or_eq_of_le' | null |
eq_of_le_of_not_lt (h₁ : a ≤ b) (h₂ : ¬a < b) : a = b := h₁.eq_or_lt.resolve_right h₂ | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | eq_of_le_of_not_lt | null |
eq_of_le_of_not_lt' (h₁ : a ≤ b) (h₂ : ¬a < b) : b = a := (eq_of_le_of_not_lt h₁ h₂).symm
alias LE.le.eq_of_not_lt := eq_of_le_of_not_lt
alias LE.le.eq_of_not_lt' := eq_of_le_of_not_lt'
@[deprecated (since := "2025-06-08")] alias eq_of_ge_of_not_gt := eq_of_le_of_not_lt'
@[deprecated (since := "2025-06-08")] alias LE.l... | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | eq_of_le_of_not_lt' | null |
Ne.le_iff_lt (h : a ≠ b) : a ≤ b ↔ a < b := ⟨fun h' ↦ lt_of_le_of_ne h' h, fun h ↦ h.le⟩ | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | Ne.le_iff_lt | null |
Ne.not_le_or_not_ge (h : a ≠ b) : ¬a ≤ b ∨ ¬b ≤ a := not_and_or.1 <| le_antisymm_iff.not.1 h
@[deprecated (since := "2025-06-07")] alias Ne.not_le_or_not_le := Ne.not_le_or_not_ge | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | Ne.not_le_or_not_ge | null |
protected Decidable.ne_iff_lt_iff_le [DecidableEq α] : (a ≠ b ↔ a < b) ↔ a ≤ b :=
⟨fun h ↦ Decidable.byCases le_of_eq (le_of_lt ∘ h.mp), fun h ↦ ⟨lt_of_le_of_ne h, ne_of_lt⟩⟩
@[simp] | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | Decidable.ne_iff_lt_iff_le | null |
ne_iff_lt_iff_le : (a ≠ b ↔ a < b) ↔ a ≤ b :=
haveI := Classical.dec
Decidable.ne_iff_lt_iff_le | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | ne_iff_lt_iff_le | null |
eq_of_forall_le_iff (H : ∀ c, c ≤ a ↔ c ≤ b) : a = b :=
((H _).1 le_rfl).antisymm ((H _).2 le_rfl) | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | eq_of_forall_le_iff | null |
eq_of_forall_ge_iff (H : ∀ c, a ≤ c ↔ b ≤ c) : a = b :=
((H _).2 le_rfl).antisymm ((H _).1 le_rfl) | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | eq_of_forall_ge_iff | null |
commutative_of_le {f : β → β → α} (comm : ∀ a b, f a b ≤ f b a) : ∀ a b, f a b = f b a :=
fun _ _ ↦ (comm _ _).antisymm <| comm _ _ | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | commutative_of_le | To prove commutativity of a binary operation `○`, we only to check `a ○ b ≤ b ○ a` for all `a`,
`b`. |
associative_of_commutative_of_le {f : α → α → α} (comm : Std.Commutative f)
(assoc : ∀ a b c, f (f a b) c ≤ f a (f b c)) : Std.Associative f where
assoc a b c :=
le_antisymm (assoc _ _ _) <| by
rw [comm.comm, comm.comm b, comm.comm _ c, comm.comm a]
exact assoc .. | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | associative_of_commutative_of_le | To prove associativity of a commutative binary operation `○`, we only to check
`(a ○ b) ○ c ≤ a ○ (b ○ c)` for all `a`, `b`, `c`. |
gt_or_le (h : a ≤ b) (c : α) : a < c ∨ c ≤ b := (lt_or_ge a c).imp id h.trans' | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | gt_or_le | null |
ge_or_lt (h : a ≤ b) (c : α) : a ≤ c ∨ c < b := (le_or_gt a c).imp id h.trans_lt' | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | ge_or_lt | null |
ge_or_le (h : a ≤ b) (c : α) : a ≤ c ∨ c ≤ b := (h.gt_or_le c).imp le_of_lt id
@[deprecated (since := "2025-05-11")] alias lt_or_le := gt_or_le
@[deprecated (since := "2025-05-11")] alias le_or_lt := ge_or_lt
@[deprecated (since := "2025-05-11")] alias le_or_le := ge_or_le | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | ge_or_le | null |
gt_or_lt (h : a < b) (c : α) : a < c ∨ c < b := (le_or_gt b c).imp h.trans_le id
@[deprecated (since := "2025-06-07")] alias lt_or_lt := gt_or_lt | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | gt_or_lt | null |
min_def' (a b : α) : min a b = if b ≤ a then b else a := by
rw [min_def]
rcases lt_trichotomy a b with (lt | eq | gt)
· rw [if_pos lt.le, if_neg (not_le.mpr lt)]
· rw [if_pos eq.le, if_pos eq.ge, eq]
· rw [if_neg (not_le.mpr gt.gt), if_pos gt.le] | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | min_def' | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.