(* Le.le_n_S Le.le_n_Sn Le.le_Sn_n *)
#[local]
Definition le_n_0_eq_stt := fun n Hle => eq_sym (proj1 (Nat.le_0_r n) Hle).(* Lt.lt_irrefl *)
#[local]
Definition lt_le_S_stt := fun n m => (proj2 (Nat.le_succ_l n m)).(* Lt.lt_le_S *)
#[local]
Definition lt_n_Sm_le_stt := fun n m => (proj1 (Nat.lt_succ_r n m)).(* Lt.lt_n_Sm_le *)
#[local]
Definition le_lt_n_Sm_stt := fun n m => (proj2 (Nat.lt_succ_r n m)).(* Lt.le_lt_n_Sm *)
#[local]
Definition le_not_lt_stt := fun n m => (proj1 (Nat.le_ngt n m)).(* Lt.le_not_lt *)
#[local]
Definition lt_not_le_stt := fun n m => (proj1 (Nat.lt_nge n m)).(* Lt.lt_0_Sn Lt.lt_n_0 *)
#[local]
Definition neq_0_lt_stt := fun n Hn => proj1 (Nat.neq_0_lt_0 n) (Nat.neq_sym 0 n Hn).#[local]
Definition lt_0_neq_stt := fun n Hlt => Nat.neq_sym n 0 (proj2 (Nat.neq_0_lt_0 n) Hlt).(* Lt.lt_n_Sn Lt.lt_S *)
#[local]
Definition lt_n_S_stt := fun n m => (proj1 (Nat.succ_lt_mono n m)).(* Lt.lt_n_S *)
#[local]
Definition lt_S_n_stt := fun n m => (proj2 (Nat.succ_lt_mono n m)).(* Lt.lt_S_n *)
#[local]
Definition lt_pred_stt := fun n m => proj1 (Nat.lt_succ_lt_pred n m).(* Lt.lt_pred *)
#[local]
Definition lt_pred_n_n_stt := fun n Hlt => Nat.lt_pred_l n (proj2 (Nat.neq_0_lt_0 n) Hlt).(* Lt.lt_le_weak *)
#[local]
Definition gt_Sn_O_stt : forall n, S n > 0 := Nat.lt_0_succ.(* Gt.gt_Sn_O *)
#[local]
Definition gt_Sn_n_stt : forall n, S n > n := Nat.lt_succ_diag_r.(* Gt.gt_Sn_n *)
#[local]
Definition gt_n_S_stt : forall n m, n > m -> S n > S m := fun n m Hgt => proj1 (Nat.succ_lt_mono m n) Hgt.(* Gt.gt_n_S *)
#[local]
Definition gt_S_n_stt : forall n m, S m > S n -> m > n := fun n m Hgt => proj2 (Nat.succ_lt_mono n m) Hgt.(* Gt.gt_S_n *)
#[local]
Definition gt_pred_stt : forall n m, m > S n -> pred m > n := fun n m Hgt => proj1 (Nat.lt_succ_lt_pred n m) Hgt.(* Gt.gt_pred *)
#[local]
Definition gt_irrefl_stt : forall n, ~ n > n := Nat.lt_irrefl.(* Gt.gt_irrefl *)
#[local]
Definition gt_asym_stt : forall n m, n > m -> ~ m > n := fun n m => Nat.lt_asymm m n.(* Gt.gt_asym *)
#[local]
Definition le_not_gt_stt : forall n m, n <= m -> ~ n > m := fun n m => proj1 (Nat.le_ngt n m).(* Gt.le_not_gt *)
#[local]
Definition gt_not_le_stt: forall n m, n > m -> ~ n <= m := fun n m => proj1 (Nat.lt_nge m n).(* Gt.gt_not_le *)
#[local]
Definition le_S_gt_stt: forall n m, S n <= m -> m > n := fun n m => proj1 (Nat.le_succ_l n m).(* Gt.le_S_gt *)
#[local]
Definition gt_S_le_stt : forall n m, S m > n -> n <= m := fun n m => proj2 (Nat.succ_le_mono n m).(* Gt.gt_S_le *)
#[local]
Definition gt_le_S_stt : forall n m, m > n -> S n <= m := fun n m => proj2 (Nat.le_succ_l n m).(* Gt.gt_le_S *)
#[local]
Definition le_gt_S_stt : forall n m, n <= m -> S m > n := fun n m => proj1 (Nat.succ_le_mono n m).(* Gt.le_gt_S *)
#[local]
Definition gt_trans_S_stt : forall n m p, S n > m -> m > p -> n > p
                          := fun n m p Hgt1 Hgt2 => Nat.lt_le_trans p m n Hgt2 (proj2 (Nat.succ_le_mono _ _) Hgt1).(* Gt.gt_trans_S *)
#[local]
Definition le_gt_trans_stt : forall n m p, m <= n -> m > p -> n > p
                           := fun n m p Hle Hgt => Nat.lt_le_trans p m n Hgt Hle.(* Gt.le_gt_trans *)
#[local]
Definition gt_le_trans_stt : forall n m p, n > m -> p <= m -> n > p
                           := fun n m p Hgt Hle => Nat.le_lt_trans p m n Hle Hgt.(* Gt.gt_le_trans *)
#[local]
Definition plus_gt_compat_l_stt : forall n m p, n > m -> p + n > p + m
                                := fun n m p Hgt => proj1 (Nat.add_lt_mono_l m n p) Hgt.(* Plus.plus_assoc *)
#[local]
Definition plus_assoc_reverse_stt := fun n m p => eq_sym (Nat.add_assoc n m p).(* Plus.plus_le_compat_r *)
#[local]
Definition le_plus_r_stt := (fun n m => Nat.le_add_l m n).#[local]
Definition le_plus_trans_stt := (fun n m p Hle => Nat.le_trans n _ _ Hle (Nat.le_add_r m p)).(* Plus.le_plus_l Plus.le_plus_r_stt Plus.le_plus_trans_stt *)
#[local]
Definition lt_plus_trans_stt := (fun n m p Hlt => Nat.lt_le_trans n _ _ Hlt (Nat.le_add_r m p)).(* Plus_lt_compat_r *)


(* ** [sub] *)
#[local]
Definition minus_n_O_stt := fun n => eq_sym (Nat.sub_0_r n).(* Minus.minus_n_O *)
#[local]
Definition minus_Sn_m_stt := fun n m Hle => eq_sym (Nat.sub_succ_l m n Hle).(* Minus.minus_Sn_m *)
#[local]
Definition minus_diag_reverse_stt := fun n => eq_sym (Nat.sub_diag n).

(* Specifications: *)
#[local] Lemma minus_plus_simpl_l_reverse_stt n m p : n - m = p + n - (p + m).