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 ⌀ |
|---|---|---|---|---|---|---|
coe_lt_iff : a < y ↔ ∀ b : α, y = b → a < b := by simp [lt_def] | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | coe_lt_iff | null |
protected lt_top_iff_ne_top : x < ⊤ ↔ x ≠ ⊤ := by cases x <;> simp
@[simp] lemma lt_untop_iff (hy : y ≠ ⊤) : a < y.untop hy ↔ a < y := by lift y to α using id hy; simp
@[simp] lemma untop_lt_iff (hx : x ≠ ⊤) : x.untop hx < b ↔ x < b := by lift x to α using id hx; simp | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | lt_top_iff_ne_top | A version of `lt_top_iff_ne_top` for `WithTop` that only requires `LT α`, not
`PartialOrder α`. |
lt_untopD_iff (hy : y = ⊤ → a < b) : a < y.untopD b ↔ a < y := by cases y <;> simp [hy] | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | lt_untopD_iff | null |
preorder [Preorder α] : Preorder (WithTop α) where
lt_iff_le_not_ge x y := by cases x <;> cases y <;> simp [lt_iff_le_not_ge]
le_refl x := by cases x <;> simp [le_def]
le_trans x y z := by cases x <;> cases y <;> cases z <;> simp [le_def]; simpa using le_trans | instance | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | preorder | null |
partialOrder [PartialOrder α] : PartialOrder (WithTop α) where
le_antisymm x y := by cases x <;> cases y <;> simp [le_def]; simpa using le_antisymm | instance | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | partialOrder | null |
coe_strictMono : StrictMono (fun a : α => (a : WithTop α)) := fun _ _ => coe_lt_coe.2 | theorem | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | coe_strictMono | null |
coe_mono : Monotone (fun a : α => (a : WithTop α)) := fun _ _ => coe_le_coe.2 | theorem | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | coe_mono | null |
monotone_iff {f : WithTop α → β} :
Monotone f ↔ Monotone (fun (a : α) => f a) ∧ ∀ x : α, f x ≤ f ⊤ :=
⟨fun h => ⟨h.comp WithTop.coe_mono, fun _ => h le_top⟩, fun h =>
WithTop.forall.2
⟨WithTop.forall.2 ⟨fun _ => le_rfl, fun _ h => (not_top_le_coe _ h).elim⟩, fun x =>
WithTop.forall.2 ⟨fun _ => h... | theorem | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | monotone_iff | null |
monotone_map_iff {f : α → β} : Monotone (WithTop.map f) ↔ Monotone f :=
monotone_iff.trans <| by simp [Monotone]
alias ⟨_, _root_.Monotone.withTop_map⟩ := monotone_map_iff | theorem | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | monotone_map_iff | null |
strictMono_iff {f : WithTop α → β} :
StrictMono f ↔ StrictMono (fun (a : α) => f a) ∧ ∀ x : α, f x < f ⊤ :=
⟨fun h => ⟨h.comp WithTop.coe_strictMono, fun _ => h (coe_lt_top _)⟩, fun h =>
WithTop.forall.2
⟨WithTop.forall.2 ⟨flip absurd (lt_irrefl _), fun _ h => (not_top_lt h).elim⟩, fun x =>
With... | theorem | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | strictMono_iff | null |
strictAnti_iff {f : WithTop α → β} :
StrictAnti f ↔ StrictAnti (fun a ↦ f a : α → β) ∧ ∀ x : α, f ⊤ < f x :=
strictMono_iff (β := βᵒᵈ)
@[simp] | theorem | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | strictAnti_iff | null |
strictMono_map_iff {f : α → β} : StrictMono (WithTop.map f) ↔ StrictMono f :=
strictMono_iff.trans <| by simp [StrictMono, coe_lt_top]
alias ⟨_, _root_.StrictMono.withTop_map⟩ := strictMono_map_iff | theorem | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | strictMono_map_iff | null |
map_le_iff (f : α → β) (mono_iff : ∀ {a b}, f a ≤ f b ↔ a ≤ b) :
x.map f ≤ y.map f ↔ x ≤ y := by cases x <;> cases y <;> simp [mono_iff] | theorem | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | map_le_iff | null |
coe_untopD_le (y : WithTop α) (a : α) : y.untopD a ≤ y := by cases y <;> simp
@[simp] | theorem | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | coe_untopD_le | null |
coe_top_lt [OrderTop α] : (⊤ : α) < x ↔ x = ⊤ := by cases x <;> simp | theorem | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | coe_top_lt | null |
eq_top_iff_forall_gt : y = ⊤ ↔ ∀ a : α, a < y := by
cases y <;> simp; simpa using ⟨_, lt_irrefl _⟩ | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | eq_top_iff_forall_gt | null |
eq_top_iff_forall_ge [NoTopOrder α] : y = ⊤ ↔ ∀ a : α, a ≤ y :=
WithBot.eq_bot_iff_forall_le (α := αᵒᵈ)
@[deprecated (since := "2025-03-19")] alias forall_gt_iff_eq_top := eq_top_iff_forall_gt
@[deprecated (since := "2025-03-19")] alias forall_ge_iff_eq_top := eq_top_iff_forall_ge | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | eq_top_iff_forall_ge | null |
forall_coe_le_iff_le [NoTopOrder α] : (∀ a : α, a ≤ x → a ≤ y) ↔ x ≤ y :=
WithBot.forall_le_coe_iff_le (α := αᵒᵈ) | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | forall_coe_le_iff_le | null |
eq_of_forall_coe_le_iff (h : ∀ a : α, a ≤ x ↔ a ≤ y) : x = y :=
WithBot.eq_of_forall_le_coe_iff (α := αᵒᵈ) h | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | eq_of_forall_coe_le_iff | null |
semilatticeInf [SemilatticeInf α] : SemilatticeInf (WithTop α) where
inf
| ⊤, ⊤ => ⊤
| (a : α), ⊤ => a
| ⊤, (b : α) => b
| (a : α), (b : α) => ↑(a ⊓ b)
inf_le_left x y := by cases x <;> cases y <;> simp
inf_le_right x y := by cases x <;> cases y <;> simp
le_inf x y z := by cases x <;> cases y <;... | instance | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | semilatticeInf | null |
coe_inf [SemilatticeInf α] (a b : α) : ((a ⊓ b : α) : WithTop α) = (a : WithTop α) ⊓ b :=
rfl | theorem | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | coe_inf | null |
semilatticeSup [SemilatticeSup α] : SemilatticeSup (WithTop α) where
sup := .map₂ (· ⊔ ·)
le_sup_left x y := by cases x <;> cases y <;> simp
le_sup_right x y := by cases x <;> cases y <;> simp
sup_le x y z := by cases x <;> cases y <;> cases z <;> simp; simpa using sup_le | instance | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | semilatticeSup | null |
coe_sup [SemilatticeSup α] (a b : α) : ((a ⊔ b : α) : WithTop α) = (a : WithTop α) ⊔ b :=
rfl | theorem | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | coe_sup | null |
lattice [Lattice α] : Lattice (WithTop α) :=
{ WithTop.semilatticeSup, WithTop.semilatticeInf with } | instance | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | lattice | null |
distribLattice [DistribLattice α] : DistribLattice (WithTop α) where
le_sup_inf x y z := by
cases x <;> cases y <;> cases z <;> simp [← coe_inf, ← coe_sup]
simpa [← coe_inf, ← coe_sup] using le_sup_inf | instance | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | distribLattice | null |
decidableEq [DecidableEq α] : DecidableEq (WithTop α) :=
inferInstanceAs <| DecidableEq (Option α) | instance | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | decidableEq | null |
decidableLE [LE α] [DecidableLE α] : DecidableLE (WithTop α)
| _, ⊤ => isTrue <| by simp
| ⊤, (a : α) => isFalse <| by simp
| (a : α), (b : α) => decidable_of_iff' _ coe_le_coe | instance | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | decidableLE | null |
decidableLT [LT α] [DecidableLT α] : DecidableLT (WithTop α)
| ⊤, _ => isFalse <| by simp
| (a : α), ⊤ => isTrue <| by simp
| (a : α), (b : α) => decidable_of_iff' _ coe_lt_coe | instance | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | decidableLT | null |
isTotal_le [LE α] [IsTotal α (· ≤ ·)] : IsTotal (WithTop α) (· ≤ ·) where
total x y := by cases x <;> cases y <;> simp; simpa using IsTotal.total .. | instance | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | isTotal_le | null |
linearOrder [LinearOrder α] : LinearOrder (WithTop α) := Lattice.toLinearOrder _
@[simp, norm_cast] lemma coe_min (a b : α) : ↑(min a b) = min (a : WithTop α) b := rfl
@[simp, norm_cast] lemma coe_max (a b : α) : ↑(max a b) = max (a : WithTop α) b := rfl
variable [DenselyOrdered α] [NoMaxOrder α] | instance | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | linearOrder | null |
le_of_forall_lt_iff_le : (∀ b : α, x < b → y ≤ b) ↔ y ≤ x := by
cases x <;> cases y <;> simp [exists_gt, forall_gt_imp_ge_iff_le_of_dense] | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | le_of_forall_lt_iff_le | null |
ge_of_forall_gt_iff_ge : (∀ a : α, a < x → a ≤ y) ↔ x ≤ y := by
cases x <;> cases y <;> simp [exists_gt, forall_lt_imp_le_iff_le_of_dense] | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | ge_of_forall_gt_iff_ge | null |
instWellFoundedLT [LT α] [WellFoundedLT α] : WellFoundedLT (WithTop α) :=
inferInstanceAs <| WellFoundedLT (WithBot αᵒᵈ)ᵒᵈ | instance | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | instWellFoundedLT | null |
instWellFoundedGT [LT α] [WellFoundedGT α] : WellFoundedGT (WithTop α) :=
inferInstanceAs <| WellFoundedGT (WithBot αᵒᵈ)ᵒᵈ | instance | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | instWellFoundedGT | null |
trichotomous.lt [Preorder α] [IsTrichotomous α (· < ·)] :
IsTrichotomous (WithTop α) (· < ·) where
trichotomous x y := by cases x <;> cases y <;> simp [trichotomous] | instance | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | trichotomous.lt | null |
IsWellOrder.lt [Preorder α] [IsWellOrder α (· < ·)] : IsWellOrder (WithTop α) (· < ·) where | instance | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | IsWellOrder.lt | null |
trichotomous.gt [Preorder α] [IsTrichotomous α (· > ·)] :
IsTrichotomous (WithTop α) (· > ·) :=
have : IsTrichotomous α (· < ·) := .swap _; .swap _ | instance | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | trichotomous.gt | null |
IsWellOrder.gt [Preorder α] [IsWellOrder α (· > ·)] : IsWellOrder (WithTop α) (· > ·) where | instance | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | IsWellOrder.gt | null |
_root_.WithBot.trichotomous.lt [Preorder α] [h : IsTrichotomous α (· < ·)] :
IsTrichotomous (WithBot α) (· < ·) where
trichotomous x y := by cases x <;> cases y <;> simp [trichotomous] | instance | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | _root_.WithBot.trichotomous.lt | null |
_root_.WithBot.isWellOrder.lt [Preorder α] [IsWellOrder α (· < ·)] :
IsWellOrder (WithBot α) (· < ·) where | instance | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | _root_.WithBot.isWellOrder.lt | null |
_root_.WithBot.trichotomous.gt [Preorder α] [h : IsTrichotomous α (· > ·)] :
IsTrichotomous (WithBot α) (· > ·) where
trichotomous x y := by cases x <;> cases y <;> simp; simpa using trichotomous_of (· > ·) .. | instance | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | _root_.WithBot.trichotomous.gt | null |
_root_.WithBot.isWellOrder.gt [Preorder α] [h : IsWellOrder α (· > ·)] :
IsWellOrder (WithBot α) (· > ·) where
trichotomous x y := by cases x <;> cases y <;> simp; simpa using trichotomous_of (· > ·) .. | instance | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | _root_.WithBot.isWellOrder.gt | null |
denselyOrdered_iff [LT α] [NoMaxOrder α] :
DenselyOrdered (WithTop α) ↔ DenselyOrdered α := by
rw [← denselyOrdered_orderDual, iff_comm, ← denselyOrdered_orderDual]
exact WithBot.denselyOrdered_iff.symm | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | denselyOrdered_iff | null |
lt_iff_exists_coe_btwn [Preorder α] [DenselyOrdered α] [NoMaxOrder α] {a b : WithTop α} :
a < b ↔ ∃ x : α, a < ↑x ∧ ↑x < b :=
⟨fun h =>
let ⟨_, hy⟩ := exists_between h
let ⟨x, hx⟩ := lt_iff_exists_coe.1 hy.2
⟨x, hx.1 ▸ hy⟩,
fun ⟨_, hx⟩ => lt_trans hx.1 hx.2⟩ | theorem | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | lt_iff_exists_coe_btwn | null |
noBotOrder [LE α] [NoBotOrder α] [Nonempty α] : NoBotOrder (WithTop α) where
exists_not_ge := fun
| ⊤ => ‹Nonempty α›.elim fun a ↦ ⟨a, by simp⟩
| (a : α) => let ⟨b, hba⟩ := exists_not_ge a; ⟨b, mod_cast hba⟩ | instance | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | noBotOrder | null |
noMinOrder [LT α] [NoMinOrder α] [Nonempty α] : NoMinOrder (WithTop α) where
exists_lt := fun
| ⊤ => ‹Nonempty α›.elim fun a ↦ ⟨a, by simp⟩
| (a : α) => let ⟨b, hab⟩ := exists_lt a; ⟨b, mod_cast hab⟩ | instance | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | noMinOrder | null |
WithBot.eq_top_iff_forall_ge [Preorder α] [Nonempty α] [NoTopOrder α]
{x : WithBot (WithTop α)} : x = ⊤ ↔ ∀ a : α, a ≤ x := by
refine ⟨by simp_all, fun H ↦ ?_⟩
induction x
· simp at H
· simpa [WithTop.eq_top_iff_forall_ge] using H | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | WithBot.eq_top_iff_forall_ge | null |
@[simp]
toDual_symm_apply (a : WithTop αᵒᵈ) : WithBot.toDual.symm a = WithTop.ofDual a :=
rfl
@[simp] | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | toDual_symm_apply | null |
ofDual_symm_apply (a : WithTop α) : WithBot.ofDual.symm a = WithTop.toDual a :=
rfl
@[simp] lemma toDual_apply_bot : WithBot.toDual (⊥ : WithBot α) = ⊤ := rfl
@[simp] lemma ofDual_apply_bot : WithBot.ofDual (⊥ : WithBot α) = ⊤ := rfl
@[simp] lemma toDual_apply_coe (a : α) : WithBot.toDual (a : WithBot α) = toDual a :... | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | ofDual_symm_apply | null |
map_toDual (f : αᵒᵈ → βᵒᵈ) (a : WithTop α) :
WithBot.map f (WithTop.toDual a) = a.map (toDual ∘ f) := rfl | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | map_toDual | null |
map_ofDual (f : α → β) (a : WithTop αᵒᵈ) :
WithBot.map f (WithTop.ofDual a) = a.map (ofDual ∘ f) := rfl | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | map_ofDual | null |
toDual_map (f : α → β) (a : WithBot α) :
WithBot.toDual (WithBot.map f a) = map (toDual ∘ f ∘ ofDual) (WithBot.toDual a) := rfl | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | toDual_map | null |
ofDual_map (f : αᵒᵈ → βᵒᵈ) (a : WithBot αᵒᵈ) :
WithBot.ofDual (WithBot.map f a) = map (ofDual ∘ f ∘ toDual) (WithBot.ofDual a) := rfl | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | ofDual_map | null |
WithBot.toDual_le_iff {x : WithBot α} {y : WithTop αᵒᵈ} :
x.toDual ≤ y ↔ WithTop.ofDual y ≤ x := by
cases x <;> cases y <;> simp [toDual_le] | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | WithBot.toDual_le_iff | null |
WithBot.le_toDual_iff {x : WithTop αᵒᵈ} {y : WithBot α} :
x ≤ WithBot.toDual y ↔ y ≤ WithTop.ofDual x := by cases x <;> cases y <;> simp [le_toDual]
@[simp] | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | WithBot.le_toDual_iff | null |
WithBot.toDual_le_toDual_iff {x y : WithBot α} : x.toDual ≤ y.toDual ↔ y ≤ x := by
cases x <;> cases y <;> simp | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | WithBot.toDual_le_toDual_iff | null |
WithBot.ofDual_le_iff {x : WithBot αᵒᵈ} {y : WithTop α} :
WithBot.ofDual x ≤ y ↔ y.toDual ≤ x := by cases x <;> cases y <;> simp [toDual_le] | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | WithBot.ofDual_le_iff | null |
WithBot.le_ofDual_iff {x : WithTop α} {y : WithBot αᵒᵈ} :
x ≤ WithBot.ofDual y ↔ y ≤ x.toDual := by cases x <;> cases y <;> simp [le_toDual]
@[simp] | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | WithBot.le_ofDual_iff | null |
WithBot.ofDual_le_ofDual_iff {x y : WithBot αᵒᵈ} :
WithBot.ofDual x ≤ WithBot.ofDual y ↔ y ≤ x := by cases x <;> cases y <;> simp | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | WithBot.ofDual_le_ofDual_iff | null |
WithTop.toDual_le_iff {x : WithTop α} {y : WithBot αᵒᵈ} :
x.toDual ≤ y ↔ WithBot.ofDual y ≤ x := by cases x <;> cases y <;> simp [toDual_le] | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | WithTop.toDual_le_iff | null |
WithTop.le_toDual_iff {x : WithBot αᵒᵈ} {y : WithTop α} :
x ≤ WithTop.toDual y ↔ y ≤ WithBot.ofDual x := by cases x <;> cases y <;> simp [le_toDual]
@[simp] | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | WithTop.le_toDual_iff | null |
WithTop.toDual_le_toDual_iff {x y : WithTop α} : x.toDual ≤ y.toDual ↔ y ≤ x := by
cases x <;> cases y <;> simp [le_toDual] | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | WithTop.toDual_le_toDual_iff | null |
WithTop.ofDual_le_iff {x : WithTop αᵒᵈ} {y : WithBot α} :
WithTop.ofDual x ≤ y ↔ y.toDual ≤ x := by cases x <;> cases y <;> simp [toDual_le] | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | WithTop.ofDual_le_iff | null |
WithTop.le_ofDual_iff {x : WithBot α} {y : WithTop αᵒᵈ} :
x ≤ WithTop.ofDual y ↔ y ≤ x.toDual := by cases x <;> cases y <;> simp [le_toDual]
@[simp] | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | WithTop.le_ofDual_iff | null |
WithTop.ofDual_le_ofDual_iff {x y : WithTop αᵒᵈ} :
WithTop.ofDual x ≤ WithTop.ofDual y ↔ y ≤ x := by cases x <;> cases y <;> simp | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | WithTop.ofDual_le_ofDual_iff | null |
WithBot.toDual_lt_iff {x : WithBot α} {y : WithTop αᵒᵈ} :
x.toDual < y ↔ WithTop.ofDual y < x := by cases x <;> cases y <;> simp [toDual_lt] | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | WithBot.toDual_lt_iff | null |
WithBot.lt_toDual_iff {x : WithTop αᵒᵈ} {y : WithBot α} :
x < y.toDual ↔ y < WithTop.ofDual x := by cases x <;> cases y <;> simp [lt_toDual]
@[simp] | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | WithBot.lt_toDual_iff | null |
WithBot.toDual_lt_toDual_iff {x y : WithBot α} : x.toDual < y.toDual ↔ y < x := by
cases x <;> cases y <;> simp | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | WithBot.toDual_lt_toDual_iff | null |
WithBot.ofDual_lt_iff {x : WithBot αᵒᵈ} {y : WithTop α} :
WithBot.ofDual x < y ↔ y.toDual < x := by cases x <;> cases y <;> simp [toDual_lt] | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | WithBot.ofDual_lt_iff | null |
WithBot.lt_ofDual_iff {x : WithTop α} {y : WithBot αᵒᵈ} :
x < WithBot.ofDual y ↔ y < x.toDual := by cases x <;> cases y <;> simp [lt_toDual]
@[simp] | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | WithBot.lt_ofDual_iff | null |
WithBot.ofDual_lt_ofDual_iff {x y : WithBot αᵒᵈ} :
WithBot.ofDual x < WithBot.ofDual y ↔ y < x := by cases x <;> cases y <;> simp | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | WithBot.ofDual_lt_ofDual_iff | null |
WithTop.toDual_lt_iff {x : WithTop α} {y : WithBot αᵒᵈ} :
WithTop.toDual x < y ↔ WithBot.ofDual y < x := by cases x <;> cases y <;> simp [toDual_lt] | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | WithTop.toDual_lt_iff | null |
WithTop.lt_toDual_iff {x : WithBot αᵒᵈ} {y : WithTop α} :
x < WithTop.toDual y ↔ y < WithBot.ofDual x := by cases x <;> cases y <;> simp [lt_toDual]
@[simp] | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | WithTop.lt_toDual_iff | null |
WithTop.toDual_lt_toDual_iff {x y : WithTop α} :
WithTop.toDual x < WithTop.toDual y ↔ y < x := by cases x <;> cases y <;> simp | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | WithTop.toDual_lt_toDual_iff | null |
WithTop.ofDual_lt_iff {x : WithTop αᵒᵈ} {y : WithBot α} :
WithTop.ofDual x < y ↔ WithBot.toDual y < x := by cases x <;> cases y <;> simp [toDual_lt] | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | WithTop.ofDual_lt_iff | null |
WithTop.lt_ofDual_iff {x : WithBot α} {y : WithTop αᵒᵈ} :
x < WithTop.ofDual y ↔ y < WithBot.toDual x := by cases x <;> cases y <;> simp [lt_toDual]
@[simp] | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | WithTop.lt_ofDual_iff | null |
WithTop.ofDual_lt_ofDual_iff {x y : WithTop αᵒᵈ} :
WithTop.ofDual x < WithTop.ofDual y ↔ y < x := by cases x <;> cases y <;> simp | lemma | Order | [
"Mathlib.Logic.Nontrivial.Basic",
"Mathlib.Order.TypeTags",
"Mathlib.Data.Option.NAry",
"Mathlib.Tactic.Contrapose",
"Mathlib.Tactic.Lift",
"Mathlib.Data.Option.Basic",
"Mathlib.Order.Lattice",
"Mathlib.Order.BoundedOrder.Basic"
] | Mathlib/Order/WithBot.lean | WithTop.ofDual_lt_ofDual_iff | null |
zorny_lemma : zorny_statement := by
let s : Set α := {x | whatever x}
suffices ∃ x ∈ s, ∀ y ∈ s, y ⊆ x → y = x by -- or with another operator xxx
proof_post_zorn
apply zorn_subset -- or another variant
rintro c hcs hc
obtain rfl | hcnemp := c.eq_empty_or_nonempty -- you might need to disjunct on c empty o... | lemma | Order | [
"Mathlib.Order.CompleteLattice.Chain",
"Mathlib.Order.Minimal"
] | Mathlib/Order/Zorn.lean | zorny_lemma | null |
exists_maximal_of_chains_bounded (h : ∀ c, IsChain r c → ∃ ub, ∀ a ∈ c, a ≺ ub)
(trans : ∀ {a b c}, a ≺ b → b ≺ c → a ≺ c) : ∃ m, ∀ a, m ≺ a → a ≺ m :=
have : ∃ ub, ∀ a ∈ maxChain r, a ≺ ub := h _ <| maxChain_spec.left
let ⟨ub, (hub : ∀ a ∈ maxChain r, a ≺ ub)⟩ := this
⟨ub, fun a ha =>
have : IsChain r (i... | theorem | Order | [
"Mathlib.Order.CompleteLattice.Chain",
"Mathlib.Order.Minimal"
] | Mathlib/Order/Zorn.lean | exists_maximal_of_chains_bounded | Local notation for the relation being considered. -/
local infixl:50 " ≺ " => r
/-- **Zorn's lemma**
If every chain has an upper bound, then there exists a maximal element. |
exists_maximal_of_nonempty_chains_bounded [Nonempty α]
(h : ∀ c, IsChain r c → c.Nonempty → ∃ ub, ∀ a ∈ c, a ≺ ub)
(trans : ∀ {a b c}, a ≺ b → b ≺ c → a ≺ c) : ∃ m, ∀ a, m ≺ a → a ≺ m :=
exists_maximal_of_chains_bounded
(fun c hc =>
(eq_empty_or_nonempty c).elim
(fun h => ⟨Classical.arbitrar... | theorem | Order | [
"Mathlib.Order.CompleteLattice.Chain",
"Mathlib.Order.Minimal"
] | Mathlib/Order/Zorn.lean | exists_maximal_of_nonempty_chains_bounded | A variant of Zorn's lemma. If every nonempty chain of a nonempty type has an upper bound, then
there is a maximal element. |
zorn_le (h : ∀ c : Set α, IsChain (· ≤ ·) c → BddAbove c) : ∃ m : α, IsMax m :=
exists_maximal_of_chains_bounded h le_trans | theorem | Order | [
"Mathlib.Order.CompleteLattice.Chain",
"Mathlib.Order.Minimal"
] | Mathlib/Order/Zorn.lean | zorn_le | null |
zorn_le_nonempty [Nonempty α]
(h : ∀ c : Set α, IsChain (· ≤ ·) c → c.Nonempty → BddAbove c) : ∃ m : α, IsMax m :=
exists_maximal_of_nonempty_chains_bounded h le_trans | theorem | Order | [
"Mathlib.Order.CompleteLattice.Chain",
"Mathlib.Order.Minimal"
] | Mathlib/Order/Zorn.lean | zorn_le_nonempty | null |
zorn_le₀ (s : Set α) (ih : ∀ c ⊆ s, IsChain (· ≤ ·) c → ∃ ub ∈ s, ∀ z ∈ c, z ≤ ub) :
∃ m, Maximal (· ∈ s) m :=
let ⟨⟨m, hms⟩, h⟩ :=
@zorn_le s _ fun c hc =>
let ⟨ub, hubs, hub⟩ :=
ih (Subtype.val '' c) (fun _ ⟨⟨_, hx⟩, _, h⟩ => h ▸ hx)
(by
rintro _ ⟨p, hpc, rfl⟩ _ ⟨q, hqc, ... | theorem | Order | [
"Mathlib.Order.CompleteLattice.Chain",
"Mathlib.Order.Minimal"
] | Mathlib/Order/Zorn.lean | zorn_le₀ | null |
zorn_le_nonempty₀ (s : Set α)
(ih : ∀ c ⊆ s, IsChain (· ≤ ·) c → ∀ y ∈ c, ∃ ub ∈ s, ∀ z ∈ c, z ≤ ub) (x : α) (hxs : x ∈ s) :
∃ m, x ≤ m ∧ Maximal (· ∈ s) m := by
have H := zorn_le₀ ({ y ∈ s | x ≤ y }) fun c hcs hc => ?_
· rcases H with ⟨m, ⟨hms, hxm⟩, hm⟩
exact ⟨m, hxm, hms, fun z hzs hmz => @hm _ ⟨hzs,... | theorem | Order | [
"Mathlib.Order.CompleteLattice.Chain",
"Mathlib.Order.Minimal"
] | Mathlib/Order/Zorn.lean | zorn_le_nonempty₀ | null |
zorn_le_nonempty_Ici₀ (a : α)
(ih : ∀ c ⊆ Ici a, IsChain (· ≤ ·) c → ∀ y ∈ c, ∃ ub, ∀ z ∈ c, z ≤ ub) (x : α) (hax : a ≤ x) :
∃ m, x ≤ m ∧ IsMax m := by
let ⟨m, hxm, ham, hm⟩ := zorn_le_nonempty₀ (Ici a) (fun c hca hc y hy ↦ ?_) x hax
· exact ⟨m, hxm, fun z hmz => hm (ham.trans hmz) hmz⟩
· have ⟨ub, hub⟩ :... | theorem | Order | [
"Mathlib.Order.CompleteLattice.Chain",
"Mathlib.Order.Minimal"
] | Mathlib/Order/Zorn.lean | zorn_le_nonempty_Ici₀ | null |
zorn_subset (S : Set (Set α))
(h : ∀ c ⊆ S, IsChain (· ⊆ ·) c → ∃ ub ∈ S, ∀ s ∈ c, s ⊆ ub) : ∃ m, Maximal (· ∈ S) m :=
zorn_le₀ S h | theorem | Order | [
"Mathlib.Order.CompleteLattice.Chain",
"Mathlib.Order.Minimal"
] | Mathlib/Order/Zorn.lean | zorn_subset | null |
zorn_subset_nonempty (S : Set (Set α))
(H : ∀ c ⊆ S, IsChain (· ⊆ ·) c → c.Nonempty → ∃ ub ∈ S, ∀ s ∈ c, s ⊆ ub) (x) (hx : x ∈ S) :
∃ m, x ⊆ m ∧ Maximal (· ∈ S) m :=
zorn_le_nonempty₀ _ (fun _ cS hc y yc => H _ cS hc ⟨y, yc⟩) _ hx | theorem | Order | [
"Mathlib.Order.CompleteLattice.Chain",
"Mathlib.Order.Minimal"
] | Mathlib/Order/Zorn.lean | zorn_subset_nonempty | null |
zorn_superset (S : Set (Set α))
(h : ∀ c ⊆ S, IsChain (· ⊆ ·) c → ∃ lb ∈ S, ∀ s ∈ c, lb ⊆ s) : ∃ m, Minimal (· ∈ S) m :=
(@zorn_le₀ (Set α)ᵒᵈ _ S) fun c cS hc => h c cS hc.symm | theorem | Order | [
"Mathlib.Order.CompleteLattice.Chain",
"Mathlib.Order.Minimal"
] | Mathlib/Order/Zorn.lean | zorn_superset | null |
zorn_superset_nonempty (S : Set (Set α))
(H : ∀ c ⊆ S, IsChain (· ⊆ ·) c → c.Nonempty → ∃ lb ∈ S, ∀ s ∈ c, lb ⊆ s) (x) (hx : x ∈ S) :
∃ m, m ⊆ x ∧ Minimal (· ∈ S) m :=
@zorn_le_nonempty₀ (Set α)ᵒᵈ _ S (fun _ cS hc y yc => H _ cS hc.symm ⟨y, yc⟩) _ hx | theorem | Order | [
"Mathlib.Order.CompleteLattice.Chain",
"Mathlib.Order.Minimal"
] | Mathlib/Order/Zorn.lean | zorn_superset_nonempty | null |
IsChain.exists_maxChain (hc : IsChain r c) : ∃ M, @IsMaxChain _ r M ∧ c ⊆ M := by
have H := zorn_subset_nonempty { s | c ⊆ s ∧ IsChain r s } ?_ c ⟨Subset.rfl, hc⟩
· obtain ⟨M, hcM, hM⟩ := H
exact ⟨M, ⟨hM.prop.2, fun d hd hMd ↦ hM.eq_of_subset ⟨hcM.trans hMd, hd⟩ hMd⟩, hcM⟩
rintro cs hcs₀ hcs₁ ⟨s, hs⟩
refine... | theorem | Order | [
"Mathlib.Order.CompleteLattice.Chain",
"Mathlib.Order.Minimal"
] | Mathlib/Order/Zorn.lean | IsChain.exists_maxChain | Every chain is contained in a maximal chain. This generalizes Hausdorff's maximality principle. |
_root_.IsChain.exists_subset_flag (hc : IsChain (· ≤ ·) c) : ∃ s : Flag α, c ⊆ s :=
let ⟨s, hs, hcs⟩ := hc.exists_maxChain; ⟨ofIsMaxChain s hs, hcs⟩ | lemma | Order | [
"Mathlib.Order.CompleteLattice.Chain",
"Mathlib.Order.Minimal"
] | Mathlib/Order/Zorn.lean | _root_.IsChain.exists_subset_flag | null |
exists_mem (a : α) : ∃ s : Flag α, a ∈ s :=
let ⟨s, hs⟩ := Set.subsingleton_singleton (a := a).isChain.exists_subset_flag
⟨s, hs rfl⟩ | lemma | Order | [
"Mathlib.Order.CompleteLattice.Chain",
"Mathlib.Order.Minimal"
] | Mathlib/Order/Zorn.lean | exists_mem | null |
exists_mem_mem (hab : a ≤ b) : ∃ s : Flag α, a ∈ s ∧ b ∈ s := by
simpa [Set.insert_subset_iff] using (IsChain.pair hab).exists_subset_flag | lemma | Order | [
"Mathlib.Order.CompleteLattice.Chain",
"Mathlib.Order.Minimal"
] | Mathlib/Order/Zorn.lean | exists_mem_mem | null |
IsCoatomic.of_isChain_bounded {α : Type*} [PartialOrder α] [OrderTop α]
(h : ∀ c : Set α, IsChain (· ≤ ·) c → c.Nonempty → ⊤ ∉ c → ∃ x ≠ ⊤, x ∈ upperBounds c) :
IsCoatomic α := by
refine ⟨fun x => le_top.eq_or_lt.imp_right fun hx => ?_⟩
have := zorn_le_nonempty₀ (Ico x ⊤) (fun c hxc hc y hy => ?_) x (left_m... | theorem | Order | [
"Mathlib.Order.Zorn",
"Mathlib.Order.Atoms"
] | Mathlib/Order/ZornAtoms.lean | IsCoatomic.of_isChain_bounded | **Zorn's lemma**: A partial order is coatomic if every nonempty chain `c`, `⊤ ∉ c`, has an upper
bound not equal to `⊤`. |
IsAtomic.of_isChain_bounded {α : Type*} [PartialOrder α] [OrderBot α]
(h :
∀ c : Set α,
IsChain (· ≤ ·) c → c.Nonempty → ⊥ ∉ c → ∃ x ≠ ⊥, x ∈ lowerBounds c) :
IsAtomic α :=
isCoatomic_dual_iff_isAtomic.mp <| IsCoatomic.of_isChain_bounded fun c hc => h c hc.symm | theorem | Order | [
"Mathlib.Order.Zorn",
"Mathlib.Order.Atoms"
] | Mathlib/Order/ZornAtoms.lean | IsAtomic.of_isChain_bounded | **Zorn's lemma**: A partial order is atomic if every nonempty chain `c`, `⊥ ∉ c`, has a lower
bound not equal to `⊥`. |
iIndepFun.indep_comap_natural_of_lt (hf : ∀ i, StronglyMeasurable (f i))
(hfi : iIndepFun f μ) (hij : i < j) :
Indep (MeasurableSpace.comap (f j) mβ) (Filtration.natural f hf i) μ := by
suffices Indep (⨆ k ∈ ({j} : Set ι), MeasurableSpace.comap (f k) mβ)
(⨆ k ∈ {k | k ≤ i}, MeasurableSpace.comap (f k) m... | theorem | Probability | [
"Mathlib.Probability.Martingale.BorelCantelli",
"Mathlib.Probability.ConditionalExpectation",
"Mathlib.Probability.Independence.Basic"
] | Mathlib/Probability/BorelCantelli.lean | iIndepFun.indep_comap_natural_of_lt | null |
iIndepFun.condExp_natural_ae_eq_of_lt [SecondCountableTopology β] [CompleteSpace β]
[NormedSpace ℝ β] (hf : ∀ i, StronglyMeasurable (f i)) (hfi : iIndepFun f μ)
(hij : i < j) : μ[f j|Filtration.natural f hf i] =ᵐ[μ] fun _ => μ[f j] := by
have : IsProbabilityMeasure μ := hfi.isProbabilityMeasure
exact condEx... | theorem | Probability | [
"Mathlib.Probability.Martingale.BorelCantelli",
"Mathlib.Probability.ConditionalExpectation",
"Mathlib.Probability.Independence.Basic"
] | Mathlib/Probability/BorelCantelli.lean | iIndepFun.condExp_natural_ae_eq_of_lt | null |
iIndepSet.condExp_indicator_filtrationOfSet_ae_eq (hsm : ∀ n, MeasurableSet (s n))
(hs : iIndepSet s μ) (hij : i < j) :
μ[(s j).indicator (fun _ => 1 : Ω → ℝ)|filtrationOfSet hsm i] =ᵐ[μ]
fun _ => μ.real (s j) := by
rw [Filtration.filtrationOfSet_eq_natural (β := ℝ) hsm]
refine (iIndepFun.condExp_natura... | theorem | Probability | [
"Mathlib.Probability.Martingale.BorelCantelli",
"Mathlib.Probability.ConditionalExpectation",
"Mathlib.Probability.Independence.Basic"
] | Mathlib/Probability/BorelCantelli.lean | iIndepSet.condExp_indicator_filtrationOfSet_ae_eq | null |
measure_limsup_eq_one {s : ℕ → Set Ω} (hsm : ∀ n, MeasurableSet (s n)) (hs : iIndepSet s μ)
(hs' : (∑' n, μ (s n)) = ∞) : μ (limsup s atTop) = 1 := by
have : IsProbabilityMeasure μ := hs.isProbabilityMeasure
rw [measure_congr (eventuallyEq_set.2 (ae_mem_limsup_atTop_iff μ <|
measurableSet_filtrationOfSet' h... | theorem | Probability | [
"Mathlib.Probability.Martingale.BorelCantelli",
"Mathlib.Probability.ConditionalExpectation",
"Mathlib.Probability.Independence.Basic"
] | Mathlib/Probability/BorelCantelli.lean | measure_limsup_eq_one | **The second Borel-Cantelli lemma**: Given a sequence of independent sets `(sₙ)` such that
`∑ n, μ sₙ = ∞`, `limsup sₙ` has measure 1. |
noncomputable
cdf (μ : Measure ℝ) : StieltjesFunction :=
condCDF ((dirac Unit.unit).prod μ) Unit.unit | def | Probability | [
"Mathlib.Probability.Kernel.Disintegration.CondCDF"
] | Mathlib/Probability/CDF.lean | cdf | Cumulative distribution function of a real measure. The definition currently makes sense only
for probability measures. In that case, it satisfies `cdf μ x = μ.real (Iic x)` (see
`ProbabilityTheory.cdf_eq_real`). |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.