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 ⌀ |
|---|---|---|---|---|---|---|
preimage (hs : IsStrongAntichain r s) {f : β → α} (hf : Injective f)
(h : ∀ a b, r' a b → r (f a) (f b)) : IsStrongAntichain r' (f ⁻¹' s) := fun _ ha _ hb hab _ =>
(hs ha hb (hf.ne hab) _).imp (mt <| h _ _) (mt <| h _ _) | theorem | Order | [
"Mathlib.Order.Bounds.Basic",
"Mathlib.Order.Preorder.Chain"
] | Mathlib/Order/Antichain.lean | preimage | null |
_root_.isStrongAntichain_insert :
IsStrongAntichain r (insert a s) ↔
IsStrongAntichain r s ∧ ∀ ⦃b⦄, b ∈ s → a ≠ b → ∀ c, ¬r a c ∨ ¬r b c :=
Set.pairwise_insert_of_symmetric fun _ _ h c => (h c).symm | theorem | Order | [
"Mathlib.Order.Bounds.Basic",
"Mathlib.Order.Preorder.Chain"
] | Mathlib/Order/Antichain.lean | _root_.isStrongAntichain_insert | null |
protected insert (hs : IsStrongAntichain r s)
(h : ∀ ⦃b⦄, b ∈ s → a ≠ b → ∀ c, ¬r a c ∨ ¬r b c) : IsStrongAntichain r (insert a s) :=
isStrongAntichain_insert.2 ⟨hs, h⟩ | theorem | Order | [
"Mathlib.Order.Bounds.Basic",
"Mathlib.Order.Preorder.Chain"
] | Mathlib/Order/Antichain.lean | insert | null |
Set.Subsingleton.isStrongAntichain (hs : s.Subsingleton) (r : α → α → Prop) :
IsStrongAntichain r s :=
hs.pairwise _ | theorem | Order | [
"Mathlib.Order.Bounds.Basic",
"Mathlib.Order.Preorder.Chain"
] | Mathlib/Order/Antichain.lean | Set.Subsingleton.isStrongAntichain | null |
IsWeakAntichain (s : Set (∀ i, α i)) : Prop :=
IsAntichain (· ≺ ·) s | def | Order | [
"Mathlib.Order.Bounds.Basic",
"Mathlib.Order.Preorder.Chain"
] | Mathlib/Order/Antichain.lean | IsWeakAntichain | A weak antichain in `Π i, α i` is a set such that no two distinct elements are strongly less
than each other. |
protected subset (hs : IsWeakAntichain s) : t ⊆ s → IsWeakAntichain t :=
IsAntichain.subset hs | theorem | Order | [
"Mathlib.Order.Bounds.Basic",
"Mathlib.Order.Preorder.Chain"
] | Mathlib/Order/Antichain.lean | subset | null |
protected eq (hs : IsWeakAntichain s) : a ∈ s → b ∈ s → a ≺ b → a = b :=
IsAntichain.eq hs | theorem | Order | [
"Mathlib.Order.Bounds.Basic",
"Mathlib.Order.Preorder.Chain"
] | Mathlib/Order/Antichain.lean | eq | null |
protected insert (hs : IsWeakAntichain s) :
(∀ ⦃b⦄, b ∈ s → a ≠ b → ¬b ≺ a) →
(∀ ⦃b⦄, b ∈ s → a ≠ b → ¬a ≺ b) → IsWeakAntichain (insert a s) :=
IsAntichain.insert hs | theorem | Order | [
"Mathlib.Order.Bounds.Basic",
"Mathlib.Order.Preorder.Chain"
] | Mathlib/Order/Antichain.lean | insert | null |
_root_.isWeakAntichain_insert :
IsWeakAntichain (insert a s) ↔ IsWeakAntichain s ∧ ∀ ⦃b⦄, b ∈ s → a ≠ b → ¬a ≺ b ∧ ¬b ≺ a :=
isAntichain_insert | theorem | Order | [
"Mathlib.Order.Bounds.Basic",
"Mathlib.Order.Preorder.Chain"
] | Mathlib/Order/Antichain.lean | _root_.isWeakAntichain_insert | null |
protected IsAntichain.isWeakAntichain (hs : IsAntichain (· ≤ ·) s) : IsWeakAntichain s :=
hs.mono fun _ _ => le_of_strongLT | theorem | Order | [
"Mathlib.Order.Bounds.Basic",
"Mathlib.Order.Preorder.Chain"
] | Mathlib/Order/Antichain.lean | IsAntichain.isWeakAntichain | null |
Set.Subsingleton.isWeakAntichain (hs : s.Subsingleton) : IsWeakAntichain s :=
hs.isAntichain _ | theorem | Order | [
"Mathlib.Order.Bounds.Basic",
"Mathlib.Order.Preorder.Chain"
] | Mathlib/Order/Antichain.lean | Set.Subsingleton.isWeakAntichain | null |
AntisymmRel (a b : α) : Prop :=
r a b ∧ r b a | def | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | AntisymmRel | The antisymmetrization relation `AntisymmRel r` is defined so that
`AntisymmRel r a b ↔ r a b ∧ r b a`. |
antisymmRel_swap : AntisymmRel (swap r) = AntisymmRel r :=
funext₂ fun _ _ ↦ propext and_comm | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | antisymmRel_swap | null |
antisymmRel_swap_apply : AntisymmRel (swap r) a b ↔ AntisymmRel r a b :=
and_comm
@[simp, refl] | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | antisymmRel_swap_apply | null |
AntisymmRel.refl [IsRefl α r] (a : α) : AntisymmRel r a a :=
⟨_root_.refl _, _root_.refl _⟩
variable {r} in | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | AntisymmRel.refl | null |
AntisymmRel.rfl [IsRefl α r] {a : α} : AntisymmRel r a a := .refl .. | lemma | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | AntisymmRel.rfl | null |
AntisymmRel.of_eq [IsRefl α r] {a b : α} (h : a = b) : AntisymmRel r a b := h ▸ .rfl
alias Eq.antisymmRel := AntisymmRel.of_eq
@[symm] | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | AntisymmRel.of_eq | null |
AntisymmRel.symm : AntisymmRel r a b → AntisymmRel r b a :=
And.symm | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | AntisymmRel.symm | null |
antisymmRel_comm : AntisymmRel r a b ↔ AntisymmRel r b a :=
And.comm
@[trans] | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | antisymmRel_comm | null |
AntisymmRel.trans [IsTrans α r] (hab : AntisymmRel r a b) (hbc : AntisymmRel r b c) :
AntisymmRel r a c :=
⟨_root_.trans hab.1 hbc.1, _root_.trans hbc.2 hab.2⟩ | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | AntisymmRel.trans | null |
AntisymmRel.decidableRel [DecidableRel r] : DecidableRel (AntisymmRel r) :=
fun _ _ ↦ instDecidableAnd
@[simp] | instance | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | AntisymmRel.decidableRel | null |
antisymmRel_iff_eq [IsRefl α r] [IsAntisymm α r] : AntisymmRel r a b ↔ a = b :=
antisymm_iff
alias ⟨AntisymmRel.eq, _⟩ := antisymmRel_iff_eq | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | antisymmRel_iff_eq | null |
AntisymmRel.left (h : AntisymmRel r a b) : r a b := h.1 | lemma | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | AntisymmRel.left | null |
AntisymmRel.right (h : AntisymmRel r a b) : r b a := h.2 | lemma | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | AntisymmRel.right | null |
@[gcongr_forward] exactAntisymmRelLeft : ForwardExt where
eval h goal := do goal.assignIfDefEq (← Lean.Meta.mkAppM ``AntisymmRel.left #[h]) | def | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | exactAntisymmRelLeft | See if the term is `AntisymmRel r a b` and the goal is `r a b`. |
@[gcongr_forward] exactAntisymmRelRight : ForwardExt where
eval h goal := do goal.assignIfDefEq (← Lean.Meta.mkAppM ``AntisymmRel.right #[h]) | def | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | exactAntisymmRelRight | See if the term is `AntisymmRel r a b` and the goal is `r b a`. |
AntisymmRel.le (h : AntisymmRel (· ≤ ·) a b) : a ≤ b := h.1 | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | AntisymmRel.le | null |
AntisymmRel.ge (h : AntisymmRel (· ≤ ·) a b) : b ≤ a := h.2 | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | AntisymmRel.ge | null |
@[simps]
AntisymmRel.setoid : Setoid α :=
⟨AntisymmRel r, .refl r, .symm, .trans⟩ | def | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | AntisymmRel.setoid | The antisymmetrization relation as an equivalence relation. |
Antisymmetrization : Type _ :=
Quotient <| AntisymmRel.setoid α r
variable {α} | def | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | Antisymmetrization | The partial order derived from a preorder by making pairwise comparable elements equal. This is
the quotient by `fun a b => a ≤ b ∧ b ≤ a`. |
toAntisymmetrization : α → Antisymmetrization α r :=
Quotient.mk _ | def | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | toAntisymmetrization | Turn an element into its antisymmetrization. |
noncomputable ofAntisymmetrization : Antisymmetrization α r → α :=
Quotient.out | def | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | ofAntisymmetrization | Get a representative from the antisymmetrization. |
@[elab_as_elim]
protected Antisymmetrization.ind {p : Antisymmetrization α r → Prop} :
(∀ a, p <| toAntisymmetrization r a) → ∀ q, p q :=
Quot.ind
@[elab_as_elim] | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | Antisymmetrization.ind | null |
protected Antisymmetrization.induction_on {p : Antisymmetrization α r → Prop}
(a : Antisymmetrization α r) (h : ∀ a, p <| toAntisymmetrization r a) : p a :=
Quotient.inductionOn' a h
@[simp] | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | Antisymmetrization.induction_on | null |
toAntisymmetrization_ofAntisymmetrization (a : Antisymmetrization α r) :
toAntisymmetrization r (ofAntisymmetrization r a) = a :=
Quotient.out_eq' _ | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | toAntisymmetrization_ofAntisymmetrization | null |
le_iff_lt_or_antisymmRel : a ≤ b ↔ a < b ∨ AntisymmRel (· ≤ ·) a b := by
rw [lt_iff_le_not_ge, AntisymmRel]
tauto | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | le_iff_lt_or_antisymmRel | null |
le_of_le_of_antisymmRel (h₁ : a ≤ b) (h₂ : AntisymmRel (· ≤ ·) b c) : a ≤ c :=
h₁.trans h₂.le | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | le_of_le_of_antisymmRel | null |
le_of_antisymmRel_of_le (h₁ : AntisymmRel (· ≤ ·) a b) (h₂ : b ≤ c) : a ≤ c :=
h₁.le.trans h₂ | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | le_of_antisymmRel_of_le | null |
lt_of_lt_of_antisymmRel (h₁ : a < b) (h₂ : AntisymmRel (· ≤ ·) b c) : a < c :=
h₁.trans_le h₂.le | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | lt_of_lt_of_antisymmRel | null |
lt_of_antisymmRel_of_lt (h₁ : AntisymmRel (· ≤ ·) a b) (h₂ : b < c) : a < c :=
h₁.le.trans_lt h₂
alias ⟨LE.le.lt_or_antisymmRel, _⟩ := le_iff_lt_or_antisymmRel
alias LE.le.trans_antisymmRel := le_of_le_of_antisymmRel
alias AntisymmRel.trans_le := le_of_antisymmRel_of_le
alias LT.lt.trans_antisymmRel := lt_of_lt_of_an... | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | lt_of_antisymmRel_of_lt | null |
AntisymmRel.le_congr (h₁ : AntisymmRel (· ≤ ·) a b) (h₂ : AntisymmRel (· ≤ ·) c d) :
a ≤ c ↔ b ≤ d where
mp h := (h₁.symm.trans_le h).trans_antisymmRel h₂
mpr h := (h₁.trans_le h).trans_antisymmRel h₂.symm | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | AntisymmRel.le_congr | null |
AntisymmRel.le_congr_left (h : AntisymmRel (· ≤ ·) a b) : a ≤ c ↔ b ≤ c :=
h.le_congr .rfl | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | AntisymmRel.le_congr_left | null |
AntisymmRel.le_congr_right (h : AntisymmRel (· ≤ ·) b c) : a ≤ b ↔ a ≤ c :=
AntisymmRel.rfl.le_congr h | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | AntisymmRel.le_congr_right | null |
AntisymmRel.lt_congr (h₁ : AntisymmRel (· ≤ ·) a b) (h₂ : AntisymmRel (· ≤ ·) c d) :
a < c ↔ b < d where
mp h := (h₁.symm.trans_lt h).trans_antisymmRel h₂
mpr h := (h₁.trans_lt h).trans_antisymmRel h₂.symm | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | AntisymmRel.lt_congr | null |
AntisymmRel.lt_congr_left (h : AntisymmRel (· ≤ ·) a b) : a < c ↔ b < c :=
h.lt_congr .rfl | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | AntisymmRel.lt_congr_left | null |
AntisymmRel.lt_congr_right (h : AntisymmRel (· ≤ ·) b c) : a < b ↔ a < c :=
AntisymmRel.rfl.lt_congr h | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | AntisymmRel.lt_congr_right | null |
AntisymmRel.antisymmRel_congr
(h₁ : AntisymmRel (· ≤ ·) a b) (h₂ : AntisymmRel (· ≤ ·) c d) :
AntisymmRel (· ≤ ·) a c ↔ AntisymmRel (· ≤ ·) b d :=
rel_congr h₁ h₂ | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | AntisymmRel.antisymmRel_congr | null |
AntisymmRel.antisymmRel_congr_left (h : AntisymmRel (· ≤ ·) a b) :
AntisymmRel (· ≤ ·) a c ↔ AntisymmRel (· ≤ ·) b c :=
rel_congr_left h | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | AntisymmRel.antisymmRel_congr_left | null |
AntisymmRel.antisymmRel_congr_right (h : AntisymmRel (· ≤ ·) b c) :
AntisymmRel (· ≤ ·) a b ↔ AntisymmRel (· ≤ ·) a c :=
rel_congr_right h | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | AntisymmRel.antisymmRel_congr_right | null |
AntisymmRel.image (h : AntisymmRel (· ≤ ·) a b) {f : α → β} (hf : Monotone f) :
AntisymmRel (· ≤ ·) (f a) (f b) :=
⟨hf h.1, hf h.2⟩ | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | AntisymmRel.image | null |
instPartialOrderAntisymmetrization : PartialOrder (Antisymmetrization α (· ≤ ·)) where
le :=
Quotient.lift₂ (· ≤ ·) fun (_ _ _ _ : α) h₁ h₂ =>
propext ⟨fun h => h₁.2.trans <| h.trans h₂.1, fun h => h₁.1.trans <| h.trans h₂.2⟩
lt :=
Quotient.lift₂ (· < ·) fun (_ _ _ _ : α) h₁ h₂ =>
propext ⟨fun h... | instance | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | instPartialOrderAntisymmetrization | null |
antisymmetrization_fibration :
Relation.Fibration (· < ·) (· < ·) (toAntisymmetrization (α := α) (· ≤ ·)) := by
rintro a ⟨b⟩ h
exact ⟨b, h, rfl⟩ | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | antisymmetrization_fibration | null |
acc_antisymmetrization_iff : Acc (· < ·)
(toAntisymmetrization (α := α) (· ≤ ·) a) ↔ Acc (· < ·) a :=
acc_lift₂_iff | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | acc_antisymmetrization_iff | null |
wellFounded_antisymmetrization_iff :
WellFounded (@LT.lt (Antisymmetrization α (· ≤ ·)) _) ↔ WellFounded (@LT.lt α _) :=
wellFounded_lift₂_iff | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | wellFounded_antisymmetrization_iff | null |
wellFoundedLT_antisymmetrization_iff :
WellFoundedLT (Antisymmetrization α (· ≤ ·)) ↔ WellFoundedLT α := by
simp_rw [isWellFounded_iff, wellFounded_antisymmetrization_iff] | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | wellFoundedLT_antisymmetrization_iff | null |
wellFoundedGT_antisymmetrization_iff :
WellFoundedGT (Antisymmetrization α (· ≤ ·)) ↔ WellFoundedGT α := by
simp_rw [isWellFounded_iff]
convert wellFounded_liftOn₂'_iff with ⟨_⟩ ⟨_⟩
exact fun _ _ _ _ h₁ h₂ ↦ propext
⟨fun h ↦ (h₂.2.trans_lt h).trans_le h₁.1, fun h ↦ (h₂.1.trans_lt h).trans_le h₁.2⟩ | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | wellFoundedGT_antisymmetrization_iff | null |
@[simp]
toAntisymmetrization_le_toAntisymmetrization_iff :
toAntisymmetrization (α := α) (· ≤ ·) a ≤ toAntisymmetrization (α := α) (· ≤ ·) b ↔ a ≤ b :=
Iff.rfl
@[simp] | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | toAntisymmetrization_le_toAntisymmetrization_iff | null |
toAntisymmetrization_lt_toAntisymmetrization_iff :
toAntisymmetrization (α := α) (· ≤ ·) a < toAntisymmetrization (α := α) (· ≤ ·) b ↔ a < b :=
Iff.rfl
@[simp] | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | toAntisymmetrization_lt_toAntisymmetrization_iff | null |
ofAntisymmetrization_le_ofAntisymmetrization_iff {a b : Antisymmetrization α (· ≤ ·)} :
ofAntisymmetrization (· ≤ ·) a ≤ ofAntisymmetrization (· ≤ ·) b ↔ a ≤ b :=
(Quotient.outRelEmbedding _).map_rel_iff
@[simp] | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | ofAntisymmetrization_le_ofAntisymmetrization_iff | null |
ofAntisymmetrization_lt_ofAntisymmetrization_iff {a b : Antisymmetrization α (· ≤ ·)} :
ofAntisymmetrization (· ≤ ·) a < ofAntisymmetrization (· ≤ ·) b ↔ a < b :=
(Quotient.outRelEmbedding _).map_rel_iff
@[mono] | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | ofAntisymmetrization_lt_ofAntisymmetrization_iff | null |
toAntisymmetrization_mono : Monotone (toAntisymmetrization (α := α) (· ≤ ·)) :=
fun _ _ => id
open scoped Relator in | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | toAntisymmetrization_mono | null |
private liftFun_antisymmRel (f : α →o β) :
((AntisymmRel.setoid α (· ≤ ·)).r ⇒ (AntisymmRel.setoid β (· ≤ ·)).r) f f := fun _ _ h =>
⟨f.mono h.1, f.mono h.2⟩ | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | liftFun_antisymmRel | null |
protected OrderHom.antisymmetrization (f : α →o β) :
Antisymmetrization α (· ≤ ·) →o Antisymmetrization β (· ≤ ·) :=
⟨Quotient.map' f <| liftFun_antisymmRel f, fun a b => Quotient.inductionOn₂' a b <| f.mono⟩
@[simp] | def | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | OrderHom.antisymmetrization | Turns an order homomorphism from `α` to `β` into one from `Antisymmetrization α` to
`Antisymmetrization β`. `Antisymmetrization` is actually a functor. See `Preorder_to_PartialOrder`. |
OrderHom.coe_antisymmetrization (f : α →o β) :
⇑f.antisymmetrization = Quotient.map' f (liftFun_antisymmRel f) :=
rfl | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | OrderHom.coe_antisymmetrization | null |
OrderHom.antisymmetrization_apply (f : α →o β) (a : Antisymmetrization α (· ≤ ·)) :
f.antisymmetrization a = Quotient.map' f (liftFun_antisymmRel f) a :=
rfl
@[simp] | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | OrderHom.antisymmetrization_apply | null |
OrderHom.antisymmetrization_apply_mk (f : α →o β) (a : α) :
f.antisymmetrization (toAntisymmetrization _ a) = toAntisymmetrization _ (f a) :=
@Quotient.map_mk _ _ (_root_.id _) (_root_.id _) f (liftFun_antisymmRel f) _
variable (α) | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | OrderHom.antisymmetrization_apply_mk | null |
@[simps]
noncomputable OrderEmbedding.ofAntisymmetrization : Antisymmetrization α (· ≤ ·) ↪o α :=
{ Quotient.outRelEmbedding _ with toFun := _root_.ofAntisymmetrization _ } | def | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | OrderEmbedding.ofAntisymmetrization | `ofAntisymmetrization` as an order embedding. |
OrderIso.dualAntisymmetrization :
(Antisymmetrization α (· ≤ ·))ᵒᵈ ≃o Antisymmetrization αᵒᵈ (· ≤ ·) where
toFun := (Quotient.map' id) fun _ _ => And.symm
invFun := (Quotient.map' id) fun _ _ => And.symm
left_inv a := Quotient.inductionOn' a fun a => by simp_rw [Quotient.map'_mk'', id]
right_inv a := Quotie... | def | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | OrderIso.dualAntisymmetrization | `Antisymmetrization` and `orderDual` commute. |
OrderIso.dualAntisymmetrization_apply (a : α) :
OrderIso.dualAntisymmetrization _ (toDual <| toAntisymmetrization _ a) =
toAntisymmetrization _ (toDual a) :=
rfl
@[simp] | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | OrderIso.dualAntisymmetrization_apply | null |
OrderIso.dualAntisymmetrization_symm_apply (a : α) :
(OrderIso.dualAntisymmetrization _).symm (toAntisymmetrization _ <| toDual a) =
toDual (toAntisymmetrization _ a) :=
rfl | theorem | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | OrderIso.dualAntisymmetrization_symm_apply | null |
prodEquiv : Antisymmetrization (α × β) (· ≤ ·) ≃o
Antisymmetrization α (· ≤ ·) × Antisymmetrization β (· ≤ ·) where
toFun := Quotient.lift (fun ab ↦ (⟦ab.1⟧, ⟦ab.2⟧)) fun ab₁ ab₂ h ↦
Prod.ext (Quotient.sound ⟨h.1.1, h.2.1⟩) (Quotient.sound ⟨h.1.2, h.2.2⟩)
invFun := Function.uncurry <| Quotient.lift₂ (fun a ... | def | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | prodEquiv | The antisymmetrization of a product preorder is order isomorphic
to the product of antisymmetrizations. |
Prod.wellFoundedLT [WellFoundedLT α] [WellFoundedLT β] : WellFoundedLT (α × β) :=
wellFoundedLT_antisymmetrization_iff.mp <|
(Antisymmetrization.prodEquiv α β).strictMono.wellFoundedLT | instance | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | Prod.wellFoundedLT | null |
Prod.wellFoundedGT [WellFoundedGT α] [WellFoundedGT β] : WellFoundedGT (α × β) :=
wellFoundedGT_antisymmetrization_iff.mp <|
(Antisymmetrization.prodEquiv α β).strictMono.wellFoundedGT | instance | Order | [
"Mathlib.Logic.Relation",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Tauto"
] | Mathlib/Order/Antisymmetrization.lean | Prod.wellFoundedGT | null |
IsAtom (a : α) : Prop :=
a ≠ ⊥ ∧ ∀ b, b < a → b = ⊥ | 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 | IsAtom | An atom of an `OrderBot` is an element with no other element between it and `⊥`,
which is not `⊥`. |
IsAtom.Iic (ha : IsAtom a) (hax : a ≤ x) : IsAtom (⟨a, hax⟩ : Set.Iic x) :=
⟨fun con => ha.1 (Subtype.mk_eq_mk.1 con), fun ⟨b, _⟩ hba => Subtype.mk_eq_mk.2 (ha.2 b hba)⟩ | 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.Iic | null |
IsAtom.of_isAtom_coe_Iic {a : Set.Iic x} (ha : IsAtom a) : IsAtom (a : α) :=
⟨fun con => ha.1 (Subtype.ext con), fun b hba =>
Subtype.mk_eq_mk.1 (ha.2 ⟨b, hba.le.trans a.prop⟩ hba)⟩ | 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_isAtom_coe_Iic | null |
isAtom_iff_le_of_ge : IsAtom a ↔ a ≠ ⊥ ∧ ∀ b ≠ ⊥, b ≤ a → a ≤ b :=
and_congr Iff.rfl <|
forall_congr' fun b => by
simp only [Ne, @not_imp_comm (b = ⊥), Classical.not_imp, lt_iff_le_not_ge] | 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_le_of_ge | null |
IsAtom.ne_bot (ha : IsAtom a) : 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 | IsAtom.ne_bot | null |
IsAtom.lt_iff (h : IsAtom a) : x < a ↔ x = ⊥ :=
⟨h.2 x, fun hx => hx.symm ▸ h.1.bot_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 | IsAtom.lt_iff | null |
IsAtom.le_iff (h : IsAtom a) : x ≤ a ↔ x = ⊥ ∨ x = a := by rw [le_iff_lt_or_eq, h.lt_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 | IsAtom.le_iff | null |
IsAtom.bot_lt (h : IsAtom a) : ⊥ < a :=
h.lt_iff.mpr rfl | 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.bot_lt | null |
IsAtom.le_iff_eq (ha : IsAtom a) (hb : b ≠ ⊥) : b ≤ a ↔ b = a :=
ha.le_iff.trans <| or_iff_right hb | 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.le_iff_eq | null |
IsAtom.ne_iff_eq_bot (ha : IsAtom a) (hba : b ≤ a) : b ≠ a ↔ b = ⊥ where
mp := (ha.le_iff.1 hba).resolve_right
mpr := by rintro rfl; exact ha.ne_bot.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.ne_iff_eq_bot | null |
IsAtom.ne_bot_iff_eq (ha : IsAtom a) (hba : b ≤ a) : b ≠ ⊥ ↔ b = a :=
(ha.ne_iff_eq_bot hba).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.ne_bot_iff_eq | null |
IsAtom.Iic_eq (h : IsAtom a) : Set.Iic a = {⊥, a} :=
Set.ext fun _ => h.le_iff
@[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.Iic_eq | null |
bot_covBy_iff : ⊥ ⋖ a ↔ IsAtom a := by
simp only [CovBy, bot_lt_iff_ne_bot, IsAtom, not_imp_not]
alias ⟨CovBy.is_atom, IsAtom.bot_covBy⟩ := bot_covBy_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 | bot_covBy_iff | null |
protected IsAtom.le_iSup (ha : IsAtom a) : a ≤ iSup f ↔ ∃ i, a ≤ f i := by
refine ⟨?_, fun ⟨i, hi⟩ => le_trans hi (le_iSup _ _)⟩
change (a ≤ ⨆ i, f i) → _
refine fun h => of_not_not fun ha' => ?_
push_neg at ha'
have ha'' : Disjoint a (⨆ i, f i) :=
disjoint_iSup_iff.2 fun i => fun x hxa hxf => le_bot_iff.... | 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.le_iSup | null |
protected IsAtom.le_sSup (ha : IsAtom a) : a ≤ sSup s ↔ ∃ b ∈ s, a ≤ b := by
simp [sSup_eq_iSup', ha.le_iSup] | 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.le_sSup | null |
IsCoatom [OrderTop α] (a : α) : Prop :=
a ≠ ⊤ ∧ ∀ b, a < b → b = ⊤
@[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 | IsCoatom | A coatom of an `OrderTop` is an element with no other element between it and `⊤`,
which is not `⊤`. |
isCoatom_dual_iff_isAtom [OrderBot α] {a : α} :
IsCoatom (OrderDual.toDual a) ↔ IsAtom a :=
Iff.rfl
@[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_dual_iff_isAtom | null |
isAtom_dual_iff_isCoatom [OrderTop α] {a : α} :
IsAtom (OrderDual.toDual a) ↔ IsCoatom a :=
Iff.rfl
alias ⟨_, IsAtom.dual⟩ := isCoatom_dual_iff_isAtom
alias ⟨_, IsCoatom.dual⟩ := isAtom_dual_iff_isCoatom
variable [OrderTop α] {a x : α} | 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_dual_iff_isCoatom | null |
IsCoatom.Ici (ha : IsCoatom a) (hax : x ≤ a) : IsCoatom (⟨a, hax⟩ : Set.Ici x) :=
ha.dual.Iic hax | 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 | null |
IsCoatom.of_isCoatom_coe_Ici {a : Set.Ici x} (ha : IsCoatom a) : IsCoatom (a : α) :=
@IsAtom.of_isAtom_coe_Iic αᵒᵈ _ _ x a ha | 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_isCoatom_coe_Ici | null |
isCoatom_iff_ge_of_le : IsCoatom a ↔ a ≠ ⊤ ∧ ∀ b ≠ ⊤, a ≤ b → b ≤ a :=
isAtom_iff_le_of_ge (α := αᵒᵈ) | 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_ge_of_le | null |
IsCoatom.ne_top (ha : IsCoatom a) : 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 | IsCoatom.ne_top | null |
IsCoatom.lt_iff (h : IsCoatom a) : a < x ↔ x = ⊤ :=
h.dual.lt_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.lt_iff | null |
IsCoatom.le_iff (h : IsCoatom a) : a ≤ x ↔ x = ⊤ ∨ x = a :=
h.dual.le_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.le_iff | null |
IsCoatom.lt_top (h : IsCoatom a) : a < ⊤ :=
h.lt_iff.mpr rfl | 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.lt_top | null |
IsCoatom.le_iff_eq (ha : IsCoatom a) (hb : b ≠ ⊤) : a ≤ b ↔ b = a := ha.dual.le_iff_eq hb | 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.le_iff_eq | null |
IsCoatom.ne_iff_eq_top (ha : IsCoatom a) (hab : a ≤ b) : b ≠ a ↔ b = ⊤ where
mp := (ha.le_iff.1 hab).resolve_right
mpr := by rintro rfl; exact ha.ne_top.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_iff_eq_top | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.