fact stringlengths 8 2.79k | type stringclasses 8 values | library stringclasses 9 values | imports listlengths 0 14 | filename stringclasses 132 values | symbolic_name stringlengths 1 71 | docstring stringlengths 18 10.2k ⌀ |
|---|---|---|---|---|---|---|
Function.id_def : @id α = fun x => x := rfl
/-! ## decidable -/
protected alias ⟨Decidable.exists_not_of_not_forall, _⟩ := Decidable.not_forall
/-! ## classical logic -/ | theorem | Batteries.Logic | [
"Batteries.Tactic.Alias"
] | Batteries/Logic.lean | Function.id_def | null |
heq_iff_eq {a b : α} : a ≍ b ↔ a = b := ⟨eq_of_heq, heq_of_eq⟩
@[simp] theorem eq_rec_constant {α : Sort _} {a a' : α} {β : Sort _} (y : β) (h : a = a') :
(@Eq.rec α a (fun _ _ => β) y a' h) = y := by cases h; rfl | theorem | Batteries.Logic | [
"Batteries.Tactic.Alias"
] | Batteries/Logic.lean | heq_iff_eq | null |
congrArg₂ (f : α → β → γ) {x x' : α} {y y' : β}
(hx : x = x') (hy : y = y') : f x y = f x' y' := by subst hx hy; rfl | theorem | Batteries.Logic | [
"Batteries.Tactic.Alias"
] | Batteries/Logic.lean | congrArg₂ | null |
congrFun₂ {β : α → Sort _} {γ : ∀ a, β a → Sort _}
{f g : ∀ a b, γ a b} (h : f = g) (a : α) (b : β a) :
f a b = g a b :=
congrFun (congrFun h _) _ | theorem | Batteries.Logic | [
"Batteries.Tactic.Alias"
] | Batteries/Logic.lean | congrFun₂ | null |
congrFun₃ {β : α → Sort _} {γ : ∀ a, β a → Sort _} {δ : ∀ a b, γ a b → Sort _}
{f g : ∀ a b c, δ a b c} (h : f = g) (a : α) (b : β a) (c : γ a b) :
f a b c = g a b c :=
congrFun₂ (congrFun h _) _ _ | theorem | Batteries.Logic | [
"Batteries.Tactic.Alias"
] | Batteries/Logic.lean | congrFun₃ | null |
funext₂ {β : α → Sort _} {γ : ∀ a, β a → Sort _}
{f g : ∀ a b, γ a b} (h : ∀ a b, f a b = g a b) : f = g :=
funext fun _ => funext <| h _ | theorem | Batteries.Logic | [
"Batteries.Tactic.Alias"
] | Batteries/Logic.lean | funext₂ | null |
funext₃ {β : α → Sort _} {γ : ∀ a, β a → Sort _} {δ : ∀ a b, γ a b → Sort _}
{f g : ∀ a b c, δ a b c} (h : ∀ a b c, f a b c = g a b c) : f = g :=
funext fun _ => funext₂ <| h _ | theorem | Batteries.Logic | [
"Batteries.Tactic.Alias"
] | Batteries/Logic.lean | funext₃ | null |
protected Eq.congr (h₁ : x₁ = y₁) (h₂ : x₂ = y₂) : x₁ = x₂ ↔ y₁ = y₂ := by
subst h₁; subst h₂; rfl | theorem | Batteries.Logic | [
"Batteries.Tactic.Alias"
] | Batteries/Logic.lean | Eq.congr | null |
Eq.congr_left {x y z : α} (h : x = y) : x = z ↔ y = z := by rw [h] | theorem | Batteries.Logic | [
"Batteries.Tactic.Alias"
] | Batteries/Logic.lean | Eq.congr_left | null |
Eq.congr_right {x y z : α} (h : x = y) : z = x ↔ z = y := by rw [h]
alias congr_arg := congrArg
alias congr_arg₂ := congrArg₂
alias congr_fun := congrFun
alias congr_fun₂ := congrFun₂
alias congr_fun₃ := congrFun₃ | theorem | Batteries.Logic | [
"Batteries.Tactic.Alias"
] | Batteries/Logic.lean | Eq.congr_right | null |
heq_of_cast_eq : ∀ (e : α = β) (_ : cast e a = a'), a ≍ a'
| rfl, rfl => .rfl | theorem | Batteries.Logic | [
"Batteries.Tactic.Alias"
] | Batteries/Logic.lean | heq_of_cast_eq | null |
cast_eq_iff_heq : cast e a = a' ↔ a ≍ a' :=
⟨heq_of_cast_eq _, fun h => by cases h; rfl⟩ | theorem | Batteries.Logic | [
"Batteries.Tactic.Alias"
] | Batteries/Logic.lean | cast_eq_iff_heq | null |
eqRec_eq_cast {α : Sort _} {a : α} {motive : (a' : α) → a = a' → Sort _}
(x : motive a rfl) {a' : α} (e : a = a') :
@Eq.rec α a motive x a' e = cast (e ▸ rfl) x := by
subst e; rfl
--Porting note: new theorem. More general version of `eqRec_heq` | theorem | Batteries.Logic | [
"Batteries.Tactic.Alias"
] | Batteries/Logic.lean | eqRec_eq_cast | null |
eqRec_heq_self {α : Sort _} {a : α} {motive : (a' : α) → a = a' → Sort _}
(x : motive a rfl) {a' : α} (e : a = a') : @Eq.rec α a motive x a' e ≍ x := by
subst e; rfl
@[simp] | theorem | Batteries.Logic | [
"Batteries.Tactic.Alias"
] | Batteries/Logic.lean | eqRec_heq_self | null |
eqRec_heq_iff_heq {α : Sort _} {a : α} {motive : (a' : α) → a = a' → Sort _}
{x : motive a rfl} {a' : α} {e : a = a'} {β : Sort _} {y : β} :
@Eq.rec α a motive x a' e ≍ y ↔ x ≍ y := by
subst e; rfl
@[simp] | theorem | Batteries.Logic | [
"Batteries.Tactic.Alias"
] | Batteries/Logic.lean | eqRec_heq_iff_heq | null |
heq_eqRec_iff_heq {α : Sort _} {a : α} {motive : (a' : α) → a = a' → Sort _}
{x : motive a rfl} {a' : α} {e : a = a'} {β : Sort _} {y : β} :
y ≍ @Eq.rec α a motive x a' e ↔ y ≍ x := by
subst e; rfl
/-! ## miscellaneous -/
@[simp] theorem not_nonempty_empty : ¬Nonempty Empty := fun ⟨h⟩ => h.elim
@[simp] theorem not_nonempty_pempty : ¬Nonempty PEmpty := fun ⟨h⟩ => h.elim
-- TODO(Mario): profile first, this is a dangerous instance
-- instance (priority := 10) {α} [Subsingleton α] : DecidableEq α
-- | a, b => isTrue (Subsingleton.elim a b)
-- TODO(Mario): profile adding `@[simp]` to `eq_iff_true_of_subsingleton` | theorem | Batteries.Logic | [
"Batteries.Tactic.Alias"
] | Batteries/Logic.lean | heq_eqRec_iff_heq | null |
subsingleton_of_forall_eq (x : α) (h : ∀ y, y = x) : Subsingleton α :=
⟨fun a b => h a ▸ h b ▸ rfl⟩ | theorem | Batteries.Logic | [
"Batteries.Tactic.Alias"
] | Batteries/Logic.lean | subsingleton_of_forall_eq | If all points are equal to a given point `x`, then `α` is a subsingleton. |
subsingleton_iff_forall_eq (x : α) : Subsingleton α ↔ ∀ y, y = x :=
⟨fun _ y => Subsingleton.elim y x, subsingleton_of_forall_eq x⟩ | theorem | Batteries.Logic | [
"Batteries.Tactic.Alias"
] | Batteries/Logic.lean | subsingleton_iff_forall_eq | null |
congr_eqRec {β : α → Sort _} (f : (x : α) → β x → γ) (h : x = x') (y : β x) :
f x' (Eq.rec y h) = f x y := by cases h; rfl | theorem | Batteries.Logic | [
"Batteries.Tactic.Alias"
] | Batteries/Logic.lean | congr_eqRec | null |
@[deprecated Std.OrientedCmp (since := "2025-07-01")]
OrientedCmp (cmp : α → α → Ordering) : Prop where
/-- The comparator operation is symmetric, in the sense that if `cmp x y` equals `.lt` then
`cmp y x = .gt` and vice versa. -/
symm (x y) : (cmp x y).swap = cmp y x
attribute [deprecated Std.OrientedOrd.eq_swap (since := "2025-07-01")] OrientedCmp.symm | class | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | OrientedCmp | `OrientedCmp cmp` asserts that `cmp` is determined by the relation `cmp x y = .lt`. |
@[deprecated Std.OrientedCmp.gt_iff_lt (since := "2025-07-01")]
cmp_eq_gt [OrientedCmp cmp] : cmp x y = .gt ↔ cmp y x = .lt := by
rw [← Ordering.swap_inj, symm]; exact .rfl
@[deprecated Std.OrientedCmp.le_iff_ge (since := "2025-07-01")] | theorem | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | cmp_eq_gt | null |
cmp_ne_gt [OrientedCmp cmp] : cmp x y ≠ .gt ↔ cmp y x ≠ .lt := not_congr cmp_eq_gt
@[deprecated Std.OrientedCmp.eq_comm (since := "2025-07-01")] | theorem | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | cmp_ne_gt | null |
cmp_eq_eq_symm [OrientedCmp cmp] : cmp x y = .eq ↔ cmp y x = .eq := by
rw [← Ordering.swap_inj, symm]; exact .rfl
@[deprecated Std.ReflCmp.compare_self (since := "2025-07-01")] | theorem | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | cmp_eq_eq_symm | null |
cmp_refl [OrientedCmp cmp] : cmp x x = .eq :=
match e : cmp x x with
| .lt => nomatch e.symm.trans (cmp_eq_gt.2 e)
| .eq => rfl
| .gt => nomatch (cmp_eq_gt.1 e).symm.trans e
@[deprecated Std.OrientedCmp.not_lt_of_lt (since := "2025-07-01")] | theorem | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | cmp_refl | null |
lt_asymm [OrientedCmp cmp] (h : cmp x y = .lt) : cmp y x ≠ .lt :=
fun h' => nomatch h.symm.trans (cmp_eq_gt.2 h')
@[deprecated Std.OrientedCmp.not_gt_of_gt (since := "2025-07-01")] | theorem | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | lt_asymm | null |
gt_asymm [OrientedCmp cmp] (h : cmp x y = .gt) : cmp y x ≠ .gt :=
mt cmp_eq_gt.1 <| lt_asymm <| cmp_eq_gt.1 h | theorem | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | gt_asymm | null |
@[deprecated Std.TransCmp (since := "2025-07-01")]
TransCmp (cmp : α → α → Ordering) : Prop extends OrientedCmp cmp where
/-- The comparator operation is transitive. -/
le_trans : cmp x y ≠ .gt → cmp y z ≠ .gt → cmp x z ≠ .gt
attribute [deprecated Std.TransCmp.le_trans (since := "2025-07-01")] TransCmp.le_trans | class | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | TransCmp | `TransCmp cmp` asserts that `cmp` induces a transitive relation. |
@[deprecated Std.TransCmp.ge_trans (since := "2025-07-01")]
ge_trans (h₁ : cmp x y ≠ .lt) (h₂ : cmp y z ≠ .lt) : cmp x z ≠ .lt := by
have := @TransCmp.le_trans _ cmp _ z y x
simp [cmp_eq_gt] at *; exact this h₂ h₁
@[deprecated Std.TransCmp.lt_of_le_of_lt (since := "2025-07-01")] | theorem | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | ge_trans | null |
le_lt_trans (h₁ : cmp x y ≠ .gt) (h₂ : cmp y z = .lt) : cmp x z = .lt :=
byContradiction fun h₃ => ge_trans (mt cmp_eq_gt.2 h₁) h₃ h₂
@[deprecated Std.TransCmp.lt_of_lt_of_le (since := "2025-07-01")] | theorem | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | le_lt_trans | null |
lt_le_trans (h₁ : cmp x y = .lt) (h₂ : cmp y z ≠ .gt) : cmp x z = .lt :=
byContradiction fun h₃ => ge_trans h₃ (mt cmp_eq_gt.2 h₂) h₁
@[deprecated Std.TransCmp.lt_trans (since := "2025-07-01")] | theorem | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | lt_le_trans | null |
lt_trans (h₁ : cmp x y = .lt) (h₂ : cmp y z = .lt) : cmp x z = .lt :=
le_lt_trans (gt_asymm <| cmp_eq_gt.2 h₁) h₂
@[deprecated Std.TransCmp.gt_trans (since := "2025-07-01")] | theorem | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | lt_trans | null |
gt_trans (h₁ : cmp x y = .gt) (h₂ : cmp y z = .gt) : cmp x z = .gt := by
rw [cmp_eq_gt] at h₁ h₂ ⊢; exact lt_trans h₂ h₁
@[deprecated Std.TransCmp.congr_left (since := "2025-07-01")] | theorem | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | gt_trans | null |
cmp_congr_left (xy : cmp x y = .eq) : cmp x z = cmp y z :=
match yz : cmp y z with
| .lt => byContradiction (ge_trans (nomatch ·.symm.trans (cmp_eq_eq_symm.1 xy)) · yz)
| .gt => byContradiction (le_trans (nomatch ·.symm.trans (cmp_eq_eq_symm.1 xy)) · yz)
| .eq => match xz : cmp x z with
| .lt => nomatch ge_trans (nomatch ·.symm.trans xy) (nomatch ·.symm.trans yz) xz
| .gt => nomatch le_trans (nomatch ·.symm.trans xy) (nomatch ·.symm.trans yz) xz
| .eq => rfl
@[deprecated Std.TransCmp.congr_left (since := "2025-07-01")] | theorem | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | cmp_congr_left | null |
cmp_congr_left' (xy : cmp x y = .eq) : cmp x = cmp y :=
funext fun _ => cmp_congr_left xy
@[deprecated Std.TransCmp.congr_right (since := "2025-07-01")] | theorem | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | cmp_congr_left' | null |
cmp_congr_right (yz : cmp y z = .eq) : cmp x y = cmp x z := by
rw [← Ordering.swap_inj, symm, symm, cmp_congr_left yz] | theorem | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | cmp_congr_right | null |
@[deprecated Std.LawfulBEqCmp (since := "2025-07-01")]
BEqCmp [BEq α] (cmp : α → α → Ordering) : Prop where
/-- `cmp x y = .eq` holds iff `x == y` is true. -/
cmp_iff_beq : cmp x y = .eq ↔ x == y
attribute [deprecated Std.LawfulBEqCmp.compare_eq_iff_beq
(since := "2025-07-01")] BEqCmp.cmp_iff_beq
@[deprecated Std.LawfulEqCmp.compare_eq_iff_eq (since := "2025-07-01")] | class | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | BEqCmp | `BEqCmp cmp` asserts that `cmp x y = .eq` and `x == y` coincide. |
BEqCmp.cmp_iff_eq [BEq α] [LawfulBEq α] [BEqCmp (α := α) cmp] : cmp x y = .eq ↔ x = y := by
simp [BEqCmp.cmp_iff_beq] | theorem | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | BEqCmp.cmp_iff_eq | null |
@[deprecated Std.LawfulLTCmp (since := "2025-07-01")]
LTCmp [LT α] (cmp : α → α → Ordering) : Prop extends OrientedCmp cmp where
/-- `cmp x y = .lt` holds iff `x < y` is true. -/
cmp_iff_lt : cmp x y = .lt ↔ x < y
attribute [deprecated Std.LawfulLTCmp.eq_lt_iff_lt (since := "2025-07-01")] LTCmp.cmp_iff_lt
@[deprecated Std.LawfulLTCmp.eq_gt_iff_gt (since := "2025-07-01")] | class | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | LTCmp | `LTCmp cmp` asserts that `cmp x y = .lt` and `x < y` coincide. |
LTCmp.cmp_iff_gt [LT α] [LTCmp (α := α) cmp] : cmp x y = .gt ↔ y < x := by
rw [OrientedCmp.cmp_eq_gt, LTCmp.cmp_iff_lt] | theorem | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | LTCmp.cmp_iff_gt | null |
@[deprecated Std.LawfulLECmp (since := "2025-07-01")]
LECmp [LE α] (cmp : α → α → Ordering) : Prop extends OrientedCmp cmp where
/-- `cmp x y ≠ .gt` holds iff `x ≤ y` is true. -/
cmp_iff_le : cmp x y ≠ .gt ↔ x ≤ y
attribute [deprecated Std.LawfulLECmp.ne_gt_iff_le (since := "2025-07-01")] LECmp.cmp_iff_le
@[deprecated Std.LawfulLECmp.ne_lt_iff_ge (since := "2025-07-01")] | class | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | LECmp | `LECmp cmp` asserts that `cmp x y ≠ .gt` and `x ≤ y` coincide. |
LECmp.cmp_iff_ge [LE α] [LECmp (α := α) cmp] : cmp x y ≠ .lt ↔ y ≤ x := by
rw [← OrientedCmp.cmp_ne_gt, LECmp.cmp_iff_le] | theorem | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | LECmp.cmp_iff_ge | null |
@[deprecated Std.LawfulBCmp (since := "2025-07-01")]
LawfulCmp [LE α] [LT α] [BEq α] (cmp : α → α → Ordering) : Prop extends
TransCmp cmp, BEqCmp cmp, LTCmp cmp, LECmp cmp | class | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | LawfulCmp | `LawfulCmp cmp` asserts that the `LE`, `LT`, `BEq` instances are all coherent with each other
and with `cmp`, describing a strict weak order (a linear order except for antisymmetry). |
@[deprecated Std.OrientedOrd (since := "2025-07-01")]
OrientedOrd (α) [Ord α] := OrientedCmp (α := α) compare | abbrev | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | OrientedOrd | `OrientedOrd α` asserts that the `Ord` instance satisfies `OrientedCmp`. |
@[deprecated Std.TransOrd (since := "2025-07-01")]
TransOrd (α) [Ord α] := TransCmp (α := α) compare | abbrev | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | TransOrd | `TransOrd α` asserts that the `Ord` instance satisfies `TransCmp`. |
@[deprecated Std.LawfulBEqOrd (since := "2025-07-01")]
BEqOrd (α) [BEq α] [Ord α] := BEqCmp (α := α) compare | abbrev | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | BEqOrd | `BEqOrd α` asserts that the `Ord` and `BEq` instances are coherent via `BEqCmp`. |
@[deprecated Std.LawfulLTOrd (since := "2025-07-01")]
LTOrd (α) [LT α] [Ord α] := LTCmp (α := α) compare | abbrev | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | LTOrd | `LTOrd α` asserts that the `Ord` instance satisfies `LTCmp`. |
@[deprecated Std.LawfulLEOrd (since := "2025-07-01")]
LEOrd (α) [LE α] [Ord α] := LECmp (α := α) compare | abbrev | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | LEOrd | `LEOrd α` asserts that the `Ord` instance satisfies `LECmp`. |
@[deprecated Std.LawfulBOrd (since := "2025-07-01")]
LawfulOrd (α) [LE α] [LT α] [BEq α] [Ord α] := LawfulCmp (α := α) compare
@[deprecated Std.TransCmp.compareOfLessAndEq_of_irrefl_of_trans_of_antisymm
(since := "2025-07-01")] | abbrev | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | LawfulOrd | `LawfulOrd α` asserts that the `Ord` instance satisfies `LawfulCmp`. |
protected TransCmp.compareOfLessAndEq
[LT α] [DecidableRel (LT.lt (α := α))] [DecidableEq α]
(lt_irrefl : ∀ x : α, ¬x < x)
(lt_trans : ∀ {x y z : α}, x < y → y < z → x < z)
(lt_antisymm : ∀ {x y : α}, ¬x < y → ¬y < x → x = y) :
TransCmp (α := α) (compareOfLessAndEq · ·) := by
have : OrientedCmp (α := α) (compareOfLessAndEq · ·) := by
refine { symm := fun x y => ?_ }
simp [compareOfLessAndEq]; split <;> [rename_i xy; split <;> [subst y; rename_i xy ne]]
· rw [if_neg, if_neg]; rfl
· rintro rfl; exact lt_irrefl _ xy
· exact fun yx => lt_irrefl _ (lt_trans xy yx)
· rw [if_neg ‹_›, if_pos rfl]; rfl
· split <;> [rfl; rename_i yx]
cases ne (lt_antisymm xy yx)
refine { this with le_trans := fun {x y z} yx zy => ?_ }
rw [Ne, this.cmp_eq_gt, compareOfLessAndEq_eq_lt] at yx zy ⊢
intro zx
if xy : x < y then exact zy (lt_trans zx xy)
else exact zy (lt_antisymm yx xy ▸ zx)
@[deprecated Std.TransCmp.compareOfLessAndEq_of_irrefl_of_trans_of_not_lt_of_antisymm
(since := "2025-07-01")] | theorem | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | TransCmp.compareOfLessAndEq | null |
TransCmp.compareOfLessAndEq_of_le
[LT α] [LE α] [DecidableRel (LT.lt (α := α))] [DecidableEq α]
(lt_irrefl : ∀ x : α, ¬x < x)
(lt_trans : ∀ {x y z : α}, x < y → y < z → x < z)
(not_lt : ∀ {x y : α}, ¬x < y → y ≤ x)
(le_antisymm : ∀ {x y : α}, x ≤ y → y ≤ x → x = y) :
TransCmp (α := α) (compareOfLessAndEq · ·) :=
.compareOfLessAndEq lt_irrefl lt_trans fun xy yx => le_antisymm (not_lt yx) (not_lt xy)
@[deprecated Std.LawfulBEqCmp.compareOfLessAndEq_of_lt_irrefl (since := "2025-07-01")] | theorem | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | TransCmp.compareOfLessAndEq_of_le | null |
protected BEqCmp.compareOfLessAndEq
[LT α] [DecidableRel (LT.lt (α := α))] [DecidableEq α] [BEq α] [LawfulBEq α]
(lt_irrefl : ∀ x : α, ¬x < x) :
BEqCmp (α := α) (compareOfLessAndEq · ·) where
cmp_iff_beq {x y} := by
simp [compareOfLessAndEq]
split <;> [skip; split] <;> simp [*]
rintro rfl; exact lt_irrefl _ ‹_›
@[deprecated Std.LawfulLTCmp.compareOfLessAndEq_of_irrefl_of_trans_of_antisymm
(since := "2025-07-01")] | theorem | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | BEqCmp.compareOfLessAndEq | null |
protected LTCmp.compareOfLessAndEq
[LT α] [DecidableRel (LT.lt (α := α))] [DecidableEq α]
(lt_irrefl : ∀ x : α, ¬x < x)
(lt_trans : ∀ {x y z : α}, x < y → y < z → x < z)
(lt_antisymm : ∀ {x y : α}, ¬x < y → ¬y < x → x = y) :
LTCmp (α := α) (compareOfLessAndEq · ·) :=
{ TransCmp.compareOfLessAndEq lt_irrefl lt_trans lt_antisymm with
cmp_iff_lt := compareOfLessAndEq_eq_lt }
@[deprecated Std.LawfulLTCmp.compareOfLessAndEq_of_irrefl_of_trans_of_not_lt_of_antisymm
(since := "2025-07-01")] | theorem | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | LTCmp.compareOfLessAndEq | null |
protected LTCmp.compareOfLessAndEq_of_le
[LT α] [DecidableRel (LT.lt (α := α))] [DecidableEq α] [LE α]
(lt_irrefl : ∀ x : α, ¬x < x)
(lt_trans : ∀ {x y z : α}, x < y → y < z → x < z)
(not_lt : ∀ {x y : α}, ¬x < y → y ≤ x)
(le_antisymm : ∀ {x y : α}, x ≤ y → y ≤ x → x = y) :
LTCmp (α := α) (compareOfLessAndEq · ·) :=
{ TransCmp.compareOfLessAndEq_of_le lt_irrefl lt_trans not_lt le_antisymm with
cmp_iff_lt := compareOfLessAndEq_eq_lt }
@[deprecated Std.LawfulLECmp.compareOfLessAndEq_of_irrefl_of_trans_of_not_lt_of_antisymm
(since := "2025-07-01")] | theorem | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | LTCmp.compareOfLessAndEq_of_le | null |
protected LECmp.compareOfLessAndEq
[LT α] [DecidableRel (LT.lt (α := α))] [DecidableEq α] [LE α]
(lt_irrefl : ∀ x : α, ¬x < x)
(lt_trans : ∀ {x y z : α}, x < y → y < z → x < z)
(not_lt : ∀ {x y : α}, ¬x < y ↔ y ≤ x)
(le_antisymm : ∀ {x y : α}, x ≤ y → y ≤ x → x = y) :
LECmp (α := α) (compareOfLessAndEq · ·) :=
have := TransCmp.compareOfLessAndEq_of_le lt_irrefl lt_trans not_lt.1 le_antisymm
{ this with
cmp_iff_le := (this.cmp_ne_gt).trans <| (not_congr compareOfLessAndEq_eq_lt).trans not_lt }
@[deprecated Std.LawfulCmp.compareOfLessAndEq_of_irrefl_of_trans_of_not_lt_of_antisymm
(since := "2025-07-01")] | theorem | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | LECmp.compareOfLessAndEq | null |
protected LawfulCmp.compareOfLessAndEq
[LT α] [DecidableRel (LT.lt (α := α))] [DecidableEq α] [BEq α] [LawfulBEq α] [LE α]
(lt_irrefl : ∀ x : α, ¬x < x)
(lt_trans : ∀ {x y z : α}, x < y → y < z → x < z)
(not_lt : ∀ {x y : α}, ¬x < y ↔ y ≤ x)
(le_antisymm : ∀ {x y : α}, x ≤ y → y ≤ x → x = y) :
LawfulCmp (α := α) (compareOfLessAndEq · ·) :=
{ TransCmp.compareOfLessAndEq_of_le lt_irrefl lt_trans not_lt.1 le_antisymm,
LTCmp.compareOfLessAndEq_of_le lt_irrefl lt_trans not_lt.1 le_antisymm,
LECmp.compareOfLessAndEq lt_irrefl lt_trans not_lt le_antisymm,
BEqCmp.compareOfLessAndEq lt_irrefl with }
@[deprecated Std.LawfulLTCmp.eq_compareOfLessAndEq (since := "2025-07-01")] | theorem | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | LawfulCmp.compareOfLessAndEq | null |
LTCmp.eq_compareOfLessAndEq
[LT α] [DecidableEq α] [BEq α] [LawfulBEq α] [BEqCmp cmp] [LTCmp cmp]
(x y : α) [Decidable (x < y)] : cmp x y = compareOfLessAndEq x y := by
simp [compareOfLessAndEq]
split <;> rename_i h1 <;> [skip; split <;> rename_i h2]
· exact LTCmp.cmp_iff_lt.2 h1
· exact BEqCmp.cmp_iff_eq.2 h2
· cases e : cmp x y
· cases h1 (LTCmp.cmp_iff_lt.1 e)
· cases h2 (BEqCmp.cmp_iff_eq.1 e)
· rfl | theorem | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | LTCmp.eq_compareOfLessAndEq | null |
@[deprecated "instance exists" (since := "2025-07-01")]
OrientedOrd.instLexOrd [Ord α] [Ord β]
[OrientedOrd α] [OrientedOrd β] : @OrientedOrd (α × β) lexOrd := by
rw [OrientedOrd, lexOrd_def]; infer_instance | theorem | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | OrientedOrd.instLexOrd | Local instance for `OrientedOrd lexOrd`. |
@[deprecated "instance exists" (since := "2025-07-01")]
TransOrd.instLexOrd [Ord α] [Ord β]
[TransOrd α] [TransOrd β] : @TransOrd (α × β) lexOrd := by
rw [TransOrd, lexOrd_def]; infer_instance | theorem | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | TransOrd.instLexOrd | Local instance for `TransOrd lexOrd`. |
@[deprecated Std.OrientedOrd.opposite (since := "2025-07-01")]
OrientedOrd.instOpposite [ord : Ord α] [inst : OrientedOrd α] :
@OrientedOrd _ ord.opposite where symm _ _ := inst.symm .. | theorem | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | OrientedOrd.instOpposite | Local instance for `OrientedOrd ord.opposite`. |
@[deprecated Std.TransOrd.opposite (since := "2025-07-01")]
TransOrd.instOpposite [ord : Ord α] [inst : TransOrd α] : @TransOrd _ ord.opposite :=
{ OrientedOrd.instOpposite with le_trans := fun h1 h2 => inst.le_trans h2 h1 } | theorem | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | TransOrd.instOpposite | Local instance for `TransOrd ord.opposite`. |
@[deprecated Std.OrientedOrd.instOn (since := "2025-07-01")]
OrientedOrd.instOn [ord : Ord β] [OrientedOrd β] (f : α → β) : @OrientedOrd _ (ord.on f) :=
inferInstanceAs (@OrientedCmp _ (compareOn f)) | theorem | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | OrientedOrd.instOn | Local instance for `OrientedOrd (ord.on f)`. |
@[deprecated Std.TransOrd.instOn (since := "2025-07-01")]
TransOrd.instOn [ord : Ord β] [TransOrd β] (f : α → β) : @TransOrd _ (ord.on f) :=
inferInstanceAs (@TransCmp _ (compareOn f)) | theorem | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | TransOrd.instOn | Local instance for `TransOrd (ord.on f)`. |
@[deprecated "instance exists" (since := "2025-07-01")]
OrientedOrd.instOrdLex [oα : Ord α] [oβ : Ord β] [OrientedOrd α] [OrientedOrd β] :
@OrientedOrd _ (oα.lex oβ) := OrientedOrd.instLexOrd | theorem | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | OrientedOrd.instOrdLex | Local instance for `OrientedOrd (oα.lex oβ)`. |
@[deprecated "instance exists" (since := "2025-07-01")]
TransOrd.instOrdLex [oα : Ord α] [oβ : Ord β] [TransOrd α] [TransOrd β] :
@TransOrd _ (oα.lex oβ) := TransOrd.instLexOrd | theorem | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | TransOrd.instOrdLex | Local instance for `TransOrd (oα.lex oβ)`. |
@[deprecated Std.OrientedOrd.instOrdLex' (since := "2025-07-01")]
OrientedOrd.instOrdLex' (ord₁ ord₂ : Ord α) [@OrientedOrd _ ord₁] [@OrientedOrd _ ord₂] :
@OrientedOrd _ (ord₁.lex' ord₂) :=
inferInstanceAs (OrientedCmp (compareLex ord₁.compare ord₂.compare)) | theorem | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | OrientedOrd.instOrdLex' | Local instance for `OrientedOrd (oα.lex' oβ)`. |
@[deprecated Std.TransOrd.instOrdLex' (since := "2025-07-01")]
TransOrd.instOrdLex' (ord₁ ord₂ : Ord α) [@TransOrd _ ord₁] [@TransOrd _ ord₂] :
@TransOrd _ (ord₁.lex' ord₂) :=
inferInstanceAs (TransCmp (compareLex ord₁.compare ord₂.compare)) | theorem | Batteries.Classes | [
"Batteries.Classes.Order"
] | Batteries/Classes/Deprecated.lean | TransOrd.instOrdLex' | Local instance for `TransOrd (oα.lex' oβ)`. |
lexOrd_def [Ord α] [Ord β] :
(lexOrd : Ord (α × β)).compare = compareLex (compareOn (·.1)) (compareOn (·.2)) := rfl | theorem | Batteries.Classes | [
"Batteries.Tactic.Basic",
"Batteries.Tactic.SeqFocus"
] | Batteries/Classes/Order.lean | lexOrd_def | null |
@[inline] Ordering.byKey (f : α → β) (cmp : β → β → Ordering) (a b : α) : Ordering :=
cmp (f a) (f b) | def | Batteries.Classes | [
"Batteries.Tactic.Basic",
"Batteries.Tactic.SeqFocus"
] | Batteries/Classes/Order.lean | Ordering.byKey | Pull back a comparator by a function `f`, by applying the comparator to both arguments. |
TotalBLE (le : α → α → Bool) : Prop where
/-- `le` is total: either `le a b` or `le b a`. -/
total : le a b ∨ le b a | class | Batteries.Classes | [
"Batteries.Tactic.Basic",
"Batteries.Tactic.SeqFocus"
] | Batteries/Classes/Order.lean | TotalBLE | `TotalBLE le` asserts that `le` has a total order, that is, `le a b ∨ le b a`. |
compareOfLessAndEq_eq_lt {x y : α} [LT α] [Decidable (x < y)] [DecidableEq α] :
compareOfLessAndEq x y = .lt ↔ x < y := by
simp [compareOfLessAndEq]
split <;> simp | theorem | Batteries.Classes | [
"Batteries.Tactic.Basic",
"Batteries.Tactic.SeqFocus"
] | Batteries/Classes/Order.lean | compareOfLessAndEq_eq_lt | null |
le_iff_ge : cmp x y ≠ .gt ↔ cmp y x ≠ .lt :=
not_congr OrientedCmp.gt_iff_lt | theorem | Batteries.Classes | [
"Batteries.Tactic.Basic",
"Batteries.Tactic.SeqFocus"
] | Batteries/Classes/Order.lean | le_iff_ge | null |
le_trans : cmp x y ≠ .gt → cmp y z ≠ .gt → cmp x z ≠ .gt := by
simp only [ne_eq, ← Ordering.isLE_iff_ne_gt]; exact isLE_trans | theorem | Batteries.Classes | [
"Batteries.Tactic.Basic",
"Batteries.Tactic.SeqFocus"
] | Batteries/Classes/Order.lean | le_trans | null |
lt_of_lt_of_le : cmp x y = .lt → cmp y z ≠ .gt → cmp x z = .lt := by
simp only [ne_eq, ← Ordering.isLE_iff_ne_gt]; exact lt_of_lt_of_isLE | theorem | Batteries.Classes | [
"Batteries.Tactic.Basic",
"Batteries.Tactic.SeqFocus"
] | Batteries/Classes/Order.lean | lt_of_lt_of_le | null |
lt_of_le_of_lt : cmp x y ≠ .gt → cmp y z = .lt → cmp x z = .lt := by
simp only [ne_eq, ← Ordering.isLE_iff_ne_gt]; exact lt_of_isLE_of_lt | theorem | Batteries.Classes | [
"Batteries.Tactic.Basic",
"Batteries.Tactic.SeqFocus"
] | Batteries/Classes/Order.lean | lt_of_le_of_lt | null |
ge_trans : cmp x y ≠ .lt → cmp y z ≠ .lt → cmp x z ≠ .lt := by
simp only [ne_eq, ← Ordering.isGE_iff_ne_lt]; exact isGE_trans | theorem | Batteries.Classes | [
"Batteries.Tactic.Basic",
"Batteries.Tactic.SeqFocus"
] | Batteries/Classes/Order.lean | ge_trans | null |
gt_of_gt_of_ge : cmp x y = .gt → cmp y z ≠ .lt → cmp x z = .gt := by
simp only [ne_eq, ← Ordering.isGE_iff_ne_lt]; exact gt_of_gt_of_isGE | theorem | Batteries.Classes | [
"Batteries.Tactic.Basic",
"Batteries.Tactic.SeqFocus"
] | Batteries/Classes/Order.lean | gt_of_gt_of_ge | null |
gt_of_ge_of_gt : cmp x y ≠ .lt → cmp y z = .gt → cmp x z = .gt := by
simp only [ne_eq, ← Ordering.isGE_iff_ne_lt]; exact gt_of_isGE_of_gt | theorem | Batteries.Classes | [
"Batteries.Tactic.Basic",
"Batteries.Tactic.SeqFocus"
] | Batteries/Classes/Order.lean | gt_of_ge_of_gt | null |
LawfulLTCmp [LT α] (cmp : α → α → Ordering) : Prop extends OrientedCmp cmp where
/-- `cmp x y = .lt` holds iff `x < y` is true. -/
eq_lt_iff_lt : cmp x y = .lt ↔ x < y | class | Batteries.Classes | [
"Batteries.Tactic.Basic",
"Batteries.Tactic.SeqFocus"
] | Batteries/Classes/Order.lean | LawfulLTCmp | `LawfulLTCmp cmp` asserts that `cmp x y = .lt` and `x < y` coincide. |
LawfulLTCmp.eq_gt_iff_gt [LT α] [LawfulLTCmp (α := α) cmp] :
cmp x y = .gt ↔ y < x := by rw [OrientedCmp.gt_iff_lt, eq_lt_iff_lt] | theorem | Batteries.Classes | [
"Batteries.Tactic.Basic",
"Batteries.Tactic.SeqFocus"
] | Batteries/Classes/Order.lean | LawfulLTCmp.eq_gt_iff_gt | null |
LawfulLECmp [LE α] (cmp : α → α → Ordering) : Prop extends OrientedCmp cmp where
/-- `cmp x y ≠ .gt` holds iff `x ≤ y` is true. -/
isLE_iff_le : (cmp x y).isLE ↔ x ≤ y | class | Batteries.Classes | [
"Batteries.Tactic.Basic",
"Batteries.Tactic.SeqFocus"
] | Batteries/Classes/Order.lean | LawfulLECmp | `LawfulLECmp cmp` asserts that `(cmp x y).isLE` and `x ≤ y` coincide. |
LawfulLECmp.isGE_iff_ge [LE α] [LawfulLECmp (α := α) cmp] :
(cmp x y).isGE ↔ y ≤ x := by rw [← Ordering.isLE_swap, ← OrientedCmp.eq_swap, isLE_iff_le] | theorem | Batteries.Classes | [
"Batteries.Tactic.Basic",
"Batteries.Tactic.SeqFocus"
] | Batteries/Classes/Order.lean | LawfulLECmp.isGE_iff_ge | null |
LawfulLECmp.ne_gt_iff_le [LE α] [LawfulLECmp (α := α) cmp] :
cmp x y ≠ .gt ↔ x ≤ y := by rw [← isLE_iff_le (cmp := cmp), Ordering.isLE_iff_ne_gt] | theorem | Batteries.Classes | [
"Batteries.Tactic.Basic",
"Batteries.Tactic.SeqFocus"
] | Batteries/Classes/Order.lean | LawfulLECmp.ne_gt_iff_le | null |
LawfulLECmp.ne_lt_iff_ge [LE α] [LawfulLECmp (α := α) cmp] :
cmp x y ≠ .lt ↔ y ≤ x := by rw [← isGE_iff_ge (cmp := cmp), Ordering.isGE_iff_ne_lt] | theorem | Batteries.Classes | [
"Batteries.Tactic.Basic",
"Batteries.Tactic.SeqFocus"
] | Batteries/Classes/Order.lean | LawfulLECmp.ne_lt_iff_ge | null |
LawfulBCmp [LE α] [LT α] [BEq α] (cmp : α → α → Ordering) : Prop extends
TransCmp cmp, LawfulBEqCmp cmp, LawfulLTCmp cmp, LawfulLECmp cmp | class | Batteries.Classes | [
"Batteries.Tactic.Basic",
"Batteries.Tactic.SeqFocus"
] | Batteries/Classes/Order.lean | LawfulBCmp | `LawfulBCmp cmp` asserts that the `LE`, `LT`, `BEq` are all coherent with each other
and with `cmp`, describing a strict weak order (a linear order except for antisymmetry). |
LawfulCmp [LE α] [LT α] (cmp : α → α → Ordering) : Prop extends
TransCmp cmp, LawfulEqCmp cmp, LawfulLTCmp cmp, LawfulLECmp cmp | class | Batteries.Classes | [
"Batteries.Tactic.Basic",
"Batteries.Tactic.SeqFocus"
] | Batteries/Classes/Order.lean | LawfulCmp | `LawfulBCmp cmp` asserts that the `LE`, `LT`, `Eq` are all coherent with each other
and with `cmp`, describing a linear order. |
LawfulLTOrd (α) [LT α] [Ord α] := LawfulLTCmp (α := α) compare | abbrev | Batteries.Classes | [
"Batteries.Tactic.Basic",
"Batteries.Tactic.SeqFocus"
] | Batteries/Classes/Order.lean | LawfulLTOrd | Class for types where the ordering function is compatible with the `LT`. |
LawfulLEOrd (α) [LE α] [Ord α] := LawfulLECmp (α := α) compare | abbrev | Batteries.Classes | [
"Batteries.Tactic.Basic",
"Batteries.Tactic.SeqFocus"
] | Batteries/Classes/Order.lean | LawfulLEOrd | Class for types where the ordering function is compatible with the `LE`. |
LawfulBOrd (α) [LE α] [LT α] [BEq α] [Ord α] := LawfulBCmp (α := α) compare | abbrev | Batteries.Classes | [
"Batteries.Tactic.Basic",
"Batteries.Tactic.SeqFocus"
] | Batteries/Classes/Order.lean | LawfulBOrd | Class for types where the ordering function is compatible with the `LE`, `LT` and `BEq`. |
LawfulOrd (α) [LE α] [LT α] [Ord α] := LawfulCmp (α := α) compare | abbrev | Batteries.Classes | [
"Batteries.Tactic.Basic",
"Batteries.Tactic.SeqFocus"
] | Batteries/Classes/Order.lean | LawfulOrd | Class for types where the ordering function is compatible with the `LE`, `LT` and `Eq`. |
OrientedOrd.instOn [ord : Ord β] [OrientedOrd β] (f : α → β) : @OrientedOrd _ (ord.on f) :=
inferInstanceAs (@OrientedCmp _ (compareOn f)) | theorem | Batteries.Classes | [
"Batteries.Tactic.Basic",
"Batteries.Tactic.SeqFocus"
] | Batteries/Classes/Order.lean | OrientedOrd.instOn | null |
TransOrd.instOn [ord : Ord β] [TransOrd β] (f : α → β) : @TransOrd _ (ord.on f) :=
inferInstanceAs (@TransCmp _ (compareOn f)) | theorem | Batteries.Classes | [
"Batteries.Tactic.Basic",
"Batteries.Tactic.SeqFocus"
] | Batteries/Classes/Order.lean | TransOrd.instOn | null |
OrientedOrd.instOrdLex' (ord₁ ord₂ : Ord α) [@OrientedOrd _ ord₁] [@OrientedOrd _ ord₂] :
@OrientedOrd _ (ord₁.lex' ord₂) :=
inferInstanceAs (OrientedCmp (compareLex ord₁.compare ord₂.compare)) | theorem | Batteries.Classes | [
"Batteries.Tactic.Basic",
"Batteries.Tactic.SeqFocus"
] | Batteries/Classes/Order.lean | OrientedOrd.instOrdLex' | null |
TransOrd.instOrdLex' (ord₁ ord₂ : Ord α) [@TransOrd _ ord₁] [@TransOrd _ ord₂] :
@TransOrd _ (ord₁.lex' ord₂) :=
inferInstanceAs (TransCmp (compareLex ord₁.compare ord₂.compare)) | theorem | Batteries.Classes | [
"Batteries.Tactic.Basic",
"Batteries.Tactic.SeqFocus"
] | Batteries/Classes/Order.lean | TransOrd.instOrdLex' | null |
LawfulLTCmp.eq_compareOfLessAndEq
[LT α] [DecidableEq α] [LawfulEqCmp cmp] [LawfulLTCmp cmp]
(x y : α) [Decidable (x < y)] : cmp x y = compareOfLessAndEq x y := by
simp only [compareOfLessAndEq]
split <;> rename_i h1 <;> [skip; split <;> rename_i h2]
· exact LawfulLTCmp.eq_lt_iff_lt.2 h1
· exact LawfulEqCmp.compare_eq_iff_eq.2 h2
· cases e : cmp x y
· cases h1 (LawfulLTCmp.eq_lt_iff_lt.1 e)
· cases h2 (LawfulEqCmp.compare_eq_iff_eq.1 e)
· rfl | theorem | Batteries.Classes | [
"Batteries.Tactic.Basic",
"Batteries.Tactic.SeqFocus"
] | Batteries/Classes/Order.lean | LawfulLTCmp.eq_compareOfLessAndEq | null |
ReflCmp.compareOfLessAndEq_of_lt_irrefl [LT α] [DecidableLT α] [DecidableEq α]
(lt_irrefl : ∀ x : α, ¬ x < x) :
ReflCmp (α := α) (compareOfLessAndEq · ·) where
compare_self {x} := by simp [compareOfLessAndEq, if_neg (lt_irrefl x)] | theorem | Batteries.Classes | [
"Batteries.Tactic.Basic",
"Batteries.Tactic.SeqFocus"
] | Batteries/Classes/Order.lean | ReflCmp.compareOfLessAndEq_of_lt_irrefl | null |
LawfulBEqCmp.compareOfLessAndEq_of_lt_irrefl
[LT α] [DecidableLT α] [DecidableEq α] [BEq α] [LawfulBEq α]
(lt_irrefl : ∀ x : α, ¬x < x) :
LawfulBEqCmp (α := α) (compareOfLessAndEq · ·) where
compare_eq_iff_beq {x y} := by
simp [compareOfLessAndEq]
split <;> [skip; split] <;> simp [*]
rintro rfl; exact lt_irrefl _ ‹_›
-- redundant? See `compareOfLessAndEq_of_lt_trans_of_lt_iff` in core | theorem | Batteries.Classes | [
"Batteries.Tactic.Basic",
"Batteries.Tactic.SeqFocus"
] | Batteries/Classes/Order.lean | LawfulBEqCmp.compareOfLessAndEq_of_lt_irrefl | null |
TransCmp.compareOfLessAndEq_of_irrefl_of_trans_of_antisymm
[LT α] [DecidableLT α] [DecidableEq α]
(lt_irrefl : ∀ x : α, ¬x < x)
(lt_trans : ∀ {x y z : α}, x < y → y < z → x < z)
(lt_antisymm : ∀ {x y : α}, ¬x < y → ¬y < x → x = y) :
TransCmp (α := α) (compareOfLessAndEq · ·) :=
TransOrd.compareOfLessAndEq_of_lt_trans_of_lt_iff lt_trans <| by
intros
constructor
· intro h₁
constructor
· intro h₂
apply lt_irrefl
exact lt_trans h₁ h₂
· intro | rfl => exact lt_irrefl _ h₁
· intro ⟨h₁, h₂⟩
by_contra h₃
apply h₂
exact lt_antisymm h₃ h₁
-- redundant? See `compareOfLessAndEq_of_antisymm_of_trans_of_total_of_not_le` in core | theorem | Batteries.Classes | [
"Batteries.Tactic.Basic",
"Batteries.Tactic.SeqFocus"
] | Batteries/Classes/Order.lean | TransCmp.compareOfLessAndEq_of_irrefl_of_trans_of_antisymm | null |
TransCmp.compareOfLessAndEq_of_irrefl_of_trans_of_not_lt_of_antisymm
[LT α] [LE α] [DecidableLT α] [DecidableEq α]
(lt_irrefl : ∀ x : α, ¬x < x)
(lt_trans : ∀ {x y z : α}, x < y → y < z → x < z)
(not_lt : ∀ {x y : α}, ¬x < y → y ≤ x)
(le_antisymm : ∀ {x y : α}, x ≤ y → y ≤ x → x = y) :
TransCmp (α := α) (compareOfLessAndEq · ·) :=
.compareOfLessAndEq_of_irrefl_of_trans_of_antisymm
lt_irrefl lt_trans fun xy yx => le_antisymm (not_lt yx) (not_lt xy)
-- make redundant? | theorem | Batteries.Classes | [
"Batteries.Tactic.Basic",
"Batteries.Tactic.SeqFocus"
] | Batteries/Classes/Order.lean | TransCmp.compareOfLessAndEq_of_irrefl_of_trans_of_not_lt_of_antisymm | null |
LawfulLTCmp.compareOfLessAndEq_of_irrefl_of_trans_of_antisymm
[LT α] [DecidableLT α] [DecidableEq α]
(lt_irrefl : ∀ x : α, ¬x < x)
(lt_trans : ∀ {x y z : α}, x < y → y < z → x < z)
(lt_antisymm : ∀ {x y : α}, ¬x < y → ¬y < x → x = y) :
LawfulLTCmp (α := α) (compareOfLessAndEq · ·) :=
{ TransCmp.compareOfLessAndEq_of_irrefl_of_trans_of_antisymm
lt_irrefl lt_trans lt_antisymm with
eq_lt_iff_lt := Batteries.compareOfLessAndEq_eq_lt }
-- make redundant? | theorem | Batteries.Classes | [
"Batteries.Tactic.Basic",
"Batteries.Tactic.SeqFocus"
] | Batteries/Classes/Order.lean | LawfulLTCmp.compareOfLessAndEq_of_irrefl_of_trans_of_antisymm | null |
LawfulLTCmp.compareOfLessAndEq_of_irrefl_of_trans_of_not_lt_of_antisymm
[LT α] [DecidableLT α] [DecidableEq α] [LE α]
(lt_irrefl : ∀ x : α, ¬x < x)
(lt_trans : ∀ {x y z : α}, x < y → y < z → x < z)
(not_lt : ∀ {x y : α}, ¬x < y → y ≤ x)
(le_antisymm : ∀ {x y : α}, x ≤ y → y ≤ x → x = y) :
LawfulLTCmp (α := α) (compareOfLessAndEq · ·) :=
{ TransCmp.compareOfLessAndEq_of_irrefl_of_trans_of_not_lt_of_antisymm
lt_irrefl lt_trans not_lt le_antisymm with
eq_lt_iff_lt := Batteries.compareOfLessAndEq_eq_lt }
-- make redundant? | theorem | Batteries.Classes | [
"Batteries.Tactic.Basic",
"Batteries.Tactic.SeqFocus"
] | Batteries/Classes/Order.lean | LawfulLTCmp.compareOfLessAndEq_of_irrefl_of_trans_of_not_lt_of_antisymm | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.