Comparison #

This file provides basic results about orderings and comparison in linear orders.

Definitions #

CmpLE: An Ordering from ≤.
Ordering.Compares: Turns an Ordering into < and = propositions.
linearOrderOfCompares: Constructs a LinearOrder instance from the fact that any two elements that are not one strictly less than the other either way are equal.

def cmpLE {α : Type u_3} [LE α] [DecidableRel fun (x1 x2 : α) => x1 ≤ x2] (x : α) (y : α) :

Like cmp, but uses a ≤ on the type instead of <. Given two elements x and y, returns a three-way comparison result Ordering.

Equations

cmpLE x y = if x ≤ y then if y ≤ x then Ordering.eq else Ordering.lt else Ordering.gt

Instances For

source

theorem cmpLE_swap {α : Type u_3} [LE α] [IsTotal α fun (x1 x2 : α) => x1 ≤ x2] [DecidableRel fun (x1 x2 : α) => x1 ≤ x2] (x : α) (y : α) :

(cmpLE x y).swap = cmpLE y x

source

theorem cmpLE_eq_cmp {α : Type u_3} [Preorder α] [IsTotal α fun (x1 x2 : α) => x1 ≤ x2] [DecidableRel fun (x1 x2 : α) => x1 ≤ x2] [DecidableRel fun (x1 x2 : α) => x1 < x2] (x : α) (y : α) :

cmpLE x y = cmp x y

source

theorem Ordering.compares_swap {α : Type u_1} [LT α] {a : α} {b : α} {o : Ordering} :

o.swap.Compares a b ↔ o.Compares b a

source

theorem Ordering.Compares.swap {α : Type u_1} [LT α] {a : α} {b : α} {o : Ordering} :

o.Compares b a → o.swap.Compares a b

Alias of the reverse direction of Ordering.compares_swap.

source

theorem Ordering.Compares.of_swap {α : Type u_1} [LT α] {a : α} {b : α} {o : Ordering} :

o.swap.Compares a b → o.Compares b a

Alias of the forward direction of Ordering.compares_swap.

source

theorem Ordering.swap_eq_iff_eq_swap {o : Ordering} {o' : Ordering} :

o.swap = o' ↔ o = o'.swap

source

theorem Ordering.Compares.eq_lt {α : Type u_1} [Preorder α] {o : Ordering} {a : α} {b : α} :

o.Compares a b → (o = Ordering.lt ↔ a < b)

source

theorem Ordering.Compares.ne_lt {α : Type u_1} [Preorder α] {o : Ordering} {a : α} {b : α} :

o.Compares a b → (o ≠ Ordering.lt ↔ b ≤ a)

source

theorem Ordering.Compares.eq_eq {α : Type u_1} [Preorder α] {o : Ordering} {a : α} {b : α} :

o.Compares a b → (o = Ordering.eq ↔ a = b)

source

theorem Ordering.Compares.eq_gt {α : Type u_1} [Preorder α] {o : Ordering} {a : α} {b : α} (h : o.Compares a b) :

o = Ordering.gt ↔ b < a

source

theorem Ordering.Compares.ne_gt {α : Type u_1} [Preorder α] {o : Ordering} {a : α} {b : α} (h : o.Compares a b) :

o ≠ Ordering.gt ↔ a ≤ b

source

theorem Ordering.Compares.le_total {α : Type u_1} [Preorder α] {a : α} {b : α} {o : Ordering} :

o.Compares a b → a ≤ b ∨ b ≤ a

source

theorem Ordering.Compares.le_antisymm {α : Type u_1} [Preorder α] {a : α} {b : α} {o : Ordering} :

o.Compares a b → a ≤ b → b ≤ a → a = b

source

theorem Ordering.Compares.inj {α : Type u_1} [Preorder α] {o₁ : Ordering} {o₂ : Ordering} {a : α} {b : α} :

o₁.Compares a b → o₂.Compares a b → o₁ = o₂

source

theorem Ordering.compares_iff_of_compares_impl {α : Type u_1} {β : Type u_2} [LinearOrder α] [Preorder β] {a : α} {b : α} {a' : β} {b' : β} (h : ∀ {o : Ordering}, o.Compares a b → o.Compares a' b') (o : Ordering) :

o.Compares a b ↔ o.Compares a' b'

source

@[deprecated Ordering.swap_then]

theorem Ordering.swap_orElse (o₁ : Ordering) (o₂ : Ordering) :

(o₁.orElse o₂).swap = o₁.swap.orElse o₂.swap

source

@[deprecated Ordering.then_eq_lt]

theorem Ordering.orElse_eq_lt (o₁ : Ordering) (o₂ : Ordering) :

o₁.orElse o₂ = Ordering.lt ↔ o₁ = Ordering.lt ∨ o₁ = Ordering.eq ∧ o₂ = Ordering.lt

source

@[simp]

theorem toDual_compares_toDual {α : Type u_1} [LT α] {a : α} {b : α} {o : Ordering} :

o.Compares (OrderDual.toDual a) (OrderDual.toDual b) ↔ o.Compares b a

source

@[simp]

theorem ofDual_compares_ofDual {α : Type u_1} [LT α] {a : αᵒᵈ} {b : αᵒᵈ} {o : Ordering} :

o.Compares (OrderDual.ofDual a) (OrderDual.ofDual b) ↔ o.Compares b a

source

theorem cmp_compares {α : Type u_1} [LinearOrder α] (a : α) (b : α) :

(cmp a b).Compares a b

source

theorem Ordering.Compares.cmp_eq {α : Type u_1} [LinearOrder α] {a : α} {b : α} {o : Ordering} (h : o.Compares a b) :

cmp a b = o

source

@[simp]

theorem cmp_swap {α : Type u_1} [Preorder α] [DecidableRel fun (x1 x2 : α) => x1 < x2] (a : α) (b : α) :

(cmp a b).swap = cmp b a

source

@[simp]

theorem cmpLE_toDual {α : Type u_1} [LE α] [DecidableRel fun (x1 x2 : α) => x1 ≤ x2] (x : α) (y : α) :

cmpLE (OrderDual.toDual x) (OrderDual.toDual y) = cmpLE y x

source

@[simp]

theorem cmpLE_ofDual {α : Type u_1} [LE α] [DecidableRel fun (x1 x2 : α) => x1 ≤ x2] (x : αᵒᵈ) (y : αᵒᵈ) :

cmpLE (OrderDual.ofDual x) (OrderDual.ofDual y) = cmpLE y x

source

@[simp]

theorem cmp_toDual {α : Type u_1} [LT α] [DecidableRel fun (x1 x2 : α) => x1 < x2] (x : α) (y : α) :

cmp (OrderDual.toDual x) (OrderDual.toDual y) = cmp y x

source

@[simp]

theorem cmp_ofDual {α : Type u_1} [LT α] [DecidableRel fun (x1 x2 : α) => x1 < x2] (x : αᵒᵈ) (y : αᵒᵈ) :

cmp (OrderDual.ofDual x) (OrderDual.ofDual y) = cmp y x

source

def linearOrderOfCompares {α : Type u_1} [Preorder α] (cmp : α → α → Ordering) (h : ∀ (a b : α), (cmp a b).Compares a b) :

LinearOrder α

Generate a linear order structure from a preorder and cmp function.

Equations

One or more equations did not get rendered due to their size.

Instances For

source

@[simp]

theorem cmp_eq_lt_iff {α : Type u_1} [LinearOrder α] (x : α) (y : α) :

cmp x y = Ordering.lt ↔ x < y

source

@[simp]

theorem cmp_eq_eq_iff {α : Type u_1} [LinearOrder α] (x : α) (y : α) :

cmp x y = Ordering.eq ↔ x = y

source

@[simp]

theorem cmp_eq_gt_iff {α : Type u_1} [LinearOrder α] (x : α) (y : α) :

cmp x y = Ordering.gt ↔ y < x

source

@[simp]

theorem cmp_self_eq_eq {α : Type u_1} [LinearOrder α] (x : α) :

cmp x x = Ordering.eq

source

theorem cmp_eq_cmp_symm {α : Type u_1} [LinearOrder α] {x : α} {y : α} {β : Type u_3} [LinearOrder β] {x' : β} {y' : β} :

cmp x y = cmp x' y' ↔ cmp y x = cmp y' x'

source

theorem lt_iff_lt_of_cmp_eq_cmp {α : Type u_1} [LinearOrder α] {x : α} {y : α} {β : Type u_3} [LinearOrder β] {x' : β} {y' : β} (h : cmp x y = cmp x' y') :

x < y ↔ x' < y'

source

theorem le_iff_le_of_cmp_eq_cmp {α : Type u_1} [LinearOrder α] {x : α} {y : α} {β : Type u_3} [LinearOrder β] {x' : β} {y' : β} (h : cmp x y = cmp x' y') :

x ≤ y ↔ x' ≤ y'

source

theorem eq_iff_eq_of_cmp_eq_cmp {α : Type u_1} [LinearOrder α] {x : α} {y : α} {β : Type u_3} [LinearOrder β] {x' : β} {y' : β} (h : cmp x y = cmp x' y') :

x = y ↔ x' = y'

source

theorem LT.lt.cmp_eq_lt {α : Type u_1} [LinearOrder α] {x : α} {y : α} (h : x < y) :

cmp x y = Ordering.lt

source

theorem LT.lt.cmp_eq_gt {α : Type u_1} [LinearOrder α] {x : α} {y : α} (h : x < y) :

cmp y x = Ordering.gt

source

theorem Eq.cmp_eq_eq {α : Type u_1} [LinearOrder α] {x : α} {y : α} (h : x = y) :

cmp x y = Ordering.eq

source

theorem Eq.cmp_eq_eq' {α : Type u_1} [LinearOrder α] {x : α} {y : α} (h : x = y) :

cmp y x = Ordering.eq

Documentation

Mathlib.Order.Compare

Comparison #

Definitions #