Interface:First-order linear order from nonstrict inequality

Here we provide theorems for a linear order for use in a proof module which has already exported Interface:First-order linear order defined via nonstrict inequality.

We start by importing propositional and predicate logic.

 param (PROPOSITIONAL Interface:Classical_propositional_calculus ) param (FIRSTORDER Interface:First-order_logic_with_quantifiability (PROPOSITIONAL) ) 

We also have as a parameter Interface:First-order linear order defined via nonstrict inequality.  param (DEFINED Interface:First-order_linear_order_defined_via_nonstrict_inequality (PROPOSITIONAL FIRSTORDER) ) 

Strict order
There is a less-than predicate which obeys the usual equality axioms.  var (object x y z x0 y0 z0 x1 y1 z1) var (variable v v0 v1 v2)

term (formula (< object object)) 

It is irreflexive, transitive, and total.  stmt (LessThanIrreflexivity  (¬ (x < x))) stmt (LessThanTransitivity  (((x < y) ∧ (y < z)) → (x < z))) stmt (LessThanTotality  (((x < y) ∨ (x = y)) ∨ (y < x))) 

We also provide greater-than, which is just an abbreviation for less-than with the order of the arguments reversed.  def ((> x y) (y < x)) 

Trichotomy
Exactly one of,  , or   hold. Our propositional logic doesn't have a notation which directly states "exactly one of three propositions holds" and even if it did, it might be inconvenient to work with. So we provide multiple theorems to express this idea.  stmt (LessThanEquality  ((x < y) → (x ≠ y))) stmt (LessThanGreaterThan  ((x < y) → (¬ (x > y)))) stmt (EqualityLessThan  ((x = y) → (¬ (x < y)))) 

Less than or equal to
The predicate  for less than or equal to was defined in Interface:First-order linear order defined via nonstrict inequality, which also provides the builder , transitivity, antisymmetry, and totality. We add some consequences and convenience theorems.

One consequence is reflexivity.  stmt (LessEqualReflexivity  (x ≤ x)) 

We also provide greater-than-or-equal, which is just an abbreviation for less-than-or-equal with the order of the arguments reversed.  def ((≥ x y) (y ≤ x)) 

Relationships between less-than, less-equal, and equality
 stmt (LessThanLessEqual  ((x < y) ↔ ((x ≤ y) ∧ (x ≠ y)))) stmt (LessEqualLessThan  ((x ≤ y) ↔ ((x < y) ∨ (x = y))))

stmt (LessThanLessEqualImplication  ((x < y) → (x ≤ y)))

stmt (EqualityLessEqual  ((x = y) → (x ≤ y)))

stmt (LessEqualLessThanTransitivity  (((x ≤ y) ∧ (y < z)) → (x < z))) </jh>

Builders
Both predicates obey the usual builders. was already defined, so it is the only one not defined here.  stmt (LessThanBuilder  (((x0 = x1) ∧ (y0 = y1)) → ((x0 < y0) ↔ (x1 < y1)))) stmt (LessThanBuilderLL  ((y0 = y1) → ((x < y0) ↔ (x < y1)))) stmt (LessThanBuilderRR  ((x0 = x1) → ((x0 < y) ↔ (x1 < y))))

stmt (buildLessThan ((x0 = x1) (y0 = y1)) ((x0 < y0) ↔ (x1 < y1))) stmt (buildLessThanLL ((y0 = y1)) ((x < y0) ↔ (x < y1))) stmt (buildLessThanRR ((x0 = x1)) ((x0 < y) ↔ (x1 < y)))

stmt (LessEqualBuilderRR  ((x0 = x1) → ((x0 ≤ y) ↔ (x1 ≤ y)))) stmt (LessEqualBuilderLL  ((y0 = y1) → ((x ≤ y0) ↔ (x ≤ y1))))

stmt (buildLessEqual ((x0 = x1) (y0 = y1)) ((x0 ≤ y0) ↔ (x1 ≤ y1))) stmt (buildLessEqualRR ((x0 = x1)) ((x0 ≤ y) ↔ (x1 ≤ y))) stmt (buildLessEqualLL ((y0 = y1)) ((x ≤ y0) ↔ (x ≤ y1))) </jh>