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 ⌀ |
|---|---|---|---|---|---|---|
max_def' (a b : α) : max a b = if b ≤ a then a else b := by
rw [max_def]
rcases lt_trichotomy a b with (lt | eq | gt)
· rw [if_pos lt.le, if_neg (not_le.mpr lt)]
· rw [if_pos eq.le, if_pos eq.ge, eq]
· rw [if_neg (not_le.mpr gt.gt), if_pos gt.le]
@[deprecated (since := "2025-05-11")] alias lt_of_not_le := lt_... | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | max_def' | null |
Ne.lt_or_gt (h : a ≠ b) : a < b ∨ b < a :=
lt_or_gt_of_ne h
@[deprecated (since := "2025-06-07")] alias Ne.lt_or_lt := Ne.lt_or_gt | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | Ne.lt_or_gt | null |
@[simp]
lt_or_lt_iff_ne : a < b ∨ b < a ↔ a ≠ b :=
ne_iff_lt_or_gt.symm | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | lt_or_lt_iff_ne | A version of `ne_iff_lt_or_gt` with LHS and RHS reversed. |
not_lt_iff_eq_or_lt : ¬a < b ↔ a = b ∨ b < a :=
not_lt.trans <| Decidable.le_iff_eq_or_lt.trans <| or_congr eq_comm Iff.rfl | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | not_lt_iff_eq_or_lt | null |
exists_ge_of_linear (a b : α) : ∃ c, a ≤ c ∧ b ≤ c :=
match le_total a b with
| Or.inl h => ⟨_, h, le_rfl⟩
| Or.inr h => ⟨_, le_rfl, h⟩ | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | exists_ge_of_linear | null |
exists_forall_ge_and {p q : α → Prop} :
(∃ i, ∀ j ≥ i, p j) → (∃ i, ∀ j ≥ i, q j) → ∃ i, ∀ j ≥ i, p j ∧ q j
| ⟨a, ha⟩, ⟨b, hb⟩ =>
let ⟨c, hac, hbc⟩ := exists_ge_of_linear a b
⟨c, fun _d hcd ↦ ⟨ha _ <| hac.trans hcd, hb _ <| hbc.trans hcd⟩⟩ | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | exists_forall_ge_and | null |
le_of_forall_lt (H : ∀ c, c < a → c < b) : a ≤ b :=
le_of_not_gt fun h ↦ lt_irrefl _ (H _ h) | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | le_of_forall_lt | null |
forall_lt_iff_le : (∀ ⦃c⦄, c < a → c < b) ↔ a ≤ b :=
⟨le_of_forall_lt, fun h _ hca ↦ lt_of_lt_of_le hca h⟩ | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | forall_lt_iff_le | null |
le_of_forall_gt (H : ∀ c, a < c → b < c) : b ≤ a :=
le_of_not_gt fun h ↦ lt_irrefl _ (H _ h) | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | le_of_forall_gt | null |
forall_gt_iff_le : (∀ ⦃c⦄, a < c → b < c) ↔ b ≤ a :=
⟨le_of_forall_gt, fun h _ hac ↦ lt_of_le_of_lt h hac⟩
@[deprecated (since := "2025-06-07")] alias le_of_forall_lt' := le_of_forall_gt
@[deprecated (since := "2025-06-07")] alias forall_lt_iff_le' := forall_gt_iff_le | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | forall_gt_iff_le | null |
eq_of_forall_lt_iff (h : ∀ c, c < a ↔ c < b) : a = b :=
(le_of_forall_lt fun _ ↦ (h _).1).antisymm <| le_of_forall_lt fun _ ↦ (h _).2 | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | eq_of_forall_lt_iff | null |
eq_of_forall_gt_iff (h : ∀ c, a < c ↔ b < c) : a = b :=
(le_of_forall_gt fun _ ↦ (h _).2).antisymm <| le_of_forall_gt fun _ ↦ (h _).1 | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | eq_of_forall_gt_iff | null |
@[deprecated lt_trichotomy (since := "2025-04-21")]
ltByCases_lt (h : x < y) {h₁ : x < y → P} {h₂ : x = y → P} {h₃ : y < x → P} :
ltByCases x y h₁ h₂ h₃ = h₁ h := dif_pos h
set_option linter.deprecated false in
@[deprecated lt_trichotomy (since := "2025-04-21")] | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | ltByCases_lt | null |
ltByCases_gt (h : y < x) {h₁ : x < y → P} {h₂ : x = y → P} {h₃ : y < x → P} :
ltByCases x y h₁ h₂ h₃ = h₃ h := (dif_neg h.not_gt).trans (dif_pos h)
set_option linter.deprecated false in
@[deprecated lt_trichotomy (since := "2025-04-21")] | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | ltByCases_gt | null |
ltByCases_eq (h : x = y) {h₁ : x < y → P} {h₂ : x = y → P} {h₃ : y < x → P} :
ltByCases x y h₁ h₂ h₃ = h₂ h := (dif_neg h.not_lt).trans (dif_neg h.not_gt)
set_option linter.deprecated false in
@[deprecated lt_trichotomy (since := "2025-04-21")] | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | ltByCases_eq | null |
ltByCases_not_lt (h : ¬ x < y) {h₁ : x < y → P} {h₂ : x = y → P} {h₃ : y < x → P}
(p : ¬ y < x → x = y := fun h' => (le_antisymm (le_of_not_gt h') (le_of_not_gt h))) :
ltByCases x y h₁ h₂ h₃ = if h' : y < x then h₃ h' else h₂ (p h') := dif_neg h
set_option linter.deprecated false in
@[deprecated lt_trichotomy (... | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | ltByCases_not_lt | null |
ltByCases_not_gt (h : ¬ y < x) {h₁ : x < y → P} {h₂ : x = y → P} {h₃ : y < x → P}
(p : ¬ x < y → x = y := fun h' => (le_antisymm (le_of_not_gt h) (le_of_not_gt h'))) :
ltByCases x y h₁ h₂ h₃ = if h' : x < y then h₁ h' else h₂ (p h') :=
dite_congr rfl (fun _ => rfl) (fun _ => dif_neg h)
set_option linter.depre... | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | ltByCases_not_gt | null |
ltByCases_ne (h : x ≠ y) {h₁ : x < y → P} {h₂ : x = y → P} {h₃ : y < x → P}
(p : ¬ x < y → y < x := fun h' => h.lt_or_gt.resolve_left h') :
ltByCases x y h₁ h₂ h₃ = if h' : x < y then h₁ h' else h₃ (p h') :=
dite_congr rfl (fun _ => rfl) (fun _ => dif_pos _)
set_option linter.deprecated false in
@[deprecated ... | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | ltByCases_ne | null |
ltByCases_comm {h₁ : x < y → P} {h₂ : x = y → P} {h₃ : y < x → P}
(p : y = x → x = y := fun h' => h'.symm) :
ltByCases x y h₁ h₂ h₃ = ltByCases y x h₃ (h₂ ∘ p) h₁ := by
refine ltByCases x y (fun h => ?_) (fun h => ?_) (fun h => ?_)
· rw [ltByCases_lt h, ltByCases_gt h]
· rw [ltByCases_eq h, ltByCases_eq h... | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | ltByCases_comm | null |
eq_iff_eq_of_lt_iff_lt_of_gt_iff_gt {x' y' : α}
(ltc : (x < y) ↔ (x' < y')) (gtc : (y < x) ↔ (y' < x')) :
x = y ↔ x' = y' := by simp_rw [eq_iff_le_not_lt, ← not_lt, ltc, gtc]
set_option linter.deprecated false in
@[deprecated lt_trichotomy (since := "2025-04-21")] | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | eq_iff_eq_of_lt_iff_lt_of_gt_iff_gt | null |
ltByCases_rec {h₁ : x < y → P} {h₂ : x = y → P} {h₃ : y < x → P} (p : P)
(hlt : (h : x < y) → h₁ h = p) (heq : (h : x = y) → h₂ h = p)
(hgt : (h : y < x) → h₃ h = p) :
ltByCases x y h₁ h₂ h₃ = p :=
ltByCases x y
(fun h => ltByCases_lt h ▸ hlt h)
(fun h => ltByCases_eq h ▸ heq h)
(fun h => ltBy... | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | ltByCases_rec | null |
ltByCases_eq_iff {h₁ : x < y → P} {h₂ : x = y → P} {h₃ : y < x → P} {p : P} :
ltByCases x y h₁ h₂ h₃ = p ↔ (∃ h, h₁ h = p) ∨ (∃ h, h₂ h = p) ∨ (∃ h, h₃ h = p) := by
refine ltByCases x y (fun h => ?_) (fun h => ?_) (fun h => ?_)
· simp only [ltByCases_lt, exists_prop_of_true, h, h.not_gt, not_false_eq_true,
... | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | ltByCases_eq_iff | null |
ltByCases_congr {x' y' : α} {h₁ : x < y → P} {h₂ : x = y → P} {h₃ : y < x → P}
{h₁' : x' < y' → P} {h₂' : x' = y' → P} {h₃' : y' < x' → P} (ltc : (x < y) ↔ (x' < y'))
(gtc : (y < x) ↔ (y' < x')) (hh'₁ : ∀ (h : x' < y'), h₁ (ltc.mpr h) = h₁' h)
(hh'₂ : ∀ (h : x' = y'), h₂ ((eq_iff_eq_of_lt_iff_lt_of_gt_iff_g... | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | ltByCases_congr | null |
@[deprecated lt_trichotomy (since := "2025-04-21")]
ltTrichotomy (x y : α) (p q r : P) := ltByCases x y (fun _ => p) (fun _ => q) (fun _ => r)
variable {p q r s : P}
set_option linter.deprecated false in
@[deprecated lt_trichotomy (since := "2025-04-21")] | abbrev | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | ltTrichotomy | Perform a case-split on the ordering of `x` and `y` in a decidable linear order,
non-dependently. |
ltTrichotomy_lt (h : x < y) : ltTrichotomy x y p q r = p := ltByCases_lt h
set_option linter.deprecated false in
@[deprecated lt_trichotomy (since := "2025-04-21")] | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | ltTrichotomy_lt | null |
ltTrichotomy_gt (h : y < x) : ltTrichotomy x y p q r = r := ltByCases_gt h
set_option linter.deprecated false in
@[deprecated lt_trichotomy (since := "2025-04-21")] | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | ltTrichotomy_gt | null |
ltTrichotomy_eq (h : x = y) : ltTrichotomy x y p q r = q := ltByCases_eq h
set_option linter.deprecated false in
@[deprecated lt_trichotomy (since := "2025-04-21")] | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | ltTrichotomy_eq | null |
ltTrichotomy_not_lt (h : ¬ x < y) :
ltTrichotomy x y p q r = if y < x then r else q := ltByCases_not_lt h
set_option linter.deprecated false in
@[deprecated lt_trichotomy (since := "2025-04-21")] | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | ltTrichotomy_not_lt | null |
ltTrichotomy_not_gt (h : ¬ y < x) :
ltTrichotomy x y p q r = if x < y then p else q := ltByCases_not_gt h
set_option linter.deprecated false in
@[deprecated lt_trichotomy (since := "2025-04-21")] | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | ltTrichotomy_not_gt | null |
ltTrichotomy_ne (h : x ≠ y) :
ltTrichotomy x y p q r = if x < y then p else r := ltByCases_ne h
set_option linter.deprecated false in
@[deprecated lt_trichotomy (since := "2025-04-21")] | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | ltTrichotomy_ne | null |
ltTrichotomy_comm : ltTrichotomy x y p q r = ltTrichotomy y x r q p := ltByCases_comm
set_option linter.deprecated false in
@[deprecated lt_trichotomy (since := "2025-04-21")] | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | ltTrichotomy_comm | null |
ltTrichotomy_self {p : P} : ltTrichotomy x y p p p = p :=
ltByCases_rec p (fun _ => rfl) (fun _ => rfl) (fun _ => rfl)
set_option linter.deprecated false in
@[deprecated lt_trichotomy (since := "2025-04-21")] | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | ltTrichotomy_self | null |
ltTrichotomy_eq_iff : ltTrichotomy x y p q r = s ↔
(x < y ∧ p = s) ∨ (x = y ∧ q = s) ∨ (y < x ∧ r = s) := by
refine ltByCases x y (fun h => ?_) (fun h => ?_) (fun h => ?_)
· simp only [ltTrichotomy_lt, false_and, true_and, or_false, h, h.not_gt, h.ne]
· simp only [ltTrichotomy_eq, false_and, true_and, or_fals... | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | ltTrichotomy_eq_iff | null |
ltTrichotomy_congr {x' y' : α} {p' q' r' : P} (ltc : (x < y) ↔ (x' < y'))
(gtc : (y < x) ↔ (y' < x')) (hh'₁ : x' < y' → p = p')
(hh'₂ : x' = y' → q = q') (hh'₃ : y' < x' → r = r') :
ltTrichotomy x y p q r = ltTrichotomy x' y' p' q' r' :=
ltByCases_congr ltc gtc hh'₁ hh'₂ hh'₃ | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | ltTrichotomy_congr | null |
min_rec (ha : a ≤ b → p a) (hb : b ≤ a → p b) : p (min a b) := by
obtain hab | hba := le_total a b <;> simp [min_eq_left, min_eq_right, *] | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | min_rec | null |
max_rec (ha : b ≤ a → p a) (hb : a ≤ b → p b) : p (max a b) := by
obtain hab | hba := le_total a b <;> simp [max_eq_left, max_eq_right, *] | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | max_rec | null |
min_rec' (p : α → Prop) (ha : p a) (hb : p b) : p (min a b) :=
min_rec (fun _ ↦ ha) fun _ ↦ hb | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | min_rec' | null |
max_rec' (p : α → Prop) (ha : p a) (hb : p b) : p (max a b) :=
max_rec (fun _ ↦ ha) fun _ ↦ hb | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | max_rec' | null |
min_def_lt (a b : α) : min a b = if a < b then a else b := by
rw [min_comm, min_def, ← ite_not]; simp only [not_le] | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | min_def_lt | null |
max_def_lt (a b : α) : max a b = if a < b then b else a := by
rw [max_comm, max_def, ← ite_not]; simp only [not_le] | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | max_def_lt | null |
lt_imp_lt_of_le_imp_le {β} [LinearOrder α] [Preorder β] {a b : α} {c d : β}
(H : a ≤ b → c ≤ d) (h : d < c) : b < a :=
lt_of_not_ge fun h' ↦ (H h').not_gt h | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | lt_imp_lt_of_le_imp_le | null |
le_imp_le_iff_lt_imp_lt {β} [LinearOrder α] [LinearOrder β] {a b : α} {c d : β} :
a ≤ b → c ≤ d ↔ d < c → b < a :=
⟨lt_imp_lt_of_le_imp_le, le_imp_le_of_lt_imp_lt⟩ | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | le_imp_le_iff_lt_imp_lt | null |
lt_iff_lt_of_le_iff_le' {β} [Preorder α] [Preorder β] {a b : α} {c d : β}
(H : a ≤ b ↔ c ≤ d) (H' : b ≤ a ↔ d ≤ c) : b < a ↔ d < c :=
lt_iff_le_not_ge.trans <| (and_congr H' (not_congr H)).trans lt_iff_le_not_ge.symm | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | lt_iff_lt_of_le_iff_le' | null |
lt_iff_lt_of_le_iff_le {β} [LinearOrder α] [LinearOrder β] {a b : α} {c d : β}
(H : a ≤ b ↔ c ≤ d) : b < a ↔ d < c := not_le.symm.trans <| (not_congr H).trans <| not_le | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | lt_iff_lt_of_le_iff_le | null |
le_iff_le_iff_lt_iff_lt {β} [LinearOrder α] [LinearOrder β] {a b : α} {c d : β} :
(a ≤ b ↔ c ≤ d) ↔ (b < a ↔ d < c) :=
⟨lt_iff_lt_of_le_iff_le, fun H ↦ not_lt.symm.trans <| (not_congr H).trans <| not_lt⟩ | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | le_iff_le_iff_lt_iff_lt | null |
rel_imp_eq_of_rel_imp_le [PartialOrder β] (r : α → α → Prop) [IsSymm α r] {f : α → β}
(h : ∀ a b, r a b → f a ≤ f b) {a b : α} : r a b → f a = f b := fun hab ↦
le_antisymm (h a b hab) (h b a <| symm hab)
/-! ### Extensionality lemmas -/
@[ext] | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | rel_imp_eq_of_rel_imp_le | A symmetric relation implies two values are equal, when it implies they're less-equal. |
Preorder.toLE_injective : Function.Injective (@Preorder.toLE α) :=
fun
| { lt := A_lt, lt_iff_le_not_ge := A_iff, .. },
{ lt := B_lt, lt_iff_le_not_ge := B_iff, .. } => by
rintro ⟨⟩
have : A_lt = B_lt := by
funext a b
rw [A_iff, B_iff]
cases this
congr
@[ext] | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | Preorder.toLE_injective | null |
PartialOrder.toPreorder_injective : Function.Injective (@PartialOrder.toPreorder α) := by
rintro ⟨⟩ ⟨⟩ ⟨⟩; congr
@[ext] | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | PartialOrder.toPreorder_injective | null |
LinearOrder.toPartialOrder_injective : Function.Injective (@LinearOrder.toPartialOrder α) :=
fun
| { le := A_le, lt := A_lt,
toDecidableLE := A_decidableLE, toDecidableEq := A_decidableEq, toDecidableLT := A_decidableLT
min := A_min, max := A_max, min_def := A_min_def, max_def := A_max_def,
compar... | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | LinearOrder.toPartialOrder_injective | null |
Preorder.ext {A B : Preorder α} (H : ∀ x y : α, (haveI := A; x ≤ y) ↔ x ≤ y) : A = B := by
ext x y; exact H x y | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | Preorder.ext | null |
PartialOrder.ext {A B : PartialOrder α} (H : ∀ x y : α, (haveI := A; x ≤ y) ↔ x ≤ y) :
A = B := by ext x y; exact H x y | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | PartialOrder.ext | null |
PartialOrder.ext_lt {A B : PartialOrder α} (H : ∀ x y : α, (haveI := A; x < y) ↔ x < y) :
A = B := by ext x y; rw [le_iff_lt_or_eq, @le_iff_lt_or_eq _ A, H] | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | PartialOrder.ext_lt | null |
LinearOrder.ext {A B : LinearOrder α} (H : ∀ x y : α, (haveI := A; x ≤ y) ↔ x ≤ y) :
A = B := by ext x y; exact H x y | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | LinearOrder.ext | null |
LinearOrder.ext_lt {A B : LinearOrder α} (H : ∀ x y : α, (haveI := A; x < y) ↔ x < y) :
A = B := LinearOrder.toPartialOrder_injective (PartialOrder.ext_lt H)
/-! ### Order dual -/ | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | LinearOrder.ext_lt | null |
OrderDual (α : Type*) : Type _ :=
α
@[inherit_doc]
notation:max α "ᵒᵈ" => OrderDual α | def | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | OrderDual | Type synonym to equip a type with the dual order: `≤` means `≥` and `<` means `>`. `αᵒᵈ` is
notation for `OrderDual α`. |
instOrd (α : Type*) [Ord α] : Ord αᵒᵈ where
compare := fun (a b : α) ↦ compare b a | instance | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | instOrd | null |
instSup (α : Type*) [Min α] : Max αᵒᵈ :=
⟨((· ⊓ ·) : α → α → α)⟩ | instance | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | instSup | null |
instInf (α : Type*) [Max α] : Min αᵒᵈ :=
⟨((· ⊔ ·) : α → α → α)⟩ | instance | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | instInf | null |
instIsTransLE [LE α] [T : IsTrans α LE.le] : IsTrans αᵒᵈ LE.le where
trans := fun _ _ _ hab hbc ↦ T.trans _ _ _ hbc hab | instance | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | instIsTransLE | null |
instIsTransLT [LT α] [T : IsTrans α LT.lt] : IsTrans αᵒᵈ LT.lt where
trans := fun _ _ _ hab hbc ↦ T.trans _ _ _ hbc hab | instance | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | instIsTransLT | null |
instPreorder (α : Type*) [Preorder α] : Preorder αᵒᵈ where
le_refl := fun _ ↦ le_refl _
le_trans := fun _ _ _ hab hbc ↦ hbc.trans hab
lt_iff_le_not_ge := fun _ _ ↦ lt_iff_le_not_ge | instance | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | instPreorder | null |
instPartialOrder (α : Type*) [PartialOrder α] : PartialOrder αᵒᵈ where
__ := inferInstanceAs (Preorder αᵒᵈ)
le_antisymm := fun a b hab hba ↦ @le_antisymm α _ a b hba hab | instance | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | instPartialOrder | null |
instLinearOrder (α : Type*) [LinearOrder α] : LinearOrder αᵒᵈ where
__ := inferInstanceAs (PartialOrder αᵒᵈ)
__ := inferInstanceAs (Ord αᵒᵈ)
le_total := fun a b : α ↦ le_total b a
max := fun a b ↦ (min a b : α)
min := fun a b ↦ (max a b : α)
min_def := fun a b ↦ show (max .. : α) = _ by rw [max_comm, max_de... | instance | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | instLinearOrder | null |
_root_.LinearOrder.swap (α : Type*) (_ : LinearOrder α) : LinearOrder α :=
inferInstanceAs <| LinearOrder (OrderDual α) | def | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | _root_.LinearOrder.swap | The opposite linear order to a given linear order |
Ord.dual_dual (α : Type*) [H : Ord α] : OrderDual.instOrd αᵒᵈ = H :=
rfl | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | Ord.dual_dual | null |
Preorder.dual_dual (α : Type*) [H : Preorder α] : OrderDual.instPreorder αᵒᵈ = H :=
rfl | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | Preorder.dual_dual | null |
instPartialOrder.dual_dual (α : Type*) [H : PartialOrder α] :
OrderDual.instPartialOrder αᵒᵈ = H :=
rfl | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | instPartialOrder.dual_dual | null |
instLinearOrder.dual_dual (α : Type*) [H : LinearOrder α] :
OrderDual.instLinearOrder αᵒᵈ = H :=
rfl | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | instLinearOrder.dual_dual | null |
Prop.hasCompl : HasCompl Prop :=
⟨Not⟩ | instance | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | Prop.hasCompl | null |
Pi.hasCompl [∀ i, HasCompl (π i)] : HasCompl (∀ i, π i) :=
⟨fun x i ↦ (x i)ᶜ⟩ | instance | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | Pi.hasCompl | null |
Pi.compl_def [∀ i, HasCompl (π i)] (x : ∀ i, π i) :
xᶜ = fun i ↦ (x i)ᶜ :=
rfl
@[simp] | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | Pi.compl_def | null |
Pi.compl_apply [∀ i, HasCompl (π i)] (x : ∀ i, π i) (i : ι) :
xᶜ i = (x i)ᶜ :=
rfl | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | Pi.compl_apply | null |
IsIrrefl.compl (r) [IsIrrefl α r] : IsRefl α rᶜ :=
⟨@irrefl α r _⟩ | instance | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | IsIrrefl.compl | null |
IsRefl.compl (r) [IsRefl α r] : IsIrrefl α rᶜ :=
⟨fun a ↦ not_not_intro (refl a)⟩ | instance | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | IsRefl.compl | null |
compl_lt [LinearOrder α] : (· < · : α → α → _)ᶜ = (· ≥ ·) := by simp [compl] | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | compl_lt | null |
compl_le [LinearOrder α] : (· ≤ · : α → α → _)ᶜ = (· > ·) := by simp [compl] | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | compl_le | null |
compl_gt [LinearOrder α] : (· > · : α → α → _)ᶜ = (· ≤ ·) := by simp [compl] | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | compl_gt | null |
compl_ge [LinearOrder α] : (· ≥ · : α → α → _)ᶜ = (· < ·) := by simp [compl] | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | compl_ge | null |
Ne.instIsEquiv_compl : IsEquiv α (· ≠ ·)ᶜ := by
convert eq_isEquiv α
simp [compl]
/-! ### Order instances on the function space -/ | instance | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | Ne.instIsEquiv_compl | null |
Pi.hasLe [∀ i, LE (π i)] :
LE (∀ i, π i) where le x y := ∀ i, x i ≤ y i | instance | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | Pi.hasLe | null |
Pi.le_def [∀ i, LE (π i)] {x y : ∀ i, π i} :
x ≤ y ↔ ∀ i, x i ≤ y i :=
Iff.rfl | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | Pi.le_def | null |
Pi.preorder [∀ i, Preorder (π i)] : Preorder (∀ i, π i) where
__ := inferInstanceAs (LE (∀ i, π i))
le_refl := fun a i ↦ le_refl (a i)
le_trans := fun _ _ _ h₁ h₂ i ↦ le_trans (h₁ i) (h₂ i) | instance | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | Pi.preorder | null |
Pi.lt_def [∀ i, Preorder (π i)] {x y : ∀ i, π i} :
x < y ↔ x ≤ y ∧ ∃ i, x i < y i := by
simp +contextual [lt_iff_le_not_ge, Pi.le_def] | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | Pi.lt_def | null |
Pi.partialOrder [∀ i, PartialOrder (π i)] : PartialOrder (∀ i, π i) where
__ := Pi.preorder
le_antisymm := fun _ _ h1 h2 ↦ funext fun b ↦ (h1 b).antisymm (h2 b) | instance | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | Pi.partialOrder | null |
@[simp]
elim_le_elim_iff {u₁ v₁ : α₁ → β} {u₂ v₂ : α₂ → β} :
Sum.elim u₁ u₂ ≤ Sum.elim v₁ v₂ ↔ u₁ ≤ v₁ ∧ u₂ ≤ v₂ :=
Sum.forall | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | elim_le_elim_iff | null |
const_le_elim_iff {b : β} {v₁ : α₁ → β} {v₂ : α₂ → β} :
Function.const _ b ≤ Sum.elim v₁ v₂ ↔ Function.const _ b ≤ v₁ ∧ Function.const _ b ≤ v₂ :=
elim_const_const b ▸ elim_le_elim_iff .. | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | const_le_elim_iff | null |
elim_le_const_iff {b : β} {u₁ : α₁ → β} {u₂ : α₂ → β} :
Sum.elim u₁ u₂ ≤ Function.const _ b ↔ u₁ ≤ Function.const _ b ∧ u₂ ≤ Function.const _ b :=
elim_const_const b ▸ elim_le_elim_iff .. | lemma | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | elim_le_const_iff | null |
StrongLT [∀ i, LT (π i)] (a b : ∀ i, π i) : Prop :=
∀ i, a i < b i
@[inherit_doc]
local infixl:50 " ≺ " => StrongLT
variable [∀ i, Preorder (π i)] {a b c : ∀ i, π i} | def | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | StrongLT | A function `a` is strongly less than a function `b` if `a i < b i` for all `i`. |
le_of_strongLT (h : a ≺ b) : a ≤ b := fun _ ↦ (h _).le | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | le_of_strongLT | null |
lt_of_strongLT [Nonempty ι] (h : a ≺ b) : a < b := by
inhabit ι
exact Pi.lt_def.2 ⟨le_of_strongLT h, default, h _⟩ | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | lt_of_strongLT | null |
strongLT_of_strongLT_of_le (hab : a ≺ b) (hbc : b ≤ c) : a ≺ c := fun _ ↦
(hab _).trans_le <| hbc _ | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | strongLT_of_strongLT_of_le | null |
strongLT_of_le_of_strongLT (hab : a ≤ b) (hbc : b ≺ c) : a ≺ c := fun _ ↦
(hab _).trans_lt <| hbc _
alias StrongLT.le := le_of_strongLT
alias StrongLT.lt := lt_of_strongLT
alias StrongLT.trans_le := strongLT_of_strongLT_of_le
alias LE.le.trans_strongLT := strongLT_of_le_of_strongLT | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | strongLT_of_le_of_strongLT | null |
le_update_iff : x ≤ Function.update y i a ↔ x i ≤ a ∧ ∀ (j) (_ : j ≠ i), x j ≤ y j :=
Function.forall_update_iff _ fun j z ↦ x j ≤ z | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | le_update_iff | null |
update_le_iff : Function.update x i a ≤ y ↔ a ≤ y i ∧ ∀ (j) (_ : j ≠ i), x j ≤ y j :=
Function.forall_update_iff _ fun j z ↦ z ≤ y j | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | update_le_iff | null |
update_le_update_iff :
Function.update x i a ≤ Function.update y i b ↔ a ≤ b ∧ ∀ (j) (_ : j ≠ i), x j ≤ y j := by
simp +contextual [update_le_iff]
@[simp] | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | update_le_update_iff | null |
update_le_update_iff' : update x i a ≤ update x i b ↔ a ≤ b := by
simp [update_le_update_iff]
@[simp] | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | update_le_update_iff' | null |
update_lt_update_iff : update x i a < update x i b ↔ a < b :=
lt_iff_lt_of_le_iff_le' update_le_update_iff' update_le_update_iff'
@[simp] | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | update_lt_update_iff | null |
le_update_self_iff : x ≤ update x i a ↔ x i ≤ a := by simp [le_update_iff]
@[simp] | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | le_update_self_iff | null |
update_le_self_iff : update x i a ≤ x ↔ a ≤ x i := by simp [update_le_iff]
@[simp] | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | update_le_self_iff | null |
lt_update_self_iff : x < update x i a ↔ x i < a := by simp [lt_iff_le_not_ge]
@[simp] | theorem | Order | [
"Mathlib.Data.Subtype",
"Mathlib.Order.Defs.LinearOrder",
"Mathlib.Order.Notation",
"Mathlib.Tactic.GRewrite",
"Mathlib.Tactic.Spread",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Inhabit",
"Mathlib.Tactic.SimpRw"
] | Mathlib/Order/Basic.lean | lt_update_self_iff | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.