Proof Assistant Projects
Collection
Digesting proof assistant libraries for AI ingestion.
•
79 items
•
Updated
•
2
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 |
End of preview. Expand
in Data Studio
Lean4-Batteries
Structured dataset from Lean 4 Batteries - the community standard library extensions.
Schema
| Column | Type | Description |
|---|---|---|
| fact | string | Declaration body |
| type | string | theorem, def, class, structure, etc. |
| library | string | Batteries module |
| imports | list | Import statements |
| filename | string | Source file path |
| symbolic_name | string | Declaration identifier |
| docstring | string | Documentation (48% coverage) |
Statistics
By Type
| Type | Count |
|---|---|
| theorem | 1,257 |
| def | 951 |
| abbrev | 48 |
| structure | 38 |
| inductive | 24 |
| class | 22 |
| instance | 4 |
| opaque | 2 |
About Batteries
Batteries is the community-maintained extended standard library for Lean 4. It provides additional data structures, algorithms, and tactics beyond the core Init and Std libraries.
Related Datasets
- Downloads last month
- 14
Source:
leanprover-community/batteries
Entries:
2,346
Files processed:
172
License:
Apache 2.0
Size of downloaded dataset files:
374 kB
Size of the auto-converted Parquet files:
374 kB
Number of rows:
2,346