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 ⌀ |
|---|---|---|---|---|---|---|
cofinite.blimsup_set_eq :
blimsup s cofinite p = { x | { n | p n ∧ x ∈ s n }.Infinite } := by
simp only [blimsup_eq, le_eq_subset, eventually_cofinite, not_forall, sInf_eq_sInter, exists_prop]
ext x
refine ⟨fun h => ?_, fun hx t h => ?_⟩ <;> contrapose! h
· simp only [mem_sInter, mem_setOf_eq, not_forall, e... | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | cofinite.blimsup_set_eq | null |
cofinite.bliminf_set_eq : bliminf s cofinite p = { x | { n | p n ∧ x ∉ s n }.Finite } := by
rw [← compl_inj_iff]
simp only [bliminf_eq_iSup_biInf, compl_iInf, compl_iSup, ← blimsup_eq_iInf_biSup,
cofinite.blimsup_set_eq]
rfl | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | cofinite.bliminf_set_eq | null |
cofinite.limsup_set_eq : limsup s cofinite = { x | { n | x ∈ s n }.Infinite } := by
simp only [← cofinite.blimsup_true s, cofinite.blimsup_set_eq, true_and] | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | cofinite.limsup_set_eq | In other words, `limsup cofinite s` is the set of elements lying inside the family `s`
infinitely often. |
cofinite.liminf_set_eq : liminf s cofinite = { x | { n | x ∉ s n }.Finite } := by
simp only [← cofinite.bliminf_true s, cofinite.bliminf_set_eq, true_and] | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | cofinite.liminf_set_eq | In other words, `liminf cofinite s` is the set of elements lying outside the family `s`
finitely often. |
exists_forall_mem_of_hasBasis_mem_blimsup {l : Filter β} {b : ι → Set β} {q : ι → Prop}
(hl : l.HasBasis q b) {u : β → Set α} {p : β → Prop} {x : α} (hx : x ∈ blimsup u l p) :
∃ f : { i | q i } → β, ∀ i, x ∈ u (f i) ∧ p (f i) ∧ f i ∈ b i := by
rw [blimsup_eq_iInf_biSup] at hx
simp only [iSup_eq_iUnion, iInf... | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | exists_forall_mem_of_hasBasis_mem_blimsup | null |
exists_forall_mem_of_hasBasis_mem_blimsup' {l : Filter β} {b : ι → Set β}
(hl : l.HasBasis (fun _ => True) b) {u : β → Set α} {p : β → Prop} {x : α}
(hx : x ∈ blimsup u l p) : ∃ f : ι → β, ∀ i, x ∈ u (f i) ∧ p (f i) ∧ f i ∈ b i := by
obtain ⟨f, hf⟩ := exists_forall_mem_of_hasBasis_mem_blimsup hl hx
exact ⟨f... | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | exists_forall_mem_of_hasBasis_mem_blimsup' | null |
frequently_lt_of_lt_limsSup {f : Filter α} [ConditionallyCompleteLinearOrder α] {a : α}
(hf : f.IsCobounded (· ≤ ·) := by isBoundedDefault)
(h : a < limsSup f) : ∃ᶠ n in f, a < n := by
contrapose! h
simp only [not_frequently, not_lt] at h
exact limsSup_le_of_le hf h | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | frequently_lt_of_lt_limsSup | null |
frequently_lt_of_limsInf_lt {f : Filter α} [ConditionallyCompleteLinearOrder α] {a : α}
(hf : f.IsCobounded (· ≥ ·) := by isBoundedDefault)
(h : limsInf f < a) : ∃ᶠ n in f, n < a :=
frequently_lt_of_lt_limsSup (α := OrderDual α) hf h | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | frequently_lt_of_limsInf_lt | null |
eventually_lt_of_lt_liminf {f : Filter α} [ConditionallyCompleteLinearOrder β] {u : α → β}
{b : β} (h : b < liminf u f)
(hu : f.IsBoundedUnder (· ≥ ·) u := by isBoundedDefault) :
∀ᶠ a in f, b < u a := by
obtain ⟨c, hc, hbc⟩ : ∃ (c : β) (_ : c ∈ { c : β | ∀ᶠ n : α in f, c ≤ u n }), b < c := by
simp_rw ... | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | eventually_lt_of_lt_liminf | null |
eventually_lt_of_limsup_lt {f : Filter α} [ConditionallyCompleteLinearOrder β] {u : α → β}
{b : β} (h : limsup u f < b)
(hu : f.IsBoundedUnder (· ≤ ·) u := by isBoundedDefault) :
∀ᶠ a in f, u a < b :=
eventually_lt_of_lt_liminf (β := βᵒᵈ) h hu | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | eventually_lt_of_limsup_lt | null |
eventually_lt_add_pos_of_limsup_le [Preorder β] [AddZeroClass α] [AddLeftStrictMono α]
{x ε : α} {u : β → α} (hu_bdd : IsBoundedUnder LE.le atTop u) (hu : Filter.limsup u atTop ≤ x)
(hε : 0 < ε) :
∀ᶠ b : β in atTop, u b < x + ε :=
eventually_lt_of_limsup_lt (lt_of_le_of_lt hu (lt_add_of_pos_right x hε)) h... | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | eventually_lt_add_pos_of_limsup_le | If `Filter.limsup u atTop ≤ x`, then for all `ε > 0`, eventually we have `u b < x + ε`. |
eventually_add_neg_lt_of_le_liminf [Preorder β] [AddZeroClass α] [AddLeftStrictMono α]
{x ε : α} {u : β → α} (hu_bdd : IsBoundedUnder GE.ge atTop u) (hu : x ≤ Filter.liminf u atTop)
(hε : ε < 0) :
∀ᶠ b : β in atTop, x + ε < u b :=
eventually_lt_of_lt_liminf (lt_of_lt_of_le (add_lt_of_neg_right x hε) hu) h... | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | eventually_add_neg_lt_of_le_liminf | If `x ≤ Filter.liminf u atTop`, then for all `ε < 0`, eventually we have `x + ε < u b`. |
exists_lt_of_limsup_le [AddZeroClass α] [AddLeftStrictMono α] {x ε : α} {u : ℕ → α}
(hu_bdd : IsBoundedUnder LE.le atTop u) (hu : Filter.limsup u atTop ≤ x) (hε : 0 < ε) :
∃ n : PNat, u n < x + ε := by
have h : ∀ᶠ n : ℕ in atTop, u n < x + ε := eventually_lt_add_pos_of_limsup_le hu_bdd hu hε
simp only [even... | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | exists_lt_of_limsup_le | If `Filter.limsup u atTop ≤ x`, then for all `ε > 0`, there exists a positive natural
number `n` such that `u n < x + ε`. |
exists_lt_of_le_liminf [AddZeroClass α] [AddLeftStrictMono α] {x ε : α} {u : ℕ → α}
(hu_bdd : IsBoundedUnder GE.ge atTop u) (hu : x ≤ Filter.liminf u atTop) (hε : ε < 0) :
∃ n : PNat, x + ε < u n := by
have h : ∀ᶠ n : ℕ in atTop, x + ε < u n := eventually_add_neg_lt_of_le_liminf hu_bdd hu hε
simp only [even... | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | exists_lt_of_le_liminf | If `x ≤ Filter.liminf u atTop`, then for all `ε < 0`, there exists a positive natural
number `n` such that ` x + ε < u n`. |
le_limsup_of_frequently_le {b : β} (hu_le : ∃ᶠ x in f, b ≤ u x)
(hu : f.IsBoundedUnder (· ≤ ·) u := by isBoundedDefault) :
b ≤ limsup u f := by
revert hu_le
rw [← not_imp_not, not_frequently]
simp_rw [← lt_iff_not_ge]
exact fun h => eventually_lt_of_limsup_lt h hu | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | le_limsup_of_frequently_le | null |
liminf_le_of_frequently_le {b : β} (hu_le : ∃ᶠ x in f, u x ≤ b)
(hu : f.IsBoundedUnder (· ≥ ·) u := by isBoundedDefault) :
liminf u f ≤ b :=
le_limsup_of_frequently_le (β := βᵒᵈ) hu_le hu | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | liminf_le_of_frequently_le | null |
frequently_lt_of_lt_limsup {b : β}
(hu : f.IsCoboundedUnder (· ≤ ·) u := by isBoundedDefault)
(h : b < limsup u f) : ∃ᶠ x in f, b < u x := by
contrapose! h
apply limsSup_le_of_le hu
simpa using h | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | frequently_lt_of_lt_limsup | null |
frequently_lt_of_liminf_lt {b : β}
(hu : f.IsCoboundedUnder (· ≥ ·) u := by isBoundedDefault)
(h : liminf u f < b) : ∃ᶠ x in f, u x < b :=
frequently_lt_of_lt_limsup (β := βᵒᵈ) hu h | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | frequently_lt_of_liminf_lt | null |
limsup_le_iff {x : β} (h₁ : f.IsCoboundedUnder (· ≤ ·) u := by isBoundedDefault)
(h₂ : f.IsBoundedUnder (· ≤ ·) u := by isBoundedDefault) :
limsup u f ≤ x ↔ ∀ y > x, ∀ᶠ a in f, u a < y := by
refine ⟨fun h _ h' ↦ eventually_lt_of_limsup_lt (h.trans_lt h') h₂, fun h ↦ ?_⟩
by_cases h' : ∀ y > x, ∃ z, x < z ∧ z... | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | limsup_le_iff | null |
limsup_le_iff' [DenselyOrdered β] {x : β}
(h₁ : IsCoboundedUnder (· ≤ ·) f u := by isBoundedDefault)
(h₂ : IsBoundedUnder (· ≤ ·) f u := by isBoundedDefault) :
limsup u f ≤ x ↔ ∀ y > x, ∀ᶠ (a : α) in f, u a ≤ y := by
refine ⟨fun h _ h' ↦ (eventually_lt_of_limsup_lt (h.trans_lt h') h₂).mono fun _ ↦ le_of_l... | lemma | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | limsup_le_iff' | null |
le_limsup_iff {x : β} (h₁ : f.IsCoboundedUnder (· ≤ ·) u := by isBoundedDefault)
(h₂ : f.IsBoundedUnder (· ≤ ·) u := by isBoundedDefault) :
x ≤ limsup u f ↔ ∀ y < x, ∃ᶠ a in f, y < u a := by
refine ⟨fun h _ h' ↦ frequently_lt_of_lt_limsup h₁ (h'.trans_le h), fun h ↦ ?_⟩
by_cases h' : ∀ y < x, ∃ z, y < z ∧ z... | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | le_limsup_iff | null |
le_limsup_iff' [DenselyOrdered β] {x : β}
(h₁ : f.IsCoboundedUnder (· ≤ ·) u := by isBoundedDefault)
(h₂ : f.IsBoundedUnder (· ≤ ·) u := by isBoundedDefault) :
x ≤ limsup u f ↔ ∀ y < x, ∃ᶠ a in f, y ≤ u a := by
refine ⟨fun h _ h' ↦ (frequently_lt_of_lt_limsup h₁ (h'.trans_le h)).mono fun _ ↦ le_of_lt, ?_⟩... | lemma | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | le_limsup_iff' | null |
le_liminf_iff {x : β} (h₁ : f.IsCoboundedUnder (· ≥ ·) u := by isBoundedDefault)
(h₂ : f.IsBoundedUnder (· ≥ ·) u := by isBoundedDefault) :
x ≤ liminf u f ↔ ∀ y < x, ∀ᶠ a in f, y < u a := limsup_le_iff (β := βᵒᵈ) h₁ h₂
/- A version of `le_liminf_iff` with large inequalities in densely ordered spaces.-/ | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | le_liminf_iff | null |
le_liminf_iff' [DenselyOrdered β] {x : β}
(h₁ : f.IsCoboundedUnder (· ≥ ·) u := by isBoundedDefault)
(h₂ : f.IsBoundedUnder (· ≥ ·) u := by isBoundedDefault) :
x ≤ liminf u f ↔ ∀ y < x, ∀ᶠ a in f, y ≤ u a := limsup_le_iff' (β := βᵒᵈ) h₁ h₂ | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | le_liminf_iff' | null |
liminf_le_iff {x : β} (h₁ : f.IsCoboundedUnder (· ≥ ·) u := by isBoundedDefault)
(h₂ : f.IsBoundedUnder (· ≥ ·) u := by isBoundedDefault) :
liminf u f ≤ x ↔ ∀ y > x, ∃ᶠ a in f, u a < y := le_limsup_iff (β := βᵒᵈ) h₁ h₂
/- A version of `liminf_le_iff` with large inequalities in densely ordered spaces.-/ | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | liminf_le_iff | null |
liminf_le_iff' [DenselyOrdered β] {x : β}
(h₁ : f.IsCoboundedUnder (· ≥ ·) u := by isBoundedDefault)
(h₂ : f.IsBoundedUnder (· ≥ ·) u := by isBoundedDefault) :
liminf u f ≤ x ↔ ∀ y > x, ∃ᶠ a in f, u a ≤ y := le_limsup_iff' (β := βᵒᵈ) h₁ h₂ | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | liminf_le_iff' | null |
liminf_le_limsup_of_frequently_le {v : α → β} (h : ∃ᶠ x in f, u x ≤ v x)
(h₁ : f.IsBoundedUnder (· ≥ ·) u := by isBoundedDefault)
(h₂ : f.IsBoundedUnder (· ≤ ·) v := by isBoundedDefault) :
liminf u f ≤ limsup v f := by
rcases f.eq_or_neBot with rfl | _
· exact (frequently_bot h).rec
have h₃ : f.IsCobo... | lemma | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | liminf_le_limsup_of_frequently_le | null |
lt_mem_sets_of_limsSup_lt (h : f.IsBounded (· ≤ ·)) (l : f.limsSup < b) :
∀ᶠ a in f, a < b :=
let ⟨c, (h : ∀ᶠ a in f, a ≤ c), hcb⟩ := exists_lt_of_csInf_lt h l
mem_of_superset h fun _a => hcb.trans_le' | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | lt_mem_sets_of_limsSup_lt | null |
gt_mem_sets_of_limsInf_gt : f.IsBounded (· ≥ ·) → b < f.limsInf → ∀ᶠ a in f, b < a :=
@lt_mem_sets_of_limsSup_lt αᵒᵈ _ _ _ | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | gt_mem_sets_of_limsInf_gt | null |
noncomputable liminf_reparam
(f : ι → α) (s : ι' → Set ι) (p : ι' → Prop) [Countable (Subtype p)] [Nonempty (Subtype p)]
(j : Subtype p) : Subtype p :=
let m : Set (Subtype p) := {j | BddBelow (range (fun (i : s j) ↦ f i))}
let g : ℕ → Subtype p := (exists_surjective_nat _).choose
have Z : ∃ n, g n ∈ m ∨ ... | def | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | liminf_reparam | Given an indexed family of sets `s j` over `j : Subtype p` and a function `f`, then
`liminf_reparam j` is equal to `j` if `f` is bounded below on `s j`, and otherwise to some
index `k` such that `f` is bounded below on `s k` (if there exists one).
To ensure good measurability behavior, this index `k` is chosen as the m... |
HasBasis.liminf_eq_ciSup_ciInf {v : Filter ι}
{p : ι' → Prop} {s : ι' → Set ι} [Countable (Subtype p)] [Nonempty (Subtype p)]
(hv : v.HasBasis p s) {f : ι → α} (hs : ∀ (j : Subtype p), (s j).Nonempty)
(H : ∃ (j : Subtype p), BddBelow (range (fun (i : s j) ↦ f i))) :
liminf f v = ⨆ (j : Subtype p), ⨅ (i ... | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | HasBasis.liminf_eq_ciSup_ciInf | Writing a liminf as a supremum of infimum, in a (possibly non-complete) conditionally complete
linear order. A reparametrization trick is needed to avoid taking the infimum of sets which are
not bounded below. |
HasBasis.liminf_eq_ite {v : Filter ι} {p : ι' → Prop} {s : ι' → Set ι}
[Countable (Subtype p)] [Nonempty (Subtype p)] (hv : v.HasBasis p s) (f : ι → α) :
liminf f v = if ∃ (j : Subtype p), s j = ∅ then sSup univ else
if ∀ (j : Subtype p), ¬BddBelow (range (fun (i : s j) ↦ f i)) then sSup ∅
else ⨆ (j... | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | HasBasis.liminf_eq_ite | Writing a liminf as a supremum of infimum, in a (possibly non-complete) conditionally complete
linear order. A reparametrization trick is needed to avoid taking the infimum of sets which are
not bounded below. |
noncomputable limsup_reparam
(f : ι → α) (s : ι' → Set ι) (p : ι' → Prop) [Countable (Subtype p)] [Nonempty (Subtype p)]
(j : Subtype p) : Subtype p :=
liminf_reparam (α := αᵒᵈ) f s p j | def | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | limsup_reparam | Given an indexed family of sets `s j` and a function `f`, then `limsup_reparam j` is equal
to `j` if `f` is bounded above on `s j`, and otherwise to some index `k` such that `f` is bounded
above on `s k` (if there exists one). To ensure good measurability behavior, this index `k` is
chosen as the minimal suitable index... |
HasBasis.limsup_eq_ciInf_ciSup {v : Filter ι}
{p : ι' → Prop} {s : ι' → Set ι} [Countable (Subtype p)] [Nonempty (Subtype p)]
(hv : v.HasBasis p s) {f : ι → α} (hs : ∀ (j : Subtype p), (s j).Nonempty)
(H : ∃ (j : Subtype p), BddAbove (range (fun (i : s j) ↦ f i))) :
limsup f v = ⨅ (j : Subtype p), ⨆ (i ... | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | HasBasis.limsup_eq_ciInf_ciSup | Writing a limsup as an infimum of supremum, in a (possibly non-complete) conditionally complete
linear order. A reparametrization trick is needed to avoid taking the supremum of sets which are
not bounded above. |
HasBasis.limsup_eq_ite {v : Filter ι} {p : ι' → Prop} {s : ι' → Set ι}
[Countable (Subtype p)] [Nonempty (Subtype p)] (hv : v.HasBasis p s) (f : ι → α) :
limsup f v = if ∃ (j : Subtype p), s j = ∅ then sInf univ else
if ∀ (j : Subtype p), ¬BddAbove (range (fun (i : s j) ↦ f i)) then sInf ∅
else ⨅ (j... | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | HasBasis.limsup_eq_ite | Writing a limsup as an infimum of supremum, in a (possibly non-complete) conditionally complete
linear order. A reparametrization trick is needed to avoid taking the supremum of sets which are
not bounded below. |
GaloisConnection.l_limsup_le [ConditionallyCompleteLattice β]
[ConditionallyCompleteLattice γ] {f : Filter α} {v : α → β} {l : β → γ} {u : γ → β}
(gc : GaloisConnection l u)
(hlv : f.IsBoundedUnder (· ≤ ·) fun x => l (v x) := by isBoundedDefault)
(hv_co : f.IsCoboundedUnder (· ≤ ·) v := by isBoundedDefa... | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | GaloisConnection.l_limsup_le | null |
OrderIso.limsup_apply {γ} [ConditionallyCompleteLattice β] [ConditionallyCompleteLattice γ]
{f : Filter α} {u : α → β} (g : β ≃o γ)
(hu : f.IsBoundedUnder (· ≤ ·) u := by isBoundedDefault)
(hu_co : f.IsCoboundedUnder (· ≤ ·) u := by isBoundedDefault)
(hgu : f.IsBoundedUnder (· ≤ ·) fun x => g (u x) := b... | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | OrderIso.limsup_apply | null |
OrderIso.liminf_apply {γ} [ConditionallyCompleteLattice β] [ConditionallyCompleteLattice γ]
{f : Filter α} {u : α → β} (g : β ≃o γ)
(hu : f.IsBoundedUnder (· ≥ ·) u := by isBoundedDefault)
(hu_co : f.IsCoboundedUnder (· ≥ ·) u := by isBoundedDefault)
(hgu : f.IsBoundedUnder (· ≥ ·) fun x => g (u x) := b... | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | OrderIso.liminf_apply | null |
limsup_max [ConditionallyCompleteLinearOrder β] {f : Filter α} {u v : α → β}
(h₁ : f.IsCoboundedUnder (· ≤ ·) u := by isBoundedDefault)
(h₂ : f.IsCoboundedUnder (· ≤ ·) v := by isBoundedDefault)
(h₃ : f.IsBoundedUnder (· ≤ ·) u := by isBoundedDefault)
(h₄ : f.IsBoundedUnder (· ≤ ·) v := by isBoundedDefa... | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | limsup_max | null |
liminf_min [ConditionallyCompleteLinearOrder β] {f : Filter α} {u v : α → β}
(h₁ : f.IsCoboundedUnder (· ≥ ·) u := by isBoundedDefault)
(h₂ : f.IsCoboundedUnder (· ≥ ·) v := by isBoundedDefault)
(h₃ : f.IsBoundedUnder (· ≥ ·) u := by isBoundedDefault)
(h₄ : f.IsBoundedUnder (· ≥ ·) v := by isBoundedDefa... | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | liminf_min | null |
limsup_finset_sup' [ConditionallyCompleteLinearOrder β] {f : Filter α}
{F : ι → α → β} {s : Finset ι} (hs : s.Nonempty)
(h₁ : ∀ i ∈ s, f.IsCoboundedUnder (· ≤ ·) (F i) := by exact fun _ _ ↦ by isBoundedDefault)
(h₂ : ∀ i ∈ s, f.IsBoundedUnder (· ≤ ·) (F i) := by exact fun _ _ ↦ by isBoundedDefault) :
li... | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | limsup_finset_sup' | null |
limsup_finset_sup [ConditionallyCompleteLinearOrder β] [OrderBot β] {f : Filter α}
{F : ι → α → β} {s : Finset ι}
(h₁ : ∀ i ∈ s, f.IsCoboundedUnder (· ≤ ·) (F i) := by exact fun _ _ ↦ by isBoundedDefault)
(h₂ : ∀ i ∈ s, f.IsBoundedUnder (· ≤ ·) (F i) := by exact fun _ _ ↦ by isBoundedDefault) :
limsup (... | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | limsup_finset_sup | null |
liminf_finset_inf' [ConditionallyCompleteLinearOrder β] {f : Filter α}
{F : ι → α → β} {s : Finset ι} (hs : s.Nonempty)
(h₁ : ∀ i ∈ s, f.IsCoboundedUnder (· ≥ ·) (F i) := by exact fun _ _ ↦ by isBoundedDefault)
(h₂ : ∀ i ∈ s, f.IsBoundedUnder (· ≥ ·) (F i) := by exact fun _ _ ↦ by isBoundedDefault) :
li... | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | liminf_finset_inf' | null |
liminf_finset_inf [ConditionallyCompleteLinearOrder β] [OrderTop β] {f : Filter α}
{F : ι → α → β} {s : Finset ι}
(h₁ : ∀ i ∈ s, f.IsCoboundedUnder (· ≥ ·) (F i) := by exact fun _ _ ↦ by isBoundedDefault)
(h₂ : ∀ i ∈ s, f.IsBoundedUnder (· ≥ ·) (F i) := by exact fun _ _ ↦ by isBoundedDefault) :
liminf (... | theorem | Order | [
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Filter.IsBounded",
"Mathlib.Order.Hom.CompleteLattice"
] | Mathlib/Order/LiminfLimsup.lean | liminf_finset_inf | null |
NoBotOrder (α : Type*) [LE α] : Prop where
/-- For each term `a`, there is some `b` which is either incomparable or strictly smaller. -/
exists_not_ge (a : α) : ∃ b, ¬a ≤ b | class | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | NoBotOrder | Order without bottom elements. |
NoTopOrder (α : Type*) [LE α] : Prop where
/-- For each term `a`, there is some `b` which is either incomparable or strictly larger. -/
exists_not_le (a : α) : ∃ b, ¬b ≤ a | class | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | NoTopOrder | Order without top elements. |
NoMinOrder (α : Type*) [LT α] : Prop where
/-- For each term `a`, there is some strictly smaller `b`. -/
exists_lt (a : α) : ∃ b, b < a | class | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | NoMinOrder | Order without minimal elements. Sometimes called coinitial or dense. |
NoMaxOrder (α : Type*) [LT α] : Prop where
/-- For each term `a`, there is some strictly greater `b`. -/
exists_gt (a : α) : ∃ b, a < b
export NoBotOrder (exists_not_ge)
export NoTopOrder (exists_not_le)
export NoMinOrder (exists_lt)
export NoMaxOrder (exists_gt) | class | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | NoMaxOrder | Order without maximal elements. Sometimes called cofinal. |
nonempty_lt [LT α] [NoMinOrder α] (a : α) : Nonempty { x // x < a } :=
nonempty_subtype.2 (exists_lt a) | instance | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | nonempty_lt | null |
nonempty_gt [LT α] [NoMaxOrder α] (a : α) : Nonempty { x // a < x } :=
nonempty_subtype.2 (exists_gt a) | instance | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | nonempty_gt | null |
IsEmpty.toNoMaxOrder [LT α] [IsEmpty α] : NoMaxOrder α := ⟨isEmptyElim⟩ | instance | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | IsEmpty.toNoMaxOrder | null |
IsEmpty.toNoMinOrder [LT α] [IsEmpty α] : NoMinOrder α := ⟨isEmptyElim⟩ | instance | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | IsEmpty.toNoMinOrder | null |
OrderDual.noBotOrder [LE α] [NoTopOrder α] : NoBotOrder αᵒᵈ :=
⟨fun a => exists_not_le (α := α) a⟩ | instance | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | OrderDual.noBotOrder | null |
OrderDual.noTopOrder [LE α] [NoBotOrder α] : NoTopOrder αᵒᵈ :=
⟨fun a => exists_not_ge (α := α) a⟩ | instance | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | OrderDual.noTopOrder | null |
OrderDual.noMinOrder [LT α] [NoMaxOrder α] : NoMinOrder αᵒᵈ :=
⟨fun a => exists_gt (α := α) a⟩ | instance | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | OrderDual.noMinOrder | null |
OrderDual.noMaxOrder [LT α] [NoMinOrder α] : NoMaxOrder αᵒᵈ :=
⟨fun a => exists_lt (α := α) a⟩ | instance | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | OrderDual.noMaxOrder | null |
noMaxOrder_of_left [Preorder α] [Preorder β] [NoMaxOrder α] : NoMaxOrder (α × β) :=
⟨fun ⟨a, b⟩ => by
obtain ⟨c, h⟩ := exists_gt a
exact ⟨(c, b), Prod.mk_lt_mk_iff_left.2 h⟩⟩ | instance | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | noMaxOrder_of_left | null |
noMaxOrder_of_right [Preorder α] [Preorder β] [NoMaxOrder β] : NoMaxOrder (α × β) :=
⟨fun ⟨a, b⟩ => by
obtain ⟨c, h⟩ := exists_gt b
exact ⟨(a, c), Prod.mk_lt_mk_iff_right.2 h⟩⟩ | instance | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | noMaxOrder_of_right | null |
noMinOrder_of_left [Preorder α] [Preorder β] [NoMinOrder α] : NoMinOrder (α × β) :=
⟨fun ⟨a, b⟩ => by
obtain ⟨c, h⟩ := exists_lt a
exact ⟨(c, b), Prod.mk_lt_mk_iff_left.2 h⟩⟩ | instance | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | noMinOrder_of_left | null |
noMinOrder_of_right [Preorder α] [Preorder β] [NoMinOrder β] : NoMinOrder (α × β) :=
⟨fun ⟨a, b⟩ => by
obtain ⟨c, h⟩ := exists_lt b
exact ⟨(a, c), Prod.mk_lt_mk_iff_right.2 h⟩⟩ | instance | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | noMinOrder_of_right | null |
NoBotOrder.to_noMinOrder (α : Type*) [LinearOrder α] [NoBotOrder α] : NoMinOrder α :=
{ exists_lt := fun a => by simpa [not_le] using exists_not_ge a } | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | NoBotOrder.to_noMinOrder | null |
NoTopOrder.to_noMaxOrder (α : Type*) [LinearOrder α] [NoTopOrder α] : NoMaxOrder α :=
{ exists_gt := fun a => by simpa [not_le] using exists_not_le a } | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | NoTopOrder.to_noMaxOrder | null |
noBotOrder_iff_noMinOrder (α : Type*) [LinearOrder α] : NoBotOrder α ↔ NoMinOrder α :=
⟨fun _ => NoBotOrder.to_noMinOrder α, fun _ => inferInstance⟩ | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | noBotOrder_iff_noMinOrder | null |
noTopOrder_iff_noMaxOrder (α : Type*) [LinearOrder α] : NoTopOrder α ↔ NoMaxOrder α :=
⟨fun _ => NoTopOrder.to_noMaxOrder α, fun _ => inferInstance⟩ | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | noTopOrder_iff_noMaxOrder | null |
NoMinOrder.not_acc [LT α] [NoMinOrder α] (a : α) : ¬Acc (· < ·) a := fun h =>
Acc.recOn h fun x _ => (exists_lt x).recOn | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | NoMinOrder.not_acc | null |
NoMaxOrder.not_acc [LT α] [NoMaxOrder α] (a : α) : ¬Acc (· > ·) a := fun h =>
Acc.recOn h fun x _ => (exists_gt x).recOn | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | NoMaxOrder.not_acc | null |
IsBot (a : α) : Prop :=
∀ b, a ≤ b | def | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | IsBot | `a : α` is a bottom element of `α` if it is less than or equal to any other element of `α`.
This predicate is roughly an unbundled version of `OrderBot`, except that a preorder may have
several bottom elements. When `α` is linear, this is useful to make a case disjunction on
`NoMinOrder α` within a proof. |
IsTop (a : α) : Prop :=
∀ b, b ≤ a | def | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | IsTop | `a : α` is a top element of `α` if it is greater than or equal to any other element of `α`.
This predicate is roughly an unbundled version of `OrderBot`, except that a preorder may have
several top elements. When `α` is linear, this is useful to make a case disjunction on
`NoMaxOrder α` within a proof. |
IsMin (a : α) : Prop :=
∀ ⦃b⦄, b ≤ a → a ≤ b | def | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | IsMin | `a` is a minimal element of `α` if no element is strictly less than it. We spell it without `<`
to avoid having to convert between `≤` and `<`. Instead, `isMin_iff_forall_not_lt` does the
conversion. |
IsMax (a : α) : Prop :=
∀ ⦃b⦄, a ≤ b → b ≤ a
@[simp] | def | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | IsMax | `a` is a maximal element of `α` if no element is strictly greater than it. We spell it without
`<` to avoid having to convert between `≤` and `<`. Instead, `isMax_iff_forall_not_lt` does the
conversion. |
not_isBot [NoBotOrder α] (a : α) : ¬IsBot a := fun h =>
let ⟨_, hb⟩ := exists_not_ge a
hb <| h _
@[simp] | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | not_isBot | null |
not_isTop [NoTopOrder α] (a : α) : ¬IsTop a := fun h =>
let ⟨_, hb⟩ := exists_not_le a
hb <| h _ | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | not_isTop | null |
protected IsBot.isMin (h : IsBot a) : IsMin a := fun b _ => h b | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | IsBot.isMin | null |
protected IsTop.isMax (h : IsTop a) : IsMax a := fun b _ => h b | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | IsTop.isMax | null |
IsTop.isMax_iff {α} [PartialOrder α] {i j : α} (h : IsTop i) : IsMax j ↔ j = i := by
simp_rw [le_antisymm_iff, h j, true_and]
exact ⟨(· (h j)), Function.swap (fun _ ↦ h · |>.trans ·)⟩ | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | IsTop.isMax_iff | null |
IsBot.isMin_iff {α} [PartialOrder α] {i j : α} (h : IsBot i) : IsMin j ↔ j = i := by
simp_rw [le_antisymm_iff, h j, and_true]
exact ⟨fun a ↦ a (h j), fun a h' ↦ fun _ ↦ Preorder.le_trans j i h' a (h h')⟩
@[simp] | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | IsBot.isMin_iff | null |
isBot_toDual_iff : IsBot (toDual a) ↔ IsTop a :=
Iff.rfl
@[simp] | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | isBot_toDual_iff | null |
isTop_toDual_iff : IsTop (toDual a) ↔ IsBot a :=
Iff.rfl
@[simp] | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | isTop_toDual_iff | null |
isMin_toDual_iff : IsMin (toDual a) ↔ IsMax a :=
Iff.rfl
@[simp] | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | isMin_toDual_iff | null |
isMax_toDual_iff : IsMax (toDual a) ↔ IsMin a :=
Iff.rfl
@[simp] | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | isMax_toDual_iff | null |
isBot_ofDual_iff {a : αᵒᵈ} : IsBot (ofDual a) ↔ IsTop a :=
Iff.rfl
@[simp] | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | isBot_ofDual_iff | null |
isTop_ofDual_iff {a : αᵒᵈ} : IsTop (ofDual a) ↔ IsBot a :=
Iff.rfl
@[simp] | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | isTop_ofDual_iff | null |
isMin_ofDual_iff {a : αᵒᵈ} : IsMin (ofDual a) ↔ IsMax a :=
Iff.rfl
@[simp] | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | isMin_ofDual_iff | null |
isMax_ofDual_iff {a : αᵒᵈ} : IsMax (ofDual a) ↔ IsMin a :=
Iff.rfl
alias ⟨_, IsTop.toDual⟩ := isBot_toDual_iff
alias ⟨_, IsBot.toDual⟩ := isTop_toDual_iff
alias ⟨_, IsMax.toDual⟩ := isMin_toDual_iff
alias ⟨_, IsMin.toDual⟩ := isMax_toDual_iff
alias ⟨_, IsTop.ofDual⟩ := isBot_ofDual_iff
alias ⟨_, IsBot.ofDual⟩ := isTo... | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | isMax_ofDual_iff | null |
IsBot.mono (ha : IsBot a) (h : b ≤ a) : IsBot b := fun _ => h.trans <| ha _ | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | IsBot.mono | null |
IsTop.mono (ha : IsTop a) (h : a ≤ b) : IsTop b := fun _ => (ha _).trans h | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | IsTop.mono | null |
IsMin.mono (ha : IsMin a) (h : b ≤ a) : IsMin b := fun _ hc => h.trans <| ha <| hc.trans h | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | IsMin.mono | null |
IsMax.mono (ha : IsMax a) (h : a ≤ b) : IsMax b := fun _ hc => (ha <| h.trans hc).trans h | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | IsMax.mono | null |
IsMin.not_lt (h : IsMin a) : ¬b < a := fun hb => hb.not_ge <| h hb.le | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | IsMin.not_lt | null |
IsMax.not_lt (h : IsMax a) : ¬a < b := fun hb => hb.not_ge <| h hb.le | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | IsMax.not_lt | null |
not_isMin_of_lt (h : b < a) : ¬IsMin a := fun ha => ha.not_lt h | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | not_isMin_of_lt | null |
not_isMax_of_lt (h : a < b) : ¬IsMax a := fun ha => ha.not_lt h
alias LT.lt.not_isMin := not_isMin_of_lt
alias LT.lt.not_isMax := not_isMax_of_lt | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | not_isMax_of_lt | null |
isMin_iff_forall_not_lt : IsMin a ↔ ∀ b, ¬b < a :=
⟨fun h _ => h.not_lt, fun h _ hba => of_not_not fun hab => h _ <| hba.lt_of_not_ge hab⟩ | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | isMin_iff_forall_not_lt | null |
isMax_iff_forall_not_lt : IsMax a ↔ ∀ b, ¬a < b :=
⟨fun h _ => h.not_lt, fun h _ hba => of_not_not fun hab => h _ <| hba.lt_of_not_ge hab⟩
@[simp] | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | isMax_iff_forall_not_lt | null |
not_isMin_iff : ¬IsMin a ↔ ∃ b, b < a := by
simp [lt_iff_le_not_ge, IsMin, not_forall]
@[simp] | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | not_isMin_iff | null |
not_isMax_iff : ¬IsMax a ↔ ∃ b, a < b := by
simp [lt_iff_le_not_ge, IsMax, not_forall]
@[simp] | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | not_isMax_iff | null |
not_isMin [NoMinOrder α] (a : α) : ¬IsMin a :=
not_isMin_iff.2 <| exists_lt a
@[simp] | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | not_isMin | null |
not_isMax [NoMaxOrder α] (a : α) : ¬IsMax a :=
not_isMax_iff.2 <| exists_gt a | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | not_isMax | null |
protected isBot (a : α) : IsBot a := fun _ => (Subsingleton.elim _ _).le | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | isBot | null |
protected isTop (a : α) : IsTop a := fun _ => (Subsingleton.elim _ _).le | theorem | Order | [
"Mathlib.Order.Synonym"
] | Mathlib/Order/Max.lean | isTop | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.