Reshuffle in preparation to break the dependency on N's implementation (#75)

Numbers/BinaryNaturals/Addition.agda

@@ -3,10 +3,13 @@
 open import LogicalFormulae
 open import Functions
 open import Lists.Lists
+open import Numbers.Naturals.Semiring
 open import Numbers.Naturals.Naturals
+open import Numbers.Naturals.Order
 open import Groups.Definition
 open import Numbers.BinaryNaturals.Definition
 open import Semirings.Definition
+open import Orders
 
 module Numbers.BinaryNaturals.Addition where
 
@@ -39,7 +42,7 @@ _+B_ : BinNat → BinNat → BinNat
     refine b pr with canonical b
     refine b pr | x :: bl = ::Inj pr
     t : NToBinNat (0 +N binNatToN (zero :: b)) ≡ zero :: b
-    t with orderIsTotal 0 (binNatToN b)
+    t with TotalOrder.totality ℕTotalOrder 0 (binNatToN b)
     t | inl (inl pos) = transitivity (doubleIsBitShift (binNatToN b) pos) (applyEquality (zero ::_) (transitivity (binToBin b) (equalityCommutative (refine b prB))))
     t | inl (inr ())
     ... | inr eq with binNatToNZero b (equalityCommutative eq)
@@ -61,9 +64,9 @@ _+B_ : BinNat → BinNat → BinNat
 
 +BIsInherited' : (a b : BinNat) → a +Binherit b ≡ canonical (a +B b)
 
-+BinheritLemma a b prA prB with orderIsTotal 0 (binNatToN a +N binNatToN b)
++BinheritLemma a b prA prB with TotalOrder.totality ℕTotalOrder 0 (binNatToN a +N binNatToN b)
 +BinheritLemma a b prA prB | inl (inl x) rewrite doubleIsBitShift (binNatToN a +N binNatToN b) x = applyEquality (one ::_) (+BIsInherited a b prA prB)
-+BinheritLemma a b prA prB | inr x with sumZeroImpliesOperandsZero (binNatToN a) (equalityCommutative x)
++BinheritLemma a b prA prB | inr x with sumZeroImpliesSummandsZero (equalityCommutative x)
 +BinheritLemma a b prA prB | inr x | fst ,, snd = ans2
   where
     bad : b ≡ []
@@ -75,10 +78,10 @@ _+B_ : BinNat → BinNat → BinNat
 
 +BIsInherited [] b _ prB = +BIsInherited[] b prB
 +BIsInherited (x :: a) [] prA _ = transitivity (applyEquality NToBinNat (Semiring.commutative ℕSemiring (binNatToN (x :: a)) 0)) (transitivity (binToBin (x :: a)) (equalityCommutative prA))
-+BIsInherited (zero :: as) (zero :: b) prA prB with orderIsTotal 0 (binNatToN as +N binNatToN b)
++BIsInherited (zero :: as) (zero :: b) prA prB with TotalOrder.totality ℕTotalOrder 0 (binNatToN as +N binNatToN b)
 ... | inl (inl 0<) rewrite Semiring.commutative ℕSemiring (binNatToN as) 0 | Semiring.commutative ℕSemiring (binNatToN b) 0 | Semiring.+Associative ℕSemiring (binNatToN as +N binNatToN as) (binNatToN b) (binNatToN b) | equalityCommutative (Semiring.+Associative ℕSemiring (binNatToN as) (binNatToN as) (binNatToN b)) | Semiring.commutative ℕSemiring (binNatToN as) (binNatToN b) | Semiring.+Associative ℕSemiring (binNatToN as) (binNatToN b) (binNatToN as) | equalityCommutative (Semiring.+Associative ℕSemiring (binNatToN as +N binNatToN b) (binNatToN as) (binNatToN b)) | Semiring.commutative ℕSemiring 0 ((binNatToN as +N binNatToN b) +N (binNatToN as +N binNatToN b)) | equalityCommutative (Semiring.+Associative ℕSemiring (binNatToN as +N binNatToN b) (binNatToN as +N binNatToN b) 0) = transitivity (doubleIsBitShift (binNatToN as +N binNatToN b) (identityOfIndiscernablesRight _<N_ 0< (Semiring.commutative ℕSemiring (binNatToN b) _))) (applyEquality (zero ::_) (+BIsInherited as b (canonicalDescends as prA) (canonicalDescends b prB)))
 +BIsInherited (zero :: as) (zero :: b) prA prB | inl (inr ())
-... | inr p with sumZeroImpliesOperandsZero (binNatToN as) (equalityCommutative p)
+... | inr p with sumZeroImpliesSummandsZero {binNatToN as} (equalityCommutative p)
 +BIsInherited (zero :: as) (zero :: b) prA prB | inr p | as=0 ,, b=0 rewrite as=0 | b=0 = exFalso ans
   where
     bad : (b : BinNat) → (pr : b ≡ canonical b) → (pr2 : binNatToN b ≡ 0) → b ≡ []
@@ -142,7 +145,7 @@ _+B_ : BinNat → BinNat → BinNat
   where
     ans : NToBinNat (2 *N (binNatToN as +N binNatToN bs)) ≡ canonical (zero :: (as +B bs))
     ans with inspect (binNatToN as +N binNatToN bs)
-    ans | zero with≡ x with sumZeroImpliesOperandsZero (binNatToN as) x
+    ans | zero with≡ x with sumZeroImpliesSummandsZero {binNatToN as} x
     ... | as=0 ,, bs=0 rewrite as=0 | bs=0 = foo
       where
         u : canonical (as +Binherit bs) ≡ []
@@ -162,7 +165,7 @@ _+B_ : BinNat → BinNat → BinNat
   where
     ans2 : incr (NToBinNat (2 *N (binNatToN as +N binNatToN bs))) ≡ one :: canonical (as +B bs)
     ans2 with inspect (binNatToN as +N binNatToN bs)
-    ans2 | zero with≡ x with sumZeroImpliesOperandsZero (binNatToN as) x
+    ans2 | zero with≡ x with sumZeroImpliesSummandsZero {binNatToN as} x
     ans2 | zero with≡ x | as=0 ,, bs=0 rewrite as=0 | bs=0 = applyEquality (one ::_) (transitivity t (+BIsInherited' as bs))
       where
         t : [] ≡ as +Binherit bs
@@ -172,7 +175,7 @@ _+B_ : BinNat → BinNat → BinNat
   where
     ans : incr (NToBinNat (2 *N (binNatToN as +N binNatToN bs))) ≡ one :: canonical (as +B bs)
     ans with inspect (binNatToN as +N binNatToN bs)
-    ans | zero with≡ x with sumZeroImpliesOperandsZero (binNatToN as) x
+    ans | zero with≡ x with sumZeroImpliesSummandsZero {binNatToN as} x
     ... | as=0 ,, bs=0 rewrite as=0 | bs=0 = applyEquality (one ::_) (transitivity t (+BIsInherited' as bs))
       where
         t : [] ≡ NToBinNat (binNatToN as +N binNatToN bs)
@@ -182,7 +185,7 @@ _+B_ : BinNat → BinNat → BinNat
   where
     ans : incr (incr (NToBinNat (2 *N (binNatToN as +N binNatToN bs)))) ≡ canonical (zero :: incr (as +B bs))
     ans with inspect (binNatToN as +N binNatToN bs)
-    ... | zero with≡ x with sumZeroImpliesOperandsZero (binNatToN as) x
+    ... | zero with≡ x with sumZeroImpliesSummandsZero {binNatToN as} x
     ans | zero with≡ x | as=0 ,, bs=0 rewrite as=0 | bs=0 = bar
       where
         u' : canonical (as +Binherit bs) ≡ []

Numbers/BinaryNaturals/Definition.agda

@@ -3,7 +3,8 @@
 open import LogicalFormulae
 open import Functions
 open import Lists.Lists
-open import Numbers.Naturals.Naturals
+open import Numbers.Naturals.Semiring
+open import Numbers.Naturals.Order
 open import Numbers.Naturals.Definition
 open import Groups.Definition
 open import Semirings.Definition
@@ -98,7 +99,7 @@ module Numbers.BinaryNaturals.Definition where
   canonicalAscends' {i} a pr = canonicalAscends {i} a (t a pr)
     where
       t : (a : BinNat) → (canonical a ≡ [] → False) → 0 <N binNatToN a
-      t a pr with orderIsTotal 0 (binNatToN a)
+      t a pr with TotalOrder.totality ℕTotalOrder 0 (binNatToN a)
       t a pr | inl (inl x) = x
       t a pr | inr x = exFalso (pr (binNatToNZero a (equalityCommutative x)))
 

Numbers/BinaryNaturals/Multiplication.agda

@@ -3,6 +3,7 @@
 open import LogicalFormulae
 open import Functions
 open import Lists.Lists
+open import Numbers.Naturals.Semiring
 open import Numbers.Naturals.Naturals
 open import Groups.Definition
 open import Numbers.BinaryNaturals.Definition
@@ -77,7 +78,7 @@ module Numbers.BinaryNaturals.Multiplication where
       t : binNatToN (as *B (zero :: bs)) +N binNatToN bs ≡ 0
       t = transitivity (equalityCommutative (nToN _)) (applyEquality binNatToN x)
       u : (binNatToN (as *B (zero :: bs)) ≡ 0) && (binNatToN bs ≡ 0)
-      u = sumZeroImpliesOperandsZero _ t
+      u = sumZeroImpliesSummandsZero t
       v : canonical bs ≡ []
       v with u
       ... | fst ,, snd = binNatToNZero bs snd

Numbers/BinaryNaturals/Order.agda

@@ -4,7 +4,9 @@ open import WellFoundedInduction
 open import LogicalFormulae
 open import Functions
 open import Lists.Lists
-open import Numbers.Naturals.Naturals
+open import Numbers.Naturals.Order
+open import Numbers.Naturals.Order.Lemmas
+open import Numbers.Naturals.Semiring
 open import Groups.Definition
 open import Numbers.BinaryNaturals.Definition
 open import Orders
@@ -27,7 +29,7 @@ module Numbers.BinaryNaturals.Order where
   badCompare'' ()
 
   _<BInherited_ : BinNat → BinNat → Compare
-  a <BInherited b with orderIsTotal (binNatToN a) (binNatToN b)
+  a <BInherited b with TotalOrder.totality ℕTotalOrder (binNatToN a) (binNatToN b)
   (a <BInherited b) | inl (inl x) = FirstLess
   (a <BInherited b) | inl (inr x) = FirstGreater
   (a <BInherited b) | inr x = Equal
@@ -283,24 +285,24 @@ module Numbers.BinaryNaturals.Order where
   chopFirstBit m n {one} FirstGreater = refl
 
   chopDouble : (a b : BinNat) (i : Bit) → (i :: a) <BInherited (i :: b) ≡ a <BInherited b
-  chopDouble a b i with orderIsTotal (binNatToN a) (binNatToN b)
-  chopDouble a b zero | inl (inl a<b) with orderIsTotal (2 *N binNatToN a) (2 *N binNatToN b)
+  chopDouble a b i with TotalOrder.totality ℕTotalOrder (binNatToN a) (binNatToN b)
+  chopDouble a b zero | inl (inl a<b) with TotalOrder.totality ℕTotalOrder (2 *N binNatToN a) (2 *N binNatToN b)
   chopDouble a b zero | inl (inl a<b) | inl (inl x) = refl
   chopDouble a b zero | inl (inl a<b) | inl (inr b<a) = exFalso (PartialOrder.irreflexive (TotalOrder.order ℕTotalOrder) (PartialOrder.<Transitive (TotalOrder.order ℕTotalOrder) b<a (lessRespectsMultiplicationLeft (binNatToN a) (binNatToN b) 2 a<b (le 1 refl))))
   chopDouble a b zero | inl (inl a<b) | inr a=b rewrite productCancelsLeft 2 (binNatToN a) (binNatToN b) (le 1 refl) a=b = exFalso (PartialOrder.irreflexive (TotalOrder.order ℕTotalOrder) a<b)
-  chopDouble a b one | inl (inl a<b) with orderIsTotal (2 *N binNatToN a) (2 *N binNatToN b)
+  chopDouble a b one | inl (inl a<b) with TotalOrder.totality ℕTotalOrder (2 *N binNatToN a) (2 *N binNatToN b)
   chopDouble a b one | inl (inl a<b) | inl (inl 2a<2b) = refl
   chopDouble a b one | inl (inl a<b) | inl (inr 2b<2a) = exFalso (PartialOrder.irreflexive (TotalOrder.order ℕTotalOrder) (PartialOrder.<Transitive (TotalOrder.order ℕTotalOrder) a<b (cancelInequalityLeft {2} 2b<2a)))
   chopDouble a b one | inl (inl a<b) | inr 2a=2b rewrite productCancelsLeft 2 (binNatToN a) (binNatToN b) (le 1 refl) 2a=2b = exFalso (PartialOrder.irreflexive (TotalOrder.order ℕTotalOrder) a<b)
-  chopDouble a b zero | inl (inr b<a) with orderIsTotal (2 *N binNatToN a) (2 *N binNatToN b)
+  chopDouble a b zero | inl (inr b<a) with TotalOrder.totality ℕTotalOrder (2 *N binNatToN a) (2 *N binNatToN b)
   chopDouble a b zero | inl (inr b<a) | inl (inl 2a<2b) = exFalso (PartialOrder.irreflexive (TotalOrder.order ℕTotalOrder) (PartialOrder.<Transitive (TotalOrder.order ℕTotalOrder) b<a (cancelInequalityLeft {2} {binNatToN a} {binNatToN b} 2a<2b)))
   chopDouble a b zero | inl (inr b<a) | inl (inr 2b<2a) = refl
   chopDouble a b zero | inl (inr b<a) | inr 2a=2b rewrite productCancelsLeft 2 (binNatToN a) (binNatToN b) (le 1 refl) 2a=2b = exFalso (PartialOrder.irreflexive (TotalOrder.order ℕTotalOrder) b<a)
-  chopDouble a b one | inl (inr b<a) with orderIsTotal (2 *N binNatToN a) (2 *N binNatToN b)
+  chopDouble a b one | inl (inr b<a) with TotalOrder.totality ℕTotalOrder (2 *N binNatToN a) (2 *N binNatToN b)
   chopDouble a b one | inl (inr b<a) | inl (inl 2a<2b) = exFalso (PartialOrder.irreflexive (TotalOrder.order ℕTotalOrder) (PartialOrder.<Transitive (TotalOrder.order ℕTotalOrder) b<a (cancelInequalityLeft {2} 2a<2b)))
   chopDouble a b one | inl (inr b<a) | inl (inr x) = refl
   chopDouble a b one | inl (inr b<a) | inr 2a=2b rewrite productCancelsLeft 2 (binNatToN a) (binNatToN b) (le 1 refl) 2a=2b = exFalso (PartialOrder.irreflexive (TotalOrder.order ℕTotalOrder) b<a)
-  chopDouble a b i | inr x with orderIsTotal (binNatToN (i :: a)) (binNatToN (i :: b))
+  chopDouble a b i | inr x with TotalOrder.totality ℕTotalOrder (binNatToN (i :: a)) (binNatToN (i :: b))
   chopDouble a b zero | inr a=b | inl (inl a<b) rewrite a=b = exFalso (PartialOrder.irreflexive (TotalOrder.order ℕTotalOrder) a<b)
   chopDouble a b one | inr a=b | inl (inl a<b) rewrite a=b = exFalso (PartialOrder.irreflexive (TotalOrder.order ℕTotalOrder) a<b)
   chopDouble a b zero | inr a=b | inl (inr b<a) rewrite a=b = exFalso (PartialOrder.irreflexive (TotalOrder.order ℕTotalOrder) b<a)
@@ -311,23 +313,23 @@ module Numbers.BinaryNaturals.Order where
   succNotLess {succ n} (le x proof) = succNotLess {n} (le x (succInjective (transitivity (applyEquality succ (transitivity (Semiring.commutative ℕSemiring (succ x) (succ n)) (transitivity (applyEquality succ (transitivity (Semiring.commutative ℕSemiring n (succ x)) (applyEquality succ (Semiring.commutative ℕSemiring x n)))) (Semiring.commutative ℕSemiring (succ (succ n)) x)))) proof)))
 
   <BIsInherited : (a b : BinNat) → a <BInherited b ≡ a <B b
-  <BIsInherited [] b with orderIsTotal 0 (binNatToN b)
+  <BIsInherited [] b with TotalOrder.totality ℕTotalOrder 0 (binNatToN b)
   <BIsInherited [] b | inl (inl x) with inspect (binNatToN b)
   <BIsInherited [] b | inl (inl x) | 0 with≡ pr rewrite binNatToNZero b pr | pr = exFalso (PartialOrder.irreflexive (TotalOrder.order ℕTotalOrder) x)
   <BIsInherited [] b | inl (inl x) | (succ bl) with≡ pr rewrite pr = equalityCommutative (zeroLess b λ p → zeroNotSucc bl b p pr)
   <BIsInherited [] b | inr 0=b rewrite canonicalSecond [] b Equal | binNatToNZero b (equalityCommutative 0=b) = refl
-  <BIsInherited (a :: as) [] with orderIsTotal (binNatToN (a :: as)) 0
+  <BIsInherited (a :: as) [] with TotalOrder.totality ℕTotalOrder (binNatToN (a :: as)) 0
   <BIsInherited (a :: as) [] | inl (inr x) with inspect (binNatToN (a :: as))
   <BIsInherited (a :: as) [] | inl (inr x) | zero with≡ pr rewrite binNatToNZero (a :: as) pr | pr = exFalso (PartialOrder.irreflexive (TotalOrder.order ℕTotalOrder) x)
   <BIsInherited (a :: as) [] | inl (inr x) | succ y with≡ pr rewrite pr = equalityCommutative (zeroLess' (a :: as) λ i → zeroNotSucc y (a :: as) i pr)
   <BIsInherited (a :: as) [] | inr x rewrite canonicalFirst (a :: as) [] Equal | binNatToNZero (a :: as) x = refl
   <BIsInherited (zero :: a) (zero :: b) = transitivity (chopDouble a b zero) (<BIsInherited a b)
-  <BIsInherited (zero :: a) (one :: b) with orderIsTotal (binNatToN (zero :: a)) (binNatToN (one :: b))
-  <BIsInherited (zero :: a) (one :: b) | inl (inl 2a<2b+1) with orderIsTotal (binNatToN a) (binNatToN b)
+  <BIsInherited (zero :: a) (one :: b) with TotalOrder.totality ℕTotalOrder (binNatToN (zero :: a)) (binNatToN (one :: b))
+  <BIsInherited (zero :: a) (one :: b) | inl (inl 2a<2b+1) with TotalOrder.totality ℕTotalOrder (binNatToN a) (binNatToN b)
   <BIsInherited (zero :: a) (one :: b) | inl (inl 2a<2b+1) | inl (inl a<b) = equalityCommutative (equalToFirstLess FirstLess a b (equalityCommutative indHyp))
      where
        t : a <BInherited b ≡ FirstLess
-       t with orderIsTotal (binNatToN a) (binNatToN b)
+       t with TotalOrder.totality ℕTotalOrder (binNatToN a) (binNatToN b)
        t | inl (inl x) = refl
        t | inl (inr x) = exFalso (PartialOrder.irreflexive (TotalOrder.order ℕTotalOrder) (PartialOrder.<Transitive (TotalOrder.order ℕTotalOrder) x a<b))
        t | inr x rewrite x = exFalso (PartialOrder.irreflexive (TotalOrder.order ℕTotalOrder) a<b)
@@ -335,12 +337,12 @@ module Numbers.BinaryNaturals.Order where
        indHyp = transitivity (equalityCommutative t) (<BIsInherited a b)
   <BIsInherited (zero :: a) (one :: b) | inl (inl 2a<2b+1) | inl (inr b<a) = exFalso (noIntegersBetweenXAndSuccX {2 *N binNatToN a} (2 *N binNatToN b) (lessRespectsMultiplicationLeft (binNatToN b) (binNatToN a) 2 b<a (le 1 refl)) 2a<2b+1)
   <BIsInherited (zero :: a) (one :: b) | inl (inl 2a<2b+1) | inr a=b rewrite a=b | canonicalFirst a b FirstLess | canonicalSecond (canonical a) b FirstLess | transitivity (equalityCommutative (binToBin a)) (transitivity (applyEquality NToBinNat a=b) (binToBin b)) = equalityCommutative (lemma1 (canonical b))
-  <BIsInherited (zero :: a) (one :: b) | inl (inr 2b+1<2a) with orderIsTotal (binNatToN a) (binNatToN b)
+  <BIsInherited (zero :: a) (one :: b) | inl (inr 2b+1<2a) with TotalOrder.totality ℕTotalOrder (binNatToN a) (binNatToN b)
   <BIsInherited (zero :: a) (one :: b) | inl (inr 2b+1<2a) | inl (inl a<b) = exFalso (PartialOrder.irreflexive (TotalOrder.order ℕTotalOrder) (PartialOrder.<Transitive (TotalOrder.order ℕTotalOrder) 2b+1<2a (PartialOrder.<Transitive (TotalOrder.order ℕTotalOrder) (lessRespectsMultiplicationLeft (binNatToN a) (binNatToN b) 2 a<b (le 1 refl)) (le zero refl))))
   <BIsInherited (zero :: a) (one :: b) | inl (inr 2b+1<2a) | inl (inr b<a) = equalityCommutative (equalToFirstGreater FirstLess a b (equalityCommutative indHyp))
     where
       t : a <BInherited b ≡ FirstGreater
-      t with orderIsTotal (binNatToN a) (binNatToN b)
+      t with TotalOrder.totality ℕTotalOrder (binNatToN a) (binNatToN b)
       t | inl (inl x) = exFalso (PartialOrder.irreflexive (TotalOrder.order ℕTotalOrder) (PartialOrder.<Transitive (TotalOrder.order ℕTotalOrder) x b<a))
       t | inl (inr x) = refl
       t | inr x rewrite x = exFalso (PartialOrder.irreflexive (TotalOrder.order ℕTotalOrder) b<a)
@@ -348,12 +350,12 @@ module Numbers.BinaryNaturals.Order where
       indHyp = transitivity (equalityCommutative t) (<BIsInherited a b)
   <BIsInherited (zero :: a) (one :: b) | inl (inr 2b+1<2a) | inr a=b rewrite a=b = exFalso (succNotLess 2b+1<2a)
   <BIsInherited (zero :: a) (one :: b) | inr 2a=2b+1 = exFalso (parity (binNatToN b) (binNatToN a) (equalityCommutative 2a=2b+1))
-  <BIsInherited (one :: a) (zero :: b) with orderIsTotal (binNatToN (one :: a)) (binNatToN (zero :: b))
-  <BIsInherited (one :: a) (zero :: b) | inl (inl 2a+1<2b) with orderIsTotal (binNatToN a) (binNatToN b)
+  <BIsInherited (one :: a) (zero :: b) with TotalOrder.totality ℕTotalOrder (binNatToN (one :: a)) (binNatToN (zero :: b))
+  <BIsInherited (one :: a) (zero :: b) | inl (inl 2a+1<2b) with TotalOrder.totality ℕTotalOrder (binNatToN a) (binNatToN b)
   <BIsInherited (one :: a) (zero :: b) | inl (inl 2a+1<2b) | inl (inl a<b) = equalityCommutative (equalToFirstLess FirstGreater a b (equalityCommutative indHyp))
     where
       t : a <BInherited b ≡ FirstLess
-      t with orderIsTotal (binNatToN a) (binNatToN b)
+      t with TotalOrder.totality ℕTotalOrder (binNatToN a) (binNatToN b)
       t | inl (inr x) = exFalso (PartialOrder.irreflexive (TotalOrder.order ℕTotalOrder) (PartialOrder.<Transitive (TotalOrder.order ℕTotalOrder) x a<b))
       t | inl (inl x) = refl
       t | inr x rewrite x = exFalso (PartialOrder.irreflexive (TotalOrder.order ℕTotalOrder) a<b)
@@ -361,12 +363,12 @@ module Numbers.BinaryNaturals.Order where
       indHyp = transitivity (equalityCommutative t) (<BIsInherited a b)
   <BIsInherited (one :: a) (zero :: b) | inl (inl 2a+1<2b) | inl (inr b<a) = exFalso (PartialOrder.irreflexive (TotalOrder.order ℕTotalOrder) (PartialOrder.<Transitive (TotalOrder.order ℕTotalOrder) 2a+1<2b (PartialOrder.<Transitive (TotalOrder.order ℕTotalOrder) (lessRespectsMultiplicationLeft (binNatToN b) (binNatToN a) 2 b<a (le 1 refl)) (le zero refl))))
   <BIsInherited (one :: a) (zero :: b) | inl (inl 2a+1<2b) | inr a=b rewrite a=b = exFalso (succNotLess 2a+1<2b)
-  <BIsInherited (one :: a) (zero :: b) | inl (inr 2b<2a+1) with orderIsTotal (binNatToN a) (binNatToN b)
+  <BIsInherited (one :: a) (zero :: b) | inl (inr 2b<2a+1) with TotalOrder.totality ℕTotalOrder (binNatToN a) (binNatToN b)
   <BIsInherited (one :: a) (zero :: b) | inl (inr 2b<2a+1) | inl (inl a<b) = exFalso (noIntegersBetweenXAndSuccX {2 *N binNatToN b} (2 *N binNatToN a) (lessRespectsMultiplicationLeft (binNatToN a) (binNatToN b) 2 a<b (le 1 refl)) 2b<2a+1)
   <BIsInherited (one :: a) (zero :: b) | inl (inr 2b<2a+1) | inl (inr b<a) = equalityCommutative (equalToFirstGreater FirstGreater a b (equalityCommutative indHyp))
     where
       t : a <BInherited b ≡ FirstGreater
-      t with orderIsTotal (binNatToN a) (binNatToN b)
+      t with TotalOrder.totality ℕTotalOrder (binNatToN a) (binNatToN b)
       t | inl (inl x) = exFalso (PartialOrder.irreflexive (TotalOrder.order ℕTotalOrder) (PartialOrder.<Transitive (TotalOrder.order ℕTotalOrder) x b<a))
       t | inl (inr x) = refl
       t | inr x rewrite x = exFalso (PartialOrder.irreflexive (TotalOrder.order ℕTotalOrder) b<a)

Numbers/BinaryNaturals/Subtraction.agda

@@ -2,6 +2,7 @@
 
 open import LogicalFormulae
 open import Lists.Lists
+open import Numbers.Naturals.Semiring
 open import Numbers.Naturals.Naturals
 open import Numbers.Naturals.Order
 open import Numbers.BinaryNaturals.Definition

Numbers/Integers/Addition.agda

@@ -1,7 +1,7 @@
 {-# OPTIONS --safe --warning=error --without-K #-}
 
 open import LogicalFormulae
-open import Numbers.Naturals.Naturals
+open import Numbers.Naturals.Semiring
 open import Numbers.Integers.Definition
 open import Semirings.Definition
 open import Groups.Groups

Numbers/Integers/Integers.agda

@@ -1,6 +1,6 @@
 {-# OPTIONS --safe --warning=error --without-K #-}
 
-open import Numbers.Naturals.Naturals
+open import Numbers.Naturals.Definition
 open import Numbers.Integers.Definition
 open import Numbers.Integers.Addition
 open import Numbers.Integers.Multiplication

Numbers/Integers/Multiplication.agda

@@ -1,7 +1,7 @@
 {-# OPTIONS --safe --warning=error --without-K #-}
 
 open import LogicalFormulae
-open import Numbers.Naturals.Naturals
+open import Numbers.Naturals.Semiring
 open import Numbers.Naturals.Multiplication
 open import Numbers.Integers.Definition
 open import Numbers.Integers.Addition

Numbers/Integers/Order.agda

@@ -1,7 +1,8 @@
 {-# OPTIONS --safe --warning=error --without-K #-}
 
 open import LogicalFormulae
-open import Numbers.Naturals.Naturals
+open import Numbers.Naturals.Semiring
+open import Numbers.Naturals.Order
 open import Numbers.Integers.Definition
 open import Numbers.Integers.Addition
 open import Numbers.Integers.Multiplication
@@ -68,13 +69,13 @@ _<Z_.proof (lessNegsuccNonneg {zero} {b}) = refl
 _<Z_.proof (lessNegsuccNonneg {succ a} {b}) = _<Z_.proof (lessNegsuccNonneg {a} {b})
 
 lessThanTotalZ : {a b : ℤ} → ((a <Z b) || (b <Z a)) || (a ≡ b)
-lessThanTotalZ {nonneg a} {nonneg b} with orderIsTotal a b
+lessThanTotalZ {nonneg a} {nonneg b} with TotalOrder.totality ℕTotalOrder a b
 lessThanTotalZ {nonneg a} {nonneg b} | inl (inl a<b) = inl (inl (lessInherits a<b))
 lessThanTotalZ {nonneg a} {nonneg b} | inl (inr b<a) = inl (inr (lessInherits b<a))
 lessThanTotalZ {nonneg a} {nonneg b} | inr a=b = inr (applyEquality nonneg a=b)
 lessThanTotalZ {nonneg a} {negSucc b} = inl (inr (lessNegsuccNonneg {b} {a}))
 lessThanTotalZ {negSucc a} {nonneg x} = inl (inl (lessNegsuccNonneg {a} {x}))
-lessThanTotalZ {negSucc a} {negSucc b} with orderIsTotal a b
+lessThanTotalZ {negSucc a} {negSucc b} with TotalOrder.totality ℕTotalOrder a b
 ... | inl (inl a<b) = inl (inr (lessInheritsNegsucc a<b))
 ... | inl (inr b<a) = inl (inl (lessInheritsNegsucc b<a))
 lessThanTotalZ {negSucc a} {negSucc .a} | inr refl = inr refl

Numbers/Modulo/Addition.agda

@@ -7,8 +7,9 @@ open import Groups.Definition
 open import Groups.Groups
 open import Groups.Abelian.Definition
 open import Groups.FiniteGroups.Definition
+open import Numbers.Naturals.Semiring
 open import Numbers.Naturals.Naturals
-open import Numbers.Naturals.Addition -- TODO remove this dependency
+open import Numbers.Naturals.Order
 open import Numbers.Primes.PrimeNumbers
 open import Setoids.Setoids
 open import Sets.FinSet
@@ -20,6 +21,7 @@ open import Orders
 open import Numbers.Modulo.Definition
 
 module Numbers.Modulo.Addition where
+open TotalOrder ℕTotalOrder
 
 cancelSumFromInequality : {a b c : ℕ} → a +N b <N a +N c → b <N c
 cancelSumFromInequality {a} {b} {c} (le x proof) = le x help
@@ -29,7 +31,7 @@ cancelSumFromInequality {a} {b} {c} (le x proof) = le x help
 
 _+n_ : {n : ℕ} {pr : 0 <N n} → ℤn n pr → ℤn n pr → ℤn n pr
 _+n_ {0} {le x ()} a b
-_+n_ {succ n} {pr} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } with orderIsTotal (a +N b) (succ n)
+_+n_ {succ n} {pr} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } with totality (a +N b) (succ n)
 _+n_ {succ n} {pr} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } | inl (inl (a+b<n)) = record { x = a +N b ; xLess = a+b<n }
 _+n_ {succ n} {pr} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } | inl (inr (n<a+b)) = record { x = subtractionNResult.result sub ; xLess = pr2 }
     where
@@ -45,12 +47,12 @@ _+n_ {succ n} {pr} record { x = a ; xLess = aLess } record { x = b ; xLess = bLe
 
 plusZnIdentityRight : {n : ℕ} → {pr : 0 <N n} → (a : ℤn n pr) → (a +n record { x = 0 ; xLess = pr }) ≡ a
 plusZnIdentityRight {zero} {()} a
-plusZnIdentityRight {succ x} {_} record { x = a ; xLess = aLess } with orderIsTotal (a +N 0) (succ x)
+plusZnIdentityRight {succ x} {_} record { x = a ; xLess = aLess } with totality (a +N 0) (succ x)
 plusZnIdentityRight {succ x} {_} record { x = a ; xLess = aLess } | inl (inl a<sx) = equalityZn _ _ (Semiring.commutative ℕSemiring a 0)
 plusZnIdentityRight {succ x} {_} record { x = a ; xLess = aLess } | inl (inr sx<a) = exFalso (f aLess sx<a)
   where
     f : (aL : a <N succ x) → (sx<a : succ x <N a +N 0) → False
-    f aL sx<a rewrite Semiring.commutative ℕSemiring a 0 = orderIsIrreflexive aL sx<a
+    f aL sx<a rewrite Semiring.commutative ℕSemiring a 0 = irreflexive (<Transitive aL sx<a)
 plusZnIdentityRight {succ x} {_} record { x = a ; xLess = aLess } | inr a=sx = exFalso (f aLess a=sx)
   where
     f : (aL : a <N succ x) → (a=sx : a +N 0 ≡ succ x) → False
@@ -59,7 +61,7 @@ plusZnIdentityRight {succ x} {_} record { x = a ; xLess = aLess } | inr a=sx = e
 
 plusZnIdentityLeft : {n : ℕ} → {pr : 0 <N n} → (a : ℤn n pr) → (record { x = 0 ; xLess = pr }) +n a ≡ a
 plusZnIdentityLeft {zero} {()}
-plusZnIdentityLeft {succ n} {pr} record { x = x ; xLess = xLess } with orderIsTotal x (succ n)
+plusZnIdentityLeft {succ n} {pr} record { x = x ; xLess = xLess } with totality x (succ n)
 plusZnIdentityLeft {succ n} {pr} record { x = x ; xLess = xLess } | inl (inl x<succn) rewrite <NRefl x<succn xLess = refl
 plusZnIdentityLeft {succ n} {pr} record { x = x ; xLess = xLess } | inl (inr succn<x) = exFalso (TotalOrder.irreflexive ℕTotalOrder (TotalOrder.<Transitive ℕTotalOrder succn<x xLess))
 plusZnIdentityLeft {succ n} {pr} record { x = x ; xLess = xLess } | inr x=succn rewrite x=succn = exFalso (TotalOrder.irreflexive ℕTotalOrder xLess)
@@ -69,28 +71,28 @@ subLemma {a} {b} {c} a<b a<c b=c rewrite b=c | <NRefl a<b a<c = refl
 
 plusZnCommutative : {n : ℕ} → {pr : 0 <N n} → (a b : ℤn n pr) → (a +n b) ≡ b +n a
 plusZnCommutative {zero} {()} a b
-plusZnCommutative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } with orderIsTotal (a +N b) (succ n)
-plusZnCommutative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } | inl (inl a+b<sn) with orderIsTotal (b +N a) (succ n)
+plusZnCommutative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } with totality (a +N b) (succ n)
+plusZnCommutative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } | inl (inl a+b<sn) with totality (b +N a) (succ n)
 plusZnCommutative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } | inl (inl a+b<sn) | inl (inl b+a<sn) = equalityZn _ _ (Semiring.commutative ℕSemiring a b)
 plusZnCommutative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } | inl (inl a+b<sn) | inl (inr sn<b+a) = exFalso (f a+b<sn sn<b+a)
   where
     f : (a +N b) <N succ n → succ n <N b +N a → False
-    f pr1 pr2 rewrite Semiring.commutative ℕSemiring b a = TotalOrder.irreflexive ℕTotalOrder (orderIsTransitive pr2 pr1)
+    f pr1 pr2 rewrite Semiring.commutative ℕSemiring b a = TotalOrder.irreflexive ℕTotalOrder (<Transitive pr2 pr1)
 plusZnCommutative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } | inl (inl a+b<sn) | inr b+a=sn = exFalso (f a+b<sn b+a=sn)
   where
     f : (a +N b) <N succ n → b +N a ≡ succ n → False
     f pr1 eq rewrite Semiring.commutative ℕSemiring b a | eq = TotalOrder.irreflexive ℕTotalOrder pr1
-plusZnCommutative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } | inl (inr sn<a+b) with orderIsTotal (b +N a) (succ n)
+plusZnCommutative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } | inl (inr sn<a+b) with totality (b +N a) (succ n)
 plusZnCommutative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } | inl (inr sn<a+b) | inl (inl b+a<sn) = exFalso (f sn<a+b b+a<sn)
   where
     f : succ n <N a +N b → b +N a <N succ n → False
-    f pr1 pr2 rewrite Semiring.commutative ℕSemiring b a = TotalOrder.irreflexive ℕTotalOrder (orderIsTransitive sn<a+b b+a<sn)
+    f pr1 pr2 rewrite Semiring.commutative ℕSemiring b a = TotalOrder.irreflexive ℕTotalOrder (<Transitive sn<a+b b+a<sn)
 plusZnCommutative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } | inl (inr sn<a+b) | inl (inr sn<b+a) = equalityZn _ _ (subLemma sn<a+b sn<b+a (Semiring.commutative ℕSemiring a b))
 plusZnCommutative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } | inl (inr sn<a+b) | inr sn=b+a = exFalso (f sn<a+b sn=b+a)
   where
     f : succ n <N a +N b → b +N a ≡ succ n → False
     f pr eq rewrite Semiring.commutative ℕSemiring b a | eq = TotalOrder.irreflexive ℕTotalOrder pr
-plusZnCommutative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } | inr sn=a+b with orderIsTotal (b +N a) (succ n)
+plusZnCommutative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } | inr sn=a+b with totality (b +N a) (succ n)
 plusZnCommutative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } | inr sn=a+b | inl (inl b+a<sn) = exFalso f
   where
     f : False

Numbers/Modulo/Definition.agda

@@ -7,8 +7,8 @@ open import Groups.Definition
 open import Groups.Groups
 open import Groups.Abelian.Definition
 open import Groups.FiniteGroups.Definition
-open import Numbers.Naturals.Naturals
-open import Numbers.Naturals.Addition -- TODO remove this dependency
+open import Numbers.Naturals.Semiring
+open import Numbers.Naturals.Order
 open import Numbers.Primes.PrimeNumbers
 open import Setoids.Setoids
 open import Sets.FinSet

Numbers/Modulo/Group.agda

@@ -7,8 +7,10 @@ open import Groups.Definition
 open import Groups.Groups
 open import Groups.Abelian.Definition
 open import Groups.FiniteGroups.Definition
+open import Numbers.Naturals.Semiring
+open import Numbers.Naturals.Order
+open import Numbers.Naturals.Order.Lemmas
 open import Numbers.Naturals.Naturals
-open import Numbers.Naturals.Addition -- TODO remove this dependency
 open import Numbers.Primes.PrimeNumbers
 open import Setoids.Setoids
 open import Sets.FinSet
@@ -22,8 +24,10 @@ open import Numbers.Modulo.Addition
 
 module Numbers.Modulo.Group where
 
+open TotalOrder ℕTotalOrder
+
 help30 : {a b c n : ℕ} → (c <N n) → (a +N b ≡ n) → (n<b+c : n <N b +N c) → (n <N a +N subtractionNResult.result (-N (inl n<b+c))) → False
-help30 {a} {b} {c} {n} c<n a+b=n n<b+c x = TotalOrder.irreflexive ℕTotalOrder (orderIsTransitive pr5 c<n)
+help30 {a} {b} {c} {n} c<n a+b=n n<b+c x = TotalOrder.irreflexive ℕTotalOrder (<Transitive pr5 c<n)
   where
     pr : n +N n <N a +N (subtractionNResult.result (-N (inl n<b+c)) +N n)
     pr = identityOfIndiscernablesRight _<N_ (additionPreservesInequality n x) (equalityCommutative (Semiring.+Associative ℕSemiring a _ n))
@@ -92,7 +96,7 @@ help25 : {a b c n : ℕ} → (a +N b ≡ n) → (b +N c ≡ n) → (a +N 0 ≡ c
 help25 {a} {b} {c} {n} a+b=n b+c=n rewrite Semiring.commutative ℕSemiring a 0 | Semiring.commutative ℕSemiring a b | equalityCommutative a+b=n = equalityCommutative (canSubtractFromEqualityLeft b+c=n)
 
 help24 : {a n : ℕ} → (a <N n) → (n <N a +N 0) → False
-help24 {a} {n} a<n n<a+0 rewrite Semiring.commutative ℕSemiring a 0 = TotalOrder.irreflexive ℕTotalOrder (orderIsTransitive a<n n<a+0)
+help24 {a} {n} a<n n<a+0 rewrite Semiring.commutative ℕSemiring a 0 = TotalOrder.irreflexive ℕTotalOrder (<Transitive a<n n<a+0)
 
 help23 : {a n : ℕ} → (a <N n) → (a +N 0 ≡ n) → False
 help23 {a} {n} a<n a+0=n rewrite Semiring.commutative ℕSemiring a 0 | a+0=n = TotalOrder.irreflexive ℕTotalOrder a<n
@@ -154,7 +158,7 @@ help19 {a} {b} {c} {n} b+c<n n<a+b a<n pr = TotalOrder.irreflexive ℕTotalOrder
     r = addStrongInequalities a<n b+c<n
 
 help18 : {a b c n : ℕ} → (b+c<n : b +N c <N n) → (n<a+b : n <N a +N b) → (a <N n) → (n <N subtractionNResult.result (-N (inl n<a+b)) +N c) → False
-help18 {a} {b} {c} {n} b+c<n n<a+b a<n pr = TotalOrder.irreflexive ℕTotalOrder (orderIsTransitive p4 a<n)
+help18 {a} {b} {c} {n} b+c<n n<a+b a<n pr = TotalOrder.irreflexive ℕTotalOrder (<Transitive p4 a<n)
   where
     p : n +N n <N (n +N subtractionNResult.result (-N (inl n<a+b))) +N c
     p = identityOfIndiscernablesRight _<N_ (additionPreservesInequalityOnLeft n pr) (Semiring.+Associative ℕSemiring n _ c)
@@ -163,7 +167,7 @@ help18 {a} {b} {c} {n} b+c<n n<a+b a<n pr = TotalOrder.irreflexive ℕTotalOrder
     p2 : n +N n <N a +N (b +N c)
     p2 = identityOfIndiscernablesRight _<N_ p' (equalityCommutative (Semiring.+Associative ℕSemiring a b c))
     p3 : n +N n <N a +N n
-    p3 = orderIsTransitive p2 (additionPreservesInequalityOnLeft a b+c<n)
+    p3 = <Transitive p2 (additionPreservesInequalityOnLeft a b+c<n)
     p4 : n <N a
     p4 = subtractionPreservesInequality n p3
 
@@ -182,7 +186,7 @@ help17 {a} {b} {c} {n} n<b+c n<a+b p1 p2 = TotalOrder.irreflexive ℕTotalOrder
     pr3 = identityOfIndiscernablesLeft _≡_ pr2'' (equalityCommutative (Semiring.+Associative ℕSemiring a b c))
 
 help16 : {a b c n : ℕ} → (n<b+c : n <N b +N c) → (n<a+b : n <N a +N b) → (a +N subtractionNResult.result (-N (inl n<b+c))) <N n → (pr : n <N subtractionNResult.result (-N (inl n<a+b)) +N c) → a +N subtractionNResult.result (-N (inl n<b+c)) ≡ subtractionNResult.result (-N (inl pr))
-help16 {a} {b} {c} {n} n<b+c n<a+b pr1 pr2 = exFalso (TotalOrder.irreflexive ℕTotalOrder (orderIsTransitive pr3 pr1''))
+help16 {a} {b} {c} {n} n<b+c n<a+b pr1 pr2 = exFalso (TotalOrder.irreflexive ℕTotalOrder (<Transitive pr3 pr1''))
   where
     pr1' : a +N (subtractionNResult.result (-N (inl n<b+c)) +N n) <N n +N n
     pr1' = identityOfIndiscernablesLeft _<N_ (additionPreservesInequality n pr1) (equalityCommutative (Semiring.+Associative ℕSemiring a _ n))
@@ -196,7 +200,7 @@ help16 {a} {b} {c} {n} n<b+c n<a+b pr1 pr2 = exFalso (TotalOrder.irreflexive ℕ
     pr3 = identityOfIndiscernablesRight _<N_ pr2'' (equalityCommutative (Semiring.+Associative ℕSemiring a b c))
 
 help15 : {a b c n : ℕ} → (n<b+c : n <N b +N c) → (n<a+b : n <N a +N b) → (n <N a +N subtractionNResult.result (-N (inl n<b+c))) → (subtractionNResult.result (-N (inl n<a+b)) +N c) <N n → False
-help15 {a} {b} {c} {n} n<b+c n<a+b pr1 pr2 = TotalOrder.irreflexive ℕTotalOrder (orderIsTransitive p2'' p1')
+help15 {a} {b} {c} {n} n<b+c n<a+b pr1 pr2 = TotalOrder.irreflexive ℕTotalOrder (<Transitive p2'' p1')
   where
     p1 : (n +N subtractionNResult.result (-N (inl n<a+b))) +N c <N n +N n
     p1 = identityOfIndiscernablesLeft _<N_ (additionPreservesInequalityOnLeft n pr2) (Semiring.+Associative ℕSemiring n _ c)
@@ -250,7 +254,7 @@ help12 {a} {b} {c} {n} n<b+c n<a+b pr1 pr2 = TotalOrder.irreflexive ℕTotalOrde
     lemm4 = identityOfIndiscernablesRight _<N_ lemm2 (equalityCommutative lemm3)
 
 help11 : {a b c n : ℕ} → (a <N n) → (b +N c ≡ n) → (n<a+b : n <N a +N b) → (n <N subtractionNResult.result (-N (inl n<a+b)) +N c) → False
-help11 {a} {b} {c} {n} a<n b+c=n n<a+b pr1 = TotalOrder.irreflexive ℕTotalOrder (orderIsTransitive a<n lemm5)
+help11 {a} {b} {c} {n} a<n b+c=n n<a+b pr1 = TotalOrder.irreflexive ℕTotalOrder (<Transitive a<n lemm5)
   where
     pr : {a b c : ℕ} → a +N (b +N c) ≡ b +N (a +N c)
     pr {a} {b} {c} rewrite Semiring.+Associative ℕSemiring a b c | Semiring.commutative ℕSemiring a b | equalityCommutative (Semiring.+Associative ℕSemiring b a c) = refl
@@ -287,7 +291,7 @@ help9 : {a n : ℕ} → (a +N 0 ≡ n) → (a <N n) → False
 help9 {a} {n} n=a+0 a<n rewrite Semiring.commutative ℕSemiring a 0 | n=a+0 = TotalOrder.irreflexive ℕTotalOrder a<n
 
 help8 : {a n : ℕ} → (n <N a +N 0) → (a <N n) → False
-help8 {a} {n} n<a+0 a<n rewrite Semiring.commutative ℕSemiring a 0 = TotalOrder.irreflexive ℕTotalOrder (orderIsTransitive a<n n<a+0)
+help8 {a} {n} n<a+0 a<n rewrite Semiring.commutative ℕSemiring a 0 = TotalOrder.irreflexive ℕTotalOrder (<Transitive a<n n<a+0)
 
 help6 : {a b c n : ℕ} → (b +N c ≡ n) → (n<a+b : n <N a +N b) → (a +N 0 ≡ subtractionNResult.result (-N (inl n<a+b)) +N c)
 help6 {a} {b} {c} {n} b+c=n n<a+b rewrite Semiring.commutative ℕSemiring a 0 = canSubtractFromEqualityLeft {n} lem'
@@ -319,7 +323,7 @@ help4 {a} {b} {c} {n} n<a+'b+c n<a+b = canSubtractFromEqualityLeft lemma'
     lemma' = identityOfIndiscernablesRight _≡_ lemma (equalityCommutative (Semiring.+Associative ℕSemiring n (subtractionNResult.result (-N (inl n<a+b))) c))
 
 help3 : {a b c n : ℕ} → (a <N n) → (b <N n) → (c <N n) → (a +N b <N n) → (pr : n <N b +N c) → a +N subtractionNResult.result (-N (inl pr)) ≡ n → False
-help3 {a} {b} {c} {n} a<n b<n c<n a+b<n n<b+c pr = TotalOrder.irreflexive ℕTotalOrder (orderIsTransitive (inter4 inter3) c<n)
+help3 {a} {b} {c} {n} a<n b<n c<n a+b<n n<b+c pr = TotalOrder.irreflexive ℕTotalOrder (<Transitive (inter4 inter3) c<n)
   where
     inter : a +N (n +N subtractionNResult.result (-N (inl n<b+c))) ≡ n +N n
     inter = identityOfIndiscernablesLeft _≡_ (applyEquality (n +N_) pr) (lemma n a (subtractionNResult.result (-N (inl n<b+c))))
@@ -356,27 +360,27 @@ help1 {a} {b} {c} {n} sn<b+c pr1 a+b<sn a<sn b<sn c<sn | record { result = b+c-s
     eep2 : a +N (b +N c) <N succ n +N c
     eep2 rewrite Semiring.+Associative ℕSemiring a b c = additionPreservesInequality c a+b<sn
     eep2' : a +N (b +N c) <N succ n +N succ n
-    eep2' = orderIsTransitive eep2 (additionPreservesInequalityOnLeft (succ n) c<sn)
+    eep2' = <Transitive eep2 (additionPreservesInequalityOnLeft (succ n) c<sn)
     ans : False
-    ans = TotalOrder.irreflexive ℕTotalOrder (orderIsTransitive eep eep2')
+    ans = TotalOrder.irreflexive ℕTotalOrder (<Transitive eep eep2')
 
 plusZnAssociative : {n : ℕ} → {pr : 0 <N n} → (a b c : ℤn n pr) → a +n (b +n c) ≡ ((a +n b) +n c)
 plusZnAssociative {zero} {()}
-plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess} record { x = c ; xLess = cLess } with orderIsTotal (a +N b) (succ n)
-plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) with orderIsTotal ((a +N b) +N c) (succ n)
-plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inl a+b+c<sn) with orderIsTotal (b +N c) (succ n)
-plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inl a+b+c<sn) | inl (inl b+c<sn) with orderIsTotal (a +N (b +N c)) (succ n)
+plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess} record { x = c ; xLess = cLess } with totality (a +N b) (succ n)
+plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) with totality ((a +N b) +N c) (succ n)
+plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inl a+b+c<sn) with totality (b +N c) (succ n)
+plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inl a+b+c<sn) | inl (inl b+c<sn) with totality (a +N (b +N c)) (succ n)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inl a+b+c<sn) | inl (inl b+c<sn) | inl (inl a+'b+c<sn) = equalityZn _ _ (Semiring.+Associative ℕSemiring a b c)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inl a+b+c<sn) | inl (inl b+c<sn) | inl (inr sn<a+'b+c) = exFalso (false {succ n} a+b+c<sn sn<a+'b+c)
   where
     false : {x : ℕ} → (a +N b) +N c <N succ n → succ n <N a +N (b +N c) → False
-    false pr1 pr2 rewrite equalityCommutative (Semiring.+Associative ℕSemiring a b c) = TotalOrder.irreflexive ℕTotalOrder (orderIsTransitive pr1 pr2)
+    false pr1 pr2 rewrite equalityCommutative (Semiring.+Associative ℕSemiring a b c) = TotalOrder.irreflexive ℕTotalOrder (<Transitive pr1 pr2)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inl a+b+c<sn) | inl (inl b+c<sn) | inr sn=a+b+c = exFalso (false a+b+c<sn sn=a+b+c)
   where
     false : {x : ℕ} → (a +N b) +N c <N x → (a +N (b +N c)) ≡ x → False
     false p1 p2 rewrite equalityCommutative (Semiring.+Associative ℕSemiring a b c) | p2 = TotalOrder.irreflexive ℕTotalOrder p1
-plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inl a+b+c<sn) | inl (inr sn<b+c) with orderIsTotal (a +N (b +N c)) (succ n)
-plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inl a+b+c<sn) | inl (inr sn<b+c) | inl (inl _) with orderIsTotal (a +N subtractionNResult.result (-N (inl sn<b+c))) (succ n)
+plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inl a+b+c<sn) | inl (inr sn<b+c) with totality (a +N (b +N c)) (succ n)
+plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inl a+b+c<sn) | inl (inr sn<b+c) | inl (inl _) with totality (a +N subtractionNResult.result (-N (inl sn<b+c))) (succ n)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inl a+b+c<sn) | inl (inr sn<b+c) | inl (inl _) | inl (inl x) with -N (inl sn<b+c)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inl a+b+c<sn) | inl (inr sn<b+c) | inl (inl a+'b+c<sn) | inl (inl x) | record { result = result ; pr = pr } = exFalso (false a+'b+c<sn pr)
   where
@@ -405,7 +409,7 @@ plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ;
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inl a+b+c<sn) | inl (inr sn<b+c) | inl (inr x) = equalityZn _ _ (exFalso (false {succ n} a+b+c<sn x))
   where
     false : {x : ℕ} → (a +N b) +N c <N succ n → succ n <N a +N (b +N c) → False
-    false pr1 pr2 rewrite equalityCommutative (Semiring.+Associative ℕSemiring a b c) = TotalOrder.irreflexive ℕTotalOrder (orderIsTransitive pr1 pr2)
+    false pr1 pr2 rewrite equalityCommutative (Semiring.+Associative ℕSemiring a b c) = TotalOrder.irreflexive ℕTotalOrder (<Transitive pr1 pr2)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inl a+b+c<sn) | inl (inr sn<b+c) | inr x = exFalso (false a+b+c<sn x)
   where
     false : (a +N b) +N c <N succ n → a +N (b +N c) ≡ succ n → False
@@ -414,12 +418,12 @@ plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ;
   where
     false : (a +N b) +N c <N succ n → b +N c ≡ succ n → False
     false pr1 pr2 rewrite equalityCommutative (Semiring.+Associative ℕSemiring a b c) | pr2 | Semiring.commutative ℕSemiring a (succ n) = cannotAddAndEnlarge' a+b+c<sn
-plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inr sn<a+b+c) with orderIsTotal (b +N c) (succ n)
-plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inr sn<a+b+c) | inl (inl b+c<sn) with orderIsTotal (a +N (b +N c)) (succ n)
+plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inr sn<a+b+c) with totality (b +N c) (succ n)
+plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inr sn<a+b+c) | inl (inl b+c<sn) with totality (a +N (b +N c)) (succ n)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inr sn<a+b+c) | inl (inl b+c<sn) | inl (inl a+'b+c<sn) = exFalso (false sn<a+b+c a+'b+c<sn)
   where
     false : (succ n <N (a +N b) +N c) → a +N (b +N c) <N succ n → False
-    false pr1 pr2 rewrite equalityCommutative (Semiring.+Associative ℕSemiring a b c) = TotalOrder.irreflexive ℕTotalOrder (orderIsTransitive pr1 pr2)
+    false pr1 pr2 rewrite equalityCommutative (Semiring.+Associative ℕSemiring a b c) = TotalOrder.irreflexive ℕTotalOrder (<Transitive pr1 pr2)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inr sn<a+b+c) | inl (inl b+c<sn) | inl (inr sn<a+'b+c) = equalityZn _ _ ans
   where
     lemma : succ n +N ((a +N b) +N c) ≡ (a +N (b +N c)) +N succ n
@@ -430,12 +434,12 @@ plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ;
   where
     false : succ n <N (a +N b) +N c → (a +N (b +N c)) ≡ succ n → False
     false pr1 pr2 rewrite equalityCommutative (Semiring.+Associative ℕSemiring a b c) | pr2 = TotalOrder.irreflexive ℕTotalOrder sn<a+b+c
-plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inr sn<a+b+c) | inl (inr sn<b+c) with orderIsTotal (a +N (b +N c)) (succ n)
+plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inr sn<a+b+c) | inl (inr sn<b+c) with totality (a +N (b +N c)) (succ n)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inr sn<a+b+c) | inl (inr sn<b+c) | inl (inl a+b+c<sn) = exFalso (false sn<a+b+c a+b+c<sn)
   where
     false : succ n <N (a +N b) +N c → (a +N (b +N c)) <N succ n → False
-    false pr1 pr2 rewrite equalityCommutative (Semiring.+Associative ℕSemiring a b c) = TotalOrder.irreflexive ℕTotalOrder (orderIsTransitive pr1 pr2)
-plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inr sn<a+b+c) | inl (inr sn<b+c) | inl (inr _) with orderIsTotal (a +N subtractionNResult.result (-N (inl sn<b+c))) (succ n)
+    false pr1 pr2 rewrite equalityCommutative (Semiring.+Associative ℕSemiring a b c) = TotalOrder.irreflexive ℕTotalOrder (<Transitive pr1 pr2)
+plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inr sn<a+b+c) | inl (inr sn<b+c) | inl (inr _) with totality (a +N subtractionNResult.result (-N (inl sn<b+c))) (succ n)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inr sn<a+b+c) | inl (inr sn<b+c) | inl (inr _) | inl (inl x) = equalityZn _ _ (help2 {a} {b} {c} {n} sn<b+c sn<a+b+c)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inr sn<a+b+c) | inl (inr sn<b+c) | inl (inr _) | inl (inr x) = equalityZn _ _ (exFalso (help1 sn<b+c x a+b<sn aLess bLess cLess))
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inr sn<a+b+c) | inl (inr sn<b+c) | inl (inr _) | inr x = exFalso (help3 aLess bLess cLess a+b<sn sn<b+c x)
@@ -443,12 +447,12 @@ plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ;
   where
     false : (succ n <N (a +N b) +N c) → (a +N (b +N c) ≡ succ n) → False
     false pr1 pr2 rewrite equalityCommutative (Semiring.+Associative ℕSemiring a b c) | pr2 = TotalOrder.irreflexive ℕTotalOrder pr1
-plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inr sn<a+b+c) | inr sn=b+c with orderIsTotal (a +N (b +N c)) (succ n)
+plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inr sn<a+b+c) | inr sn=b+c with totality (a +N (b +N c)) (succ n)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inr sn<a+b+c) | inr sn=b+c | inl (inl x) = exFalso (false sn<a+b+c x)
   where
     false : succ n <N (a +N b) +N c → a +N (b +N c) <N succ n → False
-    false p1 p2 rewrite equalityCommutative (Semiring.+Associative ℕSemiring a b c) = TotalOrder.irreflexive ℕTotalOrder (orderIsTransitive p1 p2)
-plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inr sn<a+b+c) | inr sn=b+c | inl (inr _) with orderIsTotal (a +N 0) (succ n)
+    false p1 p2 rewrite equalityCommutative (Semiring.+Associative ℕSemiring a b c) = TotalOrder.irreflexive ℕTotalOrder (<Transitive p1 p2)
+plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inr sn<a+b+c) | inr sn=b+c | inl (inr _) with totality (a +N 0) (succ n)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inr sn<a+b+c) | inr sn=b+c | inl (inr _) | inl (inl x) = equalityZn _ _ (ans sn=b+c)
   where
     ans : b +N c ≡ succ n → a +N 0 ≡ subtractionNResult.result (-N (inl sn<a+b+c))
@@ -457,8 +461,8 @@ plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ;
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inr sn<a+b+c) | inr sn=b+c | inl (inr _) | inl (inr x) = exFalso (false b a+b<sn x)
   where
     false : (b : ℕ) → a +N b <N succ n → succ n <N a +N 0 → False
-    false zero pr1 pr2 rewrite Semiring.commutative ℕSemiring a 0 = TotalOrder.irreflexive ℕTotalOrder (orderIsTransitive pr1 pr2)
-    false (succ b) pr1 pr2 rewrite Semiring.commutative ℕSemiring a 0 = TotalOrder.irreflexive ℕTotalOrder (orderIsTransitive pr2 (orderIsTransitive (le b (Semiring.commutative ℕSemiring (succ b) a)) pr1))
+    false zero pr1 pr2 rewrite Semiring.commutative ℕSemiring a 0 = TotalOrder.irreflexive ℕTotalOrder (<Transitive pr1 pr2)
+    false (succ b) pr1 pr2 rewrite Semiring.commutative ℕSemiring a 0 = TotalOrder.irreflexive ℕTotalOrder (<Transitive pr2 (<Transitive (le b (Semiring.commutative ℕSemiring (succ b) a)) pr1))
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inl (inr sn<a+b+c) | inr sn=b+c | inl (inr _) | inr x = exFalso (false b a+b<sn x)
   where
     false : (b : ℕ) → a +N b <N succ n → a +N 0 ≡ succ n → False
@@ -468,8 +472,8 @@ plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ;
   where
     false : succ n <N (a +N b) +N c → a +N (b +N c) ≡ succ n → False
     false pr1 pr2 rewrite equalityCommutative (Semiring.+Associative ℕSemiring a b c) | pr2 = TotalOrder.irreflexive ℕTotalOrder pr1
-plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inr sn=a+b+c with orderIsTotal (b +N c) (succ n)
-plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inr sn=a+b+c | inl (inl b+c<sn) with orderIsTotal (a +N (b +N c)) (succ n)
+plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inr sn=a+b+c with totality (b +N c) (succ n)
+plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inr sn=a+b+c | inl (inl b+c<sn) with totality (a +N (b +N c)) (succ n)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inr sn=a+b+c | inl (inl b+c<sn) | inl (inl a+'b+c<sn) = exFalso (false sn=a+b+c a+'b+c<sn)
   where
     false : (a +N b) +N c ≡ succ n → a +N (b +N c) <N succ n → False
@@ -483,8 +487,8 @@ plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ;
   where
     false : (a : ℕ) → (a +N b) +N c ≡ succ n → succ n <N b +N c → False
     false zero pr1 pr2 rewrite equalityCommutative (Semiring.+Associative ℕSemiring a b c) | equalityCommutative pr1 = TotalOrder.irreflexive ℕTotalOrder pr2
-    false (succ a) pr1 pr2 rewrite equalityCommutative (Semiring.+Associative ℕSemiring a b c) | equalityCommutative pr1 = TotalOrder.irreflexive ℕTotalOrder (orderIsTransitive pr2 (le a refl))
-plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inr sn=a+b+c | inr b+c=sn with orderIsTotal (a +N 0) (succ n)
+    false (succ a) pr1 pr2 rewrite equalityCommutative (Semiring.+Associative ℕSemiring a b c) | equalityCommutative pr1 = TotalOrder.irreflexive ℕTotalOrder (<Transitive pr2 (le a refl))
+plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inr sn=a+b+c | inr b+c=sn with totality (a +N 0) (succ n)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inl a+b<sn) | inr sn=a+b+c | inr b+c=sn | inl (inl a+0<sn) = equalityZn _ _ ans
   where
     a=0 : (a : ℕ) → (a +N b) +N c ≡ succ n → b +N c ≡ succ n → a ≡ 0
@@ -508,13 +512,13 @@ plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ;
         a=0 : (a : ℕ) → (a +N a ≡ a) → a ≡ 0
         a=0 zero pr = refl
         a=0 (succ a) pr = exFalso (naughtE {a} (equalityCommutative (canSubtractFromEqualityRight pr)))
-plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) with orderIsTotal (b +N c) (succ n)
-plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) | inl (inl b+c<sn) with orderIsTotal (a +N (b +N c)) (succ n)
+plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) with totality (b +N c) (succ n)
+plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) | inl (inl b+c<sn) with totality (a +N (b +N c)) (succ n)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) | inl (inl b+c<sn) | inl (inl a+'b+c<sn) = exFalso (false sn<a+b a+'b+c<sn)
   where
     false : succ n <N a +N b → a +N (b +N c) <N succ n → False
-    false pr1 pr2 rewrite Semiring.+Associative ℕSemiring a b c = cannotAddAndEnlarge' (orderIsTransitive pr2 pr1)
-plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) | inl (inl b+c<sn) | inl (inr sn<a+'b+c) with orderIsTotal (subtractionNResult.result (-N (inl sn<a+b)) +N c) (succ n)
+    false pr1 pr2 rewrite Semiring.+Associative ℕSemiring a b c = cannotAddAndEnlarge' (<Transitive pr2 pr1)
+plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) | inl (inl b+c<sn) | inl (inr sn<a+'b+c) with totality (subtractionNResult.result (-N (inl sn<a+b)) +N c) (succ n)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) | inl (inl b+c<sn) | inl (inr sn<a+'b+c) | inl (inl x) = equalityZn _ _ (help4 {a} {b} {c} {succ n} sn<a+'b+c sn<a+b)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) | inl (inl b+c<sn) | inl (inr sn<a+'b+c) | inl (inr x) = exFalso (help18 {a} {b} {c} {succ n} b+c<sn sn<a+b aLess x)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) | inl (inl b+c<sn) | inl (inr sn<a+'b+c) | inr x = exFalso (help19 {a} {b} {c} {succ n} b+c<sn sn<a+b aLess x)
@@ -522,47 +526,47 @@ plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ;
   where
     false : (succ n <N a +N b) → a +N (b +N c) ≡ succ n → False
     false pr1 pr2 rewrite Semiring.+Associative ℕSemiring a b c | equalityCommutative pr2 = cannotAddAndEnlarge' pr1
-plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) | inl (inr sn<b+c) with orderIsTotal (a +N subtractionNResult.result (-N (inl sn<b+c))) (succ n)
-plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) | inl (inr sn<b+c) | inl (inl x) with orderIsTotal (subtractionNResult.result (-N (inl sn<a+b)) +N c) (succ n)
+plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) | inl (inr sn<b+c) with totality (a +N subtractionNResult.result (-N (inl sn<b+c))) (succ n)
+plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) | inl (inr sn<b+c) | inl (inl x) with totality (subtractionNResult.result (-N (inl sn<a+b)) +N c) (succ n)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) | inl (inr sn<b+c) | inl (inl x) | inl (inl x₁) = equalityZn _ _ (help5 {a} {b} {c} {succ n} sn<b+c sn<a+b)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) | inl (inr sn<b+c) | inl (inl x) | inl (inr x1) = equalityZn _ _ (help16 {a} {b} {c} {succ n} sn<b+c sn<a+b x x1)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) | inl (inr sn<b+c) | inl (inl x) | inr x1 = exFalso (help17 {a} {b} {c} {succ n} sn<b+c sn<a+b x x1)
-plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) | inl (inr sn<b+c) | inl (inr x) with orderIsTotal (subtractionNResult.result (-N (inl sn<a+b)) +N c) (succ n)
+plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) | inl (inr sn<b+c) | inl (inr x) with totality (subtractionNResult.result (-N (inl sn<a+b)) +N c) (succ n)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) | inl (inr sn<b+c) | inl (inr x) | inl (inl x1) = equalityZn _ _ (exFalso (help15 {a} {b} {c} {succ n} sn<b+c sn<a+b x x1))
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) | inl (inr sn<b+c) | inl (inr x) | inl (inr x1) = equalityZn _ _ (help14 {a} {b} {c} {succ n} sn<b+c sn<a+b x x1)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) | inl (inr sn<b+c) | inl (inr x) | inr x1 = equalityZn _ _ (exFalso (help13 {a} {b} {c} {succ n} sn<b+c sn<a+b x x1))
-plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) | inl (inr sn<b+c) | inr x with orderIsTotal (subtractionNResult.result (-N (inl sn<a+b)) +N c) (succ n)
+plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) | inl (inr sn<b+c) | inr x with totality (subtractionNResult.result (-N (inl sn<a+b)) +N c) (succ n)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) | inl (inr sn<b+c) | inr x | inl (inl x1) = equalityZn _ _ (exFalso (help12 {a} {b} {c} {succ n} sn<b+c sn<a+b x x1))
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) | inl (inr sn<b+c) | inr x | inl (inr x1) = equalityZn _ _ (exFalso (help10 {a} {b} {c} {succ n} sn<b+c sn<a+b x x1))
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) | inl (inr sn<b+c) | inr x | inr x₁ = equalityZn _ _ refl
-plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) | inr b+c=sn with orderIsTotal (a +N 0) (succ n)
-plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) | inr b+c=sn | inl (inl a+0<sn) with orderIsTotal (subtractionNResult.result (-N (inl sn<a+b)) +N c) (succ n)
+plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) | inr b+c=sn with totality (a +N 0) (succ n)
+plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) | inr b+c=sn | inl (inl a+0<sn) with totality (subtractionNResult.result (-N (inl sn<a+b)) +N c) (succ n)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) | inr b+c=sn | inl (inl a+0<sn) | inl (inl x) = equalityZn _ _ (help6 {a} {b} {c} {succ n} b+c=sn sn<a+b)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) | inr b+c=sn | inl (inl _) | inl (inr x) = equalityZn _ _ (exFalso (help11 {a} {b} {c} {succ n} aLess b+c=sn sn<a+b x))
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) | inr b+c=sn | inl (inl a+0<sn) | inr x = equalityZn _ _ (exFalso (help7 {a} {b} {c} {succ n} b+c=sn aLess sn<a+b x))
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) | inr b+c=sn | inl (inr sn<a+0) = exFalso (help8 {a} {succ n} sn<a+0 aLess)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inl (inr sn<a+b) | inr b+c=sn | inr a+0=sn = exFalso (help9 {a} {succ n} a+0=sn aLess)
-plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inr sn=a+b with orderIsTotal c (succ n)
-plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inr sn=a+b | inl (inl c<sn) with orderIsTotal (b +N c) (succ n)
-plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inr sn=a+b | inl (inl c<sn) | inl (inl b+c<sn) with orderIsTotal (a +N (b +N c)) (succ n)
+plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inr sn=a+b with totality c (succ n)
+plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inr sn=a+b | inl (inl c<sn) with totality (b +N c) (succ n)
+plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inr sn=a+b | inl (inl c<sn) | inl (inl b+c<sn) with totality (a +N (b +N c)) (succ n)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inr sn=a+b | inl (inl c<sn) | inl (inl b+c<sn) | inl (inl a+'b+c<sn) = equalityZn _ _ (help27 {a} {b} {c} {n} sn=a+b a+'b+c<sn)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inr sn=a+b | inl (inl c<sn) | inl (inl b+c<sn) | inl (inr sn<a+'b+c) = equalityZn _ _ (help28 {a} {b} {c} {succ n} sn<a+'b+c sn=a+b)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inr sn=a+b | inl (inl c<sn) | inl (inl b+c<sn) | inr a+'b+c=sn = equalityZn _ _ (help26 {a} {b} {c} {succ n} sn=a+b a+'b+c=sn)
-plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inr sn=a+b | inl (inl c<sn) | inl (inr sn<b+c) with orderIsTotal (a +N subtractionNResult.result (-N (inl sn<b+c))) (succ n)
+plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inr sn=a+b | inl (inl c<sn) | inl (inr sn<b+c) with totality (a +N subtractionNResult.result (-N (inl sn<b+c))) (succ n)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inr sn=a+b | inl (inl c<sn) | inl (inr sn<b+c) | inl (inl x) = equalityZn _ _ (help31 {a} {b} {c} {succ n} sn=a+b sn<b+c)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inr sn=a+b | inl (inl c<sn) | inl (inr sn<b+c) | inl (inr x) = exFalso (help30 {a} {b} {c} {succ n} cLess sn=a+b sn<b+c x)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inr sn=a+b | inl (inl c<sn) | inl (inr sn<b+c) | inr x = exFalso (help29 {a} {b} {c} {succ n} cLess sn<b+c x sn=a+b)
-plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inr sn=a+b | inl (inl c<sn) | inr b+c=sn with orderIsTotal (a +N 0) (succ n)
+plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inr sn=a+b | inl (inl c<sn) | inr b+c=sn with totality (a +N 0) (succ n)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inr sn=a+b | inl (inl c<sn) | inr b+c=sn | inl (inl a+0<sn) = equalityZn _ _ (help25 {a} {b} {c} {succ n} sn=a+b b+c=sn)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inr sn=a+b | inl (inl c<sn) | inr b+c=sn | inl (inr sn<a+0) = exFalso (help24 {a} {succ n} aLess sn<a+0)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inr sn=a+b | inl (inl c<sn) | inr b+c=sn | inr a+0=sn = exFalso (help23 {a} {succ n} aLess a+0=sn)
-plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inr sn=a+b | inl (inr sn<c) = exFalso (TotalOrder.irreflexive ℕTotalOrder (orderIsTransitive sn<c cLess))
-plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inr sn=a+b | inr c=sn with orderIsTotal (b +N c) (succ n)
+plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inr sn=a+b | inl (inr sn<c) = exFalso (TotalOrder.irreflexive ℕTotalOrder (<Transitive sn<c cLess))
+plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inr sn=a+b | inr c=sn with totality (b +N c) (succ n)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inr sn=a+b | inr c=sn | inl (inl b+c<sn) = exFalso (help b+c<sn)
   where
     help : (b +N c <N succ n) → False
     help b+c<sn rewrite equalityCommutative c=sn | Semiring.commutative ℕSemiring b c = cannotAddAndEnlarge' b+c<sn
-plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inr sn=a+b | inr c=sn | inl (inr sn<b+c) with orderIsTotal (a +N subtractionNResult.result (-N (inl sn<b+c))) (succ n)
+plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inr sn=a+b | inr c=sn | inl (inr sn<b+c) with totality (a +N subtractionNResult.result (-N (inl sn<b+c))) (succ n)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inr sn=a+b | inr c=sn | inl (inr sn<b+c) | inl (inl x) = exFalso (help20 {a} {b} {c} {succ n} c=sn sn=a+b sn<b+c x)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inr sn=a+b | inr c=sn | inl (inr sn<b+c) | inl (inr x) = exFalso (help22 {a} {b} {c} {succ n} sn=a+b c=sn sn<b+c x)
 plusZnAssociative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } record { x = c ; xLess = cLess } | inr sn=a+b | inr c=sn | inl (inr sn<b+c) | inr x = equalityZn _ _ refl
@@ -580,7 +584,7 @@ inverseZn {succ n} {0<n} record { x = (succ a) ; xLess = aLess } = ans , pr
   where
     ans = record { x = subtractionNResult.result (-N (inl (canRemoveSuccFrom<N aLess))) ; xLess = subLess (succIsPositive a) aLess }
     pr : ans +n record { x = (succ a) ; xLess = aLess } ≡ record { x = 0 ; xLess = 0<n }
-    pr with orderIsTotal (subtractionNResult.result (-N (inl (canRemoveSuccFrom<N aLess))) +N (succ a)) (succ n)
+    pr with totality (subtractionNResult.result (-N (inl (canRemoveSuccFrom<N aLess))) +N (succ a)) (succ n)
     ... | inl (inl x) = exFalso f
       where
         h : subtractionNResult.result (-N (inl (canRemoveSuccFrom<N aLess))) +N succ a ≡ succ n

Numbers/Naturals/Addition.agda

@@ -14,9 +14,10 @@ addZeroRight : (x : ℕ) → (x +N zero) ≡ x
 addZeroRight zero = refl
 addZeroRight (succ x) rewrite addZeroRight x = refl
 
-succExtracts : (x y : ℕ) → (x +N succ y) ≡ (succ (x +N y))
-succExtracts zero y = refl
-succExtracts (succ x) y = applyEquality succ (succExtracts x y)
+private
+  succExtracts : (x y : ℕ) → (x +N succ y) ≡ (succ (x +N y))
+  succExtracts zero y = refl
+  succExtracts (succ x) y = applyEquality succ (succExtracts x y)
 
 succCanMove : (x y : ℕ) → (x +N succ y) ≡ (succ x +N y)
 succCanMove x y = transitivity (succExtracts x y) refl

Numbers/Naturals/Naturals.agda

@@ -4,8 +4,8 @@ open import LogicalFormulae
 open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
 open import WellFoundedInduction
 open import Functions
-open import Orders
 open import Numbers.Naturals.Definition
+open import Numbers.Naturals.Semiring
 open import Numbers.Naturals.Addition
 open import Numbers.Naturals.Order
 open import Numbers.Naturals.Multiplication
@@ -13,553 +13,338 @@ open import Numbers.Naturals.Exponentiation
 open import Numbers.Naturals.Subtraction
 open import Semirings.Definition
 open import Monoids.Definition
+open import Orders
 
 module Numbers.Naturals.Naturals where
 
-  open Numbers.Naturals.Definition using (ℕ ; zero ; succ ; succInjective ; naughtE) public
-  open Numbers.Naturals.Addition using (_+N_ ; canSubtractFromEqualityRight ; canSubtractFromEqualityLeft) public
-  open Numbers.Naturals.Multiplication using (_*N_ ; multiplicationNIsCommutative) public
-  open Numbers.Naturals.Exponentiation using (_^N_) public
-  open Numbers.Naturals.Order using (_<N_ ; le; succPreservesInequality; succIsPositive; addingIncreases; zeroNeverGreater; noIntegersBetweenXAndSuccX; a<SuccA; canRemoveSuccFrom<N) public
-  open Numbers.Naturals.Subtraction using (_-N'_) public
+record subtractionNResult (a b : ℕ) (p : a ≤N b) : Set where
+  field
+    result : ℕ
+    pr : a +N result ≡ b
 
-  ℕSemiring : Semiring 0 1 _+N_ _*N_
-  Monoid.associative (Semiring.monoid ℕSemiring) a b c = equalityCommutative (additionNIsAssociative a b c)
-  Monoid.idLeft (Semiring.monoid ℕSemiring) _ = refl
-  Monoid.idRight (Semiring.monoid ℕSemiring) a = additionNIsCommutative a 0
-  Semiring.commutative ℕSemiring = additionNIsCommutative
-  Monoid.associative (Semiring.multMonoid ℕSemiring) = multiplicationNIsAssociative
-  Monoid.idLeft (Semiring.multMonoid ℕSemiring) a = additionNIsCommutative a 0
-  Monoid.idRight (Semiring.multMonoid ℕSemiring) a = transitivity (multiplicationNIsCommutative a 1) (additionNIsCommutative a 0)
-  Semiring.productZeroLeft ℕSemiring _ = refl
-  Semiring.productZeroRight ℕSemiring a = multiplicationNIsCommutative a 0
-  Semiring.+DistributesOver* ℕSemiring = productDistributes
+subtractionNWellDefined : {a b : ℕ} → {p1 p2 : a ≤N b} → (s : subtractionNResult a b p1) → (t : subtractionNResult a b p2) → (subtractionNResult.result s ≡ subtractionNResult.result t)
+subtractionNWellDefined {a} {b} {inl x} {pr2} record { result = result1 ; pr = pr1 } record { result = result ; pr = pr } = canSubtractFromEqualityLeft {a} (transitivity pr1 (equalityCommutative pr))
+subtractionNWellDefined {a} {.a} {inr refl} {pr2} record { result = result1 ; pr = pr1 } record { result = result2 ; pr = pr } = transitivity g' (equalityCommutative g)
+  where
+    g : result2 ≡ 0
+    g = canSubtractFromEqualityLeft {a} {_} {0} (transitivity pr (equalityCommutative (addZeroRight a)))
+    g' : result1 ≡ 0
+    g' = canSubtractFromEqualityLeft {a} {_} {0} (transitivity pr1 (equalityCommutative (addZeroRight a)))
 
-  record subtractionNResult (a b : ℕ) (p : a ≤N b) : Set where
-    field
-      result : ℕ
-      pr : a +N result ≡ b
+-N : {a : ℕ} → {b : ℕ} → (pr : a ≤N b) → subtractionNResult a b pr
+-N {zero} {b} prAB = record { result = b ; pr = refl }
+-N {succ a} {zero} (inl (le x ()))
+-N {succ a} {zero} (inr ())
+-N {succ a} {succ b} (inl x) with -N {a} {b} (inl (canRemoveSuccFrom<N x))
+-N {succ a} {succ b} (inl x) | record { result = result ; pr = pr } = record { result = result ; pr = applyEquality succ pr }
+-N {succ a} {succ .a} (inr refl) = record { result = 0 ; pr = applyEquality succ (addZeroRight a) }
 
-  subtractionNWellDefined : {a b : ℕ} → {p1 p2 : a ≤N b} → (s : subtractionNResult a b p1) → (t : subtractionNResult a b p2) → (subtractionNResult.result s ≡ subtractionNResult.result t)
-  subtractionNWellDefined {a} {b} {inl x} {pr2} record { result = result1 ; pr = pr1 } record { result = result ; pr = pr } = canSubtractFromEqualityLeft {a} (transitivity pr1 (equalityCommutative pr))
-  subtractionNWellDefined {a} {.a} {inr refl} {pr2} record { result = result1 ; pr = pr1 } record { result = result2 ; pr = pr } = transitivity g' (equalityCommutative g)
-    where
-      g : result2 ≡ 0
-      g = canSubtractFromEqualityLeft {a} {_} {0} (transitivity pr (equalityCommutative (addZeroRight a)))
-      g' : result1 ≡ 0
-      g' = canSubtractFromEqualityLeft {a} {_} {0} (transitivity pr1 (equalityCommutative (addZeroRight a)))
+addOneToWeakInequality : {a b : ℕ} → (a ≤N b) → (succ a ≤N succ b)
+addOneToWeakInequality {a} {b} (inl ineq) = inl (succPreservesInequality ineq)
+addOneToWeakInequality {a} {.a} (inr refl) = inr refl
 
-  -N : {a : ℕ} → {b : ℕ} → (pr : a ≤N b) → subtractionNResult a b pr
-  -N {zero} {b} prAB = record { result = b ; pr = refl }
-  -N {succ a} {zero} (inl (le x ()))
-  -N {succ a} {zero} (inr ())
-  -N {succ a} {succ b} (inl x) with -N {a} {b} (inl (canRemoveSuccFrom<N x))
-  -N {succ a} {succ b} (inl x) | record { result = result ; pr = pr } = record { result = result ; pr = applyEquality succ pr }
-  -N {succ a} {succ .a} (inr refl) = record { result = 0 ; pr = applyEquality succ (addZeroRight a) }
+bumpUpSubtraction : {a b : ℕ} → (p1 : a ≤N b) → (s : subtractionNResult a b p1) → Sg (subtractionNResult (succ a) (succ b) (addOneToWeakInequality p1)) (λ n → subtractionNResult.result n ≡ subtractionNResult.result s)
+bumpUpSubtraction {a} {b} a<=b record { result = result ; pr = pr } = record { result = result ; pr = applyEquality succ pr } , refl
 
-  addOneToWeakInequality : {a b : ℕ} → (a ≤N b) → (succ a ≤N succ b)
-  addOneToWeakInequality {a} {b} (inl ineq) = inl (succPreservesInequality ineq)
-  addOneToWeakInequality {a} {.a} (inr refl) = inr refl
+addMinus : {a : ℕ} → {b : ℕ} → (pr : a ≤N b) → subtractionNResult.result (-N {a} {b} pr) +N a ≡ b
+addMinus {zero} {zero} p = refl
+addMinus {zero} {succ b} pr = applyEquality succ (addZeroRight b)
+addMinus {succ a} {zero} (inl (le x ()))
+addMinus {succ a} {zero} (inr ())
+addMinus {succ a} {succ b} (inl x) with (-N {succ a} {succ b} (inl x))
+addMinus {succ a} {succ b} (inl x) | record { result = result ; pr = pr } = transitivity (transitivity (applyEquality (_+N succ a) (transitivity (subtractionNWellDefined {p1 = inl (canRemoveSuccFrom<N x)} (record { result = subtractionNResult.result (-N (inl (canRemoveSuccFrom<N x))) ; pr = transitivity (additionNIsCommutative a _) (addMinus (inl (canRemoveSuccFrom<N x)))}) previous) (equalityCommutative t))) (additionNIsCommutative result (succ a))) pr
+  where
+    pr'' : (a <N b) || (a ≡ b)
+    pr'' = (inl (le (_<N_.x x) (transitivity (equalityCommutative (succExtracts (_<N_.x x) a)) (succInjective (_<N_.proof x)))))
+    previous : subtractionNResult a b pr''
+    previous = -N pr''
+    next : Sg (subtractionNResult (succ a) (succ b) (addOneToWeakInequality pr'')) λ n → subtractionNResult.result n ≡ subtractionNResult.result previous
+    next = bumpUpSubtraction pr'' previous
+    t : result ≡ subtractionNResult.result (underlying next)
+    t = subtractionNWellDefined {succ a} {succ b} {inl x} {addOneToWeakInequality pr''} (record { result = result ; pr = pr }) (underlying next)
+addMinus {succ a} {succ .a} (inr refl) = refl
 
-  bumpUpSubtraction : {a b : ℕ} → (p1 : a ≤N b) → (s : subtractionNResult a b p1) → Sg (subtractionNResult (succ a) (succ b) (addOneToWeakInequality p1)) (λ n → subtractionNResult.result n ≡ subtractionNResult.result s)
-  bumpUpSubtraction {a} {b} a<=b record { result = result ; pr = pr } = record { result = result ; pr = applyEquality succ pr } , refl
+addMinus' : {a b : ℕ} → (pr : a ≤N b) → a +N subtractionNResult.result (-N {a} {b} pr) ≡ b
+addMinus' {a} {b} pr rewrite additionNIsCommutative a (subtractionNResult.result (-N {a} {b} pr)) = addMinus {a} {b} pr
 
-  addMinus : {a : ℕ} → {b : ℕ} → (pr : a ≤N b) → subtractionNResult.result (-N {a} {b} pr) +N a ≡ b
-  addMinus {zero} {zero} p = refl
-  addMinus {zero} {succ b} pr = applyEquality succ (addZeroRight b)
-  addMinus {succ a} {zero} (inl (le x ()))
-  addMinus {succ a} {zero} (inr ())
-  addMinus {succ a} {succ b} (inl x) with (-N {succ a} {succ b} (inl x))
-  addMinus {succ a} {succ b} (inl x) | record { result = result ; pr = pr } = transitivity (transitivity (applyEquality (_+N succ a) (transitivity (subtractionNWellDefined {p1 = inl (canRemoveSuccFrom<N x)} (record { result = subtractionNResult.result (-N (inl (canRemoveSuccFrom<N x))) ; pr = transitivity (additionNIsCommutative a _) (addMinus (inl (canRemoveSuccFrom<N x)))}) previous) (equalityCommutative t))) (additionNIsCommutative result (succ a))) pr
-    where
-      pr'' : (a <N b) || (a ≡ b)
-      pr'' = (inl (le (_<N_.x x) (transitivity (equalityCommutative (succExtracts (_<N_.x x) a)) (succInjective (_<N_.proof x)))))
-      previous : subtractionNResult a b pr''
-      previous = -N pr''
-      next : Sg (subtractionNResult (succ a) (succ b) (addOneToWeakInequality pr'')) λ n → subtractionNResult.result n ≡ subtractionNResult.result previous
-      next = bumpUpSubtraction pr'' previous
-      t : result ≡ subtractionNResult.result (underlying next)
-      t = subtractionNWellDefined {succ a} {succ b} {inl x} {addOneToWeakInequality pr''} (record { result = result ; pr = pr }) (underlying next)
-  addMinus {succ a} {succ .a} (inr refl) = refl
+additionPreservesInequality : {a b : ℕ} → (c : ℕ) → a <N b → a +N c <N b +N c
+additionPreservesInequality {a} {b} zero prAB rewrite additionNIsCommutative a 0 | additionNIsCommutative b 0 = prAB
+additionPreservesInequality {a} {b} (succ c) (le x proof) = le x (transitivity (equalityCommutative (additionNIsAssociative (succ x) a (succ c))) (applyEquality (_+N succ c) proof))
 
-  addMinus' : {a b : ℕ} → (pr : a ≤N b) → a +N subtractionNResult.result (-N {a} {b} pr) ≡ b
-  addMinus' {a} {b} pr rewrite additionNIsCommutative a (subtractionNResult.result (-N {a} {b} pr)) = addMinus {a} {b} pr
+additionPreservesInequalityOnLeft : {a b : ℕ} → (c : ℕ) → a <N b → c +N a <N c +N b
+additionPreservesInequalityOnLeft {a} {b} c prAB = identityOfIndiscernablesRight (λ a b → a <N b) (identityOfIndiscernablesLeft (λ a b → a <N b) (additionPreservesInequality {a} {b} c prAB) (additionNIsCommutative a c)) (additionNIsCommutative b c)
 
-  additionPreservesInequality : {a b : ℕ} → (c : ℕ) → a <N b → a +N c <N b +N c
-  additionPreservesInequality {a} {b} zero prAB rewrite additionNIsCommutative a 0 | additionNIsCommutative b 0 = prAB
-  additionPreservesInequality {a} {b} (succ c) (le x proof) = le x (transitivity (equalityCommutative (additionNIsAssociative (succ x) a (succ c))) (applyEquality (_+N succ c) proof))
+multiplyIncreases : (a : ℕ) → (b : ℕ) → succ zero <N a → zero <N b → b <N a *N b
+multiplyIncreases zero b (le x ()) prB
+multiplyIncreases (succ zero) b (le zero ()) prb
+multiplyIncreases (succ zero) b (le (succ x) ()) prb
+multiplyIncreases (succ (succ a)) (succ b) prA prb = le (b +N a *N succ b) (applyEquality succ (transitivity (Semiring.commutative ℕSemiring _ (succ b)) (transitivity (applyEquality succ (Semiring.commutative ℕSemiring b _)) (Semiring.commutative ℕSemiring _ b))))
 
-  additionPreservesInequalityOnLeft : {a b : ℕ} → (c : ℕ) → a <N b → c +N a <N c +N b
-  additionPreservesInequalityOnLeft {a} {b} c prAB = identityOfIndiscernablesRight (λ a b → a <N b) (identityOfIndiscernablesLeft (λ a b → a <N b) (additionPreservesInequality {a} {b} c prAB) (additionNIsCommutative a c)) (additionNIsCommutative b c)
+canTimesOneOnLeft : {a b : ℕ} → (a <N b) → (a *N (succ zero)) <N b
+canTimesOneOnLeft {a} {b} prAB = identityOfIndiscernablesLeft _<N_ prAB (equalityCommutative (productWithOneRight a))
 
-  subtractionPreservesInequality : {a b : ℕ} → (c : ℕ) → a +N c <N b +N c → a <N b
-  subtractionPreservesInequality {a} {b} zero prABC rewrite additionNIsCommutative a 0 | additionNIsCommutative b 0 = prABC
-  subtractionPreservesInequality {a} {b} (succ c) (le x proof) = le x (canSubtractFromEqualityRight {b = succ c} (transitivity (additionNIsAssociative (succ x) a (succ c)) proof))
+canTimesOneOnRight : {a b : ℕ} → (a <N b) → a <N (b *N (succ zero))
+canTimesOneOnRight {a} {b} prAB = identityOfIndiscernablesRight _<N_ prAB (equalityCommutative (productWithOneRight b))
 
-  productNonzeroIsNonzero : {a b : ℕ} → zero <N a → zero <N b → zero <N a *N b
-  productNonzeroIsNonzero {zero} {b} prA prB = prA
-  productNonzeroIsNonzero {succ a} {zero} prA ()
-  productNonzeroIsNonzero {succ a} {succ b} prA prB = logical<NImpliesLe (record {})
+canSwapAddOnLeftOfInequality : {a b c : ℕ} → (a +N b <N c) → (b +N a <N c)
+canSwapAddOnLeftOfInequality {a} {b} {c} pr = identityOfIndiscernablesLeft _<N_ pr (additionNIsCommutative a b)
 
-  multiplyIncreases : (a : ℕ) → (b : ℕ) → succ zero <N a → zero <N b → b <N a *N b
-  multiplyIncreases zero b (le x ()) prB
-  multiplyIncreases (succ zero) b prA prb with leImpliesLogical<N {succ zero} {succ zero} prA
-  multiplyIncreases (succ zero) b prA prb | ()
-  multiplyIncreases (succ (succ a)) zero prA ()
-  multiplyIncreases (succ (succ a)) (succ b) prA prB =
-      identityOfIndiscernablesRight _<N_ k refl
+canSwapAddOnRightOfInequality : {a b c : ℕ} → (a <N b +N c) → (a <N c +N b)
+canSwapAddOnRightOfInequality {a} {b} {c} pr = identityOfIndiscernablesRight _<N_ pr (additionNIsCommutative b c)
+
+bumpDownOnRight : (a c : ℕ) → c *N succ a ≡ c *N a +N c
+bumpDownOnRight a c = transitivity (multiplicationNIsCommutative c (succ a)) (transitivity refl (transitivity (additionNIsCommutative c (a *N c)) ((addingPreservesEqualityRight c (multiplicationNIsCommutative a c) ))))
+
+succIsNonzero : {a : ℕ} → (succ a ≡ zero) → False
+succIsNonzero {a} ()
+
+lessImpliesNotEqual : {a b : ℕ} → (a <N b) → a ≡ b → False
+lessImpliesNotEqual {a} {.a} prAB refl = TotalOrder.irreflexive ℕTotalOrder prAB
+
+-NIsDecreasing : {a b : ℕ} → (prAB : succ a <N b) → subtractionNResult.result (-N (inl prAB)) <N b
+-NIsDecreasing {a} {b} prAB with (-N (inl prAB))
+-NIsDecreasing {a} {b} (le x proof) | record { result = result ; pr = pr } = record { x = a ; proof = pr }
+
+equalityN : (a b : ℕ) → Sg Bool (λ truth → if truth then a ≡ b else Unit)
+equalityN zero zero = ( BoolTrue , refl )
+equalityN zero (succ b) = ( BoolFalse , record {} )
+equalityN (succ a) zero = ( BoolFalse , record {} )
+equalityN (succ a) (succ b) with equalityN a b
+equalityN (succ a) (succ b) | BoolTrue , val = (BoolTrue , applyEquality succ val)
+equalityN (succ a) (succ b) | BoolFalse , val = (BoolFalse , record {})
+
+sumZeroImpliesSummandsZero : {a b : ℕ} → (a +N b ≡ zero) → ((a ≡ zero) && (b ≡ zero))
+sumZeroImpliesSummandsZero {zero} {zero} pr = record { fst = refl ; snd = refl }
+sumZeroImpliesSummandsZero {zero} {(succ b)} pr = record { fst = refl ; snd = pr }
+sumZeroImpliesSummandsZero {(succ a)} {zero} ()
+sumZeroImpliesSummandsZero {(succ a)} {(succ b)} ()
+
+productWithNonzeroZero : (a b : ℕ) → (a *N succ b ≡ zero) → a ≡ zero
+productWithNonzeroZero zero b pr = refl
+productWithNonzeroZero (succ a) b ()
+
+productOneImpliesOperandsOne : {a b : ℕ} → (a *N b ≡ 1) → (a ≡ 1) && (b ≡ 1)
+productOneImpliesOperandsOne {zero} {b} ()
+productOneImpliesOperandsOne {succ a} {zero} pr = exFalso absurd''
+  where
+    absurd : zero *N (succ a) ≡ 1
+    absurd' : 0 ≡ 1
+    absurd'' : False
+    absurd'' = succIsNonzero (equalityCommutative absurd')
+    absurd = identityOfIndiscernablesLeft _≡_ pr (productZeroIsZeroRight a)
+    absurd' = absurd
+productOneImpliesOperandsOne {succ a} {succ b} pr = record { fst = r' ; snd = (applyEquality succ (_&&_.fst q)) }
+  where
+    p : b +N a *N succ b ≡ zero
+    p = succInjective pr
+    q : (b ≡ zero) && (a *N succ b ≡ zero)
+    q = sumZeroImpliesSummandsZero p
+    r : a ≡ zero
+    r = productWithNonzeroZero a b (_&&_.snd q)
+    r' : succ a ≡ 1
+    r' = applyEquality succ r
+
+oneTimesPlusZero : (a : ℕ) → a ≡ a *N succ zero +N zero
+oneTimesPlusZero a = identityOfIndiscernablesRight _≡_ (equalityCommutative (productWithOneRight a)) (equalityCommutative (addZeroRight (a *N succ zero)))
+
+equivalentSubtraction' : (a b c d : ℕ) → (a<c : a <N c) → (d<b : d <N b) → (subtractionNResult.result (-N {a} {c} (inl a<c))) ≡ (subtractionNResult.result (-N {d} {b} (inl d<b))) → a +N b ≡ c +N d
+equivalentSubtraction' a b c d prac prdb eq with -N (inl prac)
+equivalentSubtraction' a b c d prac prdb eq | record { result = result ; pr = pr } with -N (inl prdb)
+equivalentSubtraction' a b c d prac prdb refl | record { result = .result ; pr = pr1 } | record { result = result ; pr = pr } rewrite (equalityCommutative pr) = go
+  where
+    go : a +N (d +N result) ≡ c +N d
+    go rewrite (equalityCommutative pr1) = t
       where
-        h : zero <N (succ a) *N (succ b)
-        h = productNonzeroIsNonzero {succ a} {succ b} (logical<NImpliesLe (record {})) (logical<NImpliesLe (record {}))
-        i : zero +N succ b <N (succ a) *N (succ b) +N succ b
-        i = additionPreservesInequality {zero} {succ a *N succ b} (succ b) h
-        j : zero +N succ b <N succ b +N (succ a *N succ b)
-        j = identityOfIndiscernablesRight _<N_ i (additionNIsCommutative (succ (b +N a *N succ b)) (succ b))
-        k : succ b <N succ b +N (succ a *N succ b)
-        k = identityOfIndiscernablesLeft (λ a b → a <N b) j refl
+        t : a +N (d +N result) ≡ (a +N result) +N d
+        t rewrite (additionNIsAssociative a result d) = applyEquality (λ n → a +N n) (additionNIsCommutative d result)
 
-  productCancelsRight : (a b c : ℕ) → (zero <N a) → (b *N a ≡ c *N a) → (b ≡ c)
-  productCancelsRight a zero zero aPos eq = refl
-  productCancelsRight zero zero (succ c) (le x ()) eq
-  productCancelsRight (succ a) zero (succ c) aPos eq = contr
+lessThanMeansPositiveSubtr : {a b : ℕ} → (a<b : a <N b) → (subtractionNResult.result (-N (inl a<b)) ≡ 0) → False
+lessThanMeansPositiveSubtr {a} {b} a<b pr with -N (inl a<b)
+lessThanMeansPositiveSubtr {a} {b} a<b pr | record { result = result ; pr = sub } rewrite pr | addZeroRight a = lessImpliesNotEqual a<b sub
+
+moveOneSubtraction : {a b c : ℕ} → {a<=b : a ≤N b} → (subtractionNResult.result (-N {a} {b} a<=b)) ≡ c → b ≡ a +N c
+moveOneSubtraction {a} {b} {zero} {inl a<b} pr rewrite addZeroRight a = exFalso (lessThanMeansPositiveSubtr {a} {b} a<b pr)
+moveOneSubtraction {a} {b} {succ c} {inl a<b} pr with -N (inl a<b)
+moveOneSubtraction {a} {b} {succ c} {inl a<b} pr | record { result = result ; pr = sub } rewrite pr | sub = refl
+moveOneSubtraction {a} {.a} {zero} {inr refl} pr = equalityCommutative (addZeroRight a)
+moveOneSubtraction {a} {.a} {succ c} {inr refl} pr = identityOfIndiscernablesRight _≡_ (equalityCommutative (addZeroRight a)) (applyEquality (λ t → a +N t) pr')
+  where
+    selfSub : (r : ℕ) → subtractionNResult.result (-N {r} {r} (inr refl)) ≡ zero
+    selfSub zero = refl
+    selfSub (succ r) = refl
+    pr' : 0 ≡ succ c
+    pr' = transitivity (equalityCommutative (selfSub a)) pr
+
+moveOneSubtraction' : {a b c : ℕ} → {a<=b : a ≤N b} → (b ≡ a +N c) → subtractionNResult.result (-N {a} {b} a<=b) ≡ c
+moveOneSubtraction' {a} {b} {c} {inl x} pr with -N (inl x)
+moveOneSubtraction' {a} {b} {c} {inl x} pr | record { result = result ; pr = pr1 } rewrite pr = canSubtractFromEqualityLeft pr1
+moveOneSubtraction' {a} {b} {c} {inr x} pr with -N (inr x)
+moveOneSubtraction' {a} {b} {c} {inr x} pr | record { result = result ; pr = pr1 } rewrite pr = canSubtractFromEqualityLeft pr1
+
+equivalentSubtraction : (a b c d : ℕ) → (a<c : a <N c) → (d<b : d <N b) → a +N b ≡ c +N d → (subtractionNResult.result (-N {a} {c} (inl a<c))) ≡ (subtractionNResult.result (-N {d} {b} (inl d<b)))
+equivalentSubtraction zero b c d prac (le x proof) eq with (-N (inl (le x proof)))
+equivalentSubtraction zero b c d prac (le x proof) eq | record { result = result ; pr = pr } = equalityCommutative p''
+  where
+    p : d +N result ≡ c +N d
+    p = transitivity pr eq
+    p' : d +N result ≡ d +N c
+    p' = transitivity p (additionNIsCommutative c d)
+    p'' : result ≡ c
+    p'' = canSubtractFromEqualityLeft {d} {result} {c} p'
+equivalentSubtraction (succ a) b zero d (le x ()) prdb eq
+equivalentSubtraction (succ a) b (succ c) d prac prdb eq with (-N (inl (canRemoveSuccFrom<N prac)))
+equivalentSubtraction (succ a) b (succ c) d prac prdb eq | record { result = c-a ; pr = prc-a } with -N (inl prdb)
+equivalentSubtraction (succ a) b (succ c) d prac prdb eq | record { result = c-a ; pr = prc-a } | record { result = result ; pr = pr } rewrite equalityCommutative prc-a | equalityCommutative pr | equalityCommutative (additionNIsAssociative a d result) | additionNIsCommutative (a +N c-a) d | equalityCommutative (additionNIsAssociative d a c-a) | additionNIsCommutative a d = equalityCommutative (canSubtractFromEqualityLeft eq)
+
+leLemma : (b c : ℕ) → (b ≤N c) ≡ (b +N zero ≤N c +N zero)
+leLemma b c rewrite addZeroRight c = q
+  where
+    q : (b ≤N c) ≡ (b +N zero ≤N c)
+    q rewrite addZeroRight b = refl
+
+lessCast : {a b c : ℕ} → (pr : a ≤N b) → (eq : a ≡ c) → c ≤N b
+lessCast {a} {b} pr eq rewrite eq = pr
+
+lessCast' : {a b c : ℕ} → (pr : a ≤N b) → (eq : b ≡ c) → a ≤N c
+lessCast' {a} {b} pr eq rewrite eq = pr
+
+subtractionCast : {a b c : ℕ} → {pr : a ≤N b} → (eq : a ≡ c) → (p : subtractionNResult a b pr) → Sg (subtractionNResult c b (lessCast pr eq)) (λ res → subtractionNResult.result p ≡ subtractionNResult.result res)
+subtractionCast {a} {b} {c} {a<b} eq subt rewrite eq = (subt , refl)
+
+subtractionCast' : {a b c : ℕ} → {pr : a ≤N b} → (eq : b ≡ c) → (p : subtractionNResult a b pr) → Sg (subtractionNResult a c (lessCast' pr eq)) (λ res → subtractionNResult.result p ≡ subtractionNResult.result res)
+subtractionCast' {a} {b} {c} {a<b} eq subt rewrite eq = (subt , refl)
+
+addToRightWeakInequality : (a : ℕ) → {b c : ℕ} → (pr : b ≤N c) → (b ≤N c +N a)
+addToRightWeakInequality zero {b} {c} (inl x) rewrite (addZeroRight c) = inl x
+addToRightWeakInequality (succ a) {b} {c} (inl x) = inl (TotalOrder.<Transitive ℕTotalOrder x (addingIncreases c a))
+addToRightWeakInequality zero {b} {.b} (inr refl) = inr (equalityCommutative (addZeroRight b))
+addToRightWeakInequality (succ a) {b} {.b} (inr refl) = inl (addingIncreases b a)
+
+addAssocLemma : (a b c : ℕ) → (a +N b) +N c ≡ (a +N c) +N b
+addAssocLemma a b c rewrite (additionNIsAssociative a b c) = g
+  where
+    g : a +N (b +N c) ≡ (a +N c) +N b
+    g rewrite (additionNIsAssociative a c b) = applyEquality (λ t → a +N t) (additionNIsCommutative b c)
+
+addIntoSubtraction : (a : ℕ) → {b c : ℕ} → (pr : b ≤N c) → a +N (subtractionNResult.result (-N {b} {c} pr)) ≡ subtractionNResult.result (-N {b} {c +N a} (addToRightWeakInequality a pr))
+addIntoSubtraction a {b} {c} pr with (-N {b} {c} pr)
+addIntoSubtraction a {b} {c} pr | record { result = c-b ; pr = prc-b } with (-N {b} {c +N a} (addToRightWeakInequality a pr))
+addIntoSubtraction a {b} {c} pr | record { result = c-b ; pr = prc-b } | record { result = c+a-b ; pr = prcab } = equalityCommutative g'''
+  where
+    g : (b +N c+a-b) +N c-b ≡ c +N (a +N c-b)
+    g rewrite (equalityCommutative (additionNIsAssociative c a c-b)) = applyEquality (λ t → t +N c-b) prcab
+    g' : (b +N c-b) +N c+a-b ≡ c +N (a +N c-b)
+    g' = identityOfIndiscernablesLeft _≡_ g (addAssocLemma b c+a-b c-b)
+    g'' : c +N c+a-b ≡ c +N (a +N c-b)
+    g'' = identityOfIndiscernablesLeft _≡_ g' (applyEquality (λ i → i +N c+a-b) prc-b)
+    g''' : c+a-b ≡ a +N c-b
+    g''' = canSubtractFromEqualityLeft {c} {c+a-b} {a +N c-b} g''
+
+addStrongInequalities : {a b c d : ℕ} → (a<b : a <N b) → (c<d : c <N d) → (a +N c <N b +N d)
+addStrongInequalities {zero} {zero} {c} {d} prab prcd = prcd
+addStrongInequalities {zero} {succ b} {c} {d} prab prcd rewrite (additionNIsCommutative b d) = TotalOrder.<Transitive ℕTotalOrder prcd (cannotAddAndEnlarge d b)
+addStrongInequalities {succ a} {zero} {c} {d} (le x ()) prcd
+addStrongInequalities {succ a} {succ b} {c} {d} prab prcd = succPreservesInequality (addStrongInequalities (canRemoveSuccFrom<N prab) prcd)
+
+addWeakInequalities : {a b c d : ℕ} → (a<=b : a ≤N b) → (c<=d : c ≤N d) → (a +N c) ≤N (b +N d)
+addWeakInequalities {a} {b} {c} {d} (inl x) (inl y) = inl (addStrongInequalities x y)
+addWeakInequalities {a} {b} {c} {.c} (inl x) (inr refl) = inl (additionPreservesInequality c x)
+addWeakInequalities {a} {.a} {c} {d} (inr refl) (inl x) = inl (additionPreservesInequalityOnLeft a x)
+addWeakInequalities {a} {.a} {c} {.c} (inr refl) (inr refl) = inr refl
+
+addSubIntoSub : {a b c d : ℕ} → (a<b : a ≤N b) → (c<d : c ≤N d) → (subtractionNResult.result (-N {a} {b} a<b)) +N (subtractionNResult.result (-N {c} {d} c<d)) ≡ subtractionNResult.result (-N {a +N c} {b +N d} (addWeakInequalities a<b c<d))
+addSubIntoSub {a}{b}{c}{d} a<b c<d with (-N {a} {b} a<b)
+addSubIntoSub {a} {b} {c} {d} a<b c<d | record { result = b-a ; pr = prb-a } with (-N {c} {d} c<d)
+addSubIntoSub {a} {b} {c} {d} a<b c<d | record { result = b-a ; pr = prb-a } | record { result = d-c ; pr = prd-c } with (-N {a +N c} {b +N d} (addWeakInequalities a<b c<d))
+addSubIntoSub {a} {b} {c} {d} a<b c<d | record { result = b-a ; pr = prb-a } | record { result = d-c ; pr = prd-c } | record { result = b+d-a-c ; pr = pr } = equalityCommutative r
+  where
+    pr' : (a +N c) +N b+d-a-c ≡ (a +N b-a) +N d
+    pr' rewrite prb-a = pr
+    pr'' : a +N (c +N b+d-a-c) ≡ (a +N b-a) +N d
+    pr'' rewrite (equalityCommutative (additionNIsAssociative a c b+d-a-c)) = pr'
+    pr''' : a +N (c +N b+d-a-c) ≡ a +N (b-a +N d)
+    pr''' rewrite (equalityCommutative (additionNIsAssociative a b-a d)) = pr''
+    q : c +N b+d-a-c ≡ b-a +N d
+    q = canSubtractFromEqualityLeft {a} pr'''
+    q' : c +N b+d-a-c ≡ b-a +N (c +N d-c)
+    q' rewrite prd-c = q
+    q'' : c +N b+d-a-c ≡ (b-a +N c) +N d-c
+    q'' rewrite additionNIsAssociative b-a c d-c = q'
+    q''' : c +N b+d-a-c ≡ (c +N b-a) +N d-c
+    q''' rewrite additionNIsCommutative c b-a = q''
+    q'''' : c +N b+d-a-c ≡ c +N (b-a +N d-c)
+    q'''' rewrite equalityCommutative (additionNIsAssociative c b-a d-c) = q'''
+    r : b+d-a-c ≡ b-a +N d-c
+    r = canSubtractFromEqualityLeft {c} q''''
+
+
+subtractProduct : {a b c : ℕ} → (aPos : 0 <N a) → (b<c : b <N c) →
+    (a *N (subtractionNResult.result (-N (inl b<c)))) ≡ subtractionNResult.result (-N {a *N b} {a *N c} (inl (lessRespectsMultiplicationLeft b c a b<c aPos)))
+subtractProduct {zero} {b} {c} aPos b<c = refl
+subtractProduct {succ zero} {b} {c} aPos b<c = s'
+  where
+    resbc = -N {b} {c} (inl b<c)
+    resbc' : Sg (subtractionNResult (b +N 0 *N b) c (lessCast (inl b<c) (equalityCommutative (addZeroRight b)))) ((λ res → subtractionNResult.result resbc ≡ subtractionNResult.result res))
+    resbc'' : Sg (subtractionNResult (b +N 0 *N b) (c +N 0 *N c) (lessCast' (lessCast (inl b<c) (equalityCommutative (addZeroRight b))) (equalityCommutative (addZeroRight c)))) (λ res → subtractionNResult.result (underlying resbc') ≡ subtractionNResult.result res)
+    g : (rsbc' : Sg (subtractionNResult (b +N 0 *N b) c (lessCast (inl b<c) (equalityCommutative (addZeroRight b)))) (λ res → subtractionNResult.result resbc ≡ subtractionNResult.result res)) → subtractionNResult.result resbc ≡ subtractionNResult.result (underlying rsbc')
+    g' : (rsbc'' : Sg (subtractionNResult (b +N 0 *N b) (c +N 0 *N c) (lessCast' (lessCast (inl b<c) (equalityCommutative (addZeroRight b))) (equalityCommutative (addZeroRight c)))) (λ res → subtractionNResult.result (underlying resbc') ≡ subtractionNResult.result res)) → subtractionNResult.result (underlying resbc') ≡ subtractionNResult.result (underlying rsbc'')
+    q : subtractionNResult.result resbc ≡ subtractionNResult.result (underlying resbc'')
+    r : subtractionNResult.result (underlying resbc'') ≡ subtractionNResult.result (-N {b +N 0 *N b} {c +N 0 *N c} (inl (lessRespectsMultiplicationLeft b c 1 b<c aPos)))
+    s : subtractionNResult.result resbc ≡ subtractionNResult.result (-N {b +N 0 *N b} {c +N 0 *N c} (inl (lessRespectsMultiplicationLeft b c 1 b<c aPos)))
+    s = transitivity q r
+    s' : subtractionNResult.result resbc +N 0 ≡ subtractionNResult.result (-N {b +N 0 *N b} {c +N 0 *N c} (inl (lessRespectsMultiplicationLeft b c 1 b<c aPos)))
+    s' = identityOfIndiscernablesLeft _≡_ s (equalityCommutative (addZeroRight _))
+    r = subtractionNWellDefined {b +N 0 *N b} {c +N 0 *N c} {(lessCast' (lessCast (inl b<c) (equalityCommutative (addZeroRight b))) (equalityCommutative (addZeroRight c)))} {inl (lessRespectsMultiplicationLeft b c 1 b<c aPos)} (underlying resbc'') (-N {b +N 0 *N b} {c +N 0 *N c} (inl (lessRespectsMultiplicationLeft b c 1 b<c aPos)))
+    g (a , b) = b
+    g' (a , b) = b
+    resbc'' = subtractionCast' (equalityCommutative (addZeroRight c)) (underlying resbc')
+    q = transitivity {_} {_} {subtractionNResult.result resbc} {subtractionNResult.result (underlying resbc')} {subtractionNResult.result (underlying resbc'')} (g resbc') (g' resbc'')
+    resbc' = subtractionCast {b} {c} {b +N 0 *N b} (equalityCommutative (addZeroRight b)) resbc
+
+subtractProduct {succ (succ a)} {b} {c} aPos b<c =
+  let
+    t : (succ a) *N subtractionNResult.result (-N {b} {c} (inl b<c)) ≡ subtractionNResult.result (-N {(succ a) *N b} {(succ a) *N c} (inl (lessRespectsMultiplicationLeft b c (succ a) b<c (succIsPositive a))))
+    t = subtractProduct {succ a} {b} {c} (succIsPositive a) b<c
+  in
+    go t  --go t
     where
-      h : zero ≡ succ c *N succ a
-      h = eq
-      contr : zero ≡ succ c
-      contr = exFalso (naughtE h)
-
-  productCancelsRight zero (succ b) zero (le x ()) eq
-  productCancelsRight (succ a) (succ b) zero aPos eq = contr
-    where
-      h : succ b *N succ a ≡ zero
-      h = eq
-      contr : succ b ≡ zero
-      contr = exFalso (naughtE (equalityCommutative h))
-
-  productCancelsRight zero (succ b) (succ c) (le x ()) eq
-
-  productCancelsRight (succ a) (succ b) (succ c) aPos eq = applyEquality succ (productCancelsRight (succ a) b c aPos l)
-      where
-        i : succ a +N b *N succ a ≡ succ c *N succ a
-        i = eq
-        j : succ c *N succ a ≡ succ a +N c *N succ a
-        j = refl
-        k : succ a +N b *N succ a ≡ succ a +N c *N succ a
-        k = transitivity i j
-        l : b *N succ a ≡ c *N succ a
-        l = canSubtractFromEqualityLeft {succ a} {b *N succ a} {c *N succ a} k
-
-  productCancelsLeft : (a b c : ℕ) → (zero <N a) → (a *N b ≡ a *N c) → (b ≡ c)
-  productCancelsLeft a b c aPos pr = productCancelsRight a b c aPos j
-    where
-      i : b *N a ≡ a *N c
-      i = identityOfIndiscernablesLeft _≡_ pr (multiplicationNIsCommutative a b)
-      j : b *N a ≡ c *N a
-      j = identityOfIndiscernablesRight _≡_ i (multiplicationNIsCommutative a c)
-
-  productCancelsRight' : (a b c : ℕ) → (b *N a ≡ c *N a) → (a ≡ zero) || (b ≡ c)
-  productCancelsRight' zero b c pr = inl refl
-  productCancelsRight' (succ a) b c pr = inr (productCancelsRight (succ a) b c (succIsPositive a) pr)
-
-  productCancelsLeft' : (a b c : ℕ) → (a *N b ≡ a *N c) → (a ≡ zero) || (b ≡ c)
-  productCancelsLeft' zero b c pr = inl refl
-  productCancelsLeft' (succ a) b c pr = inr (productCancelsLeft (succ a) b c (succIsPositive a) pr)
-
-  lessRespectsAddition : {a b : ℕ} (c : ℕ) → (a <N b) → ((a +N c) <N (b +N c))
-  lessRespectsAddition {a} {b} zero prAB rewrite additionNIsCommutative a 0 | additionNIsCommutative b 0 = prAB
-  lessRespectsAddition {a} {b} (succ c) prAB rewrite additionNIsCommutative a (succ c) | additionNIsCommutative b (succ c) | additionNIsCommutative c a | additionNIsCommutative c b = succPreservesInequality (lessRespectsAddition c prAB)
-
-  canTimesOneOnLeft : {a b : ℕ} → (a <N b) → (a *N (succ zero)) <N b
-  canTimesOneOnLeft {a} {b} prAB = identityOfIndiscernablesLeft _<N_ prAB (equalityCommutative (productWithOneRight a))
-
-  canTimesOneOnRight : {a b : ℕ} → (a <N b) → a <N (b *N (succ zero))
-  canTimesOneOnRight {a} {b} prAB = identityOfIndiscernablesRight _<N_ prAB (equalityCommutative (productWithOneRight b))
-
-  canSwapAddOnLeftOfInequality : {a b c : ℕ} → (a +N b <N c) → (b +N a <N c)
-  canSwapAddOnLeftOfInequality {a} {b} {c} pr = identityOfIndiscernablesLeft _<N_ pr (additionNIsCommutative a b)
-
-  canSwapAddOnRightOfInequality : {a b c : ℕ} → (a <N b +N c) → (a <N c +N b)
-  canSwapAddOnRightOfInequality {a} {b} {c} pr = identityOfIndiscernablesRight _<N_ pr (additionNIsCommutative b c)
-
-  naturalsAreNonnegative : (a : ℕ) → (a <NLogical zero) → False
-  naturalsAreNonnegative zero pr = pr
-  naturalsAreNonnegative (succ x) pr = pr
-
-  canFlipMultiplicationsInIneq : {a b c d : ℕ} → (a *N b <N c *N d) → b *N a <N d *N c
-  canFlipMultiplicationsInIneq {a} {b} {c} {d} pr = identityOfIndiscernablesRight _<N_ (identityOfIndiscernablesLeft _<N_ pr (multiplicationNIsCommutative a b)) (multiplicationNIsCommutative c d)
-
-  bumpDownOnRight : (a c : ℕ) → c *N succ a ≡ c *N a +N c
-  bumpDownOnRight a c = transitivity (multiplicationNIsCommutative c (succ a)) (transitivity refl (transitivity (additionNIsCommutative c (a *N c)) ((addingPreservesEqualityRight c (multiplicationNIsCommutative a c) ))))
-
-  lessRespectsMultiplicationLeft : (a b c : ℕ) → (a <N b) → (zero <N c) → (c *N a <N c *N b)
-  lessRespectsMultiplicationLeft zero zero c (le x ()) cPos
-  lessRespectsMultiplicationLeft zero (succ b) zero prAB (le x ())
-  lessRespectsMultiplicationLeft zero (succ b) (succ c) prAB cPos = i
-    where
-      j : zero <N succ c *N succ b
-      j = productNonzeroIsNonzero cPos prAB
-      i : succ c *N zero <N succ c *N succ b
-      i = identityOfIndiscernablesLeft _<N_ j (equalityCommutative (productZeroIsZeroRight c))
-  lessRespectsMultiplicationLeft (succ a) zero c (le x ()) cPos
-  lessRespectsMultiplicationLeft (succ a) (succ b) c prAB cPos = m
-    where
-      h : c *N a <N c *N b
-      h = lessRespectsMultiplicationLeft a b c (logical<NImpliesLe (leImpliesLogical<N prAB)) cPos
-      j : c *N a +N c <N c *N b +N c
-      j = lessRespectsAddition c h
-      i : c *N succ a <N c *N b +N c
-      i = identityOfIndiscernablesLeft _<N_ j (equalityCommutative (bumpDownOnRight a c))
-      m : c *N succ a <N c *N succ b
-      m = identityOfIndiscernablesRight _<N_ i (equalityCommutative (bumpDownOnRight b c))
-
-  lessRespectsMultiplication : (a b c : ℕ) → (a <N b) → (zero <N c) → (a *N c <N b *N c)
-  lessRespectsMultiplication a b c prAB cPos = canFlipMultiplicationsInIneq {c} {a} {c} {b} (lessRespectsMultiplicationLeft a b c prAB cPos)
-
-  succIsNonzero : {a : ℕ} → (succ a ≡ zero) → False
-  succIsNonzero {a} ()
-
-  orderIsTotal : (a b : ℕ) → ((a <N b) || (b <N a)) || (a ≡ b)
-  orderIsTotal zero zero = inr refl
-  orderIsTotal zero (succ b) = inl (inl (logical<NImpliesLe (record {})))
-  orderIsTotal (succ a) zero = inl (inr (logical<NImpliesLe (record {})))
-  orderIsTotal (succ a) (succ b) with orderIsTotal a b
-  orderIsTotal (succ a) (succ b) | inl (inl x) = inl (inl (logical<NImpliesLe (leImpliesLogical<N x)))
-  orderIsTotal (succ a) (succ b) | inl (inr x) = inl (inr (logical<NImpliesLe (leImpliesLogical<N x)))
-  orderIsTotal (succ a) (succ b) | inr x = inr (applyEquality succ x)
-
-  orderIsIrreflexive : {a b : ℕ} → (a <N b) → (b <N a) → False
-  orderIsIrreflexive {zero} {b} prAB (le x ())
-  orderIsIrreflexive {(succ a)} {zero} (le x ()) prBA
-  orderIsIrreflexive {(succ a)} {(succ b)} prAB prBA = orderIsIrreflexive {a} {b} (logical<NImpliesLe (leImpliesLogical<N prAB)) (logical<NImpliesLe (leImpliesLogical<N prBA))
-
-  orderIsTransitive : {a b c : ℕ} → (a <N b) → (b <N c) → (a <N c)
-  orderIsTransitive {a} {.(succ (x +N a))} {.(succ (y +N succ (x +N a)))} (le x refl) (le y refl) = le (y +N succ x) (applyEquality succ (additionNIsAssociative y (succ x) a))
-
-  <NWellfounded : WellFounded _<N_
-  <NWellfounded = λ x → access (go x)
-    where
-      lemma : {a b c : ℕ} → a <N b → b <N succ c → a <N c
-      lemma {a} {b} {c} (le y succYAeqB) (le z zbEqC') = le (y +N z) p
+      go : (succ a) *N subtractionNResult.result (-N {b} {c} (inl b<c)) ≡ subtractionNResult.result (-N {(succ a) *N b} {(succ a) *N c} (inl (lessRespectsMultiplicationLeft b c (succ a) b<c (succIsPositive a)))) → (subtractionNResult.result (-N (inl b<c)) +N (subtractionNResult.result (-N (inl b<c)) +N a *N subtractionNResult.result (-N (inl b<c))) ≡ subtractionNResult.result (-N (inl (lessRespectsMultiplicationLeft b c (succ (succ a)) b<c aPos))))
+      go t = transitivity {_} {_} {lhs} {middle2} {rhs} u' v
         where
-          zbEqC : z +N b ≡ c
-          zSuccYAEqC : z +N (succ y +N a) ≡ c
-          zSuccYAEqC' : z +N (succ (y +N a)) ≡ c
-          zSuccYAEqC'' : succ (z +N (y +N a)) ≡ c
-          zSuccYAEqC''' : succ ((z +N y) +N a) ≡ c
-          p : succ ((y +N z) +N a) ≡ c
-          p = identityOfIndiscernablesLeft _≡_ zSuccYAEqC''' (applyEquality (λ n → succ (n +N a)) (additionNIsCommutative z y))
-          zSuccYAEqC''' = identityOfIndiscernablesLeft _≡_ zSuccYAEqC'' (equalityCommutative (applyEquality succ (additionNIsAssociative z y a)))
-          zSuccYAEqC'' = identityOfIndiscernablesLeft _≡_ zSuccYAEqC' (succExtracts z (y +N a))
-          zSuccYAEqC' = identityOfIndiscernablesLeft _≡_ zSuccYAEqC (applyEquality (λ r → z +N r) refl)
-          zbEqC = succInjective zbEqC'
-          zSuccYAEqC = identityOfIndiscernablesLeft _≡_ zbEqC (applyEquality (λ r → z +N r) (equalityCommutative succYAeqB))
-      go : ∀ n m → m <N n → Accessible _<N_ m
-      go zero m (le x ())
-      go (succ n) zero mLessN = access (λ y ())
-      go (succ n) (succ m) smLessSN = access (λ o (oLessSM : o <N succ m) → go n o (lemma oLessSM smLessSN))
+          c-b = subtractionNResult.result (-N {b} {c} (inl b<c))
+          lhs = c-b +N (succ a) *N c-b
+          middle = subtractionNResult.result (-N {(succ a) *N b} {(succ a) *N c} (inl (lessRespectsMultiplicationLeft b c (succ a) b<c (succIsPositive a))))
+          middle2 = subtractionNResult.result (-N {b +N (succ a *N b)} {c +N (succ a *N c)} (addWeakInequalities (inl b<c) (inl (lessRespectsMultiplicationLeft b c (succ a) b<c (succIsPositive a)))))
+          rhs = subtractionNResult.result (-N {succ (succ a) *N b} {(succ (succ a)) *N c} (inl (lessRespectsMultiplicationLeft b c (succ (succ a)) b<c aPos)))
+          lhs' : lhs ≡ c-b +N middle
+          u : c-b +N middle ≡ middle2
+          u' : lhs ≡ middle2
+          v : middle2 ≡ rhs
+          u'' : c-b +N subtractionNResult.result (-N {(succ a) *N b} {(succ a) *N c} (inl (lessRespectsMultiplicationLeft b c (succ a) b<c (succIsPositive a)))) ≡ rhs
 
-  lessImpliesNotEqual : {a b : ℕ} → (a <N b) → a ≡ b → False
-  lessImpliesNotEqual {a} {.a} prAB refl = orderIsIrreflexive prAB prAB
+          u'' rewrite equalityCommutative v = u
+          u' rewrite equalityCommutative u = lhs'
+          lhs' rewrite t = refl
+          u = addSubIntoSub (inl b<c) (inl (lessRespectsMultiplicationLeft b c (succ a) b<c (succIsPositive a)))
+          v = subtractionNWellDefined {succ (succ a) *N b} {succ (succ a) *N c} {addWeakInequalities (inl b<c) (inl (lessRespectsMultiplicationLeft b c (succ a) b<c (succIsPositive a)))} {inl (lessRespectsMultiplicationLeft b c (succ (succ a)) b<c aPos)} (-N {b +N (succ a *N b)} {c +N (succ a *N c)} (addWeakInequalities (inl b<c) (inl (lessRespectsMultiplicationLeft b c (succ a) b<c (succIsPositive a))))) (-N {(succ (succ a)) *N b} {(succ (succ a)) *N c} (inl (lessRespectsMultiplicationLeft b c (succ (succ a)) b<c aPos)))
 
-  -NIsDecreasing : {a b : ℕ} → (prAB : succ a <N b) → subtractionNResult.result (-N (inl prAB)) <N b
-  -NIsDecreasing {a} {b} prAB with (-N (inl prAB))
-  -NIsDecreasing {a} {b} (le x proof) | record { result = result ; pr = pr } = record { x = a ; proof = pr }
+subtractProduct' : {a b c : ℕ} → (aPos : 0 <N a) → (b<c : b <N c) →
+  (subtractionNResult.result (-N (inl b<c))) *N a ≡ subtractionNResult.result (-N {a *N b} {a *N c} (inl (lessRespectsMultiplicationLeft b c a b<c aPos)))
+subtractProduct' {a} aPos b<c = identityOfIndiscernablesLeft _≡_ (subtractProduct aPos b<c) (multiplicationNIsCommutative a _)
 
-  equalityN : (a b : ℕ) → Sg Bool (λ truth → if truth then a ≡ b else Unit)
-  equalityN zero zero = ( BoolTrue , refl )
-  equalityN zero (succ b) = ( BoolFalse , record {} )
-  equalityN (succ a) zero = ( BoolFalse , record {} )
-  equalityN (succ a) (succ b) with equalityN a b
-  equalityN (succ a) (succ b) | BoolTrue , val = (BoolTrue , applyEquality succ val)
-  equalityN (succ a) (succ b) | BoolFalse , val = (BoolFalse , record {})
+equalityDecidable : (a b : ℕ) → (a ≡ b) || ((a ≡ b) → False)
+equalityDecidable zero zero = inl refl
+equalityDecidable zero (succ b) = inr naughtE
+equalityDecidable (succ a) zero = inr λ t → naughtE (equalityCommutative t)
+equalityDecidable (succ a) (succ b) with equalityDecidable a b
+equalityDecidable (succ a) (succ b) | inl x = inl (applyEquality succ x)
+equalityDecidable (succ a) (succ b) | inr x = inr (λ t → x (succInjective t))
 
-  sumZeroImpliesSummandsZero : {a b : ℕ} → (a +N b ≡ zero) → ((a ≡ zero) && (b ≡ zero))
-  sumZeroImpliesSummandsZero {zero} {zero} pr = record { fst = refl ; snd = refl }
-  sumZeroImpliesSummandsZero {zero} {(succ b)} pr = record { fst = refl ; snd = pr }
-  sumZeroImpliesSummandsZero {(succ a)} {zero} ()
-  sumZeroImpliesSummandsZero {(succ a)} {(succ b)} ()
+cannotAddKeepingEquality : (a b : ℕ) → (a ≡ a +N succ b) → False
+cannotAddKeepingEquality zero zero pr = naughtE pr
+cannotAddKeepingEquality (succ a) zero pr = cannotAddKeepingEquality a zero (succInjective pr)
+cannotAddKeepingEquality zero (succ b) pr = naughtE pr
+cannotAddKeepingEquality (succ a) (succ b) pr = cannotAddKeepingEquality a (succ b) (succInjective pr)
 
-  productWithNonzeroZero : (a b : ℕ) → (a *N succ b ≡ zero) → a ≡ zero
-  productWithNonzeroZero zero b pr = refl
-  productWithNonzeroZero (succ a) b ()
-
-  productOneImpliesOperandsOne : {a b : ℕ} → (a *N b ≡ 1) → (a ≡ 1) && (b ≡ 1)
-  productOneImpliesOperandsOne {zero} {b} ()
-  productOneImpliesOperandsOne {succ a} {zero} pr = exFalso absurd''
-    where
-      absurd : zero *N (succ a) ≡ 1
-      absurd' : 0 ≡ 1
-      absurd'' : False
-      absurd'' = succIsNonzero (equalityCommutative absurd')
-      absurd = identityOfIndiscernablesLeft _≡_ pr (productZeroIsZeroRight a)
-      absurd' = absurd
-  productOneImpliesOperandsOne {succ a} {succ b} pr = record { fst = r' ; snd = (applyEquality succ (_&&_.fst q)) }
-    where
-      p : b +N a *N succ b ≡ zero
-      p = succInjective pr
-      q : (b ≡ zero) && (a *N succ b ≡ zero)
-      q = sumZeroImpliesSummandsZero p
-      r : a ≡ zero
-      r = productWithNonzeroZero a b (_&&_.snd q)
-      r' : succ a ≡ 1
-      r' = applyEquality succ r
-
-  oneTimesPlusZero : (a : ℕ) → a ≡ a *N succ zero +N zero
-  oneTimesPlusZero a = identityOfIndiscernablesRight _≡_ (equalityCommutative (productWithOneRight a)) (equalityCommutative (addZeroRight (a *N succ zero)))
-
-  cancelInequalityLeft : {a b c : ℕ} → a *N b <N a *N c → b <N c
-  cancelInequalityLeft {a} {zero} {zero} (le x proof) rewrite (productZeroIsZeroRight a) = exFalso (succIsNonzero {x +N zero} proof)
-  cancelInequalityLeft {a} {zero} {succ c} pr = succIsPositive c
-  cancelInequalityLeft {a} {succ b} {zero} (le x proof) rewrite (productZeroIsZeroRight a) = exFalso (succIsNonzero {x +N a *N succ b} proof)
-  cancelInequalityLeft {a} {succ b} {succ c} pr = succPreservesInequality q'
-    where
-      p' : succ b *N a <N succ c *N a
-      p' = canFlipMultiplicationsInIneq {a} {succ b} {a} {succ c} pr
-      p'' : b *N a +N a <N succ c *N a
-      p'' = identityOfIndiscernablesLeft _<N_ p' (additionNIsCommutative a (b *N a))
-      p''' : b *N a +N a <N c *N a +N a
-      p''' = identityOfIndiscernablesRight _<N_ p'' (additionNIsCommutative a (c *N a))
-      p : b *N a <N c *N a
-      p = subtractionPreservesInequality a p'''
-      q : a *N b <N a *N c
-      q = canFlipMultiplicationsInIneq {b} {a} {c} {a} p
-      q' : b <N c
-      q' = cancelInequalityLeft {a} {b} {c} q
-
-  cannotAddAndEnlarge : (a b : ℕ) → a <N succ (a +N b)
-  cannotAddAndEnlarge a b = le b (applyEquality succ (additionNIsCommutative b a))
-
-  cannotAddAndEnlarge' : {a b : ℕ} → a +N b <N a → False
-  cannotAddAndEnlarge' {a} {zero} pr rewrite addZeroRight a = lessIrreflexive pr
-  cannotAddAndEnlarge' {a} {succ b} pr rewrite (succExtracts a b) = lessIrreflexive {a} (lessTransitive {a} {succ (a +N b)} {a} (cannotAddAndEnlarge a b) pr)
-
-  cannotAddAndEnlarge'' : {a b : ℕ} → a +N succ b ≡ a → False
-  cannotAddAndEnlarge'' {a} {b} pr = naughtE (equalityCommutative inter)
-    where
-      inter : succ b ≡ 0
-      inter rewrite additionNIsCommutative a (succ b) = canSubtractFromEqualityRight pr
-
-  equivalentSubtraction' : (a b c d : ℕ) → (a<c : a <N c) → (d<b : d <N b) → (subtractionNResult.result (-N {a} {c} (inl a<c))) ≡ (subtractionNResult.result (-N {d} {b} (inl d<b))) → a +N b ≡ c +N d
-  equivalentSubtraction' a b c d prac prdb eq with -N (inl prac)
-  equivalentSubtraction' a b c d prac prdb eq | record { result = result ; pr = pr } with -N (inl prdb)
-  equivalentSubtraction' a b c d prac prdb refl | record { result = .result ; pr = pr1 } | record { result = result ; pr = pr } rewrite (equalityCommutative pr) = go
-    where
-      go : a +N (d +N result) ≡ c +N d
-      go rewrite (equalityCommutative pr1) = t
-        where
-          t : a +N (d +N result) ≡ (a +N result) +N d
-          t rewrite (additionNIsAssociative a result d) = applyEquality (λ n → a +N n) (additionNIsCommutative d result)
-
-  lessThanMeansPositiveSubtr : {a b : ℕ} → (a<b : a <N b) → (subtractionNResult.result (-N (inl a<b)) ≡ 0) → False
-  lessThanMeansPositiveSubtr {a} {b} a<b pr with -N (inl a<b)
-  lessThanMeansPositiveSubtr {a} {b} a<b pr | record { result = result ; pr = sub } rewrite pr | addZeroRight a = lessImpliesNotEqual a<b sub
-
-  moveOneSubtraction : {a b c : ℕ} → {a<=b : a ≤N b} → (subtractionNResult.result (-N {a} {b} a<=b)) ≡ c → b ≡ a +N c
-  moveOneSubtraction {a} {b} {zero} {inl a<b} pr rewrite addZeroRight a = exFalso (lessThanMeansPositiveSubtr {a} {b} a<b pr)
-  moveOneSubtraction {a} {b} {succ c} {inl a<b} pr with -N (inl a<b)
-  moveOneSubtraction {a} {b} {succ c} {inl a<b} pr | record { result = result ; pr = sub } rewrite pr | sub = refl
-  moveOneSubtraction {a} {.a} {zero} {inr refl} pr = equalityCommutative (addZeroRight a)
-  moveOneSubtraction {a} {.a} {succ c} {inr refl} pr = identityOfIndiscernablesRight _≡_ (equalityCommutative (addZeroRight a)) (applyEquality (λ t → a +N t) pr')
-    where
-      selfSub : (r : ℕ) → subtractionNResult.result (-N {r} {r} (inr refl)) ≡ zero
-      selfSub zero = refl
-      selfSub (succ r) = refl
-      pr' : 0 ≡ succ c
-      pr' = transitivity (equalityCommutative (selfSub a)) pr
-
-  moveOneSubtraction' : {a b c : ℕ} → {a<=b : a ≤N b} → (b ≡ a +N c) → subtractionNResult.result (-N {a} {b} a<=b) ≡ c
-  moveOneSubtraction' {a} {b} {c} {inl x} pr with -N (inl x)
-  moveOneSubtraction' {a} {b} {c} {inl x} pr | record { result = result ; pr = pr1 } rewrite pr = canSubtractFromEqualityLeft pr1
-  moveOneSubtraction' {a} {b} {c} {inr x} pr with -N (inr x)
-  moveOneSubtraction' {a} {b} {c} {inr x} pr | record { result = result ; pr = pr1 } rewrite pr = canSubtractFromEqualityLeft pr1
-
-  equivalentSubtraction : (a b c d : ℕ) → (a<c : a <N c) → (d<b : d <N b) → a +N b ≡ c +N d → (subtractionNResult.result (-N {a} {c} (inl a<c))) ≡ (subtractionNResult.result (-N {d} {b} (inl d<b)))
-  equivalentSubtraction zero b c d prac (le x proof) eq with (-N (inl (le x proof)))
-  equivalentSubtraction zero b c d prac (le x proof) eq | record { result = result ; pr = pr } = equalityCommutative p''
-    where
-      p : d +N result ≡ c +N d
-      p = transitivity pr eq
-      p' : d +N result ≡ d +N c
-      p' = transitivity p (additionNIsCommutative c d)
-      p'' : result ≡ c
-      p'' = canSubtractFromEqualityLeft {d} {result} {c} p'
-  equivalentSubtraction (succ a) b zero d (le x ()) prdb eq
-  equivalentSubtraction (succ a) b (succ c) d prac prdb eq with (-N (inl (canRemoveSuccFrom<N prac)))
-  equivalentSubtraction (succ a) b (succ c) d prac prdb eq | record { result = c-a ; pr = prc-a } with -N (inl prdb)
-  equivalentSubtraction (succ a) b (succ c) d prac prdb eq | record { result = c-a ; pr = prc-a } | record { result = result ; pr = pr } rewrite equalityCommutative prc-a | equalityCommutative pr | equalityCommutative (additionNIsAssociative a d result) | additionNIsCommutative (a +N c-a) d | equalityCommutative (additionNIsAssociative d a c-a) | additionNIsCommutative a d = equalityCommutative (canSubtractFromEqualityLeft eq)
-
-  leLemma : (b c : ℕ) → (b ≤N c) ≡ (b +N zero ≤N c +N zero)
-  leLemma b c rewrite addZeroRight c = q
-    where
-      q : (b ≤N c) ≡ (b +N zero ≤N c)
-      q rewrite addZeroRight b = refl
-
-  lessCast : {a b c : ℕ} → (pr : a ≤N b) → (eq : a ≡ c) → c ≤N b
-  lessCast {a} {b} pr eq rewrite eq = pr
-
-  lessCast' : {a b c : ℕ} → (pr : a ≤N b) → (eq : b ≡ c) → a ≤N c
-  lessCast' {a} {b} pr eq rewrite eq = pr
-
-  subtractionCast : {a b c : ℕ} → {pr : a ≤N b} → (eq : a ≡ c) → (p : subtractionNResult a b pr) → Sg (subtractionNResult c b (lessCast pr eq)) (λ res → subtractionNResult.result p ≡ subtractionNResult.result res)
-  subtractionCast {a} {b} {c} {a<b} eq subt rewrite eq = (subt , refl)
-
-  subtractionCast' : {a b c : ℕ} → {pr : a ≤N b} → (eq : b ≡ c) → (p : subtractionNResult a b pr) → Sg (subtractionNResult a c (lessCast' pr eq)) (λ res → subtractionNResult.result p ≡ subtractionNResult.result res)
-  subtractionCast' {a} {b} {c} {a<b} eq subt rewrite eq = (subt , refl)
-
-  addToRightWeakInequality : (a : ℕ) → {b c : ℕ} → (pr : b ≤N c) → (b ≤N c +N a)
-  addToRightWeakInequality zero {b} {c} (inl x) rewrite (addZeroRight c) = inl x
-  addToRightWeakInequality (succ a) {b} {c} (inl x) = inl (orderIsTransitive x (addingIncreases c a))
-  addToRightWeakInequality zero {b} {.b} (inr refl) = inr (equalityCommutative (addZeroRight b))
-  addToRightWeakInequality (succ a) {b} {.b} (inr refl) = inl (addingIncreases b a)
-
-  addAssocLemma : (a b c : ℕ) → (a +N b) +N c ≡ (a +N c) +N b
-  addAssocLemma a b c rewrite (additionNIsAssociative a b c) = g
-    where
-      g : a +N (b +N c) ≡ (a +N c) +N b
-      g rewrite (additionNIsAssociative a c b) = applyEquality (λ t → a +N t) (additionNIsCommutative b c)
-
-  addIntoSubtraction : (a : ℕ) → {b c : ℕ} → (pr : b ≤N c) → a +N (subtractionNResult.result (-N {b} {c} pr)) ≡ subtractionNResult.result (-N {b} {c +N a} (addToRightWeakInequality a pr))
-  addIntoSubtraction a {b} {c} pr with (-N {b} {c} pr)
-  addIntoSubtraction a {b} {c} pr | record { result = c-b ; pr = prc-b } with (-N {b} {c +N a} (addToRightWeakInequality a pr))
-  addIntoSubtraction a {b} {c} pr | record { result = c-b ; pr = prc-b } | record { result = c+a-b ; pr = prcab } = equalityCommutative g'''
-    where
-      g : (b +N c+a-b) +N c-b ≡ c +N (a +N c-b)
-      g rewrite (equalityCommutative (additionNIsAssociative c a c-b)) = applyEquality (λ t → t +N c-b) prcab
-      g' : (b +N c-b) +N c+a-b ≡ c +N (a +N c-b)
-      g' = identityOfIndiscernablesLeft _≡_ g (addAssocLemma b c+a-b c-b)
-      g'' : c +N c+a-b ≡ c +N (a +N c-b)
-      g'' = identityOfIndiscernablesLeft _≡_ g' (applyEquality (λ i → i +N c+a-b) prc-b)
-      g''' : c+a-b ≡ a +N c-b
-      g''' = canSubtractFromEqualityLeft {c} {c+a-b} {a +N c-b} g''
-
-  addStrongInequalities : {a b c d : ℕ} → (a<b : a <N b) → (c<d : c <N d) → (a +N c <N b +N d)
-  addStrongInequalities {zero} {zero} {c} {d} prab prcd = prcd
-  addStrongInequalities {zero} {succ b} {c} {d} prab prcd rewrite (additionNIsCommutative b d) = orderIsTransitive prcd (cannotAddAndEnlarge d b)
-  addStrongInequalities {succ a} {zero} {c} {d} (le x ()) prcd
-  addStrongInequalities {succ a} {succ b} {c} {d} prab prcd = succPreservesInequality (addStrongInequalities (canRemoveSuccFrom<N prab) prcd)
-
-  addWeakInequalities : {a b c d : ℕ} → (a<=b : a ≤N b) → (c<=d : c ≤N d) → (a +N c) ≤N (b +N d)
-  addWeakInequalities {a} {b} {c} {d} (inl x) (inl y) = inl (addStrongInequalities x y)
-  addWeakInequalities {a} {b} {c} {.c} (inl x) (inr refl) = inl (additionPreservesInequality c x)
-  addWeakInequalities {a} {.a} {c} {d} (inr refl) (inl x) = inl (additionPreservesInequalityOnLeft a x)
-  addWeakInequalities {a} {.a} {c} {.c} (inr refl) (inr refl) = inr refl
-
-  addSubIntoSub : {a b c d : ℕ} → (a<b : a ≤N b) → (c<d : c ≤N d) → (subtractionNResult.result (-N {a} {b} a<b)) +N (subtractionNResult.result (-N {c} {d} c<d)) ≡ subtractionNResult.result (-N {a +N c} {b +N d} (addWeakInequalities a<b c<d))
-  addSubIntoSub {a}{b}{c}{d} a<b c<d with (-N {a} {b} a<b)
-  addSubIntoSub {a} {b} {c} {d} a<b c<d | record { result = b-a ; pr = prb-a } with (-N {c} {d} c<d)
-  addSubIntoSub {a} {b} {c} {d} a<b c<d | record { result = b-a ; pr = prb-a } | record { result = d-c ; pr = prd-c } with (-N {a +N c} {b +N d} (addWeakInequalities a<b c<d))
-  addSubIntoSub {a} {b} {c} {d} a<b c<d | record { result = b-a ; pr = prb-a } | record { result = d-c ; pr = prd-c } | record { result = b+d-a-c ; pr = pr } = equalityCommutative r
-    where
-      pr' : (a +N c) +N b+d-a-c ≡ (a +N b-a) +N d
-      pr' rewrite prb-a = pr
-      pr'' : a +N (c +N b+d-a-c) ≡ (a +N b-a) +N d
-      pr'' rewrite (equalityCommutative (additionNIsAssociative a c b+d-a-c)) = pr'
-      pr''' : a +N (c +N b+d-a-c) ≡ a +N (b-a +N d)
-      pr''' rewrite (equalityCommutative (additionNIsAssociative a b-a d)) = pr''
-      q : c +N b+d-a-c ≡ b-a +N d
-      q = canSubtractFromEqualityLeft {a} pr'''
-      q' : c +N b+d-a-c ≡ b-a +N (c +N d-c)
-      q' rewrite prd-c = q
-      q'' : c +N b+d-a-c ≡ (b-a +N c) +N d-c
-      q'' rewrite additionNIsAssociative b-a c d-c = q'
-      q''' : c +N b+d-a-c ≡ (c +N b-a) +N d-c
-      q''' rewrite additionNIsCommutative c b-a = q''
-      q'''' : c +N b+d-a-c ≡ c +N (b-a +N d-c)
-      q'''' rewrite equalityCommutative (additionNIsAssociative c b-a d-c) = q'''
-      r : b+d-a-c ≡ b-a +N d-c
-      r = canSubtractFromEqualityLeft {c} q''''
-
-
-  subtractProduct : {a b c : ℕ} → (aPos : 0 <N a) → (b<c : b <N c) →
-      (a *N (subtractionNResult.result (-N (inl b<c)))) ≡ subtractionNResult.result (-N {a *N b} {a *N c} (inl (lessRespectsMultiplicationLeft b c a b<c aPos)))
-  subtractProduct {zero} {b} {c} aPos b<c = refl
-  subtractProduct {succ zero} {b} {c} aPos b<c = s'
-    where
-      resbc = -N {b} {c} (inl b<c)
-      resbc' : Sg (subtractionNResult (b +N 0 *N b) c (lessCast (inl b<c) (equalityCommutative (addZeroRight b)))) ((λ res → subtractionNResult.result resbc ≡ subtractionNResult.result res))
-      resbc'' : Sg (subtractionNResult (b +N 0 *N b) (c +N 0 *N c) (lessCast' (lessCast (inl b<c) (equalityCommutative (addZeroRight b))) (equalityCommutative (addZeroRight c)))) (λ res → subtractionNResult.result (underlying resbc') ≡ subtractionNResult.result res)
-      g : (rsbc' : Sg (subtractionNResult (b +N 0 *N b) c (lessCast (inl b<c) (equalityCommutative (addZeroRight b)))) (λ res → subtractionNResult.result resbc ≡ subtractionNResult.result res)) → subtractionNResult.result resbc ≡ subtractionNResult.result (underlying rsbc')
-      g' : (rsbc'' : Sg (subtractionNResult (b +N 0 *N b) (c +N 0 *N c) (lessCast' (lessCast (inl b<c) (equalityCommutative (addZeroRight b))) (equalityCommutative (addZeroRight c)))) (λ res → subtractionNResult.result (underlying resbc') ≡ subtractionNResult.result res)) → subtractionNResult.result (underlying resbc') ≡ subtractionNResult.result (underlying rsbc'')
-      q : subtractionNResult.result resbc ≡ subtractionNResult.result (underlying resbc'')
-      r : subtractionNResult.result (underlying resbc'') ≡ subtractionNResult.result (-N {b +N 0 *N b} {c +N 0 *N c} (inl (lessRespectsMultiplicationLeft b c 1 b<c aPos)))
-      s : subtractionNResult.result resbc ≡ subtractionNResult.result (-N {b +N 0 *N b} {c +N 0 *N c} (inl (lessRespectsMultiplicationLeft b c 1 b<c aPos)))
-      s = transitivity q r
-      s' : subtractionNResult.result resbc +N 0 ≡ subtractionNResult.result (-N {b +N 0 *N b} {c +N 0 *N c} (inl (lessRespectsMultiplicationLeft b c 1 b<c aPos)))
-      s' = identityOfIndiscernablesLeft _≡_ s (equalityCommutative (addZeroRight _))
-      r = subtractionNWellDefined {b +N 0 *N b} {c +N 0 *N c} {(lessCast' (lessCast (inl b<c) (equalityCommutative (addZeroRight b))) (equalityCommutative (addZeroRight c)))} {inl (lessRespectsMultiplicationLeft b c 1 b<c aPos)} (underlying resbc'') (-N {b +N 0 *N b} {c +N 0 *N c} (inl (lessRespectsMultiplicationLeft b c 1 b<c aPos)))
-      g (a , b) = b
-      g' (a , b) = b
-      resbc'' = subtractionCast' (equalityCommutative (addZeroRight c)) (underlying resbc')
-      q = transitivity {_} {_} {subtractionNResult.result resbc} {subtractionNResult.result (underlying resbc')} {subtractionNResult.result (underlying resbc'')} (g resbc') (g' resbc'')
-      resbc' = subtractionCast {b} {c} {b +N 0 *N b} (equalityCommutative (addZeroRight b)) resbc
-
-  subtractProduct {succ (succ a)} {b} {c} aPos b<c =
-    let
-      t : (succ a) *N subtractionNResult.result (-N {b} {c} (inl b<c)) ≡ subtractionNResult.result (-N {(succ a) *N b} {(succ a) *N c} (inl (lessRespectsMultiplicationLeft b c (succ a) b<c (succIsPositive a))))
-      t = subtractProduct {succ a} {b} {c} (succIsPositive a) b<c
-    in
-      go t  --go t
-      where
-        go : (succ a) *N subtractionNResult.result (-N {b} {c} (inl b<c)) ≡ subtractionNResult.result (-N {(succ a) *N b} {(succ a) *N c} (inl (lessRespectsMultiplicationLeft b c (succ a) b<c (succIsPositive a)))) → (subtractionNResult.result (-N (inl b<c)) +N (subtractionNResult.result (-N (inl b<c)) +N a *N subtractionNResult.result (-N (inl b<c))) ≡ subtractionNResult.result (-N (inl (lessRespectsMultiplicationLeft b c (succ (succ a)) b<c aPos))))
-        go t = transitivity {_} {_} {lhs} {middle2} {rhs} u' v
-          where
-            c-b = subtractionNResult.result (-N {b} {c} (inl b<c))
-            lhs = c-b +N (succ a) *N c-b
-            middle = subtractionNResult.result (-N {(succ a) *N b} {(succ a) *N c} (inl (lessRespectsMultiplicationLeft b c (succ a) b<c (succIsPositive a))))
-            middle2 = subtractionNResult.result (-N {b +N (succ a *N b)} {c +N (succ a *N c)} (addWeakInequalities (inl b<c) (inl (lessRespectsMultiplicationLeft b c (succ a) b<c (succIsPositive a)))))
-            rhs = subtractionNResult.result (-N {succ (succ a) *N b} {(succ (succ a)) *N c} (inl (lessRespectsMultiplicationLeft b c (succ (succ a)) b<c aPos)))
-            lhs' : lhs ≡ c-b +N middle
-            u : c-b +N middle ≡ middle2
-            u' : lhs ≡ middle2
-            v : middle2 ≡ rhs
-            u'' : c-b +N subtractionNResult.result (-N {(succ a) *N b} {(succ a) *N c} (inl (lessRespectsMultiplicationLeft b c (succ a) b<c (succIsPositive a)))) ≡ rhs
-
-            u'' rewrite equalityCommutative v = u
-            u' rewrite equalityCommutative u = lhs'
-            lhs' rewrite t = refl
-            u = addSubIntoSub (inl b<c) (inl (lessRespectsMultiplicationLeft b c (succ a) b<c (succIsPositive a)))
-            v = subtractionNWellDefined {succ (succ a) *N b} {succ (succ a) *N c} {addWeakInequalities (inl b<c) (inl (lessRespectsMultiplicationLeft b c (succ a) b<c (succIsPositive a)))} {inl (lessRespectsMultiplicationLeft b c (succ (succ a)) b<c aPos)} (-N {b +N (succ a *N b)} {c +N (succ a *N c)} (addWeakInequalities (inl b<c) (inl (lessRespectsMultiplicationLeft b c (succ a) b<c (succIsPositive a))))) (-N {(succ (succ a)) *N b} {(succ (succ a)) *N c} (inl (lessRespectsMultiplicationLeft b c (succ (succ a)) b<c aPos)))
-
-  subtractProduct' : {a b c : ℕ} → (aPos : 0 <N a) → (b<c : b <N c) →
-    (subtractionNResult.result (-N (inl b<c))) *N a ≡ subtractionNResult.result (-N {a *N b} {a *N c} (inl (lessRespectsMultiplicationLeft b c a b<c aPos)))
-  subtractProduct' {a} aPos b<c = identityOfIndiscernablesLeft _≡_ (subtractProduct aPos b<c) (multiplicationNIsCommutative a _)
-
-  equalityDecidable : (a b : ℕ) → (a ≡ b) || ((a ≡ b) → False)
-  equalityDecidable zero zero = inl refl
-  equalityDecidable zero (succ b) = inr naughtE
-  equalityDecidable (succ a) zero = inr λ t → naughtE (equalityCommutative t)
-  equalityDecidable (succ a) (succ b) with equalityDecidable a b
-  equalityDecidable (succ a) (succ b) | inl x = inl (applyEquality succ x)
-  equalityDecidable (succ a) (succ b) | inr x = inr (λ t → x (succInjective t))
-
-  cannotAddKeepingEquality : (a b : ℕ) → (a ≡ a +N succ b) → False
-  cannotAddKeepingEquality zero zero pr = naughtE pr
-  cannotAddKeepingEquality (succ a) zero pr = cannotAddKeepingEquality a zero (succInjective pr)
-  cannotAddKeepingEquality zero (succ b) pr = naughtE pr
-  cannotAddKeepingEquality (succ a) (succ b) pr = cannotAddKeepingEquality a (succ b) (succInjective pr)
-
-  ℕTotalOrder : TotalOrder ℕ
-  PartialOrder._<_ (TotalOrder.order ℕTotalOrder) = _<N_
-  PartialOrder.irreflexive (TotalOrder.order ℕTotalOrder) = lessIrreflexive
-  PartialOrder.<Transitive (TotalOrder.order ℕTotalOrder) = orderIsTransitive
-  TotalOrder.totality ℕTotalOrder = orderIsTotal
-
-  doubleIsAddTwo : (a : ℕ) → a +N a ≡ 2 *N a
-  doubleIsAddTwo a rewrite additionNIsCommutative a 0 = refl
-
-  productZeroImpliesOperandZero : {a b : ℕ} → a *N b ≡ 0 → (a ≡ 0) || (b ≡ 0)
-  productZeroImpliesOperandZero {zero} {b} pr = inl refl
-  productZeroImpliesOperandZero {succ a} {zero} pr = inr refl
-  productZeroImpliesOperandZero {succ a} {succ b} ()
-
-  sumZeroImpliesOperandsZero : (a : ℕ) {b : ℕ} → a +N b ≡ 0 → (a ≡ 0) && (b ≡ 0)
-  sumZeroImpliesOperandsZero zero {zero} pr = refl ,, refl
-
-  inequalityShrinkRight : {a b c : ℕ} → a +N b <N c → b <N c
-  inequalityShrinkRight {a} {b} {c} (le x proof) = le (x +N a) (transitivity (applyEquality succ (additionNIsAssociative x a b)) proof)
-
-  inequalityShrinkLeft : {a b c : ℕ} → a +N b <N c → a <N c
-  inequalityShrinkLeft {a} {b} {c} (le x proof) = le (x +N b) (transitivity (applyEquality succ (transitivity (additionNIsAssociative x b a) (applyEquality (x +N_) (additionNIsCommutative b a)))) proof)
-
-  <NWellDefined' : {a b c d : ℕ} → a ≡ c → b ≡ d → a <N b → c <N d
-  <NWellDefined' {a} {b} {c} {d} a=c b=d a<b rewrite a=c | b=d = a<b
+<NWellDefined' : {a b c d : ℕ} → a ≡ c → b ≡ d → a <N b → c <N d
+<NWellDefined' {a} {b} {c} {d} a=c b=d a<b rewrite a=c | b=d = a<b

Numbers/Naturals/Order.agda

@@ -1,17 +1,21 @@
 {-# OPTIONS --warning=error --safe --without-K #-}
 
 open import LogicalFormulae
+open import Semirings.Definition
 open import Numbers.Naturals.Definition
-open import Numbers.Naturals.Addition
+open import Numbers.Naturals.Semiring
+open import Orders
 
 module Numbers.Naturals.Order where
+open Semiring ℕSemiring
 
-infix 5 _<NLogical_
-_<NLogical_ : ℕ → ℕ → Set
-zero <NLogical zero = False
-zero <NLogical (succ n) = True
-(succ n) <NLogical zero = False
-(succ n) <NLogical (succ m) = n <NLogical m
+private
+  infix 5 _<NLogical_
+  _<NLogical_ : ℕ → ℕ → Set
+  zero <NLogical zero = False
+  zero <NLogical (succ n) = True
+  (succ n) <NLogical zero = False
+  (succ n) <NLogical (succ m) = n <NLogical m
 
 infix 5 _<N_
 record _<N_ (a : ℕ) (b : ℕ) : Set where
@@ -25,42 +29,43 @@ _≤N_ : ℕ → ℕ → Set
 a ≤N b = (a <N b) || (a ≡ b)
 
 succIsPositive : (a : ℕ) → zero <N succ a
-succIsPositive a = le a (applyEquality succ (additionNIsCommutative a 0))
+succIsPositive a = le a (applyEquality succ (Semiring.commutative ℕSemiring a 0))
 
 aLessSucc : (a : ℕ) → (a <NLogical succ a)
 aLessSucc zero = record {}
 aLessSucc (succ a) = aLessSucc a
 
-succPreservesInequalityLogical : {a b : ℕ} → (a <NLogical b) → (succ a <NLogical succ b)
-succPreservesInequalityLogical {a} {b} prAB = prAB
+private
+  succPreservesInequalityLogical : {a b : ℕ} → (a <NLogical b) → (succ a <NLogical succ b)
+  succPreservesInequalityLogical {a} {b} prAB = prAB
 
-lessTransitiveLogical : {a b c : ℕ} → (a <NLogical b) → (b <NLogical c) → (a <NLogical c)
-lessTransitiveLogical {a} {zero} {zero} prAB prBC = prAB
-lessTransitiveLogical {a} {(succ b)} {zero} prAB ()
-lessTransitiveLogical {zero} {zero} {(succ c)} prAB prBC = record {}
-lessTransitiveLogical {(succ a)} {zero} {(succ c)} () prBC
-lessTransitiveLogical {zero} {(succ b)} {(succ c)} prAB prBC = record {}
-lessTransitiveLogical {(succ a)} {(succ b)} {(succ c)} prAB prBC = lessTransitiveLogical {a} {b} {c} prAB prBC
+  lessTransitiveLogical : {a b c : ℕ} → (a <NLogical b) → (b <NLogical c) → (a <NLogical c)
+  lessTransitiveLogical {a} {zero} {zero} prAB prBC = prAB
+  lessTransitiveLogical {a} {(succ b)} {zero} prAB ()
+  lessTransitiveLogical {zero} {zero} {(succ c)} prAB prBC = record {}
+  lessTransitiveLogical {(succ a)} {zero} {(succ c)} () prBC
+  lessTransitiveLogical {zero} {(succ b)} {(succ c)} prAB prBC = record {}
+  lessTransitiveLogical {(succ a)} {(succ b)} {(succ c)} prAB prBC = lessTransitiveLogical {a} {b} {c} prAB prBC
 
-aLessXPlusSuccA : (a x : ℕ) → (a <NLogical x +N succ a)
-aLessXPlusSuccA a zero = aLessSucc a
-aLessXPlusSuccA zero (succ x) = record {}
-aLessXPlusSuccA (succ a) (succ x) = lessTransitiveLogical {a} {succ a} {x +N succ (succ a)} (aLessXPlusSuccA a zero) (aLessXPlusSuccA (succ a) x)
+  aLessXPlusSuccA : (a x : ℕ) → (a <NLogical x +N succ a)
+  aLessXPlusSuccA a zero = aLessSucc a
+  aLessXPlusSuccA zero (succ x) = record {}
+  aLessXPlusSuccA (succ a) (succ x) = lessTransitiveLogical {a} {succ a} {x +N succ (succ a)} (aLessXPlusSuccA a zero) (aLessXPlusSuccA (succ a) x)
 
-leImpliesLogical<N : {a b : ℕ} → (a <N b) → (a <NLogical b)
-leImpliesLogical<N {zero} {zero} (le x ())
-leImpliesLogical<N {zero} {(succ b)} (le x proof) = record {}
-leImpliesLogical<N {(succ a)} {zero} (le x ())
-leImpliesLogical<N {(succ a)} {(succ .(succ a))} (le zero refl) = aLessSucc a
-leImpliesLogical<N {(succ a)} {(succ .(succ (x +N succ a)))} (le (succ x) refl) = succPreservesInequalityLogical {a} {succ (x +N succ a)} (lessTransitiveLogical {a} {succ a} {succ (x +N succ a)} (aLessSucc a) (aLessXPlusSuccA a x))
+  leImpliesLogical<N : {a b : ℕ} → (a <N b) → (a <NLogical b)
+  leImpliesLogical<N {zero} {zero} (le x ())
+  leImpliesLogical<N {zero} {(succ b)} (le x proof) = record {}
+  leImpliesLogical<N {(succ a)} {zero} (le x ())
+  leImpliesLogical<N {(succ a)} {(succ .(succ a))} (le zero refl) = aLessSucc a
+  leImpliesLogical<N {(succ a)} {(succ .(succ (x +N succ a)))} (le (succ x) refl) = succPreservesInequalityLogical {a} {succ (x +N succ a)} (lessTransitiveLogical {a} {succ a} {succ (x +N succ a)} (aLessSucc a) (aLessXPlusSuccA a x))
 
-logical<NImpliesLe : {a b : ℕ} → (a <NLogical b) → (a <N b)
-logical<NImpliesLe {zero} {zero} ()
-_<N_.x (logical<NImpliesLe {zero} {succ b} prAB) = b
-_<N_.proof (logical<NImpliesLe {zero} {succ b} prAB) = applyEquality succ (addZeroRight b)
-logical<NImpliesLe {(succ a)} {zero} ()
-logical<NImpliesLe {(succ a)} {(succ b)} prAB with logical<NImpliesLe {a} prAB
-logical<NImpliesLe {(succ a)} {(succ .(succ (x +N a)))} prAB | le x refl = le x (succCanMove (succ x) a)
+  logical<NImpliesLe : {a b : ℕ} → (a <NLogical b) → (a <N b)
+  logical<NImpliesLe {zero} {zero} ()
+  _<N_.x (logical<NImpliesLe {zero} {succ b} prAB) = b
+  _<N_.proof (logical<NImpliesLe {zero} {succ b} prAB) = applyEquality succ (sumZeroRight b)
+  logical<NImpliesLe {(succ a)} {zero} ()
+  logical<NImpliesLe {(succ a)} {(succ b)} prAB with logical<NImpliesLe {a} prAB
+  logical<NImpliesLe {(succ a)} {(succ .(succ (x +N a)))} prAB | le x refl = le x (applyEquality succ (transitivity (commutative x _) (applyEquality succ (commutative a _))))
 
 lessTransitive : {a b c : ℕ} → (a <N b) → (b <N c) → (a <N c)
 lessTransitive {a} {b} {c} prab prbc = logical<NImpliesLe (lessTransitiveLogical {a} {b} {c} (leImpliesLogical<N prab) (leImpliesLogical<N prbc))
@@ -73,13 +78,13 @@ succPreservesInequality : {a b : ℕ} → (a <N b) → (succ a <N succ b)
 succPreservesInequality {a} {b} prAB = logical<NImpliesLe (succPreservesInequalityLogical {a} {b} (leImpliesLogical<N prAB))
 
 canRemoveSuccFrom<N : {a b : ℕ} → (succ a <N succ b) → (a <N b)
-canRemoveSuccFrom<N {a} {b} (le x proof) rewrite additionNIsCommutative x (succ a) | additionNIsCommutative a x = le x (succInjective proof)
+canRemoveSuccFrom<N {a} {b} (le x proof) rewrite commutative x (succ a) | commutative a x = le x (succInjective proof)
 
 a<SuccA : (a : ℕ) → a <N succ a
 a<SuccA a = le zero refl
 
 canAddToOneSideOfInequality : {a b : ℕ} (c : ℕ) → a <N b → a <N (b +N c)
-canAddToOneSideOfInequality {a} {b} c (le x proof) = le (x +N c) (transitivity (applyEquality succ (additionNIsAssociative x c a)) (transitivity (applyEquality (λ i → (succ x) +N i) (additionNIsCommutative c a)) (transitivity (applyEquality succ (equalityCommutative (additionNIsAssociative x a c))) (applyEquality (_+N c) proof))))
+canAddToOneSideOfInequality {a} {b} c (le x proof) = le (x +N c) (transitivity (applyEquality succ (equalityCommutative (+Associative x c a))) (transitivity (applyEquality (λ i → (succ x) +N i) (commutative c a)) (transitivity (applyEquality succ (+Associative x a c)) (applyEquality (_+N c) proof))))
 
 addingIncreases : (a b : ℕ) → a <N a +N succ b
 addingIncreases zero b = succIsPositive b
@@ -91,7 +96,7 @@ zeroNeverGreater {a} (le x ())
 noIntegersBetweenXAndSuccX : {a : ℕ} (x : ℕ) → (x <N a) → (a <N succ x) → False
 noIntegersBetweenXAndSuccX {zero} x x<a a<sx = zeroNeverGreater x<a
 noIntegersBetweenXAndSuccX {succ a} x (le y proof) (le z proof1) with succInjective proof1
-... | ah rewrite (equalityCommutative proof) | (succExtracts z (y +N x)) | equalityCommutative (additionNIsAssociative (succ z) y x) | additionNIsCommutative (succ (z +N y)) x = lessIrreflexive {x} (le (z +N y) (transitivity (additionNIsCommutative _ x) ah))
+... | ah rewrite (equalityCommutative proof) | (succExtracts z (y +N x)) | +Associative (succ z) y x | commutative (succ (z +N y)) x = lessIrreflexive {x} (le (z +N y) (transitivity (commutative _ x) ah))
 
 <NWellDefined : {a b : ℕ} → (p1 : a <N b) → (p2 : a <N b) → _<N_.x p1 ≡ _<N_.x p2
 <NWellDefined {a} {b} (le x proof) (le y proof1) = equalityCommutative r
@@ -100,3 +105,80 @@ noIntegersBetweenXAndSuccX {succ a} x (le y proof) (le z proof1) with succInject
     q = succInjective {y +N a} {x +N a} (transitivity proof1 (equalityCommutative proof))
     r : y ≡ x
     r = canSubtractFromEqualityRight q
+
+private
+  orderIsTotal : (a b : ℕ) → ((a <N b) || (b <N a)) || (a ≡ b)
+  orderIsTotal zero zero = inr refl
+  orderIsTotal zero (succ b) = inl (inl (logical<NImpliesLe (record {})))
+  orderIsTotal (succ a) zero = inl (inr (logical<NImpliesLe (record {})))
+  orderIsTotal (succ a) (succ b) with orderIsTotal a b
+  orderIsTotal (succ a) (succ b) | inl (inl x) = inl (inl (logical<NImpliesLe (leImpliesLogical<N x)))
+  orderIsTotal (succ a) (succ b) | inl (inr x) = inl (inr (logical<NImpliesLe (leImpliesLogical<N x)))
+  orderIsTotal (succ a) (succ b) | inr x = inr (applyEquality succ x)
+
+  orderIsIrreflexive : {a b : ℕ} → (a <N b) → (b <N a) → False
+  orderIsIrreflexive {zero} {b} prAB (le x ())
+  orderIsIrreflexive {(succ a)} {zero} (le x ()) prBA
+  orderIsIrreflexive {(succ a)} {(succ b)} prAB prBA = orderIsIrreflexive {a} {b} (logical<NImpliesLe (leImpliesLogical<N prAB)) (logical<NImpliesLe (leImpliesLogical<N prBA))
+
+  orderIsTransitive : {a b c : ℕ} → (a <N b) → (b <N c) → (a <N c)
+  orderIsTransitive {a} {.(succ (x +N a))} {.(succ (y +N succ (x +N a)))} (le x refl) (le y refl) = le (y +N succ x) (applyEquality succ (equalityCommutative (+Associative y (succ x) a)))
+
+ℕTotalOrder : TotalOrder ℕ
+PartialOrder._<_ (TotalOrder.order ℕTotalOrder) = _<N_
+PartialOrder.irreflexive (TotalOrder.order ℕTotalOrder) = lessIrreflexive
+PartialOrder.<Transitive (TotalOrder.order ℕTotalOrder) = orderIsTransitive
+TotalOrder.totality ℕTotalOrder = orderIsTotal
+
+cannotAddAndEnlarge : (a b : ℕ) → a <N succ (a +N b)
+cannotAddAndEnlarge a b = le b (applyEquality succ (commutative b a))
+
+cannotAddAndEnlarge' : {a b : ℕ} → a +N b <N a → False
+cannotAddAndEnlarge' {a} {zero} pr rewrite sumZeroRight a = lessIrreflexive pr
+cannotAddAndEnlarge' {a} {succ b} pr rewrite (succExtracts a b) = lessIrreflexive {a} (lessTransitive {a} {succ (a +N b)} {a} (cannotAddAndEnlarge a b) pr)
+
+cannotAddAndEnlarge'' : {a b : ℕ} → a +N succ b ≡ a → False
+cannotAddAndEnlarge'' {a} {b} pr = naughtE (equalityCommutative inter)
+  where
+    inter : succ b ≡ 0
+    inter rewrite commutative a (succ b) = canSubtractFromEqualityRight pr
+
+naturalsAreNonnegative : (a : ℕ) → (a <N zero) → False
+naturalsAreNonnegative zero ()
+naturalsAreNonnegative (succ x) ()
+
+lessRespectsAddition : {a b : ℕ} (c : ℕ) → (a <N b) → ((a +N c) <N (b +N c))
+lessRespectsAddition {a} {b} zero prAB rewrite commutative a 0 | commutative b 0 = prAB
+lessRespectsAddition {a} {b} (succ c) prAB rewrite commutative a (succ c) | commutative b (succ c) | commutative c a | commutative c b = succPreservesInequality (lessRespectsAddition c prAB)
+
+lessRespectsMultiplicationLeft : (a b c : ℕ) → (a <N b) → (zero <N c) → (c *N a <N c *N b)
+lessRespectsMultiplicationLeft zero zero c (le x ()) cPos
+lessRespectsMultiplicationLeft zero (succ b) zero prAB (le x ())
+lessRespectsMultiplicationLeft zero (succ b) (succ c) prAB cPos = i
+  where
+    productNonzeroIsNonzero : {a b : ℕ} → zero <N a → zero <N b → zero <N a *N b
+    productNonzeroIsNonzero {zero} {b} prA prB = prA
+    productNonzeroIsNonzero {succ a} {zero} prA ()
+    productNonzeroIsNonzero {succ a} {succ b} prA prB = le (b +N a *N succ b) (applyEquality succ (Semiring.sumZeroRight ℕSemiring _))
+
+    j : zero <N succ c *N succ b
+    j = productNonzeroIsNonzero cPos prAB
+    i : succ c *N zero <N succ c *N succ b
+    i = identityOfIndiscernablesLeft _<N_ j (equalityCommutative (productZeroRight c))
+lessRespectsMultiplicationLeft (succ a) zero c (le x ()) cPos
+lessRespectsMultiplicationLeft (succ a) (succ b) c prAB cPos = m
+  where
+    h : c *N a <N c *N b
+    h = lessRespectsMultiplicationLeft a b c (canRemoveSuccFrom<N prAB) cPos
+    j : c *N a +N c <N c *N b +N c
+    j = lessRespectsAddition c h
+    i : c *N succ a <N c *N b +N c
+    i = identityOfIndiscernablesLeft _<N_ j (equalityCommutative (transitivity (multiplicationNIsCommutative c _) (transitivity (applyEquality (c +N_) (multiplicationNIsCommutative a _)) (commutative c _))))
+    m : c *N succ a <N c *N succ b
+    m = identityOfIndiscernablesRight _<N_ i (equalityCommutative (transitivity (multiplicationNIsCommutative c _) (transitivity (commutative c _) (applyEquality (_+N c) (multiplicationNIsCommutative b _)))))
+
+canFlipMultiplicationsInIneq : {a b c d : ℕ} → (a *N b <N c *N d) → b *N a <N d *N c
+canFlipMultiplicationsInIneq {a} {b} {c} {d} pr = identityOfIndiscernablesRight _<N_ (identityOfIndiscernablesLeft _<N_ pr (multiplicationNIsCommutative a b)) (multiplicationNIsCommutative c d)
+
+lessRespectsMultiplication : (a b c : ℕ) → (a <N b) → (zero <N c) → (a *N c <N b *N c)
+lessRespectsMultiplication a b c prAB cPos = canFlipMultiplicationsInIneq {c} {a} {c} {b} (lessRespectsMultiplicationLeft a b c prAB cPos)

Numbers/Naturals/Order/Lemmas.agda

@@ -0,0 +1,83 @@
+{-# OPTIONS --warning=error --safe --without-K #-}
+
+open import LogicalFormulae
+open import Semirings.Definition
+open import Numbers.Naturals.Order
+open import Numbers.Naturals.Semiring
+open import Orders
+
+module Numbers.Naturals.Order.Lemmas where
+open Semiring ℕSemiring
+
+inequalityShrinkRight : {a b c : ℕ} → a +N b <N c → b <N c
+inequalityShrinkRight {a} {b} {c} (le x proof) = le (x +N a) (transitivity (applyEquality succ (equalityCommutative (Semiring.+Associative ℕSemiring x a b))) proof)
+
+inequalityShrinkLeft : {a b c : ℕ} → a +N b <N c → a <N c
+inequalityShrinkLeft {a} {b} {c} (le x proof) = le (x +N b) (transitivity (applyEquality succ (transitivity (equalityCommutative (Semiring.+Associative ℕSemiring x b a)) (applyEquality (x +N_) (Semiring.commutative ℕSemiring b a)))) proof)
+
+productCancelsRight : (a b c : ℕ) → (zero <N a) → (b *N a ≡ c *N a) → (b ≡ c)
+productCancelsRight a zero zero aPos eq = refl
+productCancelsRight zero zero (succ c) (le x ()) eq
+productCancelsRight (succ a) zero (succ c) aPos eq = contr
+  where
+    h : zero ≡ succ c *N succ a
+    h = eq
+    contr : zero ≡ succ c
+    contr = exFalso (naughtE h)
+productCancelsRight zero (succ b) zero (le x ()) eq
+productCancelsRight (succ a) (succ b) zero aPos eq = contr
+  where
+    h : succ b *N succ a ≡ zero
+    h = eq
+    contr : succ b ≡ zero
+    contr = exFalso (naughtE (equalityCommutative h))
+productCancelsRight zero (succ b) (succ c) (le x ()) eq
+productCancelsRight (succ a) (succ b) (succ c) aPos eq = applyEquality succ (productCancelsRight (succ a) b c aPos l)
+    where
+      i : succ a +N b *N succ a ≡ succ c *N succ a
+      i = eq
+      j : succ c *N succ a ≡ succ a +N c *N succ a
+      j = refl
+      k : succ a +N b *N succ a ≡ succ a +N c *N succ a
+      k = transitivity i j
+      l : b *N succ a ≡ c *N succ a
+      l = canSubtractFromEqualityLeft {succ a} {b *N succ a} {c *N succ a} k
+
+productCancelsLeft : (a b c : ℕ) → (zero <N a) → (a *N b ≡ a *N c) → (b ≡ c)
+productCancelsLeft a b c aPos pr = productCancelsRight a b c aPos j
+  where
+    i : b *N a ≡ a *N c
+    i = identityOfIndiscernablesLeft _≡_ pr (multiplicationNIsCommutative a b)
+    j : b *N a ≡ c *N a
+    j = identityOfIndiscernablesRight _≡_ i (multiplicationNIsCommutative a c)
+
+productCancelsRight' : (a b c : ℕ) → (b *N a ≡ c *N a) → (a ≡ zero) || (b ≡ c)
+productCancelsRight' zero b c pr = inl refl
+productCancelsRight' (succ a) b c pr = inr (productCancelsRight (succ a) b c (succIsPositive a) pr)
+
+productCancelsLeft' : (a b c : ℕ) → (a *N b ≡ a *N c) → (a ≡ zero) || (b ≡ c)
+productCancelsLeft' zero b c pr = inl refl
+productCancelsLeft' (succ a) b c pr = inr (productCancelsLeft (succ a) b c (succIsPositive a) pr)
+
+subtractionPreservesInequality : {a b : ℕ} → (c : ℕ) → a +N c <N b +N c → a <N b
+subtractionPreservesInequality {a} {b} zero prABC rewrite commutative a 0 | commutative b 0 = prABC
+subtractionPreservesInequality {a} {b} (succ c) (le x proof) = le x (canSubtractFromEqualityRight {b = succ c} (transitivity (equalityCommutative (+Associative (succ x) a (succ c))) proof))
+
+cancelInequalityLeft : {a b c : ℕ} → a *N b <N a *N c → b <N c
+cancelInequalityLeft {a} {zero} {zero} (le x proof) rewrite (productZeroRight a) = exFalso (naughtE (equalityCommutative proof))
+cancelInequalityLeft {a} {zero} {succ c} pr = succIsPositive c
+cancelInequalityLeft {a} {succ b} {zero} (le x proof) rewrite (productZeroRight a) = exFalso (naughtE (equalityCommutative proof))
+cancelInequalityLeft {a} {succ b} {succ c} pr = succPreservesInequality q'
+  where
+    p' : succ b *N a <N succ c *N a
+    p' = canFlipMultiplicationsInIneq {a} {succ b} {a} {succ c} pr
+    p'' : b *N a +N a <N succ c *N a
+    p'' = identityOfIndiscernablesLeft _<N_ p' (commutative a (b *N a))
+    p''' : b *N a +N a <N c *N a +N a
+    p''' = identityOfIndiscernablesRight _<N_ p'' (commutative a (c *N a))
+    p : b *N a <N c *N a
+    p = subtractionPreservesInequality a p'''
+    q : a *N b <N a *N c
+    q = canFlipMultiplicationsInIneq {b} {a} {c} {a} p
+    q' : b <N c
+    q' = cancelInequalityLeft {a} {b} {c} q

Numbers/Naturals/Order/WellFounded.agda

@@ -0,0 +1,36 @@
+{-# OPTIONS --warning=error --safe --without-K #-}
+
+open import LogicalFormulae
+open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
+open import WellFoundedInduction
+open import Functions
+open import Numbers.Naturals.Semiring
+open import Numbers.Naturals.Order
+open import Semirings.Definition
+open import Orders
+
+module Numbers.Naturals.Order.WellFounded where
+open Semiring ℕSemiring
+
+<NWellfounded : WellFounded _<N_
+<NWellfounded = λ x → access (go x)
+  where
+    lemma : {a b c : ℕ} → a <N b → b <N succ c → a <N c
+    lemma {a} {b} {c} (le y succYAeqB) (le z zbEqC') = le (y +N z) p
+      where
+        zbEqC : z +N b ≡ c
+        zSuccYAEqC : z +N (succ y +N a) ≡ c
+        zSuccYAEqC' : z +N (succ (y +N a)) ≡ c
+        zSuccYAEqC'' : succ (z +N (y +N a)) ≡ c
+        zSuccYAEqC''' : succ ((z +N y) +N a) ≡ c
+        p : succ ((y +N z) +N a) ≡ c
+        p = identityOfIndiscernablesLeft _≡_ zSuccYAEqC''' (applyEquality (λ n → succ (n +N a)) (commutative z y))
+        zSuccYAEqC''' = identityOfIndiscernablesLeft _≡_ zSuccYAEqC'' (applyEquality succ (+Associative z y a))
+        zSuccYAEqC'' = identityOfIndiscernablesLeft _≡_ zSuccYAEqC' (succExtracts z (y +N a))
+        zSuccYAEqC' = identityOfIndiscernablesLeft _≡_ zSuccYAEqC (applyEquality (λ r → z +N r) refl)
+        zbEqC = succInjective zbEqC'
+        zSuccYAEqC = identityOfIndiscernablesLeft _≡_ zbEqC (applyEquality (λ r → z +N r) (equalityCommutative succYAeqB))
+    go : ∀ n m → m <N n → Accessible _<N_ m
+    go zero m (le x ())
+    go (succ n) zero mLessN = access (λ y ())
+    go (succ n) (succ m) smLessSN = access (λ o (oLessSM : o <N succ m) → go n o (lemma oLessSM smLessSN))

Numbers/Naturals/Semiring.agda

@@ -0,0 +1,39 @@
+{-# OPTIONS --warning=error --safe --without-K #-}
+
+open import LogicalFormulae
+open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
+open import WellFoundedInduction
+open import Functions
+open import Orders
+open import Numbers.Naturals.Definition
+open import Numbers.Naturals.Addition
+open import Numbers.Naturals.Multiplication
+open import Semirings.Definition
+open import Monoids.Definition
+
+module Numbers.Naturals.Semiring where
+
+open Numbers.Naturals.Definition using (ℕ ; zero ; succ ; succInjective ; naughtE) public
+open Numbers.Naturals.Addition using (_+N_ ; canSubtractFromEqualityRight ; canSubtractFromEqualityLeft) public
+open Numbers.Naturals.Multiplication using (_*N_ ; multiplicationNIsCommutative) public
+
+ℕSemiring : Semiring 0 1 _+N_ _*N_
+Monoid.associative (Semiring.monoid ℕSemiring) a b c = equalityCommutative (additionNIsAssociative a b c)
+Monoid.idLeft (Semiring.monoid ℕSemiring) _ = refl
+Monoid.idRight (Semiring.monoid ℕSemiring) a = additionNIsCommutative a 0
+Semiring.commutative ℕSemiring = additionNIsCommutative
+Monoid.associative (Semiring.multMonoid ℕSemiring) = multiplicationNIsAssociative
+Monoid.idLeft (Semiring.multMonoid ℕSemiring) a = additionNIsCommutative a 0
+Monoid.idRight (Semiring.multMonoid ℕSemiring) a = transitivity (multiplicationNIsCommutative a 1) (additionNIsCommutative a 0)
+Semiring.productZeroLeft ℕSemiring _ = refl
+Semiring.productZeroRight ℕSemiring a = multiplicationNIsCommutative a 0
+Semiring.+DistributesOver* ℕSemiring = productDistributes
+Semiring.+DistributesOver*' ℕSemiring a b c rewrite multiplicationNIsCommutative (a +N b) c | multiplicationNIsCommutative a c | multiplicationNIsCommutative b c = productDistributes c a b
+
+succExtracts : (x y : ℕ) → (x +N succ y) ≡ (succ (x +N y))
+succExtracts x y = transitivity (Semiring.commutative ℕSemiring x (succ y)) (applyEquality succ (Semiring.commutative ℕSemiring y x))
+
+productZeroImpliesOperandZero : {a b : ℕ} → a *N b ≡ 0 → (a ≡ 0) || (b ≡ 0)
+productZeroImpliesOperandZero {zero} {b} pr = inl refl
+productZeroImpliesOperandZero {succ a} {zero} pr = inr refl
+productZeroImpliesOperandZero {succ a} {succ b} ()

Numbers/Naturals/WithK.agda

@@ -5,7 +5,8 @@ open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
 open import WellFoundedInduction
 open import Functions
 open import Orders
-open import Numbers.Naturals.Naturals
+open import Numbers.Naturals.Semiring
+open import Numbers.Naturals.Order
 
 module Numbers.Naturals.WithK where
 

Numbers/Primes/IntegerFactorisation.agda

@@ -1,272 +1,274 @@
 {-# OPTIONS --warning=error --safe #-}
 
 open import LogicalFormulae
-open import Numbers.Naturals.Naturals
-open import Numbers.Naturals.Addition
+open import Numbers.Naturals.Semiring
 open import Numbers.Naturals.Order
+open import Numbers.Naturals.Order.Lemmas
+open import Numbers.Naturals.Order.WellFounded
 open import Numbers.Primes.PrimeNumbers
 open import WellFoundedInduction
 open import Semirings.Definition
 open import Orders
 
 module Numbers.Primes.IntegerFactorisation where
+open TotalOrder ℕTotalOrder
 
-    -- Represent a factorisation into increasing factors
-    -- Note that 0 cannot be expressed this way.
-    record factorisationNonunit (minFactor : ℕ) (a : ℕ) : Set where
-      inductive
-      field
-        1<a : 1 <N a
-        firstFactor : ℕ
-        firstFactorNontrivial : 1 <N firstFactor
-        firstFactorBiggerMin : minFactor ≤N firstFactor
-        firstFactorDivision : divisionAlgResult firstFactor a
-        firstFactorDivides : divisionAlgResult.rem firstFactorDivision ≡ 0
-        firstFactorPrime : Prime firstFactor
-        otherFactorsNumber : ℕ
-        otherFactors : ((divisionAlgResult.quot firstFactorDivision ≡ 1) && (otherFactorsNumber ≡ 0)) || (((1 <N divisionAlgResult.quot firstFactorDivision) && (factorisationNonunit firstFactor (divisionAlgResult.quot firstFactorDivision))))
+-- Represent a factorisation into increasing factors
+-- Note that 0 cannot be expressed this way.
+record factorisationNonunit (minFactor : ℕ) (a : ℕ) : Set where
+  inductive
+  field
+    1<a : 1 <N a
+    firstFactor : ℕ
+    firstFactorNontrivial : 1 <N firstFactor
+    firstFactorBiggerMin : minFactor ≤N firstFactor
+    firstFactorDivision : divisionAlgResult firstFactor a
+    firstFactorDivides : divisionAlgResult.rem firstFactorDivision ≡ 0
+    firstFactorPrime : Prime firstFactor
+    otherFactorsNumber : ℕ
+    otherFactors : ((divisionAlgResult.quot firstFactorDivision ≡ 1) && (otherFactorsNumber ≡ 0)) || (((1 <N divisionAlgResult.quot firstFactorDivision) && (factorisationNonunit firstFactor (divisionAlgResult.quot firstFactorDivision))))
 
-    lemma : (p : ℕ) → p *N 1 +N 0 ≡ p
-    lemma p rewrite Semiring.sumZeroRight ℕSemiring (p *N 1) | Semiring.productOneRight ℕSemiring p = refl
+lemma : (p : ℕ) → p *N 1 +N 0 ≡ p
+lemma p rewrite Semiring.sumZeroRight ℕSemiring (p *N 1) | Semiring.productOneRight ℕSemiring p = refl
 
-    lemma' : {a b : ℕ} → a *N zero +N 0 ≡ b → b ≡ zero
-    lemma' {a} {b} pr rewrite Semiring.sumZeroRight ℕSemiring (a *N zero) | Semiring.productZeroRight ℕSemiring a = equalityCommutative pr
+lemma' : {a b : ℕ} → a *N zero +N 0 ≡ b → b ≡ zero
+lemma' {a} {b} pr rewrite Semiring.sumZeroRight ℕSemiring (a *N zero) | Semiring.productZeroRight ℕSemiring a = equalityCommutative pr
 
-    primeFactorisation : {p : ℕ} → (pr : Prime p) → factorisationNonunit 1 p
-    primeFactorisation {p} record { p>1 = p>1 ; pr = pr } = record {1<a = p>1 ; firstFactor = p ; firstFactorNontrivial = p>1 ; firstFactorBiggerMin = inl p>1 ; firstFactorDivision = record { quot = 1 ; rem = 0 ; pr = lemma p  ; remIsSmall = zeroIsValidRem p ; quotSmall = inl (TotalOrder.<Transitive ℕTotalOrder (le zero refl) p>1) } ; firstFactorDivides = refl ; firstFactorPrime = record { p>1 = p>1 ; pr = pr} ; otherFactors = inl record { fst = refl ; snd = refl } ; otherFactorsNumber = 0 }
+primeFactorisation : {p : ℕ} → (pr : Prime p) → factorisationNonunit 1 p
+primeFactorisation {p} record { p>1 = p>1 ; pr = pr } = record {1<a = p>1 ; firstFactor = p ; firstFactorNontrivial = p>1 ; firstFactorBiggerMin = inl p>1 ; firstFactorDivision = record { quot = 1 ; rem = 0 ; pr = lemma p  ; remIsSmall = zeroIsValidRem p ; quotSmall = inl (TotalOrder.<Transitive ℕTotalOrder (le zero refl) p>1) } ; firstFactorDivides = refl ; firstFactorPrime = record { p>1 = p>1 ; pr = pr} ; otherFactors = inl record { fst = refl ; snd = refl } ; otherFactorsNumber = 0 }
+  where
+    proof : (s : ℕ) → s *N 1 +N 0 ≡ s
+    proof s rewrite Semiring.sumZeroRight ℕSemiring (s *N 1) | multiplicationNIsCommutative s 1 | Semiring.sumZeroRight ℕSemiring s = refl
+
+twoAsFact : factorisationNonunit 2 2
+factorisationNonunit.1<a twoAsFact = succPreservesInequality (succIsPositive 0)
+factorisationNonunit.firstFactor twoAsFact = 2
+factorisationNonunit.firstFactorNontrivial twoAsFact = succPreservesInequality (succIsPositive 0)
+factorisationNonunit.firstFactorBiggerMin twoAsFact = inr refl
+factorisationNonunit.firstFactorDivision twoAsFact = record { quot = 1 ; rem = 0 ; remIsSmall = zeroIsValidRem 2 ; pr = refl ; quotSmall = inl (le 1 refl) }
+factorisationNonunit.firstFactorDivides twoAsFact = refl
+factorisationNonunit.firstFactorPrime twoAsFact = twoIsPrime
+factorisationNonunit.otherFactorsNumber twoAsFact = 0
+factorisationNonunit.otherFactors twoAsFact = inl record { fst = refl ; snd = refl }
+
+fourFact : factorisationNonunit 1 4
+factorisationNonunit.1<a fourFact = succPreservesInequality (succIsPositive 2)
+factorisationNonunit.firstFactor fourFact = 2
+factorisationNonunit.firstFactorNontrivial fourFact = succPreservesInequality (succIsPositive 0)
+factorisationNonunit.firstFactorBiggerMin fourFact = inl (succPreservesInequality (succIsPositive 0))
+factorisationNonunit.firstFactorDivision fourFact = record { quot = 2 ; rem = 0 ; remIsSmall = zeroIsValidRem 2 ; pr = refl ; quotSmall = inl (le 1 refl) }
+factorisationNonunit.firstFactorDivides fourFact = refl
+factorisationNonunit.firstFactorPrime fourFact = twoIsPrime
+factorisationNonunit.otherFactorsNumber fourFact = 1
+factorisationNonunit.otherFactors fourFact = inr record { fst = succPreservesInequality (succIsPositive 0) ; snd = twoAsFact }
+
+lessLemma : {y : ℕ} → (1 <N y) → (zero <N y)
+lessLemma {.(succ (x +N 1))} (le x refl) = succIsPositive (x +N 1)
+
+canReduceFactorBound : {a i j : ℕ} → factorisationNonunit i a → j <N i → factorisationNonunit j a
+canReduceFactorBound {a} {i} {j} record { 1<a = 1<a ; firstFactor = firstFactor ; firstFactorNontrivial = firstFactorNontrivial ; firstFactorBiggerMin = inl ff<i ; firstFactorDivision = firstFactorDivision ; firstFactorDivides = firstFactorDivides ; firstFactorPrime = firstFactorPrime ; otherFactors = otherFactors } j<i = record { 1<a = 1<a ; firstFactor = firstFactor ; firstFactorNontrivial = firstFactorNontrivial ; firstFactorBiggerMin = inl (lessTransitive j<i ff<i) ; firstFactorDivision = firstFactorDivision ; firstFactorDivides = firstFactorDivides ; firstFactorPrime = firstFactorPrime ; otherFactors = otherFactors }
+canReduceFactorBound {a} {i} {j} record { 1<a = 1<a ; firstFactor = firstFactor ; firstFactorNontrivial = firstFactorNontrivial ; firstFactorBiggerMin = inr ff=i ; firstFactorDivision = firstFactorDivision ; firstFactorDivides = firstFactorDivides ; firstFactorPrime = firstFactorPrime ; otherFactors = otherFactors } j<i = record { 1<a = 1<a ; firstFactor = firstFactor ; firstFactorNontrivial = firstFactorNontrivial ; firstFactorBiggerMin = inl (identityOfIndiscernablesRight _<N_ j<i ff=i) ; firstFactorDivision = firstFactorDivision ; firstFactorDivides = firstFactorDivides ; firstFactorPrime = firstFactorPrime ; otherFactors = otherFactors }
+
+canReduceFactorBound' : {a i j : ℕ} → factorisationNonunit i a → j ≤N i → factorisationNonunit j a
+canReduceFactorBound' {a} {i} {j} factA (inl x) = canReduceFactorBound factA x
+canReduceFactorBound' {a} {i} {.i} factA (inr refl) = factA
+
+canIncreaseFactorBound : {a i : ℕ} → (fact : factorisationNonunit 1 a) → (∀ x → 1 <N x → x <N i → x ∣ a → False) → (i ≤N factorisationNonunit.firstFactor fact) → factorisationNonunit i a
+canIncreaseFactorBound {a} {i} record { 1<a = 1<a ; firstFactor = firstFactor ; firstFactorNontrivial = firstFactorNontrivial ; firstFactorBiggerMin = firstFactorBiggerMin ; firstFactorDivision = firstFactorDivision ; firstFactorDivides = firstFactorDivides ; firstFactorPrime = firstFactorPrime ; otherFactors = otherFactors } noSmaller iSmallEnough = record { 1<a = 1<a ; firstFactor = firstFactor ; firstFactorNontrivial = Prime.p>1 firstFactorPrime ; firstFactorBiggerMin = iSmallEnough ; firstFactorDivision = firstFactorDivision ; firstFactorDivides = firstFactorDivides ; firstFactorPrime = firstFactorPrime ; otherFactors = otherFactors }
+
+-- Get the smallest prime factor of the number
+everyNumberHasAPrimeFactor : {a : ℕ} → (1 <N a) → Sg ℕ (λ i → ((i ∣ a) && (1 <N i)) && ((Prime i) && (∀ x → x <N i → 1 <N x → x ∣ a → False)))
+everyNumberHasAPrimeFactor {a} 1<a with compositeOrPrime a 1<a
+everyNumberHasAPrimeFactor {a} 1<a | inl record { n>1 = n>1 ; divisor = divisor ; dividesN = dividesN ; divisorLessN = divisorLessN ; divisorNot1 = divisorNot1 ; divisorPrime = divisorPrime ; noSmallerDivisors = noSmallerDivisors } = ( divisor , record { fst = record { fst = dividesN ; snd = divisorNot1 } ; snd = record { fst = divisorPrime ; snd = noSmallerDivisors } } )
+everyNumberHasAPrimeFactor {a} 1<a | inr x = (a , record { fst = record { fst = aDivA a ; snd = 1<a } ; snd = record { fst = x ; snd = λ y y<a 1<y y|a → irreflexive (<WellDefined (equalityCommutative (Prime.pr x y|a y<a (lessLemma 1<y))) refl 1<y) }} )
+
+lemma2 : {a b c : ℕ} → 1 <N a → 0 <N b → a *N b +N 0 ≡ c → b <N c
+lemma2 {zero} {b} {c} 1<a _ pr = exFalso (zeroNeverGreater 1<a)
+lemma2 {succ zero} {b} {c} 1<a _ pr = exFalso (lessIrreflexive 1<a)
+lemma2 {succ (succ a)} {zero} {zero} 1<a t pr = exFalso (lessIrreflexive t)
+lemma2 {succ (succ a)} {zero} {succ c} 1<a t pr = succIsPositive c
+lemma2 {succ (succ a)} {succ b} {c} 1<a t pr = le (b +N (a *N succ b)) go
+  where
+    assocLemm : (a b c : ℕ) → (a +N b) +N c ≡ (a +N c) +N b
+    assocLemm a b c rewrite equalityCommutative (Semiring.+Associative ℕSemiring a b c) | Semiring.commutative ℕSemiring b c | Semiring.+Associative ℕSemiring a c b = refl
+    go : succ ((b +N a *N succ b) +N succ b) ≡ c
+    go rewrite Semiring.sumZeroRight ℕSemiring (succ (b +N succ (b +N a *N succ b))) | equalityCommutative (assocLemm b (succ b) (a *N succ b)) | Semiring.+Associative ℕSemiring b (succ b) (a *N succ b) = pr
+
+factorIntegerLemma : (x : ℕ) (indHyp : (y : ℕ) (y<x : y <N x) → ((y <N 2) || (factorisationNonunit 1 y))) → ((x <N 2) || (factorisationNonunit 1 x))
+factorIntegerLemma zero indHyp = inl (succIsPositive 1)
+factorIntegerLemma (succ zero) indHyp = inl (succPreservesInequality (succIsPositive 0))
+factorIntegerLemma (succ (succ x)) indHyp with everyNumberHasAPrimeFactor {succ (succ x)} (succPreservesInequality (succIsPositive x))
+factorIntegerLemma (succ (succ x)) indHyp | a , record { fst = record { fst = divides record {quot = zero ; rem = .0 ; pr = ssxDivA ; remIsSmall = r } refl ; snd = 1<a }; snd = record { fst = primeA ; snd = smallerFactors } } rewrite Semiring.sumZeroRight ℕSemiring (a *N zero) | multiplicationNIsCommutative a 0 = exFalso (naughtE ssxDivA)
+factorIntegerLemma (succ (succ x)) indHyp | a , record { fst = record { fst = divides record {quot = succ zero ; rem = .0 ; pr = ssxDivA ; remIsSmall = r } refl ; snd = 1<a }; snd = record { fst = primeA ; snd = smallerFactors } } = inr record { 1<a = succPreservesInequality (succIsPositive x) ; firstFactor = a ; firstFactorNontrivial = Prime.p>1 primeA ; firstFactorBiggerMin = inl (Prime.p>1 primeA) ; firstFactorDivision = record { quot = 1 ; rem = 0 ; pr = ssxDivA ; remIsSmall = r ; quotSmall = inl (TotalOrder.<Transitive ℕTotalOrder (le zero refl) 1<a) } ; firstFactorDivides = refl ; firstFactorPrime = record { p>1 = Prime.p>1 primeA ; pr = Prime.pr primeA } ; otherFactors = inl record { fst = refl ; snd = refl } ; otherFactorsNumber = 0 }
+
+factorIntegerLemma (succ (succ x)) indHyp | a , record { fst = record { fst = divides record {quot = succ (succ qu) ; rem = .0 ; pr = ssxDivA ; remIsSmall = remSmall } refl ; snd = 1<a }; snd = record { fst = primeA ; snd = smallerFactors } } = inr record { 1<a = succPreservesInequality (succIsPositive x) ; firstFactor = a ; firstFactorNontrivial = Prime.p>1 primeA ; firstFactorBiggerMin = inl (Prime.p>1 primeA) ; firstFactorDivision = record { quot = succ (succ qu) ; rem = 0 ; pr = ssxDivA ; remIsSmall = remSmall ; quotSmall = inl (TotalOrder.<Transitive ℕTotalOrder (le zero refl) 1<a) } ; firstFactorDivides = refl ; firstFactorPrime = record { p>1 = Prime.p>1 primeA ; pr = Prime.pr primeA } ; otherFactors = inr record {fst = succPreservesInequality (succIsPositive qu) ; snd = factNonunit} ; otherFactorsNumber = succ (factorisationNonunit.otherFactorsNumber indHypRes') }
+  where
+    indHypRes : ((succ (succ qu)) <N 2) || factorisationNonunit 1 (succ (succ qu))
+    indHypRes = indHyp (succ (succ qu)) (lemma2 {a} {succ (succ qu)} {succ (succ x)} 1<a (succIsPositive (succ qu)) ssxDivA)
+    indHypRes' : factorisationNonunit 1 (succ (succ qu))
+    indHypRes' with indHypRes
+    indHypRes' | inl y = exFalso (zeroNeverGreater (canRemoveSuccFrom<N (canRemoveSuccFrom<N y)))
+    indHypRes' | inr y = y
+    z|ssx : (z : ℕ) → z ∣ succ (succ qu) → z ∣ succ (succ x)
+    z|ssx z z|ssq = (divisibilityTransitive z|ssq (divides (record { quot = a ; rem = 0 ; pr = identityOfIndiscernablesLeft _≡_ ssxDivA (applyEquality (λ t → t +N 0) (multiplicationNIsCommutative a (succ (succ qu)))) ; remIsSmall = zeroIsValidRem (succ (succ qu)) ; quotSmall = inl (succIsPositive _) }) refl))
+    factNonunit : factorisationNonunit a (succ (succ qu))
+    factNonunit with totality a (factorisationNonunit.firstFactor indHypRes')
+    factNonunit | inl (inl a<ff) = canIncreaseFactorBound indHypRes' (λ z 1<z z<a z|ssq → smallerFactors z z<a 1<z (z|ssx z z|ssq)) (inl a<ff)
+    factNonunit | inl (inr ff<a) = exFalso (smallerFactors (factorisationNonunit.firstFactor indHypRes') ff<a (factorisationNonunit.firstFactorNontrivial indHypRes') (z|ssx (factorisationNonunit.firstFactor indHypRes') (divides (factorisationNonunit.firstFactorDivision indHypRes') (factorisationNonunit.firstFactorDivides indHypRes'))))
+    factNonunit | inr ff=a = canIncreaseFactorBound indHypRes' (λ z 1<z z<a z|ssq → smallerFactors z z<a 1<z (divisibilityTransitive z|ssq (divides (record { quot = a ; rem = 0 ; pr = identityOfIndiscernablesLeft _≡_ ssxDivA (applyEquality (λ t → t +N 0) (multiplicationNIsCommutative a (succ (succ qu)))) ; remIsSmall = zeroIsValidRem (succ (succ qu)) ; quotSmall = inl (succIsPositive _) }) refl))) (inr ff=a)
+
+factorInteger : (a : ℕ) → (1 <N a) → factorisationNonunit 1 a
+factorInteger a 1<a with (rec <NWellfounded (λ n → (n <N 2) || (factorisationNonunit 1 n))) factorIntegerLemma
+... | bl with bl a
+factorInteger a 1<a | bl | inl x = exFalso (noIntegersBetweenXAndSuccX 1 1<a x)
+factorInteger a 1<a | bl | inr x = x
+
+lessTransLemma : {p i j : ℕ} → p <N i → i ≤N j → p <N j
+lessTransLemma {p} {i} {j} p<i (inl x) = <Transitive p<i x
+lessTransLemma {p} {i} {j} p<i (inr x) rewrite x = p<i
+
+lemma4' : {quot rem b : ℕ} → (quot +N quot) +N rem ≡ succ b → quot <N succ b
+lemma4' {zero} {rem} {b} pr = succIsPositive b
+lemma4' {succ quot} {rem} {b} pr rewrite equalityCommutative (Semiring.+Associative ℕSemiring quot (succ quot) rem) = succPreservesInequality (le (quot +N rem) (succInjective (transitivity (applyEquality succ (Semiring.commutative ℕSemiring _ quot)) pr)))
+
+lemma4 : {quot a rem b : ℕ} → (a *N quot +N rem ≡ succ b) → (1 <N a) → (quot <N succ b)
+lemma4 {quot} {zero} {rem} {b} pr 1<a = exFalso (zeroNeverGreater 1<a)
+lemma4 {quot} {succ zero} {rem} {b} pr 1<a = exFalso (lessIrreflexive 1<a)
+lemma4 {quot} {succ (succ zero)} {rem} {b} pr 1<a rewrite Semiring.sumZeroRight ℕSemiring quot = lemma4' pr
+lemma4 {quot} {succ (succ (succ a))} {rem} {b} pr 1<a = lemma4 {quot} {succ (succ a)} {quot +N rem} {b} p' (succPreservesInequality (succIsPositive a))
+  where
+    p' : (quot +N (quot +N a *N quot)) +N (quot +N rem) ≡ succ b
+    p' rewrite Semiring.commutative ℕSemiring quot (quot +N (quot +N a *N quot)) | Semiring.+Associative ℕSemiring (quot +N (quot +N a *N quot)) quot rem = pr
+
+noSmallerFactors : {a i p : ℕ} → (factorisationNonunit i a) → (Prime p) → (p <N i) → (p ∣ a) → False
+noSmallerFactors {a} {i} {p} factA pPrime p<i p|a with rec <NWellfounded (λ b → (factorisationNonunit i b) → p ∣ b → False)
+... | indHyp = (indHyp prf) a factA p|a
+  where
+    prf : (x : ℕ) (ind : (y : ℕ) (y<x : y <N x) (factY : factorisationNonunit i y) (p|y : p ∣ y) → False) (factX : factorisationNonunit i x) (p|x : p ∣ x) → False
+    prf x ind record { 1<a = 1<a ; firstFactor = firstFactor ; firstFactorNontrivial = firstFactorNontrivial ; firstFactorBiggerMin = firstFactorBiggerMin ; firstFactorDivision = firstFactorDivision ; firstFactorDivides = firstFactorDivides ; firstFactorPrime = firstFactorPrime ; otherFactors = (inl record { fst = quotFirstfact=1 ; snd = otherFactorsNumber }) } p|x = exFalso bad
       where
-        proof : (s : ℕ) → s *N 1 +N 0 ≡ s
-        proof s rewrite Semiring.sumZeroRight ℕSemiring (s *N 1) | multiplicationNIsCommutative s 1 | Semiring.sumZeroRight ℕSemiring s = refl
-
-    twoAsFact : factorisationNonunit 2 2
-    factorisationNonunit.1<a twoAsFact = succPreservesInequality (succIsPositive 0)
-    factorisationNonunit.firstFactor twoAsFact = 2
-    factorisationNonunit.firstFactorNontrivial twoAsFact = succPreservesInequality (succIsPositive 0)
-    factorisationNonunit.firstFactorBiggerMin twoAsFact = inr refl
-    factorisationNonunit.firstFactorDivision twoAsFact = record { quot = 1 ; rem = 0 ; remIsSmall = zeroIsValidRem 2 ; pr = refl ; quotSmall = inl (le 1 refl) }
-    factorisationNonunit.firstFactorDivides twoAsFact = refl
-    factorisationNonunit.firstFactorPrime twoAsFact = twoIsPrime
-    factorisationNonunit.otherFactorsNumber twoAsFact = 0
-    factorisationNonunit.otherFactors twoAsFact = inl record { fst = refl ; snd = refl }
-
-    fourFact : factorisationNonunit 1 4
-    factorisationNonunit.1<a fourFact = succPreservesInequality (succIsPositive 2)
-    factorisationNonunit.firstFactor fourFact = 2
-    factorisationNonunit.firstFactorNontrivial fourFact = succPreservesInequality (succIsPositive 0)
-    factorisationNonunit.firstFactorBiggerMin fourFact = inl (succPreservesInequality (succIsPositive 0))
-    factorisationNonunit.firstFactorDivision fourFact = record { quot = 2 ; rem = 0 ; remIsSmall = zeroIsValidRem 2 ; pr = refl ; quotSmall = inl (le 1 refl) }
-    factorisationNonunit.firstFactorDivides fourFact = refl
-    factorisationNonunit.firstFactorPrime fourFact = twoIsPrime
-    factorisationNonunit.otherFactorsNumber fourFact = 1
-    factorisationNonunit.otherFactors fourFact = inr record { fst = succPreservesInequality (succIsPositive 0) ; snd = twoAsFact }
-
-    lessLemma : {y : ℕ} → (1 <N y) → (zero <N y)
-    lessLemma {.(succ (x +N 1))} (le x refl) = succIsPositive (x +N 1)
-
-    canReduceFactorBound : {a i j : ℕ} → factorisationNonunit i a → j <N i → factorisationNonunit j a
-    canReduceFactorBound {a} {i} {j} record { 1<a = 1<a ; firstFactor = firstFactor ; firstFactorNontrivial = firstFactorNontrivial ; firstFactorBiggerMin = inl ff<i ; firstFactorDivision = firstFactorDivision ; firstFactorDivides = firstFactorDivides ; firstFactorPrime = firstFactorPrime ; otherFactors = otherFactors } j<i = record { 1<a = 1<a ; firstFactor = firstFactor ; firstFactorNontrivial = firstFactorNontrivial ; firstFactorBiggerMin = inl (lessTransitive j<i ff<i) ; firstFactorDivision = firstFactorDivision ; firstFactorDivides = firstFactorDivides ; firstFactorPrime = firstFactorPrime ; otherFactors = otherFactors }
-    canReduceFactorBound {a} {i} {j} record { 1<a = 1<a ; firstFactor = firstFactor ; firstFactorNontrivial = firstFactorNontrivial ; firstFactorBiggerMin = inr ff=i ; firstFactorDivision = firstFactorDivision ; firstFactorDivides = firstFactorDivides ; firstFactorPrime = firstFactorPrime ; otherFactors = otherFactors } j<i = record { 1<a = 1<a ; firstFactor = firstFactor ; firstFactorNontrivial = firstFactorNontrivial ; firstFactorBiggerMin = inl (identityOfIndiscernablesRight _<N_ j<i ff=i) ; firstFactorDivision = firstFactorDivision ; firstFactorDivides = firstFactorDivides ; firstFactorPrime = firstFactorPrime ; otherFactors = otherFactors }
-
-    canReduceFactorBound' : {a i j : ℕ} → factorisationNonunit i a → j ≤N i → factorisationNonunit j a
-    canReduceFactorBound' {a} {i} {j} factA (inl x) = canReduceFactorBound factA x
-    canReduceFactorBound' {a} {i} {.i} factA (inr refl) = factA
-
-    canIncreaseFactorBound : {a i : ℕ} → (fact : factorisationNonunit 1 a) → (∀ x → 1 <N x → x <N i → x ∣ a → False) → (i ≤N factorisationNonunit.firstFactor fact) → factorisationNonunit i a
-    canIncreaseFactorBound {a} {i} record { 1<a = 1<a ; firstFactor = firstFactor ; firstFactorNontrivial = firstFactorNontrivial ; firstFactorBiggerMin = firstFactorBiggerMin ; firstFactorDivision = firstFactorDivision ; firstFactorDivides = firstFactorDivides ; firstFactorPrime = firstFactorPrime ; otherFactors = otherFactors } noSmaller iSmallEnough = record { 1<a = 1<a ; firstFactor = firstFactor ; firstFactorNontrivial = Prime.p>1 firstFactorPrime ; firstFactorBiggerMin = iSmallEnough ; firstFactorDivision = firstFactorDivision ; firstFactorDivides = firstFactorDivides ; firstFactorPrime = firstFactorPrime ; otherFactors = otherFactors }
-
-    -- Get the smallest prime factor of the number
-    everyNumberHasAPrimeFactor : {a : ℕ} → (1 <N a) → Sg ℕ (λ i → ((i ∣ a) && (1 <N i)) && ((Prime i) && (∀ x → x <N i → 1 <N x → x ∣ a → False)))
-    everyNumberHasAPrimeFactor {a} 1<a with compositeOrPrime a 1<a
-    everyNumberHasAPrimeFactor {a} 1<a | inl record { n>1 = n>1 ; divisor = divisor ; dividesN = dividesN ; divisorLessN = divisorLessN ; divisorNot1 = divisorNot1 ; divisorPrime = divisorPrime ; noSmallerDivisors = noSmallerDivisors } = ( divisor , record { fst = record { fst = dividesN ; snd = divisorNot1 } ; snd = record { fst = divisorPrime ; snd = noSmallerDivisors } } )
-    everyNumberHasAPrimeFactor {a} 1<a | inr x = (a , record { fst = record { fst = aDivA a ; snd = 1<a } ; snd = record { fst = x ; snd = λ y y<a 1<y y|a → lessImpliesNotEqual 1<y (equalityCommutative (Prime.pr x y|a y<a (lessLemma 1<y))) }} )
-
-    lemma2 : {a b c : ℕ} → 1 <N a → 0 <N b → a *N b +N 0 ≡ c → b <N c
-    lemma2 {zero} {b} {c} 1<a _ pr = exFalso (zeroNeverGreater 1<a)
-    lemma2 {succ zero} {b} {c} 1<a _ pr = exFalso (lessIrreflexive 1<a)
-    lemma2 {succ (succ a)} {zero} {zero} 1<a t pr = exFalso (lessIrreflexive t)
-    lemma2 {succ (succ a)} {zero} {succ c} 1<a t pr = succIsPositive c
-    lemma2 {succ (succ a)} {succ b} {c} 1<a t pr = le (b +N (a *N succ b)) go
+        x=firstFact : firstFactor *N 1 +N 0 ≡ x
+        x=firstFact rewrite equalityCommutative firstFactorDivides | equalityCommutative quotFirstfact=1 = divisionAlgResult.pr firstFactorDivision
+        x=firstFact' : firstFactor ≡ x
+        x=firstFact' = transitivity (equalityCommutative (lemma firstFactor)) x=firstFact
+        p|firstFact : p ∣ firstFactor
+        p|firstFact rewrite x=firstFact' = p|x
+        p=firstFact : p ≡ firstFactor
+        p=firstFact = primeDivPrimeImpliesEqual pPrime firstFactorPrime p|firstFact
+        i<=firstFactor : i ≤N p
+        i<=firstFactor rewrite p=firstFact = firstFactorBiggerMin
+        bad : False
+        bad with i<=firstFactor
+        ... | inl t = TotalOrder.irreflexive ℕTotalOrder (TotalOrder.<Transitive ℕTotalOrder t p<i)
+        ... | inr eq rewrite eq = TotalOrder.irreflexive ℕTotalOrder p<i
+    prf zero ind record { 1<a = 1<a ; firstFactor = firstFactor ; firstFactorNontrivial = firstFactorNontrivial ; firstFactorBiggerMin = firstFactorBiggerMin ; firstFactorDivision = firstFactorDivision ; firstFactorDivides = firstFactorDivides ; firstFactorPrime = firstFactorPrime ; otherFactors = (inr otherFact) } p|x = zeroNeverGreater 1<a
+    prf (succ x) ind record { 1<a = 1<a ; firstFactor = firstFactor ; firstFactorNontrivial = firstFactorNontrivial ; firstFactorBiggerMin = firstFactorBiggerMin ; firstFactorDivision = firstFactorDivision ; firstFactorDivides = firstFactorDivides ; firstFactorPrime = firstFactorPrime ; otherFactors = (inr otherFact) } p|x = ind (divisionAlgResult.quot firstFactorDivision) (lemma4 {divisionAlgResult.quot firstFactorDivision} {firstFactor} {divisionAlgResult.rem firstFactorDivision} {x} (divisionAlgResult.pr (firstFactorDivision)) (primesAreBiggerThanOne firstFactorPrime)) (canReduceFactorBound' (_&&_.snd otherFact) firstFactorBiggerMin) (p|q p|ffOrQ)
       where
-        assocLemm : (a b c : ℕ) → (a +N b) +N c ≡ (a +N c) +N b
-        assocLemm a b c rewrite equalityCommutative (Semiring.+Associative ℕSemiring a b c) | Semiring.commutative ℕSemiring b c | Semiring.+Associative ℕSemiring a c b = refl
-        go : succ ((b +N a *N succ b) +N succ b) ≡ c
-        go rewrite Semiring.sumZeroRight ℕSemiring (succ (b +N succ (b +N a *N succ b))) | equalityCommutative (assocLemm b (succ b) (a *N succ b)) | Semiring.+Associative ℕSemiring b (succ b) (a *N succ b) = pr
-
-    factorIntegerLemma : (x : ℕ) (indHyp : (y : ℕ) (y<x : y <N x) → ((y <N 2) || (factorisationNonunit 1 y))) → ((x <N 2) || (factorisationNonunit 1 x))
-    factorIntegerLemma zero indHyp = inl (succIsPositive 1)
-    factorIntegerLemma (succ zero) indHyp = inl (succPreservesInequality (succIsPositive 0))
-    factorIntegerLemma (succ (succ x)) indHyp with everyNumberHasAPrimeFactor {succ (succ x)} (succPreservesInequality (succIsPositive x))
-    factorIntegerLemma (succ (succ x)) indHyp | a , record { fst = record { fst = divides record {quot = zero ; rem = .0 ; pr = ssxDivA ; remIsSmall = r } refl ; snd = 1<a }; snd = record { fst = primeA ; snd = smallerFactors } } rewrite Semiring.sumZeroRight ℕSemiring (a *N zero) | multiplicationNIsCommutative a 0 = exFalso (naughtE ssxDivA)
-    factorIntegerLemma (succ (succ x)) indHyp | a , record { fst = record { fst = divides record {quot = succ zero ; rem = .0 ; pr = ssxDivA ; remIsSmall = r } refl ; snd = 1<a }; snd = record { fst = primeA ; snd = smallerFactors } } = inr record { 1<a = succPreservesInequality (succIsPositive x) ; firstFactor = a ; firstFactorNontrivial = Prime.p>1 primeA ; firstFactorBiggerMin = inl (Prime.p>1 primeA) ; firstFactorDivision = record { quot = 1 ; rem = 0 ; pr = ssxDivA ; remIsSmall = r ; quotSmall = inl (TotalOrder.<Transitive ℕTotalOrder (le zero refl) 1<a) } ; firstFactorDivides = refl ; firstFactorPrime = record { p>1 = Prime.p>1 primeA ; pr = Prime.pr primeA } ; otherFactors = inl record { fst = refl ; snd = refl } ; otherFactorsNumber = 0 }
-
-    factorIntegerLemma (succ (succ x)) indHyp | a , record { fst = record { fst = divides record {quot = succ (succ qu) ; rem = .0 ; pr = ssxDivA ; remIsSmall = remSmall } refl ; snd = 1<a }; snd = record { fst = primeA ; snd = smallerFactors } } = inr record { 1<a = succPreservesInequality (succIsPositive x) ; firstFactor = a ; firstFactorNontrivial = Prime.p>1 primeA ; firstFactorBiggerMin = inl (Prime.p>1 primeA) ; firstFactorDivision = record { quot = succ (succ qu) ; rem = 0 ; pr = ssxDivA ; remIsSmall = remSmall ; quotSmall = inl (TotalOrder.<Transitive ℕTotalOrder (le zero refl) 1<a) } ; firstFactorDivides = refl ; firstFactorPrime = record { p>1 = Prime.p>1 primeA ; pr = Prime.pr primeA } ; otherFactors = inr record {fst = succPreservesInequality (succIsPositive qu) ; snd = factNonunit} ; otherFactorsNumber = succ (factorisationNonunit.otherFactorsNumber indHypRes') }
-      where
-        indHypRes : ((succ (succ qu)) <N 2) || factorisationNonunit 1 (succ (succ qu))
-        indHypRes = indHyp (succ (succ qu)) (lemma2 {a} {succ (succ qu)} {succ (succ x)} 1<a (succIsPositive (succ qu)) ssxDivA)
-        indHypRes' : factorisationNonunit 1 (succ (succ qu))
-        indHypRes' with indHypRes
-        indHypRes' | inl y = exFalso (zeroNeverGreater (canRemoveSuccFrom<N (canRemoveSuccFrom<N y)))
-        indHypRes' | inr y = y
-        z|ssx : (z : ℕ) → z ∣ succ (succ qu) → z ∣ succ (succ x)
-        z|ssx z z|ssq = (divisibilityTransitive z|ssq (divides (record { quot = a ; rem = 0 ; pr = identityOfIndiscernablesLeft _≡_ ssxDivA (applyEquality (λ t → t +N 0) (multiplicationNIsCommutative a (succ (succ qu)))) ; remIsSmall = zeroIsValidRem (succ (succ qu)) ; quotSmall = inl (succIsPositive _) }) refl))
-        factNonunit : factorisationNonunit a (succ (succ qu))
-        factNonunit with orderIsTotal a (factorisationNonunit.firstFactor indHypRes')
-        factNonunit | inl (inl a<ff) = canIncreaseFactorBound indHypRes' (λ z 1<z z<a z|ssq → smallerFactors z z<a 1<z (z|ssx z z|ssq)) (inl a<ff)
-        factNonunit | inl (inr ff<a) = exFalso (smallerFactors (factorisationNonunit.firstFactor indHypRes') ff<a (factorisationNonunit.firstFactorNontrivial indHypRes') (z|ssx (factorisationNonunit.firstFactor indHypRes') (divides (factorisationNonunit.firstFactorDivision indHypRes') (factorisationNonunit.firstFactorDivides indHypRes'))))
-        factNonunit | inr ff=a = canIncreaseFactorBound indHypRes' (λ z 1<z z<a z|ssq → smallerFactors z z<a 1<z (divisibilityTransitive z|ssq (divides (record { quot = a ; rem = 0 ; pr = identityOfIndiscernablesLeft _≡_ ssxDivA (applyEquality (λ t → t +N 0) (multiplicationNIsCommutative a (succ (succ qu)))) ; remIsSmall = zeroIsValidRem (succ (succ qu)) ; quotSmall = inl (succIsPositive _) }) refl))) (inr ff=a)
-
-    factorInteger : (a : ℕ) → (1 <N a) → factorisationNonunit 1 a
-    factorInteger a 1<a with (rec <NWellfounded (λ n → (n <N 2) || (factorisationNonunit 1 n))) factorIntegerLemma
-    ... | bl with bl a
-    factorInteger a 1<a | bl | inl x = exFalso (noIntegersBetweenXAndSuccX 1 1<a x)
-    factorInteger a 1<a | bl | inr x = x
-
-    lessTransLemma : {p i j : ℕ} → p <N i → i ≤N j → p <N j
-    lessTransLemma {p} {i} {j} p<i (inl x) = orderIsTransitive p<i x
-    lessTransLemma {p} {i} {j} p<i (inr x) rewrite x = p<i
-
-    lemma4' : {quot rem b : ℕ} → (quot +N quot) +N rem ≡ succ b → quot <N succ b
-    lemma4' {zero} {rem} {b} pr = succIsPositive b
-    lemma4' {succ quot} {rem} {b} pr rewrite equalityCommutative (Semiring.+Associative ℕSemiring quot (succ quot) rem) = succPreservesInequality (le (quot +N rem) (succInjective (transitivity (applyEquality succ (Semiring.commutative ℕSemiring _ quot)) pr)))
-
-    lemma4 : {quot a rem b : ℕ} → (a *N quot +N rem ≡ succ b) → (1 <N a) → (quot <N succ b)
-    lemma4 {quot} {zero} {rem} {b} pr 1<a = exFalso (zeroNeverGreater 1<a)
-    lemma4 {quot} {succ zero} {rem} {b} pr 1<a = exFalso (lessIrreflexive 1<a)
-    lemma4 {quot} {succ (succ zero)} {rem} {b} pr 1<a rewrite Semiring.sumZeroRight ℕSemiring quot = lemma4' pr
-    lemma4 {quot} {succ (succ (succ a))} {rem} {b} pr 1<a = lemma4 {quot} {succ (succ a)} {quot +N rem} {b} p' (succPreservesInequality (succIsPositive a))
-      where
-        p' : (quot +N (quot +N a *N quot)) +N (quot +N rem) ≡ succ b
-        p' rewrite Semiring.commutative ℕSemiring quot (quot +N (quot +N a *N quot)) | Semiring.+Associative ℕSemiring (quot +N (quot +N a *N quot)) quot rem = pr
-
-    noSmallerFactors : {a i p : ℕ} → (factorisationNonunit i a) → (Prime p) → (p <N i) → (p ∣ a) → False
-    noSmallerFactors {a} {i} {p} factA pPrime p<i p|a with rec <NWellfounded (λ b → (factorisationNonunit i b) → p ∣ b → False)
-    ... | indHyp = (indHyp prf) a factA p|a
-      where
-        prf : (x : ℕ) (ind : (y : ℕ) (y<x : y <N x) (factY : factorisationNonunit i y) (p|y : p ∣ y) → False) (factX : factorisationNonunit i x) (p|x : p ∣ x) → False
-        prf x ind record { 1<a = 1<a ; firstFactor = firstFactor ; firstFactorNontrivial = firstFactorNontrivial ; firstFactorBiggerMin = firstFactorBiggerMin ; firstFactorDivision = firstFactorDivision ; firstFactorDivides = firstFactorDivides ; firstFactorPrime = firstFactorPrime ; otherFactors = (inl record { fst = quotFirstfact=1 ; snd = otherFactorsNumber }) } p|x = exFalso bad
+        succXNotSmaller : succ x <N firstFactor → False
+        succXNotSmaller = divisorIsSmaller {firstFactor} {x} (divides firstFactorDivision firstFactorDivides)
+        succXNotSmaller' : firstFactor ≤N succ x
+        succXNotSmaller' = notSmallerMeansGE succXNotSmaller
+        inter : firstFactor *N (divisionAlgResult.quot firstFactorDivision) +N divisionAlgResult.rem firstFactorDivision ≡ (succ x)
+        inter = divisionAlgResult.pr firstFactorDivision
+        inter' : firstFactor *N (divisionAlgResult.quot firstFactorDivision) +N 0 ≡ (succ x)
+        inter' rewrite equalityCommutative firstFactorDivides = inter
+        inter'' : firstFactor *N (divisionAlgResult.quot firstFactorDivision) ≡ (succ x)
+        inter'' rewrite equalityCommutative (Semiring.sumZeroRight ℕSemiring (firstFactor *N (divisionAlgResult.quot firstFactorDivision))) = inter'
+        p|ff*q : p ∣ firstFactor *N (divisionAlgResult.quot firstFactorDivision)
+        p|ff*q rewrite inter'' = p|x
+        p|ffOrQ : (p ∣ firstFactor) || (p ∣ divisionAlgResult.quot firstFactorDivision)
+        p|ffOrQ = primesArePrime pPrime p|ff*q
+        p|ffIsFalse : (p ∣ firstFactor) → False
+        p|ffIsFalse p|ff = lessIrreflexive (lessTransLemma p<i i<=p)
           where
-            x=firstFact : firstFactor *N 1 +N 0 ≡ x
-            x=firstFact rewrite equalityCommutative firstFactorDivides | equalityCommutative quotFirstfact=1 = divisionAlgResult.pr firstFactorDivision
-            x=firstFact' : firstFactor ≡ x
-            x=firstFact' = transitivity (equalityCommutative (lemma firstFactor)) x=firstFact
-            p|firstFact : p ∣ firstFactor
-            p|firstFact rewrite x=firstFact' = p|x
-            p=firstFact : p ≡ firstFactor
-            p=firstFact = primeDivPrimeImpliesEqual pPrime firstFactorPrime p|firstFact
-            i<=firstFactor : i ≤N p
-            i<=firstFactor rewrite p=firstFact = firstFactorBiggerMin
-            bad : False
-            bad with i<=firstFactor
-            ... | inl t = TotalOrder.irreflexive ℕTotalOrder (TotalOrder.<Transitive ℕTotalOrder t p<i)
-            ... | inr eq rewrite eq = TotalOrder.irreflexive ℕTotalOrder p<i
-        prf zero ind record { 1<a = 1<a ; firstFactor = firstFactor ; firstFactorNontrivial = firstFactorNontrivial ; firstFactorBiggerMin = firstFactorBiggerMin ; firstFactorDivision = firstFactorDivision ; firstFactorDivides = firstFactorDivides ; firstFactorPrime = firstFactorPrime ; otherFactors = (inr otherFact) } p|x = zeroNeverGreater 1<a
-        prf (succ x) ind record { 1<a = 1<a ; firstFactor = firstFactor ; firstFactorNontrivial = firstFactorNontrivial ; firstFactorBiggerMin = firstFactorBiggerMin ; firstFactorDivision = firstFactorDivision ; firstFactorDivides = firstFactorDivides ; firstFactorPrime = firstFactorPrime ; otherFactors = (inr otherFact) } p|x = ind (divisionAlgResult.quot firstFactorDivision) (lemma4 {divisionAlgResult.quot firstFactorDivision} {firstFactor} {divisionAlgResult.rem firstFactorDivision} {x} (divisionAlgResult.pr (firstFactorDivision)) (primesAreBiggerThanOne firstFactorPrime)) (canReduceFactorBound' (_&&_.snd otherFact) firstFactorBiggerMin) (p|q p|ffOrQ)
-          where
-            succXNotSmaller : succ x <N firstFactor → False
-            succXNotSmaller = divisorIsSmaller {firstFactor} {x} (divides firstFactorDivision firstFactorDivides)
-            succXNotSmaller' : firstFactor ≤N succ x
-            succXNotSmaller' = notSmallerMeansGE succXNotSmaller
-            inter : firstFactor *N (divisionAlgResult.quot firstFactorDivision) +N divisionAlgResult.rem firstFactorDivision ≡ (succ x)
-            inter = divisionAlgResult.pr firstFactorDivision
-            inter' : firstFactor *N (divisionAlgResult.quot firstFactorDivision) +N 0 ≡ (succ x)
-            inter' rewrite equalityCommutative firstFactorDivides = inter
-            inter'' : firstFactor *N (divisionAlgResult.quot firstFactorDivision) ≡ (succ x)
-            inter'' rewrite equalityCommutative (Semiring.sumZeroRight ℕSemiring (firstFactor *N (divisionAlgResult.quot firstFactorDivision))) = inter'
-            p|ff*q : p ∣ firstFactor *N (divisionAlgResult.quot firstFactorDivision)
-            p|ff*q rewrite inter'' = p|x
-            p|ffOrQ : (p ∣ firstFactor) || (p ∣ divisionAlgResult.quot firstFactorDivision)
-            p|ffOrQ = primesArePrime pPrime p|ff*q
-            p|ffIsFalse : (p ∣ firstFactor) → False
-            p|ffIsFalse p|ff = lessIrreflexive (lessTransLemma p<i i<=p)
-              where
-                p=ff : p ≡ firstFactor
-                p=ff = primeDivPrimeImpliesEqual pPrime firstFactorPrime p|ff
-                i<=p : i ≤N p
-                i<=p rewrite p=ff = firstFactorBiggerMin
-            p|q : ((p ∣ firstFactor) || (p ∣ divisionAlgResult.quot firstFactorDivision)) → (p ∣ divisionAlgResult.quot firstFactorDivision)
-            p|q (inl fls) = exFalso (p|ffIsFalse fls)
-            p|q (inr res) = res
+            p=ff : p ≡ firstFactor
+            p=ff = primeDivPrimeImpliesEqual pPrime firstFactorPrime p|ff
+            i<=p : i ≤N p
+            i<=p rewrite p=ff = firstFactorBiggerMin
+        p|q : ((p ∣ firstFactor) || (p ∣ divisionAlgResult.quot firstFactorDivision)) → (p ∣ divisionAlgResult.quot firstFactorDivision)
+        p|q (inl fls) = exFalso (p|ffIsFalse fls)
+        p|q (inr res) = res
 
-    lemma3 : {a : ℕ} → a ≡ 0 → 1 <N a → False
-    lemma3 {a} a=0 pr rewrite a=0 = zeroNeverGreater pr
+lemma3 : {a : ℕ} → a ≡ 0 → 1 <N a → False
+lemma3 {a} a=0 pr rewrite a=0 = zeroNeverGreater pr
 
-    firstFactorUniqueLemma : {i : ℕ} → (a : ℕ) → (1 <N a) → (f1 : factorisationNonunit i a) → (f2 : factorisationNonunit i a) → (factorisationNonunit.firstFactor f1 <N factorisationNonunit.firstFactor f2) → False
-    firstFactorUniqueLemma {i} a 1<a f1 f2 ff1<ff2 = go
+firstFactorUniqueLemma : {i : ℕ} → (a : ℕ) → (1 <N a) → (f1 : factorisationNonunit i a) → (f2 : factorisationNonunit i a) → (factorisationNonunit.firstFactor f1 <N factorisationNonunit.firstFactor f2) → False
+firstFactorUniqueLemma {i} a 1<a f1 f2 ff1<ff2 = go
+  where
+    p1 = factorisationNonunit.firstFactor f1
+    rem1 = divisionAlgResult.quot (factorisationNonunit.firstFactorDivision f1)
+    p2 = factorisationNonunit.firstFactor f2
+    rem2 = divisionAlgResult.quot (factorisationNonunit.firstFactorDivision f2)
+    p1<p2 : p1 <N p2
+    p1<p2 = ff1<ff2
+    a=p2rem2 : a ≡ p2 *N rem2
+    a=p2rem2 with divisionAlgResult.pr (factorisationNonunit.firstFactorDivision f2)
+    ... | ff rewrite factorisationNonunit.firstFactorDivides f2 | Semiring.sumZeroRight ℕSemiring (factorisationNonunit.firstFactor f2 *N divisionAlgResult.quot (factorisationNonunit.firstFactorDivision f2)) = equalityCommutative ff
+    p1|second : (p1 ∣ p2) || (p1 ∣ rem2)
+    p1|second = primesArePrime {p1} {p2} {rem2} (factorisationNonunit.firstFactorPrime f1) lem
       where
-        p1 = factorisationNonunit.firstFactor f1
-        rem1 = divisionAlgResult.quot (factorisationNonunit.firstFactorDivision f1)
-        p2 = factorisationNonunit.firstFactor f2
-        rem2 = divisionAlgResult.quot (factorisationNonunit.firstFactorDivision f2)
-        p1<p2 : p1 <N p2
-        p1<p2 = ff1<ff2
-        a=p2rem2 : a ≡ p2 *N rem2
-        a=p2rem2 with divisionAlgResult.pr (factorisationNonunit.firstFactorDivision f2)
-        ... | ff rewrite factorisationNonunit.firstFactorDivides f2 | Semiring.sumZeroRight ℕSemiring (factorisationNonunit.firstFactor f2 *N divisionAlgResult.quot (factorisationNonunit.firstFactorDivision f2)) = equalityCommutative ff
-        p1|second : (p1 ∣ p2) || (p1 ∣ rem2)
-        p1|second = primesArePrime {p1} {p2} {rem2} (factorisationNonunit.firstFactorPrime f1) lem
-          where
-            lem : p1 ∣ (p2 *N rem2)
-            lem = identityOfIndiscernablesRight _∣_ (divides (factorisationNonunit.firstFactorDivision f1) (factorisationNonunit.firstFactorDivides f1)) a=p2rem2
-        p1|second' : ((p1 ∣ p2) || (p1 ∣ rem2)) → ((p1 ≡ p2) || (p1 ∣ rem2))
-        p1|second' (inl x) = inl (primeDivPrimeImpliesEqual (factorisationNonunit.firstFactorPrime f1) (factorisationNonunit.firstFactorPrime f2) x)
-        p1|second' (inr x) = inr x
-        p1|second'' : (p1 ≡ p2) || (p1 ∣ rem2)
-        p1|second'' = p1|second' p1|second
-        go : False
-        go with p1|second''
-        go | inl x = lessImpliesNotEqual ff1<ff2 x
-        go | inr x with factorisationNonunit.otherFactors f2
-        go | inr x | inl record { fst = rem2=1 ; snd = _ } rewrite rem2=1 = exFalso (oneIsNotPrime res)
-          where
-            1prime' : Prime p1 ≡ Prime 1
-            1prime' = applyEquality Prime (oneHasNoDivisors x)
-            res : Prime 1
-            res rewrite equalityCommutative 1prime' = (factorisationNonunit.firstFactorPrime f1)
-        go | inr x | inr p1|rem2 with factorisationNonunit.otherFactors f2
-        go | inr x | inr p1|rem2 | inl record { fst = rem2=1 ; snd = _ } rewrite rem2=1 = exFalso (oneIsNotPrime res)
-          where
-            1prime' : Prime p1 ≡ Prime 1
-            1prime' = applyEquality Prime (oneHasNoDivisors x)
-            res : Prime 1
-            res rewrite equalityCommutative 1prime' = (factorisationNonunit.firstFactorPrime f1)
-        go | inr x | inr p1|rem2 | inr factorRem2 = noSmallerFactors (_&&_.snd factorRem2) (factorisationNonunit.firstFactorPrime f1) p1<p2 x
-
-    firstFactorUnique : {i : ℕ} → (a : ℕ) → (1 <N a) → (f1 : factorisationNonunit i a) → (f2 : factorisationNonunit i a) → (factorisationNonunit.firstFactor f1 ≡ factorisationNonunit.firstFactor f2)
-    firstFactorUnique {i} a 1<a f1 f2 with orderIsTotal (factorisationNonunit.firstFactor f1) (factorisationNonunit.firstFactor f2)
-    firstFactorUnique {i} a 1<a f1 f2 | inl (inl f1<f2) = exFalso (firstFactorUniqueLemma a 1<a f1 f2 f1<f2)
-    firstFactorUnique {i} a 1<a f1 f2 | inl (inr f2<f1) = exFalso (firstFactorUniqueLemma a 1<a f2 f1 f2<f1)
-    firstFactorUnique {i} a 1<a f1 f2 | inr x = x
-
-    factorListLemma : {i : ℕ} → (a : ℕ) → (1 <N a) → (f1 : factorisationNonunit i a) → (f2 : factorisationNonunit i a) → (divisionAlgResult.quot (factorisationNonunit.firstFactorDivision f2)) ≡ (divisionAlgResult.quot (factorisationNonunit.firstFactorDivision f1))
-    factorListLemma {i} a 1<a f1 f2 with firstFactorUnique {i} a 1<a f1 f2
-    ... | firstFactEqual = res
+        lem : p1 ∣ (p2 *N rem2)
+        lem = identityOfIndiscernablesRight _∣_ (divides (factorisationNonunit.firstFactorDivision f1) (factorisationNonunit.firstFactorDivides f1)) a=p2rem2
+    p1|second' : ((p1 ∣ p2) || (p1 ∣ rem2)) → ((p1 ≡ p2) || (p1 ∣ rem2))
+    p1|second' (inl x) = inl (primeDivPrimeImpliesEqual (factorisationNonunit.firstFactorPrime f1) (factorisationNonunit.firstFactorPrime f2) x)
+    p1|second' (inr x) = inr x
+    p1|second'' : (p1 ≡ p2) || (p1 ∣ rem2)
+    p1|second'' = p1|second' p1|second
+    go : False
+    go with p1|second''
+    go | inl x = irreflexive (<WellDefined x refl ff1<ff2)
+    go | inr x with factorisationNonunit.otherFactors f2
+    go | inr x | inl record { fst = rem2=1 ; snd = _ } rewrite rem2=1 = exFalso (oneIsNotPrime res)
       where
-        div1 : divisionAlgResult (factorisationNonunit.firstFactor f1) a
-        div1 = factorisationNonunit.firstFactorDivision f1
-        rem1=0 : divisionAlgResult.rem div1 ≡ 0
-        rem1=0 = factorisationNonunit.firstFactorDivides f1
-        pr1 : (factorisationNonunit.firstFactor f1) *N (divisionAlgResult.quot div1) +N 0 ≡ a
-        pr1 rewrite equalityCommutative rem1=0 = divisionAlgResult.pr div1
-        pr1' : (factorisationNonunit.firstFactor f1) *N (divisionAlgResult.quot div1) ≡ a
-        pr1' rewrite equalityCommutative (Semiring.sumZeroRight ℕSemiring ((factorisationNonunit.firstFactor f1) *N (divisionAlgResult.quot div1))) = pr1
-        div2 : divisionAlgResult (factorisationNonunit.firstFactor f2) a
-        div2 = factorisationNonunit.firstFactorDivision f2
-        rem2=0 : divisionAlgResult.rem div2 ≡ 0
-        rem2=0 = factorisationNonunit.firstFactorDivides f2
-        pr2 : (factorisationNonunit.firstFactor f2) *N (divisionAlgResult.quot div2) +N 0 ≡ a
-        pr2 rewrite equalityCommutative rem2=0 = divisionAlgResult.pr div2
-        pr2' : (factorisationNonunit.firstFactor f2) *N (divisionAlgResult.quot div2) ≡ a
-        pr2' rewrite equalityCommutative (Semiring.sumZeroRight ℕSemiring ((factorisationNonunit.firstFactor f2) *N (divisionAlgResult.quot div2))) = pr2
-        pr : (factorisationNonunit.firstFactor f2) *N (divisionAlgResult.quot div2) ≡ (factorisationNonunit.firstFactor f1) *N (divisionAlgResult.quot div1)
-        pr = transitivity pr2' (equalityCommutative pr1')
-        pr' : (factorisationNonunit.firstFactor f1) *N (divisionAlgResult.quot div2) ≡ (factorisationNonunit.firstFactor f1) *N (divisionAlgResult.quot div1)
-        pr' = identityOfIndiscernablesLeft _≡_ pr (applyEquality (λ t → t *N divisionAlgResult.quot div2) (equalityCommutative firstFactEqual))
-        positive : zero <N factorisationNonunit.firstFactor f1
-        positive = lessTransitive (succIsPositive 0) (factorisationNonunit.firstFactorNontrivial f1)
-        res : divisionAlgResult.quot div2 ≡ divisionAlgResult.quot div1
-        res = productCancelsLeft (factorisationNonunit.firstFactor f1) (divisionAlgResult.quot div2) (divisionAlgResult.quot div1) positive pr'
+        1prime' : Prime p1 ≡ Prime 1
+        1prime' = applyEquality Prime (oneHasNoDivisors x)
+        res : Prime 1
+        res rewrite equalityCommutative 1prime' = (factorisationNonunit.firstFactorPrime f1)
+    go | inr x | inr p1|rem2 with factorisationNonunit.otherFactors f2
+    go | inr x | inr p1|rem2 | inl record { fst = rem2=1 ; snd = _ } rewrite rem2=1 = exFalso (oneIsNotPrime res)
+      where
+        1prime' : Prime p1 ≡ Prime 1
+        1prime' = applyEquality Prime (oneHasNoDivisors x)
+        res : Prime 1
+        res rewrite equalityCommutative 1prime' = (factorisationNonunit.firstFactorPrime f1)
+    go | inr x | inr p1|rem2 | inr factorRem2 = noSmallerFactors (_&&_.snd factorRem2) (factorisationNonunit.firstFactorPrime f1) p1<p2 x
 
-    factorListSameLength : {i : ℕ} → (a : ℕ) → (1 <N a) → (f1 : factorisationNonunit i a) → (f2 : factorisationNonunit i a) → (divisionAlgResult.quot (factorisationNonunit.firstFactorDivision f1) ≡ 1) → divisionAlgResult.quot (factorisationNonunit.firstFactorDivision f2) ≡ 1
-    factorListSameLength {i} a 1<a f1 f2 quot=1 with firstFactorUnique {i} a 1<a f1 f2
-    ... | firstFactEqual with factorListLemma {i} a 1<a f1 f2
-    ... | eq = transitivity eq quot=1
+firstFactorUnique : {i : ℕ} → (a : ℕ) → (1 <N a) → (f1 : factorisationNonunit i a) → (f2 : factorisationNonunit i a) → (factorisationNonunit.firstFactor f1 ≡ factorisationNonunit.firstFactor f2)
+firstFactorUnique {i} a 1<a f1 f2 with totality (factorisationNonunit.firstFactor f1) (factorisationNonunit.firstFactor f2)
+firstFactorUnique {i} a 1<a f1 f2 | inl (inl f1<f2) = exFalso (firstFactorUniqueLemma a 1<a f1 f2 f1<f2)
+firstFactorUnique {i} a 1<a f1 f2 | inl (inr f2<f1) = exFalso (firstFactorUniqueLemma a 1<a f2 f1 f2<f1)
+firstFactorUnique {i} a 1<a f1 f2 | inr x = x
+
+factorListLemma : {i : ℕ} → (a : ℕ) → (1 <N a) → (f1 : factorisationNonunit i a) → (f2 : factorisationNonunit i a) → (divisionAlgResult.quot (factorisationNonunit.firstFactorDivision f2)) ≡ (divisionAlgResult.quot (factorisationNonunit.firstFactorDivision f1))
+factorListLemma {i} a 1<a f1 f2 with firstFactorUnique {i} a 1<a f1 f2
+... | firstFactEqual = res
+  where
+    div1 : divisionAlgResult (factorisationNonunit.firstFactor f1) a
+    div1 = factorisationNonunit.firstFactorDivision f1
+    rem1=0 : divisionAlgResult.rem div1 ≡ 0
+    rem1=0 = factorisationNonunit.firstFactorDivides f1
+    pr1 : (factorisationNonunit.firstFactor f1) *N (divisionAlgResult.quot div1) +N 0 ≡ a
+    pr1 rewrite equalityCommutative rem1=0 = divisionAlgResult.pr div1
+    pr1' : (factorisationNonunit.firstFactor f1) *N (divisionAlgResult.quot div1) ≡ a
+    pr1' rewrite equalityCommutative (Semiring.sumZeroRight ℕSemiring ((factorisationNonunit.firstFactor f1) *N (divisionAlgResult.quot div1))) = pr1
+    div2 : divisionAlgResult (factorisationNonunit.firstFactor f2) a
+    div2 = factorisationNonunit.firstFactorDivision f2
+    rem2=0 : divisionAlgResult.rem div2 ≡ 0
+    rem2=0 = factorisationNonunit.firstFactorDivides f2
+    pr2 : (factorisationNonunit.firstFactor f2) *N (divisionAlgResult.quot div2) +N 0 ≡ a
+    pr2 rewrite equalityCommutative rem2=0 = divisionAlgResult.pr div2
+    pr2' : (factorisationNonunit.firstFactor f2) *N (divisionAlgResult.quot div2) ≡ a
+    pr2' rewrite equalityCommutative (Semiring.sumZeroRight ℕSemiring ((factorisationNonunit.firstFactor f2) *N (divisionAlgResult.quot div2))) = pr2
+    pr : (factorisationNonunit.firstFactor f2) *N (divisionAlgResult.quot div2) ≡ (factorisationNonunit.firstFactor f1) *N (divisionAlgResult.quot div1)
+    pr = transitivity pr2' (equalityCommutative pr1')
+    pr' : (factorisationNonunit.firstFactor f1) *N (divisionAlgResult.quot div2) ≡ (factorisationNonunit.firstFactor f1) *N (divisionAlgResult.quot div1)
+    pr' = identityOfIndiscernablesLeft _≡_ pr (applyEquality (λ t → t *N divisionAlgResult.quot div2) (equalityCommutative firstFactEqual))
+    positive : zero <N factorisationNonunit.firstFactor f1
+    positive = lessTransitive (succIsPositive 0) (factorisationNonunit.firstFactorNontrivial f1)
+    res : divisionAlgResult.quot div2 ≡ divisionAlgResult.quot div1
+    res = productCancelsLeft (factorisationNonunit.firstFactor f1) (divisionAlgResult.quot div2) (divisionAlgResult.quot div1) positive pr'
+
+factorListSameLength : {i : ℕ} → (a : ℕ) → (1 <N a) → (f1 : factorisationNonunit i a) → (f2 : factorisationNonunit i a) → (divisionAlgResult.quot (factorisationNonunit.firstFactorDivision f1) ≡ 1) → divisionAlgResult.quot (factorisationNonunit.firstFactorDivision f2) ≡ 1
+factorListSameLength {i} a 1<a f1 f2 quot=1 with firstFactorUnique {i} a 1<a f1 f2
+... | firstFactEqual with factorListLemma {i} a 1<a f1 f2
+... | eq = transitivity eq quot=1

Numbers/Rationals/Lemmas.agda

@@ -2,7 +2,10 @@
 
 open import WellFoundedInduction
 open import LogicalFormulae
-open import Numbers.Naturals.Naturals
+open import Numbers.Naturals.Semiring
+open import Numbers.Naturals.Order
+open import Numbers.Naturals.Order.WellFounded
+open import Numbers.Naturals.Order.Lemmas
 open import Numbers.Integers.Integers
 open import Numbers.Integers.Order
 open import Groups.Groups
@@ -22,6 +25,8 @@ open import Orders
 
 module Numbers.Rationals.Lemmas where
 
+open import Semirings.Lemmas ℕSemiring
+
 open PartiallyOrderedRing ℤPOrderedRing
 open import Rings.Orders.Total.Lemmas ℤOrderedRing
 open SetoidTotalOrder (totalOrderToSetoidTotalOrder ℤOrder)