diff --git a/Everything/Safe.agda b/Everything/Safe.agda
index 37dce6b..cb002a0 100644
--- a/Everything/Safe.agda
+++ b/Everything/Safe.agda
@@ -2,14 +2,14 @@
 
 -- This file contains everything that can be compiled in --safe mode.
 
-open import Numbers.Naturals
+open import Numbers.Naturals.Naturals
 open import Numbers.BinaryNaturals.Definition
 
 open import Lists.Lists
 
 open import Groups.Groups
 open import Groups.FinitePermutations
-open import Groups.GroupsLemmas
+open import Groups.Lemmas
 
 open import Fields.Fields
 open import Fields.FieldOfFractions
@@ -34,4 +34,8 @@ open import WellFoundedInduction
 
 open import ClassicalLogic.ClassicalFive
 
+open import Monoids.Definition
+
+open import Semirings.Definition
+
 module Everything.Safe where
diff --git a/Everything/WithK.agda b/Everything/WithK.agda
index b084cc2..fef8285 100644
--- a/Everything/WithK.agda
+++ b/Everything/WithK.agda
@@ -27,5 +27,7 @@ open import Rings.Examples.Proofs
 
 open import Groups.FreeGroups
 open import Groups.Groups2
+open import Groups.Examples.ExampleSheet1
+open import Groups.LectureNotes.Lecture1
 
 module Everything.WithK where
diff --git a/Fields/FieldOfFractions.agda b/Fields/FieldOfFractions.agda
index 520348e..f265177 100644
--- a/Fields/FieldOfFractions.agda
+++ b/Fields/FieldOfFractions.agda
@@ -2,8 +2,8 @@
 
 open import LogicalFormulae
 open import Groups.Groups
-open import Groups.GroupDefinition
-open import Groups.GroupsLemmas
+open import Groups.Definition
+open import Groups.Lemmas
 open import Rings.Definition
 open import Rings.Lemmas
 open import Rings.IntegralDomains
diff --git a/Fields/FieldOfFractionsOrder.agda b/Fields/FieldOfFractionsOrder.agda
index 58fb801..bc99570 100644
--- a/Fields/FieldOfFractionsOrder.agda
+++ b/Fields/FieldOfFractionsOrder.agda
@@ -2,8 +2,8 @@
 
 open import LogicalFormulae
 open import Groups.Groups
-open import Groups.GroupDefinition
-open import Groups.GroupsLemmas
+open import Groups.Definition
+open import Groups.Lemmas
 open import Rings.Definition
 open import Rings.Lemmas
 open import Rings.IntegralDomains
diff --git a/Fields/Fields.agda b/Fields/Fields.agda
index bc950f5..4eadb99 100644
--- a/Fields/Fields.agda
+++ b/Fields/Fields.agda
@@ -2,7 +2,7 @@
 
 open import LogicalFormulae
 open import Groups.Groups
-open import Groups.GroupDefinition
+open import Groups.Definition
 open import Rings.Definition
 open import Rings.Lemmas
 open import Setoids.Setoids
diff --git a/Groups/GroupActions.agda b/Groups/Actions.agda
similarity index 100%
rename from Groups/GroupActions.agda
rename to Groups/Actions.agda
diff --git a/Groups/GroupCosets.agda b/Groups/Cosets.agda
similarity index 100%
rename from Groups/GroupCosets.agda
rename to Groups/Cosets.agda
diff --git a/Groups/CyclicGroups.agda b/Groups/CyclicGroups.agda
index 065a6bf..b06fad1 100644
--- a/Groups/CyclicGroups.agda
+++ b/Groups/CyclicGroups.agda
@@ -8,7 +8,7 @@ open import Numbers.Naturals
 open import Numbers.Integers
 open import Sets.FinSet
 open import Groups.Groups
-open import Groups.GroupDefinition
+open import Groups.Definition
 
 module Groups.CyclicGroups where
 
diff --git a/Groups/GroupDefinition.agda b/Groups/Definition.agda
similarity index 92%
rename from Groups/GroupDefinition.agda
rename to Groups/Definition.agda
index 51d4a3b..90ff332 100644
--- a/Groups/GroupDefinition.agda
+++ b/Groups/Definition.agda
@@ -4,10 +4,10 @@ open import LogicalFormulae
 open import Setoids.Setoids
 open import Functions
 open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
-open import Numbers.Naturals
+open import Numbers.Naturals.Naturals
 open import Sets.FinSet
 
-module Groups.GroupDefinition where
+module Groups.Definition where
 
   record Group {lvl1 lvl2} {A : Set lvl1} (S : Setoid {lvl1} {lvl2} A) (_·_ : A → A → A) : Set (lsuc lvl1 ⊔ lvl2) where
     open Setoid S
diff --git a/Groups/GroupsExampleSheet1.agda b/Groups/Examples/ExampleSheet1.agda
similarity index 98%
rename from Groups/GroupsExampleSheet1.agda
rename to Groups/Examples/ExampleSheet1.agda
index 5ff53ed..f9a83ed 100644
--- a/Groups/GroupsExampleSheet1.agda
+++ b/Groups/Examples/ExampleSheet1.agda
@@ -1,17 +1,19 @@
 {-# OPTIONS --safe --warning=error #-}
 
 open import LogicalFormulae
-open import Setoids
+open import Setoids.Setoids
 open import Functions
 open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
-open import Naturals
-open import Integers
-open import FinSet
-open import Groups
-open import Rings
-open import Fields
+open import Numbers.Naturals.Naturals
+open import Numbers.Integers
+open import Sets.FinSet
+open import Groups.Definition
+open import Groups.Groups
+open import Rings.Definition
+open import Rings.Lemmas
+open import Fields.Fields
 
-module GroupsExampleSheet1 where
+module Groups.Examples.ExampleSheet1 where
 
   {-
     Question 1: e is the unique solution of x^2 = x
diff --git a/Groups/GroupsExamples.agda b/Groups/Examples/Examples.agda
similarity index 97%
rename from Groups/GroupsExamples.agda
rename to Groups/Examples/Examples.agda
index b52c8c6..8c9634a 100644
--- a/Groups/GroupsExamples.agda
+++ b/Groups/Examples/Examples.agda
@@ -1,19 +1,20 @@
 {-# OPTIONS --safe --warning=error #-}
 
-open import Groups
+open import Groups.Definition
 open import Orders
-open import Integers
-open import Setoids
+open import Numbers.Integers
+open import Setoids.Setoids
 open import LogicalFormulae
-open import FinSet
+open import Sets.FinSet
 open import Functions
-open import Naturals
+open import Numbers.Naturals
 open import IntegersModN
-open import RingExamples
+open import Rings.Examples.Examples
 open import PrimeNumbers
-open import Groups2
+open import Groups.Groups2
+open import Groups.CyclicGroups
 
-module GroupsExamples where
+module Groups.Examples.Examples where
   elementPowZ : (n : ℕ) → (elementPower ℤGroup (nonneg 1) n) ≡ nonneg n
   elementPowZ zero = refl
   elementPowZ (succ n) rewrite elementPowZ n = refl
diff --git a/Groups/FinitePermutations.agda b/Groups/FinitePermutations.agda
index bee2bc2..f6adbe8 100644
--- a/Groups/FinitePermutations.agda
+++ b/Groups/FinitePermutations.agda
@@ -1,7 +1,7 @@
 {-# OPTIONS --safe --warning=error --without-K #-}
 
 open import LogicalFormulae
-open import Numbers.Naturals -- for length
+open import Numbers.Naturals.Naturals -- for length
 open import Lists.Lists
 open import Functions
 open import Groups.SymmetryGroups
diff --git a/Groups/FreeGroups.agda b/Groups/FreeGroups.agda
index 8c36bc3..ade249e 100644
--- a/Groups/FreeGroups.agda
+++ b/Groups/FreeGroups.agda
@@ -5,10 +5,10 @@ open import WithK
 open import Setoids.Setoids
 open import Functions
 open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
-open import Numbers.Naturals
-open import Numbers.NaturalsWithK
+open import Numbers.Naturals.Naturals
+open import Numbers.Naturals.WithK
 open import Sets.FinSet
-open import Groups.GroupDefinition
+open import Groups.Definition
 open import Groups.SymmetryGroups
 open import DecidableSet
 
diff --git a/Groups/Groups.agda b/Groups/Groups.agda
index b555272..5fe5b13 100644
--- a/Groups/Groups.agda
+++ b/Groups/Groups.agda
@@ -4,9 +4,9 @@ open import LogicalFormulae
 open import Setoids.Setoids
 open import Functions
 open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
-open import Numbers.Naturals
+open import Numbers.Naturals.Naturals
 open import Sets.FinSet
-open import Groups.GroupDefinition
+open import Groups.Definition
 
 module Groups.Groups where
 
diff --git a/Groups/Groups2.agda b/Groups/Groups2.agda
index f5a1fcb..9045559 100644
--- a/Groups/Groups2.agda
+++ b/Groups/Groups2.agda
@@ -1,14 +1,14 @@
 {-# OPTIONS --safe --warning=error #-}
 
 open import Groups.Groups
-open import Groups.GroupDefinition
+open import Groups.Definition
 open import Orders
 open import Numbers.Integers
 open import Setoids.Setoids
 open import LogicalFormulae
 open import Sets.FinSet
 open import Functions
-open import Numbers.Naturals
+open import Numbers.Naturals.Naturals
 open import IntegersModN
 open import Rings.Examples.Examples
 open import PrimeNumbers
diff --git a/Groups/LectureNotes/Lecture1.agda b/Groups/LectureNotes/Lecture1.agda
index 9dcda01..8f4d7eb 100644
--- a/Groups/LectureNotes/Lecture1.agda
+++ b/Groups/LectureNotes/Lecture1.agda
@@ -4,13 +4,13 @@ open import LogicalFormulae
 open import Setoids.Setoids
 open import Functions
 open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
-open import Numbers.Naturals
+open import Numbers.Naturals.Naturals
 open import Numbers.Integers
 open import Numbers.Rationals
 open import Sets.FinSet
-open import Groups.GroupDefinition
+open import Groups.Definition
 open import Groups.Groups
-open import Rings.RingDefinition
+open import Rings.Definition
 open import IntegersModN
 
 module Groups.LectureNotes.Lecture1 where
diff --git a/Groups/GroupsLemmas.agda b/Groups/Lemmas.agda
similarity index 95%
rename from Groups/GroupsLemmas.agda
rename to Groups/Lemmas.agda
index e0638b5..a14fdfd 100644
--- a/Groups/GroupsLemmas.agda
+++ b/Groups/Lemmas.agda
@@ -4,11 +4,11 @@ open import LogicalFormulae
 open import Setoids.Setoids
 open import Functions
 open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
-open import Numbers.Naturals
+open import Numbers.Naturals.Naturals
 open import Groups.Groups
-open import Groups.GroupDefinition
+open import Groups.Definition
 
-module Groups.GroupsLemmas where
+module Groups.Lemmas where
   invInv : {a b : _} → {A : Set a} → {_·_ : A → A → A} → {S : Setoid {a} {b} A} → (G : Group S _·_) → {x : A} → Setoid._∼_ S (Group.inverse G (Group.inverse G x)) x
   invInv {S = S} G {x} = symmetric (transferToRight' G invRight)
     where
diff --git a/Groups/SymmetryGroups.agda b/Groups/SymmetryGroups.agda
index d80b712..cdbcf78 100644
--- a/Groups/SymmetryGroups.agda
+++ b/Groups/SymmetryGroups.agda
@@ -4,10 +4,10 @@ open import LogicalFormulae
 open import Setoids.Setoids
 open import Functions
 open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
-open import Numbers.Naturals
+open import Numbers.Naturals.Naturals
 open import Sets.FinSet
 open import Groups.Groups
-open import Groups.GroupDefinition
+open import Groups.Definition
 
 module Groups.SymmetryGroups where
   data SymmetryGroupElements {a b : _} {A : Set a} (S : Setoid {a} {b} A) : Set (a ⊔ b) where
diff --git a/IntegersModN.agda b/IntegersModN.agda
index 38245dc..fc60dab 100644
--- a/IntegersModN.agda
+++ b/IntegersModN.agda
@@ -1,15 +1,18 @@
 {-# OPTIONS --safe --warning=error #-}
 
 open import LogicalFormulae
-open import Groups.GroupDefinition
+open import Groups.Definition
 open import Groups.Groups
-open import Numbers.Naturals
+open import Numbers.Naturals.Naturals
+open import Numbers.Naturals.Addition -- TODO remove this dependency
 open import PrimeNumbers
 open import Setoids.Setoids
 open import Sets.FinSet
 open import Sets.FinSetWithK
 open import Functions
-open import Numbers.NaturalsWithK
+open import Numbers.Naturals.WithK
+open import Semirings.Definition
+open import Orders
 
 module IntegersModN where
   record ℤn (n : ℕ) (pr : 0 <N n) : Set where
@@ -24,7 +27,7 @@ module IntegersModN where
   cancelSumFromInequality {a} {b} {c} (le x proof) = le x help
     where
       help : succ x +N b ≡ c
-      help rewrite equalityCommutative (additionNIsAssociative (succ x) a b) | additionNIsCommutative x a | additionNIsAssociative (succ a) x b | additionNIsCommutative a (x +N b) | additionNIsCommutative (succ (x +N b)) a = canSubtractFromEqualityLeft {a} proof
+      help rewrite Semiring.+Associative ℕSemiring (succ x) a b | Semiring.commutative ℕSemiring x a | equalityCommutative (Semiring.+Associative ℕSemiring (succ a) x b) | Semiring.commutative ℕSemiring a (x +N b) | Semiring.commutative ℕSemiring (succ (x +N b)) a = canSubtractFromEqualityLeft {a} proof
 
   _+n_ : {n : ℕ} {pr : 0 <N n} → ℤn n pr → ℤn n pr → ℤn n pr
   _+n_ {0} {le x ()} a b
@@ -45,15 +48,15 @@ module IntegersModN where
   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 } | inl (inl a<sx) = equalityZn _ _ (additionNIsCommutative a 0)
+  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 additionNIsCommutative a 0 = orderIsIrreflexive aL sx<a
+      f aL sx<a rewrite Semiring.commutative ℕSemiring a 0 = orderIsIrreflexive 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
-      f aL a=sx rewrite additionNIsCommutative a 0 | a=sx = lessIrreflexive aL
+      f aL a=sx rewrite Semiring.commutative ℕSemiring a 0 | a=sx = TotalOrder.irreflexive ℕTotalOrder aL
 
 
   plusZnIdentityLeft : {n : ℕ} → {pr : 0 <N n} → (a : ℤn n pr) → (record { x = 0 ; xLess = pr }) +n a ≡ a
@@ -61,7 +64,7 @@ module IntegersModN where
   plusZnIdentityLeft {succ n} {pr} record { x = x ; xLess = xLess } with orderIsTotal 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 (cannotBeLeqAndG {x} {succ n} (inl xLess) succn<x)
-  plusZnIdentityLeft {succ n} {pr} record { x = x ; xLess = xLess } | inr x=succn rewrite x=succn = exFalso (lessIrreflexive xLess)
+  plusZnIdentityLeft {succ n} {pr} record { x = x ; xLess = xLess } | inr x=succn rewrite x=succn = exFalso (TotalOrder.irreflexive ℕTotalOrder xLess)
 
   subLemma : {a b c : ℕ} → (pr1 : a <N b) → (pr2 : a <N c) → (pr : b ≡ c) → (subtractionNResult.result (-N (inl pr1))) ≡ (subtractionNResult.result (-N (inl pr2)))
   subLemma {a} {b} {c} a<b a<c b=c rewrite b=c | <NRefl a<b a<c = refl
@@ -70,47 +73,47 @@ module IntegersModN where
   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 } | inl (inl a+b<sn) | inl (inl b+a<sn) = equalityZn _ _ (additionNIsCommutative a b)
+  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 additionNIsCommutative b a = lessIrreflexive (orderIsTransitive pr2 pr1)
+      f pr1 pr2 rewrite Semiring.commutative ℕSemiring b a = TotalOrder.irreflexive ℕTotalOrder (orderIsTransitive 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 additionNIsCommutative b a | eq = lessIrreflexive pr1
+      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) | 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 additionNIsCommutative b a = lessIrreflexive (orderIsTransitive 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 (additionNIsCommutative a b))
+      f pr1 pr2 rewrite Semiring.commutative ℕSemiring b a = TotalOrder.irreflexive ℕTotalOrder (orderIsTransitive 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 additionNIsCommutative b a | eq = lessIrreflexive pr
+      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 | inl (inl b+a<sn) = exFalso f
     where
       f : False
-      f rewrite additionNIsCommutative b a | sn=a+b = lessIrreflexive b+a<sn
+      f rewrite Semiring.commutative ℕSemiring b a | sn=a+b = TotalOrder.irreflexive ℕTotalOrder b+a<sn
   plusZnCommutative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } | inr sn=a+b | inl (inr sn<b+a) = exFalso f
     where
       f : False
-      f rewrite additionNIsCommutative b a | sn=a+b = lessIrreflexive sn<b+a
+      f rewrite Semiring.commutative ℕSemiring b a | sn=a+b = TotalOrder.irreflexive ℕTotalOrder sn<b+a
   plusZnCommutative {succ n} {_} record { x = a ; xLess = aLess } record { x = b ; xLess = bLess } | inr sn=a+b | inr sn=b+a = equalityZn _ _ refl
 
   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 = lessIrreflexive (orderIsTransitive pr5 c<n)
+  help30 {a} {b} {c} {n} c<n a+b=n n<b+c x = TotalOrder.irreflexive ℕTotalOrder (orderIsTransitive 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) (additionNIsAssociative a _ n)
+      pr = identityOfIndiscernablesRight _ _ _ _<N_ (additionPreservesInequality n x) (equalityCommutative (Semiring.+Associative ℕSemiring a _ n))
       pr2 : n +N n <N a +N (b +N c)
       pr2 = identityOfIndiscernablesRight _ _ _ _<N_ pr (applyEquality (a +N_) (addMinus (inl n<b+c)))
       pr3 : n +N n <N (a +N b) +N c
-      pr3 rewrite additionNIsAssociative a b c = pr2
+      pr3 rewrite equalityCommutative (Semiring.+Associative ℕSemiring a b c) = pr2
       pr4 : n +N n <N c +N n
-      pr4 rewrite additionNIsCommutative c n = identityOfIndiscernablesRight _ _ _ _<N_ pr3 (applyEquality (_+N c) a+b=n)
+      pr4 rewrite Semiring.commutative ℕSemiring c n = identityOfIndiscernablesRight _ _ _ _<N_ pr3 (applyEquality (_+N c) a+b=n)
       pr5 : n <N c
       pr5 = subtractionPreservesInequality n pr4
 
@@ -118,34 +121,34 @@ module IntegersModN where
   help31 {a} {b} {c} {n} a+b=n n<b+c = canSubtractFromEqualityLeft pr2
     where
       pr1 : a +N (n +N subtractionNResult.result (-N (inl n<b+c))) ≡ n +N c
-      pr1 rewrite addMinus' (inl n<b+c) | equalityCommutative (additionNIsAssociative a b c) | a+b=n = refl
+      pr1 rewrite addMinus' (inl n<b+c) | Semiring.+Associative ℕSemiring a b c | a+b=n = refl
       pr2 : n +N (a +N subtractionNResult.result (-N (inl n<b+c))) ≡ n +N c
       pr2 = identityOfIndiscernablesLeft _ _ _ _≡_ pr1 (lemm a n (subtractionNResult.result (-N (inl n<b+c))))
         where
           lemm : (a b c : ℕ) → a +N (b +N c) ≡ b +N (a +N c)
-          lemm a b c rewrite equalityCommutative (additionNIsAssociative a b c) | additionNIsCommutative a b | additionNIsAssociative b a c = refl
+          lemm a b c rewrite Semiring.+Associative ℕSemiring a b c | Semiring.commutative ℕSemiring a b | equalityCommutative (Semiring.+Associative ℕSemiring b a c) = refl
 
   help7 : {a b c n : ℕ} → b +N c ≡ n → a <N n → (n<a+b : n <N a +N b) → (subtractionNResult.result (-N (inl n<a+b)) +N c ≡ n) → False
-  help7 {a} {b} {c} {n} b+c=n a<n n<a+b x = lessIrreflexive (identityOfIndiscernablesLeft _ _ _ _<N_ a<n pr5)
+  help7 {a} {b} {c} {n} b+c=n a<n n<a+b x = TotalOrder.irreflexive ℕTotalOrder (identityOfIndiscernablesLeft _ _ _ _<N_ a<n pr5)
     where
       pr : (n +N subtractionNResult.result (-N (inl n<a+b))) +N c ≡ n +N n
-      pr = identityOfIndiscernablesLeft _ _ _ _≡_ (applyEquality (n +N_) x) (equalityCommutative (additionNIsAssociative n _ c))
+      pr = identityOfIndiscernablesLeft _ _ _ _≡_ (applyEquality (n +N_) x) (Semiring.+Associative ℕSemiring n _ c)
       pr2 : (a +N b) +N c ≡ n +N n
       pr2 = identityOfIndiscernablesLeft _ _ _ _≡_ pr (applyEquality (_+N c) (addMinus' (inl n<a+b)))
       pr3 : a +N (b +N c) ≡ n +N n
-      pr3 rewrite equalityCommutative (additionNIsAssociative a b c) = pr2
+      pr3 rewrite Semiring.+Associative ℕSemiring a b c = pr2
       pr4 : a +N n ≡ n +N n
       pr4 = identityOfIndiscernablesLeft _ _ _ _≡_ pr3 (applyEquality (a +N_) b+c=n)
       pr5 : a ≡ n
       pr5 = canSubtractFromEqualityRight pr4
 
   help29 : {a b c n : ℕ} → (c <N n) → (n<b+c : n <N b +N c) → (a +N subtractionNResult.result (-N (inl n<b+c))) ≡ n → a +N b ≡ n → False
-  help29 {a} {b} {c} {n} c<n n<b+c pr a+b=n = lessIrreflexive (identityOfIndiscernablesLeft _ _ _ _<N_ c<n p4)
+  help29 {a} {b} {c} {n} c<n n<b+c pr a+b=n = TotalOrder.irreflexive ℕTotalOrder (identityOfIndiscernablesLeft _ _ _ _<N_ c<n p4)
     where
       p1 : a +N (subtractionNResult.result (-N (inl n<b+c)) +N n) ≡ n +N n
-      p1 = identityOfIndiscernablesLeft _ _ _ _≡_ (applyEquality (_+N n) pr) (additionNIsAssociative a _ n)
+      p1 = identityOfIndiscernablesLeft _ _ _ _≡_ (applyEquality (_+N n) pr) (equalityCommutative (Semiring.+Associative ℕSemiring a _ n))
       p2 : (a +N b) +N c ≡ n +N n
-      p2 rewrite additionNIsAssociative a b c = identityOfIndiscernablesLeft _ _ _ _≡_ p1 (applyEquality (a +N_) (addMinus (inl n<b+c)))
+      p2 rewrite equalityCommutative (Semiring.+Associative ℕSemiring a b c) = identityOfIndiscernablesLeft _ _ _ _≡_ p1 (applyEquality (a +N_) (addMinus (inl n<b+c)))
       p3 : n +N c ≡ n +N n
       p3 = identityOfIndiscernablesLeft _ _ _ _≡_ p2 (applyEquality (_+N c) a+b=n)
       p4 : c ≡ n
@@ -155,288 +158,288 @@ module IntegersModN where
   help28 {a} {b} {c} {n} pr a+b=n = canSubtractFromEqualityLeft p2
     where
       p1 : a +N (b +N c) ≡ n +N c
-      p1 rewrite equalityCommutative (additionNIsAssociative a b c) | a+b=n = refl
+      p1 rewrite Semiring.+Associative ℕSemiring a b c | a+b=n = refl
       p2 : n +N subtractionNResult.result (-N (inl pr)) ≡ n +N c
       p2 = identityOfIndiscernablesLeft _ _ _ _≡_ p1 (equalityCommutative (addMinus' (inl pr)))
 
   help27 : {a b c n : ℕ} → (a +N b ≡ succ n) → (a +N (b +N c) <N succ n) → a +N (b +N c) ≡ c
-  help27 {a} {b} {zero} {n} a+b=sn a+b+c<sn rewrite additionNIsCommutative b 0 | a+b=sn = exFalso (lessIrreflexive a+b+c<sn)
-  help27 {a} {b} {succ c} {n} a+b=sn a+b+c<sn rewrite equalityCommutative (additionNIsAssociative a b (succ c)) | a+b=sn = exFalso (cannotAddAndEnlarge' a+b+c<sn)
+  help27 {a} {b} {zero} {n} a+b=sn a+b+c<sn rewrite Semiring.commutative ℕSemiring b 0 | a+b=sn = exFalso (TotalOrder.irreflexive ℕTotalOrder a+b+c<sn)
+  help27 {a} {b} {succ c} {n} a+b=sn a+b+c<sn rewrite Semiring.+Associative ℕSemiring a b (succ c) | a+b=sn = exFalso (cannotAddAndEnlarge' a+b+c<sn)
 
   help26 : {a b c n : ℕ} → (a +N b ≡ n) → (a +N (b +N c) ≡ n) → 0 ≡ c
-  help26 {a} {b} {c} {n} a+b=n a+b+c=n rewrite (equalityCommutative (additionNIsAssociative a b c)) | a+b=n | additionNIsCommutative n c = equalityCommutative (canSubtractFromEqualityRight a+b+c=n)
+  help26 {a} {b} {c} {n} a+b=n a+b+c=n rewrite Semiring.+Associative ℕSemiring a b c | a+b=n | Semiring.commutative ℕSemiring n c = equalityCommutative (canSubtractFromEqualityRight a+b+c=n)
 
   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 additionNIsCommutative a 0 | additionNIsCommutative a b | equalityCommutative a+b=n = equalityCommutative (canSubtractFromEqualityLeft b+c=n)
+  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 additionNIsCommutative a 0 = lessIrreflexive (orderIsTransitive a<n n<a+0)
+  help24 {a} {n} a<n n<a+0 rewrite Semiring.commutative ℕSemiring a 0 = TotalOrder.irreflexive ℕTotalOrder (orderIsTransitive 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 additionNIsCommutative a 0 | a+0=n = lessIrreflexive a<n
+  help23 {a} {n} a<n a+0=n rewrite Semiring.commutative ℕSemiring a 0 | a+0=n = TotalOrder.irreflexive ℕTotalOrder a<n
 
   help22 : {a b c n : ℕ} → (a +N b ≡ n) → (c ≡ n) → (n<b+c : n <N b +N c) → (n <N a +N subtractionNResult.result (-N (inl n<b+c))) → False
-  help22 {a} {b} {c} {.c} a+b=n refl n<b+c pr = lessIrreflexive (identityOfIndiscernablesRight _ _ _ _<N_ pr4 a+b=n)
+  help22 {a} {b} {c} {.c} a+b=n refl n<b+c pr = TotalOrder.irreflexive ℕTotalOrder (identityOfIndiscernablesRight _ _ _ _<N_ pr4 a+b=n)
     where
       pr1 : c +N c <N a +N (subtractionNResult.result (-N (inl n<b+c)) +N c)
-      pr1 = identityOfIndiscernablesRight _ _ _ _<N_ (additionPreservesInequality c pr) (additionNIsAssociative a _ c)
+      pr1 = identityOfIndiscernablesRight _ _ _ _<N_ (additionPreservesInequality c pr) (equalityCommutative (Semiring.+Associative ℕSemiring a _ c))
       pr2 : c +N c <N a +N (b +N c)
       pr2 = identityOfIndiscernablesRight _ _ _ _<N_ pr1 (applyEquality (a +N_) (addMinus (inl n<b+c)))
       pr3 : c +N c <N (a +N b) +N c
-      pr3 = identityOfIndiscernablesRight _ _ _ _<N_ pr2 (equalityCommutative (additionNIsAssociative a b c))
+      pr3 = identityOfIndiscernablesRight _ _ _ _<N_ pr2 (Semiring.+Associative ℕSemiring a b c)
       pr4 : c <N a +N b
       pr4 = subtractionPreservesInequality c pr3
 
   help21 : {a b c n : ℕ} → (a +N b ≡ n) → (b +N c ≡ n) → (c ≡ n) → (a <N n) → False
-  help21 {a} {b} {c} {.c} a+b=n b+c=n refl a<n = lessIrreflexive (identityOfIndiscernablesLeft _ _ _ _<N_ a<n a=c)
+  help21 {a} {b} {c} {.c} a+b=n b+c=n refl a<n = TotalOrder.irreflexive ℕTotalOrder (identityOfIndiscernablesLeft _ _ _ _<N_ a<n a=c)
     where
       b=0 : b ≡ 0
       a=c : a ≡ c
       a=c = identityOfIndiscernablesLeft _ _ _ _≡_ a+b=n lemm
         where
           lemm : a +N b ≡ a
-          lemm rewrite b=0 | additionNIsCommutative a 0 = refl
+          lemm rewrite b=0 | Semiring.commutative ℕSemiring a 0 = refl
       b=0' : (b c : ℕ) → (b +N c ≡ c) → b ≡ 0
       b=0' zero c b+c=c = refl
       b=0' (succ b) zero b+c=c = naughtE (equalityCommutative b+c=c)
       b=0' (succ b) (succ c) b+c=c = b=0' (succ b) c bl2
         where
           bl2 : succ b +N c ≡ c
-          bl2 rewrite additionNIsCommutative b c | additionNIsCommutative (succ c) b = succInjective b+c=c
+          bl2 rewrite Semiring.commutative ℕSemiring b c | Semiring.commutative ℕSemiring (succ c) b = succInjective b+c=c
       b=0 = b=0' b c b+c=n
 
   help20 : {a b c n : ℕ} → (c ≡ n) → (a +N b ≡ n) → (n<b+c : n <N b +N c) → (a +N subtractionNResult.result (-N (inl n<b+c)) <N n) → False
-  help20 {a} {b} {c} {n} c=n a+b=n n<b+c pr = lessIrreflexive (identityOfIndiscernablesLeft _ _ _ _<N_ pr5 c=n)
+  help20 {a} {b} {c} {n} c=n a+b=n n<b+c pr = TotalOrder.irreflexive ℕTotalOrder (identityOfIndiscernablesLeft _ _ _ _<N_ pr5 c=n)
     where
       pr1 : a +N (subtractionNResult.result (-N (inl n<b+c)) +N n) <N n +N n
-      pr1 = identityOfIndiscernablesLeft _ _ _ _<N_ (additionPreservesInequality n pr) (additionNIsAssociative a _ n)
+      pr1 = identityOfIndiscernablesLeft _ _ _ _<N_ (additionPreservesInequality n pr) (equalityCommutative (Semiring.+Associative ℕSemiring a _ n))
       pr2 : a +N (b +N c) <N n +N n
       pr2 = identityOfIndiscernablesLeft _ _ _ _<N_ pr1 (applyEquality (a +N_) (addMinus (inl n<b+c)))
       pr3 : (a +N b) +N c <N n +N n
-      pr3 rewrite additionNIsAssociative a b c = pr2
+      pr3 rewrite equalityCommutative (Semiring.+Associative ℕSemiring a b c) = pr2
       pr4 : c +N n <N n +N n
-      pr4 = identityOfIndiscernablesLeft _ _ _ _<N_ pr3 (transitivity (applyEquality (_+N c) a+b=n) (additionNIsCommutative n c))
+      pr4 = identityOfIndiscernablesLeft _ _ _ _<N_ pr3 (transitivity (applyEquality (_+N c) a+b=n) (Semiring.commutative ℕSemiring n c))
       pr5 : c <N n
       pr5 = subtractionPreservesInequality n pr4
 
   help19 : {a b c n : ℕ} → (b+c<n : b +N c <N n) → (n<a+b : n <N a +N b) → (a <N n) → (subtractionNResult.result (-N (inl n<a+b)) +N c ≡ n) → False
-  help19 {a} {b} {c} {n} b+c<n n<a+b a<n pr = lessIrreflexive (identityOfIndiscernablesLeft _ _ _ _<N_ r q')
+  help19 {a} {b} {c} {n} b+c<n n<a+b a<n pr = TotalOrder.irreflexive ℕTotalOrder (identityOfIndiscernablesLeft _ _ _ _<N_ r q')
     where
       p : (n +N subtractionNResult.result (-N (inl n<a+b))) +N c ≡ n +N n
-      p = identityOfIndiscernablesLeft _ _ _ _≡_ (applyEquality (n +N_ ) pr) (equalityCommutative (additionNIsAssociative n _ c))
+      p = identityOfIndiscernablesLeft _ _ _ _≡_ (applyEquality (n +N_ ) pr) (Semiring.+Associative ℕSemiring n _ c)
       q : (a +N b) +N c ≡ n +N n
       q = identityOfIndiscernablesLeft _ _ _ _≡_ p (applyEquality (_+N c) (addMinus' (inl n<a+b)))
       q' : a +N (b +N c) ≡ n +N n
-      q' = identityOfIndiscernablesLeft _ _ _ _≡_ q (additionNIsAssociative a b c)
+      q' = identityOfIndiscernablesLeft _ _ _ _≡_ q (equalityCommutative (Semiring.+Associative ℕSemiring a b c))
       r : a +N (b +N c) <N n +N n
       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 = lessIrreflexive (orderIsTransitive p4 a<n)
+  help18 {a} {b} {c} {n} b+c<n n<a+b a<n pr = TotalOrder.irreflexive ℕTotalOrder (orderIsTransitive 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) (equalityCommutative (additionNIsAssociative n _ c))
+      p = identityOfIndiscernablesRight _ _ _ _<N_ (additionPreservesInequalityOnLeft n pr) (Semiring.+Associative ℕSemiring n _ c)
       p' : n +N n <N (a +N b) +N c
       p' = identityOfIndiscernablesRight _ _ _ _<N_ p (applyEquality (_+N c) (addMinus' (inl n<a+b)))
       p2 : n +N n <N a +N (b +N c)
-      p2 = identityOfIndiscernablesRight _ _ _ _<N_ p' (additionNIsAssociative a b 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)
       p4 : n <N a
       p4 = subtractionPreservesInequality n p3
 
   help17 : {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) → (subtractionNResult.result (-N (inl n<a+b)) +N c) ≡ n → False
-  help17 {a} {b} {c} {n} n<b+c n<a+b p1 p2 = lessIrreflexive (identityOfIndiscernablesLeft _ _ _ _<N_ pr1'' pr3)
+  help17 {a} {b} {c} {n} n<b+c n<a+b p1 p2 = TotalOrder.irreflexive ℕTotalOrder (identityOfIndiscernablesLeft _ _ _ _<N_ pr1'' pr3)
     where
       pr1' : a +N (subtractionNResult.result (-N (inl n<b+c)) +N n) <N n +N n
-      pr1' = identityOfIndiscernablesLeft _ _ _ _<N_ (additionPreservesInequality n p1) (additionNIsAssociative a _ n)
+      pr1' = identityOfIndiscernablesLeft _ _ _ _<N_ (additionPreservesInequality n p1) (equalityCommutative (Semiring.+Associative ℕSemiring a _ n))
       pr1'' : a +N (b +N c) <N n +N n
       pr1'' = identityOfIndiscernablesLeft _ _ _ _<N_ pr1' (applyEquality (a +N_) (addMinus (inl n<b+c)))
       pr2' : (n +N subtractionNResult.result (-N (inl n<a+b))) +N c ≡ n +N n
-      pr2' = identityOfIndiscernablesLeft _ _ _ _≡_ (applyEquality (n +N_) p2) (equalityCommutative (additionNIsAssociative n _ c))
+      pr2' = identityOfIndiscernablesLeft _ _ _ _≡_ (applyEquality (n +N_) p2) (Semiring.+Associative ℕSemiring n _ c)
       pr2'' : (a +N b) +N c ≡ n +N n
       pr2'' = identityOfIndiscernablesLeft _ _ _ _≡_ pr2' (applyEquality (_+N c) (addMinus' (inl n<a+b)))
       pr3 : a +N (b +N c) ≡ n +N n
-      pr3 = identityOfIndiscernablesLeft _ _ _ _≡_ pr2'' (additionNIsAssociative a b c)
+      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 (lessIrreflexive (orderIsTransitive pr3 pr1''))
+  help16 {a} {b} {c} {n} n<b+c n<a+b pr1 pr2 = exFalso (TotalOrder.irreflexive ℕTotalOrder (orderIsTransitive 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) (additionNIsAssociative a _ n)
+      pr1' = identityOfIndiscernablesLeft _ _ _ _<N_ (additionPreservesInequality n pr1) (equalityCommutative (Semiring.+Associative ℕSemiring a _ n))
       pr1'' : a +N (b +N c) <N n +N n
       pr1'' = identityOfIndiscernablesLeft _ _ _ _<N_ pr1' (applyEquality (a +N_) (addMinus (inl n<b+c)))
       pr2' : n +N n <N (n +N subtractionNResult.result (-N (inl n<a+b))) +N c
-      pr2' = identityOfIndiscernablesRight _ _ _ _<N_ (additionPreservesInequalityOnLeft n pr2) (equalityCommutative (additionNIsAssociative n _ c))
+      pr2' = identityOfIndiscernablesRight _ _ _ _<N_ (additionPreservesInequalityOnLeft n pr2) (Semiring.+Associative ℕSemiring n _ c)
       pr2'' : n +N n <N (a +N b) +N c
       pr2'' = identityOfIndiscernablesRight _ _ _ _<N_ pr2' (applyEquality (_+N c) (addMinus' (inl n<a+b)))
       pr3 : n +N n <N a +N (b +N c)
-      pr3 = identityOfIndiscernablesRight _ _ _ _<N_ pr2'' (additionNIsAssociative a b c)
+      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 = lessIrreflexive (orderIsTransitive p2'' p1')
+  help15 {a} {b} {c} {n} n<b+c n<a+b pr1 pr2 = TotalOrder.irreflexive ℕTotalOrder (orderIsTransitive 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) (equalityCommutative (additionNIsAssociative n _ c))
+      p1 = identityOfIndiscernablesLeft _ _ _ _<N_ (additionPreservesInequalityOnLeft n pr2) (Semiring.+Associative ℕSemiring n _ c)
       p1' : (a +N b) +N c <N n +N n
       p1' = identityOfIndiscernablesLeft _ _ _ _<N_ p1 (applyEquality (_+N c) (addMinus' (inl n<a+b)))
       p2 : n +N n <N a +N (subtractionNResult.result (-N (inl n<b+c)) +N n)
-      p2 = identityOfIndiscernablesRight _ _ _ _<N_ (additionPreservesInequality n pr1) (additionNIsAssociative a _ n)
+      p2 = identityOfIndiscernablesRight _ _ _ _<N_ (additionPreservesInequality n pr1) (equalityCommutative (Semiring.+Associative ℕSemiring a _ n))
       p2' : n +N n <N a +N (b +N c)
       p2' = identityOfIndiscernablesRight _ _ _ _<N_ p2 (applyEquality (a +N_) (addMinus (inl n<b+c)))
       p2'' : n +N n <N (a +N b) +N c
-      p2'' = identityOfIndiscernablesRight _ _ _ _<N_ p2' (equalityCommutative (additionNIsAssociative a b c))
+      p2'' = identityOfIndiscernablesRight _ _ _ _<N_ p2' (Semiring.+Associative ℕSemiring a b c)
 
   help14 : {a b c n : ℕ} → (n<b+c : n <N b +N c) → (n<a+b : n <N a +N b) → (pr1 : n <N a +N subtractionNResult.result (-N (inl n<b+c))) → (pr2 : n <N subtractionNResult.result (-N (inl n<a+b)) +N c) → subtractionNResult.result (-N (inl pr1)) ≡ subtractionNResult.result (-N (inl pr2))
-  help14 {a} {b} {c} {n} n<b+c n<a+b pr1 pr2 = equivalentSubtraction _ _ _ _ pr1 pr2 (transitivity (equalityCommutative (additionNIsAssociative n _ c)) (transitivity (applyEquality (_+N c) (addMinus' (inl n<a+b))) (transitivity (additionNIsAssociative a b c) (equalityCommutative p2))))
+  help14 {a} {b} {c} {n} n<b+c n<a+b pr1 pr2 = equivalentSubtraction _ _ _ _ pr1 pr2 (transitivity (Semiring.+Associative ℕSemiring n _ c) (transitivity (applyEquality (_+N c) (addMinus' (inl n<a+b))) (transitivity (equalityCommutative (Semiring.+Associative ℕSemiring a b c)) (equalityCommutative p2))))
     where
       p1 : (a +N subtractionNResult.result (-N (inl n<b+c))) +N n ≡ a +N (subtractionNResult.result (-N (inl n<b+c)) +N n)
-      p1 = additionNIsAssociative a _ n
+      p1 = equalityCommutative (Semiring.+Associative ℕSemiring a _ n)
       p2 : (a +N subtractionNResult.result (-N (inl n<b+c))) +N n ≡ a +N (b +N c)
       p2 = identityOfIndiscernablesRight _ _ _ _≡_ p1 (applyEquality (a +N_) (addMinus (inl n<b+c)))
 
   help13 : {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) → False
-  help13 {a} {b} {c} {n} n<b+c n<a+b pr1 pr2 = lessIrreflexive (identityOfIndiscernablesRight _ _ _ _<N_ lemm1' lemm3)
+  help13 {a} {b} {c} {n} n<b+c n<a+b pr1 pr2 = TotalOrder.irreflexive ℕTotalOrder (identityOfIndiscernablesRight _ _ _ _<N_ lemm1' lemm3)
     where
       lemm1 : n +N n <N a +N (subtractionNResult.result (-N (inl n<b+c)) +N n)
-      lemm1 = identityOfIndiscernablesRight _ _ _ _<N_ (additionPreservesInequality n pr1) (additionNIsAssociative a _ n)
+      lemm1 = identityOfIndiscernablesRight _ _ _ _<N_ (additionPreservesInequality n pr1) (equalityCommutative (Semiring.+Associative ℕSemiring a _ n))
       lemm1' : n +N n <N a +N (b +N c)
       lemm1' = identityOfIndiscernablesRight _ _ _ _<N_ lemm1 (applyEquality (a +N_) (addMinus (inl n<b+c)))
       lemm2 : (n +N subtractionNResult.result (-N (inl n<a+b))) +N c ≡ n +N n
-      lemm2 = identityOfIndiscernablesLeft _ _ _ _≡_ (applyEquality (n +N_) pr2) (equalityCommutative (additionNIsAssociative n _ c))
+      lemm2 = identityOfIndiscernablesLeft _ _ _ _≡_ (applyEquality (n +N_) pr2) (Semiring.+Associative ℕSemiring n _ c)
       lemm2' : (a +N b) +N c ≡ n +N n
       lemm2' = identityOfIndiscernablesLeft _ _ _ _≡_ lemm2 (applyEquality (_+N c) (addMinus' (inl n<a+b)))
       lemm3 : a +N (b +N c) ≡ n +N n
-      lemm3 rewrite equalityCommutative (additionNIsAssociative a b c) = lemm2'
+      lemm3 rewrite Semiring.+Associative ℕSemiring a b c = lemm2'
 
   help12 : {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 → subtractionNResult.result (-N (inl n<a+b)) +N c <N n → False
-  help12 {a} {b} {c} {n} n<b+c n<a+b pr1 pr2 = lessIrreflexive lemm4
+  help12 {a} {b} {c} {n} n<b+c n<a+b pr1 pr2 = TotalOrder.irreflexive ℕTotalOrder lemm4
     where
       pr : {a b c : ℕ} → a +N (b +N c) ≡ b +N (a +N c)
-      pr {a} {b} {c} rewrite equalityCommutative (additionNIsAssociative a b c) | additionNIsCommutative a b | additionNIsAssociative b a c = refl
+      pr {a} {b} {c} rewrite Semiring.+Associative ℕSemiring a b c | Semiring.commutative ℕSemiring a b | equalityCommutative (Semiring.+Associative ℕSemiring b a c) = refl
       lemm1 : (n +N subtractionNResult.result (-N (inl n<a+b))) +N c <N n +N n
-      lemm1 = identityOfIndiscernablesLeft _ _ _ _<N_ (additionPreservesInequalityOnLeft n pr2) (equalityCommutative (additionNIsAssociative n _ c ))
+      lemm1 = identityOfIndiscernablesLeft _ _ _ _<N_ (additionPreservesInequalityOnLeft n pr2) (Semiring.+Associative ℕSemiring n _ c)
       lemm2 : (a +N b) +N c <N n +N n
       lemm2 = identityOfIndiscernablesLeft _ _ _ _<N_ lemm1 (applyEquality (_+N c) (addMinus' (inl n<a+b)))
       lemm1' : a +N (subtractionNResult.result (-N (inl n<b+c)) +N n) ≡ n +N n
-      lemm1' = identityOfIndiscernablesLeft _ _ _ _≡_ (applyEquality (_+N n) pr1) (additionNIsAssociative a _ n)
+      lemm1' = identityOfIndiscernablesLeft _ _ _ _≡_ (applyEquality (_+N n) pr1) (equalityCommutative (Semiring.+Associative ℕSemiring a _ n))
       lemm2' : a +N (b +N c) ≡ n +N n
       lemm2' = identityOfIndiscernablesLeft _ _ _ _≡_ lemm1' (applyEquality (a +N_) (addMinus (inl n<b+c)))
       lemm3 : (a +N b) +N c ≡ n +N n
-      lemm3 rewrite additionNIsAssociative a b c = lemm2'
+      lemm3 rewrite equalityCommutative (Semiring.+Associative ℕSemiring a b c) = lemm2'
       lemm4 : (a +N b) +N c <N (a +N b) +N c
       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 = lessIrreflexive (orderIsTransitive a<n lemm5)
+  help11 {a} {b} {c} {n} a<n b+c=n n<a+b pr1 = TotalOrder.irreflexive ℕTotalOrder (orderIsTransitive a<n lemm5)
     where
       pr : {a b c : ℕ} → a +N (b +N c) ≡ b +N (a +N c)
-      pr {a} {b} {c} rewrite equalityCommutative (additionNIsAssociative a b c) | additionNIsCommutative a b | additionNIsAssociative b a c = refl
+      pr {a} {b} {c} rewrite Semiring.+Associative ℕSemiring a b c | Semiring.commutative ℕSemiring a b | equalityCommutative (Semiring.+Associative ℕSemiring b a c) = refl
       lemm : n +N n <N (n +N subtractionNResult.result (-N (inl n<a+b))) +N c
-      lemm = identityOfIndiscernablesRight _ _ _ _<N_ (additionPreservesInequalityOnLeft n pr1) (equalityCommutative (additionNIsAssociative n _ c))
+      lemm = identityOfIndiscernablesRight _ _ _ _<N_ (additionPreservesInequalityOnLeft n pr1) (Semiring.+Associative ℕSemiring n _ c)
       lemm2 : n +N n <N (a +N b) +N c
       lemm2 = identityOfIndiscernablesRight _ _ _ _<N_ lemm (applyEquality (_+N c) (addMinus' (inl n<a+b)))
       lemm3 : n +N n <N a +N (b +N c)
-      lemm3 = identityOfIndiscernablesRight _ _ _ _<N_ lemm2 (additionNIsAssociative a b c)
+      lemm3 = identityOfIndiscernablesRight _ _ _ _<N_ lemm2 (equalityCommutative (Semiring.+Associative ℕSemiring a b c))
       lemm4 : n +N n <N a +N n
       lemm4 = identityOfIndiscernablesRight _ _ _ _<N_ lemm3 (applyEquality (a +N_) b+c=n)
       lemm5 : n <N a
       lemm5 = subtractionPreservesInequality n lemm4
 
   help10 : {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 <N subtractionNResult.result (-N (inl n<a+b)) +N c) → False
-  help10 {a} {b} {c} {n} n<b+c n<a+b pr1 pr2 = lessIrreflexive lemm6
+  help10 {a} {b} {c} {n} n<b+c n<a+b pr1 pr2 = TotalOrder.irreflexive ℕTotalOrder lemm6
     where
       pr : {a b c : ℕ} → a +N (b +N c) ≡ b +N (a +N c)
-      pr {a} {b} {c} rewrite equalityCommutative (additionNIsAssociative a b c) | additionNIsCommutative a b | additionNIsAssociative b a c = refl
+      pr {a} {b} {c} rewrite Semiring.+Associative ℕSemiring a b c | Semiring.commutative ℕSemiring a b | equalityCommutative (Semiring.+Associative ℕSemiring b a c) = refl
       lemm : a +N (n +N subtractionNResult.result (-N (inl n<b+c))) ≡ n +N n
       lemm = identityOfIndiscernablesLeft _ _ _ _≡_ (applyEquality (n +N_) pr1) (pr {n} {a})
       lemm2 : a +N (b +N c) ≡ n +N n
       lemm2 = identityOfIndiscernablesLeft _ _ _ _≡_ lemm (applyEquality (a +N_) (addMinus' (inl n<b+c)))
       lemm3 : n +N n <N (n +N subtractionNResult.result (-N (inl n<a+b))) +N c
-      lemm3 = identityOfIndiscernablesRight _ _ _ _<N_ (additionPreservesInequalityOnLeft n pr2) (equalityCommutative (additionNIsAssociative n _ c))
+      lemm3 = identityOfIndiscernablesRight _ _ _ _<N_ (additionPreservesInequalityOnLeft n pr2) (Semiring.+Associative ℕSemiring n _ c)
       lemm4 : n +N n <N (a +N b) +N c
       lemm4 = identityOfIndiscernablesRight _ _ _ _<N_ lemm3 (applyEquality (_+N c) (addMinus' (inl n<a+b)))
       lemm5 : n +N n <N a +N (b +N c)
-      lemm5 = identityOfIndiscernablesRight _ _ _ _<N_ lemm4 (additionNIsAssociative a b c)
+      lemm5 = identityOfIndiscernablesRight _ _ _ _<N_ lemm4 (equalityCommutative (Semiring.+Associative ℕSemiring a b c))
       lemm6 : a +N (b +N c) <N a +N (b +N c)
       lemm6 = identityOfIndiscernablesLeft _ _ _ _<N_ lemm5 (equalityCommutative lemm2)
 
   help9 : {a n : ℕ} → (a +N 0 ≡ n) → (a <N n) → False
-  help9 {a} {n} n=a+0 a<n rewrite additionNIsCommutative a 0 | n=a+0 = lessIrreflexive a<n
+  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 additionNIsCommutative a 0 = lessIrreflexive (orderIsTransitive a<n n<a+0)
+  help8 {a} {n} n<a+0 a<n rewrite Semiring.commutative ℕSemiring a 0 = TotalOrder.irreflexive ℕTotalOrder (orderIsTransitive 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 additionNIsCommutative a 0 = canSubtractFromEqualityLeft {n} lem'
+  help6 {a} {b} {c} {n} b+c=n n<a+b rewrite Semiring.commutative ℕSemiring a 0 = canSubtractFromEqualityLeft {n} lem'
     where
       lem : n +N a ≡ (n +N subtractionNResult.result (-N (inl n<a+b))) +N c
-      lem rewrite addMinus' (inl n<a+b) | additionNIsAssociative a b c | b+c=n = additionNIsCommutative n a
+      lem rewrite addMinus' (inl n<a+b) | equalityCommutative (Semiring.+Associative ℕSemiring a b c) | b+c=n = Semiring.commutative ℕSemiring n a
       lem' : n +N a ≡ n +N (subtractionNResult.result (-N (inl n<a+b)) +N c)
-      lem' = identityOfIndiscernablesRight _ _ _ _≡_ lem (additionNIsAssociative n _ c)
+      lem' = identityOfIndiscernablesRight _ _ _ _≡_ lem (equalityCommutative (Semiring.+Associative ℕSemiring n _ c))
 
   help5 : {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)) ≡ subtractionNResult.result (-N (inl n<a+b)) +N c
   help5 {a} {b} {c} {n} n<b+c n<a+b = canSubtractFromEqualityLeft {n} lemma''
     where
       lemma : a +N (n +N subtractionNResult.result (-N (inl n<b+c))) ≡ (n +N subtractionNResult.result (-N (inl n<a+b))) +N c
-      lemma rewrite addMinus' (inl n<b+c) | addMinus' (inl n<a+b) = equalityCommutative (additionNIsAssociative a b c)
+      lemma rewrite addMinus' (inl n<b+c) | addMinus' (inl n<a+b) = Semiring.+Associative ℕSemiring a b c
       lemma' : a +N (n +N subtractionNResult.result (-N (inl n<b+c))) ≡ n +N (subtractionNResult.result (-N (inl n<a+b)) +N c)
-      lemma' = identityOfIndiscernablesRight _ _ _ _≡_ lemma (additionNIsAssociative n _ c)
+      lemma' = identityOfIndiscernablesRight _ _ _ _≡_ lemma (equalityCommutative (Semiring.+Associative ℕSemiring n _ c))
       lemma'' : n +N (a +N subtractionNResult.result (-N (inl n<b+c))) ≡ n +N (subtractionNResult.result (-N (inl n<a+b)) +N c)
       lemma'' = identityOfIndiscernablesLeft _ _ _ _≡_ lemma' (pr {a} {n} {subtractionNResult.result (-N (inl n<b+c))})
         where
           pr : {a b c : ℕ} → a +N (b +N c) ≡ b +N (a +N c)
-          pr {a} {b} {c} rewrite equalityCommutative (additionNIsAssociative a b c) | additionNIsCommutative a b | additionNIsAssociative b a c = refl
+          pr {a} {b} {c} rewrite Semiring.+Associative ℕSemiring a b c | Semiring.commutative ℕSemiring a b | equalityCommutative (Semiring.+Associative ℕSemiring b a c) = refl
 
   help4 : {a b c n : ℕ} → (n<a+'b+c : n <N a +N (b +N c)) → (n<a+b : n <N a +N b) → (subtractionNResult.result (-N (inl n<a+'b+c)) ≡ subtractionNResult.result (-N (inl n<a+b)) +N c)
   help4 {a} {b} {c} {n} n<a+'b+c n<a+b = canSubtractFromEqualityLeft lemma'
     where
       lemma : (n +N subtractionNResult.result (-N (inl n<a+'b+c))) ≡ (n +N subtractionNResult.result (-N (inl n<a+b))) +N c
-      lemma rewrite addMinus' (inl n<a+'b+c) | addMinus' (inl n<a+b) = equalityCommutative (additionNIsAssociative a b c)
+      lemma rewrite addMinus' (inl n<a+'b+c) | addMinus' (inl n<a+b) = Semiring.+Associative ℕSemiring a b c
       lemma' : n +N subtractionNResult.result (-N (inl n<a+'b+c)) ≡ n +N (subtractionNResult.result (-N (inl n<a+b)) +N c)
-      lemma' = identityOfIndiscernablesRight _ _ _ _≡_ lemma (additionNIsAssociative n (subtractionNResult.result (-N (inl n<a+b))) c)
+      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 = lessIrreflexive (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 (orderIsTransitive (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))))
         where
           lemma : (a b c : ℕ) → a +N (b +N c) ≡ b +N (a +N c)
-          lemma a b c rewrite equalityCommutative (additionNIsAssociative a b c) | equalityCommutative (additionNIsAssociative b a c) = applyEquality (_+N c) (additionNIsCommutative a b)
+          lemma a b c rewrite Semiring.+Associative ℕSemiring a b c | Semiring.+Associative ℕSemiring b a c = applyEquality (_+N c) (Semiring.commutative ℕSemiring a b)
       inter2 : n +N n ≡ a +N (b +N c)
       inter2 = equalityCommutative (identityOfIndiscernablesLeft _ _ _ _≡_ inter (applyEquality (a +N_) (addMinus' (inl n<b+c))))
       inter3 : n +N n <N n +N c
-      inter3 rewrite inter2 | equalityCommutative (additionNIsAssociative a b c) = additionPreservesInequality c a+b<n
+      inter3 rewrite inter2 | Semiring.+Associative ℕSemiring a b c = additionPreservesInequality c a+b<n
       inter4 : (n +N n <N n +N c) → n <N c
-      inter4 pr rewrite additionNIsCommutative n c = subtractionPreservesInequality n pr
+      inter4 pr rewrite Semiring.commutative ℕSemiring n c = subtractionPreservesInequality n pr
 
   help2 : {a b c n : ℕ} → (sn<b+c : succ n <N b +N c) → (sn<a+b+c : succ n <N (a +N b) +N c) → a +N subtractionNResult.result (-N (inl sn<b+c)) ≡ subtractionNResult.result (-N (inl sn<a+b+c))
   help2 {a} {b} {c} {n} sn<b+c sn<a+b+c = res inter
     where
       inter : a +N (subtractionNResult.result (-N (inl sn<b+c)) +N succ n) ≡ subtractionNResult.result (-N (inl sn<a+b+c)) +N succ n
-      inter rewrite addMinus (inl sn<b+c) | addMinus (inl sn<a+b+c) = equalityCommutative (additionNIsAssociative a b c)
+      inter rewrite addMinus (inl sn<b+c) | addMinus (inl sn<a+b+c) = Semiring.+Associative ℕSemiring a b c
       res : (a +N (subtractionNResult.result (-N (inl sn<b+c)) +N succ n) ≡ subtractionNResult.result (-N (inl sn<a+b+c)) +N succ n) → a +N subtractionNResult.result (-N (inl sn<b+c)) ≡ subtractionNResult.result (-N (inl sn<a+b+c))
-      res pr = canSubtractFromEqualityRight {_} {succ n} (identityOfIndiscernablesLeft _ _ _ _≡_ pr (equalityCommutative (additionNIsAssociative a (subtractionNResult.result (-N (inl sn<b+c))) (succ n))))
+      res pr = canSubtractFromEqualityRight {_} {succ n} (identityOfIndiscernablesLeft _ _ _ _≡_ pr (Semiring.+Associative ℕSemiring a (subtractionNResult.result (-N (inl sn<b+c))) (succ n)))
 
   help1 : {a b c n : ℕ} → (sn<b+c : succ n <N b +N c) → (pr1 : succ n <N a +N subtractionNResult.result (-N (inl sn<b+c))) → (a +N b <N succ n) → (a <N succ n) → (b <N succ n) → (c <N succ n) → False
   help1 {a} {b} {c} {n} sn<b+c pr1 a+b<sn a<sn b<sn c<sn with -N (inl sn<b+c)
   help1 {a} {b} {c} {n} sn<b+c pr1 a+b<sn a<sn b<sn c<sn | record { result = b+c-sn ; pr = Prb+c-sn } = ans
     where
       b+c-nNonzero : b+c-sn ≡ 0 → False
-      b+c-nNonzero pr rewrite (equalityCommutative Prb+c-sn) | pr | additionNIsCommutative n 0 = lessIrreflexive sn<b+c
+      b+c-nNonzero pr rewrite (equalityCommutative Prb+c-sn) | pr | Semiring.commutative ℕSemiring n 0 = TotalOrder.irreflexive ℕTotalOrder sn<b+c
       2sn<a+b+c' : succ n +N succ n <N succ n +N (a +N b+c-sn)
       2sn<a+b+c' = additionPreservesInequalityOnLeft (succ n) pr1
       2sn<a+b+c'' : succ n +N succ n <N a +N (succ n +N b+c-sn)
-      2sn<a+b+c'' rewrite equalityCommutative (additionNIsAssociative a (succ n) b+c-sn) | additionNIsCommutative a (succ n) | additionNIsAssociative (succ n) a b+c-sn = 2sn<a+b+c'
+      2sn<a+b+c'' rewrite Semiring.+Associative ℕSemiring a (succ n) b+c-sn | Semiring.commutative ℕSemiring a (succ n) | equalityCommutative (Semiring.+Associative ℕSemiring (succ n) a b+c-sn) = 2sn<a+b+c'
       eep : succ n +N succ n <N a +N (b +N c)
       eep rewrite equalityCommutative Prb+c-sn = 2sn<a+b+c''
       eep2 : a +N (b +N c) <N succ n +N c
-      eep2 rewrite equalityCommutative (additionNIsAssociative a b c) = additionPreservesInequality c a+b<sn
+      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)
       ans : False
-      ans = lessIrreflexive (orderIsTransitive eep eep2')
+      ans = TotalOrder.irreflexive ℕTotalOrder (orderIsTransitive 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} {()}
@@ -444,29 +447,29 @@ module IntegersModN where
   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 } | inl (inl a+b<sn) | inl (inl a+b+c<sn) | inl (inl b+c<sn) | inl (inl a+'b+c<sn) = equalityZn _ _ (equalityCommutative (additionNIsAssociative 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 (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 additionNIsAssociative a b c = lessIrreflexive (orderIsTransitive pr1 pr2)
+      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 (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 additionNIsAssociative a b c | p2 = lessIrreflexive p1
+      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) | 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
       false : a +N (b +N c) <N succ n → succ n +N result ≡ b +N c → False
-      false pr1 pr2 rewrite equalityCommutative pr2 | equalityCommutative (additionNIsAssociative a (succ n) result) | additionNIsCommutative a (succ n) | additionNIsAssociative (succ n) a result = cannotAddAndEnlarge' pr1
+      false pr1 pr2 rewrite equalityCommutative pr2 | Semiring.+Associative ℕSemiring a (succ n) result | Semiring.commutative ℕSemiring a (succ n) | equalityCommutative (Semiring.+Associative ℕSemiring (succ n) a result) = cannotAddAndEnlarge' 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 (inl a+b+c<sn) | inl (inr sn<b+c) | inl (inl _) | inl (inr 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 (inr x) | record { result = result ; pr = pr } = exFalso false
     where
       lemma : a +N (succ n +N result) ≡ a +N (b +N c)
       lemma' : a +N (succ n +N result) <N succ n
       lemma'' : succ n +N (a +N result) <N succ n
-      lemma'' = identityOfIndiscernablesLeft _ _ _ _<N_ lemma' (transitivity (equalityCommutative (additionNIsAssociative a (succ n) result)) (transitivity (applyEquality (λ t → t +N result) (additionNIsCommutative a (succ n))) (additionNIsAssociative (succ n) a result)))
+      lemma'' = identityOfIndiscernablesLeft _ _ _ _<N_ lemma' (transitivity (Semiring.+Associative ℕSemiring a (succ n) result) (transitivity (applyEquality (λ t → t +N result) (Semiring.commutative ℕSemiring a (succ n))) (equalityCommutative (Semiring.+Associative ℕSemiring (succ n) a result))))
       lemma = applyEquality (λ i → a +N i) pr
       lemma' rewrite lemma = a+'b+c<sn
       false : False
@@ -477,42 +480,42 @@ module IntegersModN where
       lemma : a +N (succ n +N result) <N succ n
       lemma rewrite pr = a+'b+c<sn
       lemma' : succ n +N (a +N result) <N succ n
-      lemma' = identityOfIndiscernablesLeft _ _ _ _<N_ lemma (transitivity (equalityCommutative (additionNIsAssociative a (succ n) result)) (transitivity (applyEquality (λ t → t +N result) (additionNIsCommutative a (succ n))) (additionNIsAssociative (succ n) a result)))
+      lemma' = identityOfIndiscernablesLeft _ _ _ _<N_ lemma (transitivity (Semiring.+Associative ℕSemiring a (succ n) result) (transitivity (applyEquality (λ t → t +N result) (Semiring.commutative ℕSemiring a (succ n))) (equalityCommutative (Semiring.+Associative ℕSemiring (succ n) a result))))
       false : False
       false = cannotAddAndEnlarge' lemma'
   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 additionNIsAssociative a b c = lessIrreflexive (orderIsTransitive pr1 pr2)
+      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 (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
-      false pr1 pr2 rewrite equalityCommutative pr2 | additionNIsAssociative a b c = lessIrreflexive pr1
+      false pr1 pr2 rewrite equalityCommutative pr2 | equalityCommutative (Semiring.+Associative ℕSemiring a b c) = 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 (inl a+b+c<sn) | inr sn=b+c = exFalso (false a+b+c<sn sn=b+c)
     where
       false : (a +N b) +N c <N succ n → b +N c ≡ succ n → False
-      false pr1 pr2 rewrite additionNIsAssociative a b c | pr2 | additionNIsCommutative a (succ n) = cannotAddAndEnlarge' a+b+c<sn
+      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) | 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 additionNIsAssociative a b c = lessIrreflexive (orderIsTransitive pr1 pr2)
+      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 (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
-      lemma rewrite additionNIsAssociative a b c = additionNIsCommutative (succ n) _
+      lemma rewrite equalityCommutative (Semiring.+Associative ℕSemiring a b c) = Semiring.commutative ℕSemiring (succ n) _
       ans : subtractionNResult.result (-N (inl sn<a+'b+c)) ≡ subtractionNResult.result (-N (inl sn<a+b+c))
       ans = equivalentSubtraction _ _ _ _ sn<a+'b+c sn<a+b+c lemma
   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) | inr x = exFalso (false sn<a+b+c x)
     where
       false : succ n <N (a +N b) +N c → (a +N (b +N c)) ≡ succ n → False
-      false pr1 pr2 rewrite additionNIsAssociative a b c | pr2 = lessIrreflexive sn<a+b+c
+      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) | 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 additionNIsAssociative a b c = lessIrreflexive (orderIsTransitive pr1 pr2)
+      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)
   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))
@@ -520,60 +523,60 @@ module IntegersModN where
   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) | inr 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) ≡ succ n) → False
-      false pr1 pr2 rewrite additionNIsAssociative a b c | pr2 = lessIrreflexive pr1
+      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 | 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 additionNIsAssociative a b c = lessIrreflexive (orderIsTransitive p1 p2)
+      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)
   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))
       ans pr with -N (inl sn<a+b+c)
-      ans b+c=sn | record { result = result ; pr = pr1 } rewrite additionNIsCommutative a 0 | additionNIsAssociative a b c | b+c=sn | additionNIsCommutative (succ n) result = equalityCommutative (canSubtractFromEqualityRight pr1)
+      ans b+c=sn | record { result = result ; pr = pr1 } rewrite Semiring.commutative ℕSemiring a 0 | equalityCommutative (Semiring.+Associative ℕSemiring a b c) | b+c=sn | Semiring.commutative ℕSemiring (succ n) result = equalityCommutative (canSubtractFromEqualityRight 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 _) | 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 additionNIsCommutative a 0 = lessIrreflexive (orderIsTransitive pr1 pr2)
-      false (succ b) pr1 pr2 rewrite additionNIsCommutative a 0 = lessIrreflexive (orderIsTransitive pr2 (orderIsTransitive (le b (additionNIsCommutative (succ b) a)) pr1))
+      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))
   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
-      false zero pr1 pr2 rewrite pr2 = lessIrreflexive pr1
-      false (succ b) pr1 pr2 rewrite additionNIsCommutative a 0 | pr2 = cannotAddAndEnlarge' pr1
+      false zero pr1 pr2 rewrite pr2 = TotalOrder.irreflexive ℕTotalOrder pr1
+      false (succ b) pr1 pr2 rewrite Semiring.commutative ℕSemiring a 0 | pr2 = cannotAddAndEnlarge' 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 | inr x = exFalso (false sn<a+b+c x)
     where
       false : succ n <N (a +N b) +N c → a +N (b +N c) ≡ succ n → False
-      false pr1 pr2 rewrite additionNIsAssociative a b c | pr2 = lessIrreflexive pr1
+      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 | 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
-      false pr1 pr2 rewrite additionNIsAssociative a b c | pr1 = lessIrreflexive pr2
+      false pr1 pr2 rewrite equalityCommutative (Semiring.+Associative ℕSemiring a b c) | pr1 = TotalOrder.irreflexive ℕTotalOrder pr2
   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 (inr sn<a+'b+c) = exFalso (false sn=a+b+c sn<a+'b+c)
     where
       false : (a +N b) +N c ≡ succ n → succ n <N a +N (b +N c) → False
-      false pr1 pr2 rewrite additionNIsAssociative a b c | pr1 = lessIrreflexive pr2
+      false pr1 pr2 rewrite equalityCommutative (Semiring.+Associative ℕSemiring a b c) | pr1 = TotalOrder.irreflexive ℕTotalOrder pr2
   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) | inr _ = equalityZn _ _ 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 | inl (inr sn<b+c) = exFalso (false a sn=a+b+c sn<b+c)
     where
       false : (a : ℕ) → (a +N b) +N c ≡ succ n → succ n <N b +N c → False
-      false zero pr1 pr2 rewrite additionNIsAssociative a b c | equalityCommutative pr1 = lessIrreflexive pr2
-      false (succ a) pr1 pr2 rewrite additionNIsAssociative a b c | equalityCommutative pr1 = lessIrreflexive (orderIsTransitive pr2 (le a refl))
+      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)
   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
-      a=0 zero pr1 pr2 rewrite additionNIsAssociative a b c | pr2 = refl
-      a=0 (succ a) pr1 pr2 rewrite additionNIsAssociative a b c | pr2 = canSubtractFromEqualityRight pr1
+      a=0 zero pr1 pr2 rewrite equalityCommutative (Semiring.+Associative ℕSemiring a b c) | pr2 = refl
+      a=0 (succ a) pr1 pr2 rewrite equalityCommutative (Semiring.+Associative ℕSemiring a b c) | pr2 = canSubtractFromEqualityRight pr1
       ans : a +N 0 ≡ 0
-      ans rewrite additionNIsCommutative a 0 = a=0 a sn=a+b+c b+c=sn
+      ans rewrite Semiring.commutative ℕSemiring a 0 = a=0 a sn=a+b+c 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) | inr sn=a+b+c | inr b+c=sn | inl (inr sn<a+0) = exFalso (false sn<a+0 sn=a+b+c b+c=sn)
     where
       false : succ n <N a +N 0 → (a +N b) +N c ≡ succ n → b +N c ≡ succ n → False
-      false pr1 pr2 pr3 rewrite additionNIsAssociative a b c | pr3 | additionNIsCommutative a 0 = zeroNeverGreater {succ n} (identityOfIndiscernablesRight _ _ _ _<N_ pr1 (a=0 a pr2))
+      false pr1 pr2 pr3 rewrite equalityCommutative (Semiring.+Associative ℕSemiring a b c) | pr3 | Semiring.commutative ℕSemiring a 0 = zeroNeverGreater {succ n} (identityOfIndiscernablesRight _ _ _ _<N_ pr1 (a=0 a pr2))
         where
           a=0 : (a : ℕ) → (a +N succ n ≡ succ n) → a ≡ 0
           a=0 zero pr = refl
@@ -581,7 +584,7 @@ module IntegersModN where
   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 | inr sn=a+0 = exFalso (false sn=a+b+c b+c=sn sn=a+0)
     where
       false : (a +N b) +N c ≡ succ n → b +N c ≡ succ n → a +N 0 ≡ succ n → False
-      false pr1 pr2 pr3 rewrite additionNIsAssociative a b c | pr2 | equalityCommutative pr3 | additionNIsCommutative a 0 = naughtE (identityOfIndiscernablesLeft _ _ _ _≡_ pr3 (a=0 a pr1))
+      false pr1 pr2 pr3 rewrite equalityCommutative (Semiring.+Associative ℕSemiring a b c) | pr2 | equalityCommutative pr3 | Semiring.commutative ℕSemiring a 0 = naughtE (identityOfIndiscernablesLeft _ _ _ _≡_ pr3 (a=0 a pr1))
         where
           a=0 : (a : ℕ) → (a +N a ≡ a) → a ≡ 0
           a=0 zero pr = refl
@@ -591,7 +594,7 @@ module IntegersModN where
   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 equalityCommutative (additionNIsAssociative a b c) = cannotAddAndEnlarge' (orderIsTransitive pr2 pr1)
+      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)
   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)
@@ -599,7 +602,7 @@ module IntegersModN where
   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) | inr 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) ≡ succ n → False
-      false pr1 pr2 rewrite equalityCommutative (additionNIsAssociative a b c) | equalityCommutative pr2 = cannotAddAndEnlarge' pr1
+      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) | inl (inl x) | inl (inl x₁) = equalityZn _ _ (help5 {a} {b} {c} {succ n} sn<b+c sn<a+b)
@@ -634,12 +637,12 @@ module IntegersModN where
   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 (lessIrreflexive (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 | 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 | 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 | additionNIsCommutative b c = cannotAddAndEnlarge' b+c<sn
+      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) | 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)
@@ -647,7 +650,7 @@ module IntegersModN where
   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 | inr b+c=sn = exFalso (help21 {a} {b} {c} {succ n} sn=a+b b+c=sn c=sn aLess)
 
   subLess : {a b : ℕ} → (0<a : 0 <N a) → (a<b : a <N b) → subtractionNResult.result (-N (inl a<b)) <N b
-  subLess {zero} {b} 0<a a<b = exFalso (lessIrreflexive 0<a)
+  subLess {zero} {b} 0<a a<b = exFalso (TotalOrder.irreflexive ℕTotalOrder 0<a)
   subLess {succ a} {b} _ a<b with -N (inl a<b)
   ... | record { result = b-a ; pr = pr } = record { x = a ; proof = pr }
 
@@ -664,13 +667,13 @@ module IntegersModN where
           h : subtractionNResult.result (-N (inl (le (_<N_.x aLess) (transitivity (equalityCommutative (succExtracts (_<N_.x aLess) a)) (succInjective (_<N_.proof aLess)))))) +N succ a ≡ succ n
           h = addMinus {succ a} {succ n} (inl aLess)
           f : False
-          f rewrite h = lessIrreflexive x
+          f rewrite h = TotalOrder.irreflexive ℕTotalOrder x
       ... | inl (inr x) = exFalso f
         where
           h : subtractionNResult.result (-N (inl (subtractOneFromInequality aLess))) +N succ a ≡ succ n
           h = addMinus {succ a} {succ n} (inl aLess)
           f : False
-          f rewrite h = lessIrreflexive x
+          f rewrite h = TotalOrder.irreflexive ℕTotalOrder x
       ... | (inr n-a+sa=sn) = equalityZn _ _ refl
 
   ℤnGroup : (n : ℕ) → (pr : 0 <N n) → Group (reflSetoid (ℤn n pr)) _+n_
diff --git a/KeyValue.agda b/KeyValue.agda
index 7fca3b1..4128628 100644
--- a/KeyValue.agda
+++ b/KeyValue.agda
@@ -6,7 +6,8 @@ open import Maybe
 open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
 open import Vectors
 
-open import Numbers.Naturals
+open import Numbers.Naturals.Naturals
+open import Numbers.Naturals.Order
 
 module KeyValue where
   record ReducedMap {a b c : _} (keys : Set a) (values : Set b) (keyOrder : TotalOrder {_} {c} keys) (min : keys) : Set (a ⊔ b ⊔ c)
diff --git a/KeyValueWithDomain.agda b/KeyValueWithDomain.agda
index e965305..a3a286f 100644
--- a/KeyValueWithDomain.agda
+++ b/KeyValueWithDomain.agda
@@ -7,7 +7,7 @@ open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
 open import KeyValue
 open import Vectors
 
-open import Numbers.Naturals
+open import Numbers.Naturals.Naturals
 
 module KeyValueWithDomain where
 
diff --git a/Lists/Lists.agda b/Lists/Lists.agda
index 517a332..e13337b 100644
--- a/Lists/Lists.agda
+++ b/Lists/Lists.agda
@@ -2,7 +2,8 @@
 
 open import LogicalFormulae
 open import Functions
-open import Numbers.Naturals -- for length
+open import Numbers.Naturals.Naturals -- for length
+open import Semirings.Definition
 
 module Lists.Lists where
   data List {a} (A : Set a) : Set a where
@@ -154,4 +155,4 @@ module Lists.Lists where
 
   lengthRev : {a : _} {A : Set a} (l : List A) → length (rev l) ≡ length l
   lengthRev [] = refl
-  lengthRev (x :: l) rewrite lengthConcat (rev l) (x :: []) | lengthRev l | additionNIsCommutative (length l) 1 = refl
+  lengthRev (x :: l) rewrite lengthConcat (rev l) (x :: []) | lengthRev l | Semiring.commutative ℕSemiring (length l) 1 = refl
diff --git a/Logic/PropositionalAxiomsTautology.agda b/Logic/PropositionalAxiomsTautology.agda
index e7ce4f1..73b5c1e 100644
--- a/Logic/PropositionalAxiomsTautology.agda
+++ b/Logic/PropositionalAxiomsTautology.agda
@@ -4,7 +4,7 @@ open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
 open import LogicalFormulae
 open import Logic.PropositionalLogic
 open import Functions
-open import Numbers.Naturals
+open import Numbers.Naturals.Naturals
 open import Vectors
 
 module Logic.PropositionalAxiomsTautology where
diff --git a/Logic/PropositionalLogic.agda b/Logic/PropositionalLogic.agda
index 06d56d7..36e04de 100644
--- a/Logic/PropositionalLogic.agda
+++ b/Logic/PropositionalLogic.agda
@@ -4,7 +4,7 @@ open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
 open import LogicalFormulae
 open import Functions
 
-open import Numbers.Naturals
+open import Numbers.Naturals.Naturals
 open import Vectors
 
 module Logic.PropositionalLogic where
diff --git a/Logic/PropositionalLogicExamples.agda b/Logic/PropositionalLogicExamples.agda
index 20dda0b..8a78209 100644
--- a/Logic/PropositionalLogicExamples.agda
+++ b/Logic/PropositionalLogicExamples.agda
@@ -4,7 +4,7 @@ open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
 open import LogicalFormulae
 open import Logic.PropositionalLogic
 open import Functions
-open import Numbers.Naturals
+open import Numbers.Naturals.Naturals
 open import Vectors
 
 module Logic.PropositionalLogicExamples where
diff --git a/Monoids/Definition.agda b/Monoids/Definition.agda
new file mode 100644
index 0000000..e9babc7
--- /dev/null
+++ b/Monoids/Definition.agda
@@ -0,0 +1,13 @@
+{-# OPTIONS --safe --warning=error --without-K #-}
+
+open import LogicalFormulae
+open import Functions
+open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
+
+module Monoids.Definition where
+
+record Monoid {a : _} {A : Set a} (Zero : A) (_+_ : A → A → A) : Set a where
+  field
+    associative : (a b c : A) → a + (b + c) ≡ (a + b) + c
+    idLeft : (a : A) → Zero + a ≡ a
+    idRight : (a : A) → a + Zero ≡ a
diff --git a/Numbers/BinaryNaturals/Addition.agda b/Numbers/BinaryNaturals/Addition.agda
index 54ecc3a..48ddbd6 100644
--- a/Numbers/BinaryNaturals/Addition.agda
+++ b/Numbers/BinaryNaturals/Addition.agda
@@ -3,9 +3,10 @@
 open import LogicalFormulae
 open import Functions
 open import Lists.Lists
-open import Numbers.Naturals
-open import Groups.GroupDefinition
+open import Numbers.Naturals.Naturals
+open import Groups.Definition
 open import Numbers.BinaryNaturals.Definition
+open import Semirings.Definition
 
 module Numbers.BinaryNaturals.Addition where
 
@@ -73,9 +74,9 @@ _+B_ : BinNat → BinNat → BinNat
     ans2 rewrite bad | bad2 = refl
 
 +BIsInherited [] b _ prB = +BIsInherited[] b prB
-+BIsInherited (x :: a) [] prA _ = transitivity (applyEquality NToBinNat (additionNIsCommutative (binNatToN (x :: a)) 0)) (transitivity (binToBin (x :: a)) (equalityCommutative prA))
++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)
-... | inl (inl 0<) rewrite additionNIsCommutative (binNatToN as) 0 | additionNIsCommutative (binNatToN b) 0 | equalityCommutative (additionNIsAssociative (binNatToN as +N binNatToN as) (binNatToN b) (binNatToN b)) | additionNIsAssociative (binNatToN as) (binNatToN as) (binNatToN b) | additionNIsCommutative (binNatToN as) (binNatToN b) | equalityCommutative (additionNIsAssociative (binNatToN as) (binNatToN b) (binNatToN as)) | additionNIsAssociative (binNatToN as +N binNatToN b) (binNatToN as) (binNatToN b) | additionNIsCommutative 0 ((binNatToN as +N binNatToN b) +N (binNatToN as +N binNatToN b)) | additionNIsAssociative (binNatToN as +N binNatToN b) (binNatToN as +N binNatToN b) 0 = transitivity (doubleIsBitShift (binNatToN as +N binNatToN b) (identityOfIndiscernablesRight _ _ _ _<N_ 0< (additionNIsCommutative (binNatToN b) _))) (applyEquality (zero ::_) (+BIsInherited as b (canonicalDescends as prA) (canonicalDescends b prB)))
+... | 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)
 +BIsInherited (zero :: as) (zero :: b) prA prB | inr p | as=0 ,, b=0 rewrite as=0 | b=0 = exFalso ans
@@ -93,9 +94,9 @@ _+B_ : BinNat → BinNat → BinNat
     ans with inspect (canonical b)
     ans | [] with≡ x rewrite x = nono prB
     ans | (x₁ :: y) with≡ x = nono (transitivity (equalityCommutative x) (transitivity (equalityCommutative t) u))
-+BIsInherited (zero :: as) (one :: b) prA prB rewrite additionNIsCommutative (binNatToN as +N (binNatToN as +N zero)) (succ (binNatToN b +N (binNatToN b +N zero))) | additionNIsCommutative (binNatToN b +N (binNatToN b +N zero)) (binNatToN as +N (binNatToN as +N zero)) | equalityCommutative (productDistributes 2 (binNatToN as) (binNatToN b)) = +BinheritLemma as b (canonicalDescends as prA) (canonicalDescends b prB)
-+BIsInherited (one :: as) (zero :: bs) prA prB rewrite equalityCommutative (productDistributes 2 (binNatToN as) (binNatToN bs)) = +BinheritLemma as bs (canonicalDescends as prA) (canonicalDescends bs prB)
-+BIsInherited (one :: as) (one :: bs) prA prB rewrite additionNIsCommutative (binNatToN as +N (binNatToN as +N zero)) (succ (binNatToN bs +N (binNatToN bs +N zero))) | additionNIsCommutative (binNatToN bs +N (binNatToN bs +N zero)) (2 *N binNatToN as) | equalityCommutative (productDistributes 2 (binNatToN as) (binNatToN bs)) | +BinheritLemma as bs (canonicalDescends as prA) (canonicalDescends bs prB) = refl
++BIsInherited (zero :: as) (one :: b) prA prB rewrite Semiring.commutative ℕSemiring (binNatToN as +N (binNatToN as +N zero)) (succ (binNatToN b +N (binNatToN b +N zero))) | Semiring.commutative ℕSemiring (binNatToN b +N (binNatToN b +N zero)) (binNatToN as +N (binNatToN as +N zero)) | equalityCommutative (Semiring.+DistributesOver* ℕSemiring 2 (binNatToN as) (binNatToN b)) = +BinheritLemma as b (canonicalDescends as prA) (canonicalDescends b prB)
++BIsInherited (one :: as) (zero :: bs) prA prB rewrite equalityCommutative (Semiring.+DistributesOver* ℕSemiring 2 (binNatToN as) (binNatToN bs)) = +BinheritLemma as bs (canonicalDescends as prA) (canonicalDescends bs prB)
++BIsInherited (one :: as) (one :: bs) prA prB rewrite Semiring.commutative ℕSemiring (binNatToN as +N (binNatToN as +N zero)) (succ (binNatToN bs +N (binNatToN bs +N zero))) | Semiring.commutative ℕSemiring (binNatToN bs +N (binNatToN bs +N zero)) (2 *N binNatToN as) | equalityCommutative (Semiring.+DistributesOver* ℕSemiring 2 (binNatToN as) (binNatToN bs)) | +BinheritLemma as bs (canonicalDescends as prA) (canonicalDescends bs prB) = refl
 
 +BIsInherited'[] : (b : BinNat) → [] +Binherit b ≡ canonical ([] +B b)
 +BIsInherited'[] [] = refl
@@ -126,7 +127,7 @@ _+B_ : BinNat → BinNat → BinNat
 +BIsInherited' [] b = +BIsInherited'[] b
 +BIsInherited' (zero :: a) [] with inspect (binNatToN a)
 +BIsInherited' (zero :: a) [] | zero with≡ x rewrite x | binNatToNZero a x = refl
-+BIsInherited' (zero :: a) [] | succ y with≡ x rewrite x | additionNIsCommutative (y +N succ (y +N 0)) 0 = transitivity (doubleIsBitShift' y) (transitivity (applyEquality (λ i → (zero :: NToBinNat i)) (equalityCommutative x)) (transitivity (applyEquality (λ i → zero :: i) (binToBin a)) (canonicalAscends' {zero} a bad)))
++BIsInherited' (zero :: a) [] | succ y with≡ x rewrite x | Semiring.commutative ℕSemiring (y +N succ (y +N 0)) 0 = transitivity (doubleIsBitShift' y) (transitivity (applyEquality (λ i → (zero :: NToBinNat i)) (equalityCommutative x)) (transitivity (applyEquality (λ i → zero :: i) (binToBin a)) (canonicalAscends' {zero} a bad)))
   where
     bad : canonical a ≡ [] → False
     bad pr with transitivity (equalityCommutative x) (transitivity (equalityCommutative (binNatToNIsCanonical a)) (applyEquality binNatToN pr))
@@ -136,8 +137,8 @@ _+B_ : BinNat → BinNat → BinNat
 +BIsInherited' (one :: a) [] | succ n with≡ x rewrite x | doubleIsBitShift' n = applyEquality incr {_} {zero :: canonical a} (transitivity {x = _} {NToBinNat (2 *N succ n)} bl (transitivity (doubleIsBitShift' n) (applyEquality (zero ::_) (transitivity (applyEquality NToBinNat (equalityCommutative x)) (binToBin a)))))
   where
     bl : incr (NToBinNat ((n +N succ (n +N 0)) +N 0)) ≡ NToBinNat (succ (n +N succ (n +N 0)))
-    bl rewrite equalityCommutative x | additionNIsCommutative (n +N succ (n +N 0)) 0 = refl
-+BIsInherited' (zero :: as) (zero :: bs) rewrite equalityCommutative (productDistributes 2 (binNatToN as) (binNatToN bs)) = ans
+    bl rewrite equalityCommutative x | Semiring.commutative ℕSemiring (n +N succ (n +N 0)) 0 = refl
++BIsInherited' (zero :: as) (zero :: bs) rewrite equalityCommutative (Semiring.+DistributesOver* ℕSemiring 2 (binNatToN as) (binNatToN bs)) = ans
   where
     ans : NToBinNat (2 *N (binNatToN as +N binNatToN bs)) ≡ canonical (zero :: (as +B bs))
     ans with inspect (binNatToN as +N binNatToN bs)
@@ -157,7 +158,7 @@ _+B_ : BinNat → BinNat → BinNat
         u rewrite equalityCommutative (binNatToNIsCanonical (as +B bs)) | equalityCommutative (+BIsInherited' as bs) | x | nToN (succ y) = succIsPositive y
         ans2 : zero :: NToBinNat (binNatToN as +N binNatToN bs) ≡ canonical (zero :: (as +B bs))
         ans2 rewrite +BIsInherited' as bs = canonicalAscends (as +B bs) u
-+BIsInherited' (zero :: as) (one :: bs) rewrite additionNIsCommutative (2 *N binNatToN as) (succ (2 *N binNatToN bs)) | additionNIsCommutative (2 *N binNatToN bs) (2 *N binNatToN as) | equalityCommutative (productDistributes 2 (binNatToN as) (binNatToN bs)) = ans2
++BIsInherited' (zero :: as) (one :: bs) rewrite Semiring.commutative ℕSemiring (2 *N binNatToN as) (succ (2 *N binNatToN bs)) | Semiring.commutative ℕSemiring (2 *N binNatToN bs) (2 *N binNatToN as) | equalityCommutative (Semiring.+DistributesOver* ℕSemiring 2 (binNatToN as) (binNatToN bs)) = ans2
   where
     ans2 : incr (NToBinNat (2 *N (binNatToN as +N binNatToN bs))) ≡ one :: canonical (as +B bs)
     ans2 with inspect (binNatToN as +N binNatToN bs)
@@ -167,7 +168,7 @@ _+B_ : BinNat → BinNat → BinNat
         t : [] ≡ as +Binherit bs
         t rewrite as=0 | bs=0 = refl
     ans2 | succ y with≡ x rewrite x | doubleIsBitShift' y = applyEquality (one ::_) (transitivity (applyEquality NToBinNat (equalityCommutative x)) (+BIsInherited' as bs))
-+BIsInherited' (one :: as) (zero :: bs) rewrite equalityCommutative (productDistributes 2 (binNatToN as) (binNatToN bs)) = ans
++BIsInherited' (one :: as) (zero :: bs) rewrite equalityCommutative (Semiring.+DistributesOver* ℕSemiring 2 (binNatToN as) (binNatToN bs)) = ans
   where
     ans : incr (NToBinNat (2 *N (binNatToN as +N binNatToN bs))) ≡ one :: canonical (as +B bs)
     ans with inspect (binNatToN as +N binNatToN bs)
@@ -177,7 +178,7 @@ _+B_ : BinNat → BinNat → BinNat
         t : [] ≡ NToBinNat (binNatToN as +N binNatToN bs)
         t rewrite as=0 | bs=0 = refl
     ans | succ y with≡ x rewrite x | doubleIsBitShift' y = applyEquality (one ::_) (transitivity (applyEquality NToBinNat (equalityCommutative x)) (+BIsInherited' as bs))
-+BIsInherited' (one :: as) (one :: bs) rewrite additionNIsCommutative (2 *N binNatToN as) (succ (2 *N binNatToN bs)) | additionNIsCommutative (2 *N binNatToN bs) (2 *N binNatToN as) | equalityCommutative (productDistributes 2 (binNatToN as) (binNatToN bs)) = ans
++BIsInherited' (one :: as) (one :: bs) rewrite Semiring.commutative ℕSemiring (2 *N binNatToN as) (succ (2 *N binNatToN bs)) | Semiring.commutative ℕSemiring (2 *N binNatToN bs) (2 *N binNatToN as) | equalityCommutative (Semiring.+DistributesOver* ℕSemiring 2 (binNatToN as) (binNatToN bs)) = ans
   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)
diff --git a/Numbers/BinaryNaturals/Definition.agda b/Numbers/BinaryNaturals/Definition.agda
index 763b185..624da8e 100644
--- a/Numbers/BinaryNaturals/Definition.agda
+++ b/Numbers/BinaryNaturals/Definition.agda
@@ -3,8 +3,11 @@
 open import LogicalFormulae
 open import Functions
 open import Lists.Lists
-open import Numbers.Naturals
-open import Groups.GroupDefinition
+open import Numbers.Naturals.Naturals
+open import Numbers.Naturals.Definition
+open import Groups.Definition
+open import Semirings.Definition
+open import Orders
 
 module Numbers.BinaryNaturals.Definition where
 
@@ -140,7 +143,7 @@ module Numbers.BinaryNaturals.Definition where
   doubleIsBitShift' : (a : ℕ) → NToBinNat (2 *N succ a) ≡ zero :: NToBinNat (succ a)
   doubleIsBitShift' zero = refl
   doubleIsBitShift' (succ a) with doubleIsBitShift' a
-  ... | bl rewrite additionNIsCommutative a (succ (succ (a +N 0))) | additionNIsCommutative (succ (a +N 0)) a | additionNIsCommutative a (succ (a +N 0)) | additionNIsCommutative (a +N 0) a | bl = refl
+  ... | bl rewrite Semiring.commutative ℕSemiring a (succ (succ (a +N 0))) | Semiring.commutative ℕSemiring (succ (a +N 0)) a | Semiring.commutative ℕSemiring a (succ (a +N 0)) | Semiring.commutative ℕSemiring (a +N 0) a | bl = refl
 
   doubleIsBitShift : (a : ℕ) → (0 <N a) → NToBinNat (2 *N a) ≡ zero :: NToBinNat a
   doubleIsBitShift zero ()
@@ -249,9 +252,9 @@ module Numbers.BinaryNaturals.Definition where
   doubleInj (succ a) (succ b) pr = applyEquality succ (doubleInj a b u)
     where
       t : a +N a ≡ b +N b
-      t rewrite additionNIsCommutative (succ a) 0 | additionNIsCommutative (succ b) 0 | additionNIsCommutative a (succ a) | additionNIsCommutative b (succ b) = succInjective (succInjective pr)
+      t rewrite Semiring.commutative ℕSemiring (succ a) 0 | Semiring.commutative ℕSemiring (succ b) 0 | Semiring.commutative ℕSemiring a (succ a) | Semiring.commutative ℕSemiring b (succ b) = succInjective (succInjective pr)
       u : a +N (a +N zero) ≡ b +N (b +N zero)
-      u rewrite additionNIsCommutative a 0 | additionNIsCommutative b 0 = t
+      u rewrite Semiring.commutative ℕSemiring a 0 | Semiring.commutative ℕSemiring b 0 = t
 
   binNatToNZero [] pr = refl
   binNatToNZero (zero :: xs) pr with inspect (canonical xs)
@@ -264,7 +267,7 @@ module Numbers.BinaryNaturals.Definition where
 
   binNatToNSucc [] = refl
   binNatToNSucc (zero :: n) = refl
-  binNatToNSucc (one :: n) rewrite additionNIsCommutative (binNatToN n) zero | additionNIsCommutative (binNatToN (incr n)) 0 | binNatToNSucc n = applyEquality succ (additionNIsCommutative (binNatToN n) (succ (binNatToN n)))
+  binNatToNSucc (one :: n) rewrite Semiring.commutative ℕSemiring (binNatToN n) zero | Semiring.commutative ℕSemiring (binNatToN (incr n)) 0 | binNatToNSucc n = applyEquality succ (Semiring.commutative ℕSemiring (binNatToN n) (succ (binNatToN n)))
 
   incrNonzero (one :: xs) pr with inspect (canonical (incr xs))
   incrNonzero (one :: xs) pr | [] with≡ x = incrNonzero xs x
@@ -282,11 +285,11 @@ module Numbers.BinaryNaturals.Definition where
       ans rewrite t | pr = refl
   nToN (succ x) | (bit :: xs) with≡ pr = transitivity (binNatToNSucc (NToBinNat x)) (applyEquality succ (nToN x))
 
-  parity zero (succ b) pr rewrite additionNIsCommutative b (succ (b +N 0)) = bad pr
+  parity zero (succ b) pr rewrite Semiring.commutative ℕSemiring b (succ (b +N 0)) = bad pr
     where
       bad : (1 ≡ succ (succ ((b +N 0) +N b))) → False
       bad ()
-  parity (succ a) (succ b) pr rewrite additionNIsCommutative b (succ (b +N 0)) | additionNIsCommutative a (succ (a +N 0)) | additionNIsCommutative (a +N 0) a | additionNIsCommutative (b +N 0) b = parity a b (succInjective (succInjective pr))
+  parity (succ a) (succ b) pr rewrite Semiring.commutative ℕSemiring b (succ (b +N 0)) | Semiring.commutative ℕSemiring a (succ (a +N 0)) | Semiring.commutative ℕSemiring (a +N 0) a | Semiring.commutative ℕSemiring (b +N 0) b = parity a b (succInjective (succInjective pr))
 
   binNatToNZero' [] pr = refl
   binNatToNZero' (zero :: xs) pr with inspect (canonical xs)
@@ -311,13 +314,13 @@ module Numbers.BinaryNaturals.Definition where
       v with inspect (binNatToN a)
       v | zero with≡ x = x
       v | succ a' with≡ x with inspect (binNatToN (zero :: a))
-      v | succ a' with≡ x | zero with≡ pr2 rewrite pr2 = exFalso (lessIrreflexive 0<a)
-      v | succ a' with≡ x | succ y with≡ pr2 rewrite u = exFalso (lessIrreflexive 0<a)
+      v | succ a' with≡ x | zero with≡ pr2 rewrite pr2 = exFalso (TotalOrder.irreflexive ℕTotalOrder 0<a)
+      v | succ a' with≡ x | succ y with≡ pr2 rewrite u = exFalso (TotalOrder.irreflexive ℕTotalOrder 0<a)
       t : 0 <N binNatToN a
       t with binNatToN a
-      t | succ bl rewrite additionNIsCommutative (succ bl) 0 = succIsPositive bl
+      t | succ bl rewrite Semiring.commutative ℕSemiring (succ bl) 0 = succIsPositive bl
       contr'' : (x : ℕ) → (0 <N x) → (x ≡ 0) → False
-      contr'' x 0<x x=0 rewrite x=0 = lessIrreflexive 0<x
+      contr'' x 0<x x=0 rewrite x=0 = TotalOrder.irreflexive ℕTotalOrder 0<x
   canonicalAscends {zero} a 0<a | (x₁ :: y) with≡ x rewrite x = refl
   canonicalAscends {one} a 0<a = refl
 
diff --git a/Numbers/BinaryNaturals/Multiplication.agda b/Numbers/BinaryNaturals/Multiplication.agda
index cdb97eb..b7e0f39 100644
--- a/Numbers/BinaryNaturals/Multiplication.agda
+++ b/Numbers/BinaryNaturals/Multiplication.agda
@@ -3,10 +3,11 @@
 open import LogicalFormulae
 open import Functions
 open import Lists.Lists
-open import Numbers.Naturals
-open import Groups.GroupDefinition
+open import Numbers.Naturals.Naturals
+open import Groups.Definition
 open import Numbers.BinaryNaturals.Definition
 open import Numbers.BinaryNaturals.Addition
+open import Semirings.Definition
 
 module Numbers.BinaryNaturals.Multiplication where
 
@@ -92,7 +93,7 @@ module Numbers.BinaryNaturals.Multiplication where
   binNatToNDistributesPlus a b = transitivity (equalityCommutative (binNatToNIsCanonical (a +B b))) (transitivity (applyEquality binNatToN (equalityCommutative (+BIsInherited' a b))) (nToN (binNatToN a +N binNatToN b)))
 
   +BAssociative : (a b c : BinNat) → canonical (a +B (b +B c)) ≡ canonical ((a +B b) +B c)
-  +BAssociative a b c rewrite equalityCommutative (+BIsInherited' a (b +B c)) | equalityCommutative (+BIsInherited' (a +B b) c) | binNatToNDistributesPlus a b | binNatToNDistributesPlus b c | additionNIsAssociative (binNatToN a) (binNatToN b) (binNatToN c) = refl
+  +BAssociative a b c rewrite equalityCommutative (+BIsInherited' a (b +B c)) | equalityCommutative (+BIsInherited' (a +B b) c) | binNatToNDistributesPlus a b | binNatToNDistributesPlus b c | equalityCommutative (Semiring.+Associative ℕSemiring (binNatToN a) (binNatToN b) (binNatToN c)) = refl
 
   timesOne : (a b : BinNat) → (canonical b) ≡ (one :: []) → canonical (a *B b) ≡ canonical a
   timesOne [] b pr = refl
@@ -173,7 +174,7 @@ module Numbers.BinaryNaturals.Multiplication where
     where
       ans : (a b : BinNat) → binNatToN a *N binNatToN b ≡ binNatToN (a *B b)
       ans [] b = refl
-      ans (zero :: a) b rewrite equalityCommutative (ans a b) = equalityCommutative (multiplicationNIsAssociative 2 (binNatToN a) (binNatToN b))
-      ans (one :: a) b rewrite binNatToNDistributesPlus (zero :: (a *B b)) b | additionNIsCommutative (binNatToN b) ((2 *N (binNatToN a)) *N (binNatToN b)) | equalityCommutative (ans a b) = applyEquality (_+N binNatToN b) (equalityCommutative (multiplicationNIsAssociative 2 (binNatToN a) (binNatToN b)))
+      ans (zero :: a) b rewrite equalityCommutative (ans a b) = equalityCommutative (Semiring.*Associative ℕSemiring 2 (binNatToN a) (binNatToN b))
+      ans (one :: a) b rewrite binNatToNDistributesPlus (zero :: (a *B b)) b | Semiring.commutative ℕSemiring (binNatToN b) ((2 *N (binNatToN a)) *N (binNatToN b)) | equalityCommutative (ans a b) = applyEquality (_+N binNatToN b) (equalityCommutative (Semiring.*Associative ℕSemiring 2 (binNatToN a) (binNatToN b)))
       t : (binNatToN a *N binNatToN b) ≡ binNatToN (canonical (a *B b))
       t = transitivity (ans a b) (equalityCommutative (binNatToNIsCanonical (a *B b)))
diff --git a/Numbers/BinaryNaturals/Order.agda b/Numbers/BinaryNaturals/Order.agda
index 99e3e50..ae9c43c 100644
--- a/Numbers/BinaryNaturals/Order.agda
+++ b/Numbers/BinaryNaturals/Order.agda
@@ -3,10 +3,11 @@
 open import LogicalFormulae
 open import Functions
 open import Lists.Lists
-open import Numbers.Naturals
-open import Groups.GroupDefinition
+open import Numbers.Naturals.Naturals
+open import Groups.Definition
 open import Numbers.BinaryNaturals.Definition
 open import Orders
+open import Semirings.Definition
 
 module Numbers.BinaryNaturals.Order where
 
@@ -278,7 +279,7 @@ module Numbers.BinaryNaturals.Order where
   chopDouble a b i | inr a=b | inr x = refl
 
   succNotLess : {n : ℕ} → succ n <N n → False
-  succNotLess {succ n} (le x proof) = succNotLess {n} (le x (succInjective (transitivity (applyEquality succ (transitivity (additionNIsCommutative (succ x) (succ n)) (transitivity (applyEquality succ (transitivity (additionNIsCommutative n (succ x)) (applyEquality succ (additionNIsCommutative x n)))) (additionNIsCommutative (succ (succ n)) x)))) proof)))
+  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)
diff --git a/Numbers/Integers.agda b/Numbers/Integers.agda
index b23174c..e274d23 100644
--- a/Numbers/Integers.agda
+++ b/Numbers/Integers.agda
@@ -1,1569 +1,1574 @@
 {-# OPTIONS --safe --warning=error #-}
 
 open import LogicalFormulae
-open import Numbers.Naturals
-open import Numbers.NaturalsWithK -- TODO: remove this dependency, it's baked into ZSimple
+open import Numbers.Naturals.Naturals
+open import Numbers.Naturals.Order -- TODO: remove dependencies on everything other than Naturals.Naturals
+open import Numbers.Naturals.Definition
+open import Numbers.Naturals.Addition
+open import Numbers.Naturals.WithK -- TODO: remove this dependency, it's baked into ZSimple
 open import Groups.Groups
-open import Groups.GroupDefinition
+open import Groups.Definition
 open import Rings.Definition
 open import Functions
 open import Orders
 open import Setoids.Setoids
 open import Setoids.Orders
 open import Rings.IntegralDomains
+open import Semirings.Definition
 
 module Numbers.Integers where
-    data ℤ : Set where
-      nonneg : ℕ → ℤ
-      negSucc : ℕ → ℤ
-
-    data ℤSimple : Set where
-      negative : (a : ℕ) → (0 <N a) → ℤSimple
-      positive : (a : ℕ) → (0 <N a) → ℤSimple
-      zZero : ℤSimple
-
-    convertZ : ℤ → ℤSimple
-    convertZ (nonneg zero) = zZero
-    convertZ (nonneg (succ x)) = positive (succ x) (succIsPositive x)
-    convertZ (negSucc x) = negative (succ x) (succIsPositive x)
-
-    convertZ' : ℤSimple → ℤ
-    convertZ' (negative zero (le x ()))
-    convertZ' (negative (succ a) x) = negSucc a
-    convertZ' (positive a x) = nonneg a
-    convertZ' zZero = nonneg zero
-
-    zIsZ : (a : ℤ) → convertZ' (convertZ a) ≡ a
-    zIsZ (nonneg zero) = refl
-    zIsZ (nonneg (succ x)) = refl
-    zIsZ (negSucc x) = refl
-
-    zIsZ' : (a : ℤSimple) → convertZ (convertZ' a) ≡ a
-    zIsZ' (negative zero (le x ()))
-    zIsZ' (negative (succ a) x) = help
-      where
-        eq : (succIsPositive a) ≡ x
-        eq = <NRefl {0} {succ a} (succIsPositive a) x
-        help : negative (succ a) (succIsPositive a) ≡ negative (succ a) x
-        help rewrite eq = refl
-    zIsZ' (positive zero (le x ()))
-    zIsZ' (positive (succ a) x) = help
-      where
-        eq : (succIsPositive a) ≡ x
-        eq = <NRefl {0} {succ a} (succIsPositive a) x
-        help : positive (succ a) (succIsPositive a) ≡ positive (succ a) x
-        help rewrite eq = refl
-    zIsZ' zZero = refl
-
-    posIsPos : {a : ℕ} → (pr1 pr2 : 0 <N a) → (positive a pr1 ≡ positive a pr2)
-    posIsPos {a} pr1 pr2 rewrite <NRefl pr1 pr2 = refl
-
-    negIsNeg : {a : ℕ} → (pr1 pr2 : 0 <N a) → (negative a pr1 ≡ negative a pr2)
-    negIsNeg {a} pr1 pr2 rewrite <NRefl pr1 pr2 = refl
-
-    infix 15 _+Z_
-    _+Z_ : ℤ → ℤ → ℤ
-    nonneg zero +Z r = r
-    nonneg (succ x) +Z nonneg y = nonneg (succ x +N y)
-    nonneg (succ x) +Z negSucc zero = nonneg x
-    nonneg (succ x) +Z negSucc (succ a) = nonneg x +Z negSucc a
-    negSucc a +Z nonneg zero = negSucc a
-    negSucc zero +Z nonneg (succ x) = nonneg x
-    negSucc (succ a) +Z nonneg (succ x) = negSucc a +Z nonneg x
-    negSucc zero +Z negSucc b = negSucc (succ b)
-    negSucc (succ a) +Z negSucc b = negSucc (succ a +N succ b)
-
-    depth : ℤSimple → ℕ
-    depth (negative a x) = a
-    depth (positive a x) = a
-    depth zZero = 0
-
-    plusZ' : (height : ℕ) → (a : ℤSimple) → (b : ℤSimple) → (depth a +N depth b ≡ height) → ℤSimple
-    plusZ' zero (negative zero (le x ())) (negative a₁ x₁) pr
-    plusZ' zero (negative (succ a) (le x proof)) (negative a₁ x₁) pr = naughtE (equalityCommutative pr)
-    plusZ' zero (negative zero (le x ())) (positive a₁ x₁) pr
-    plusZ' zero (negative (succ a) (le x proof)) (positive a₁ x₁) pr = naughtE (equalityCommutative pr)
-    plusZ' zero (negative zero (le x ())) zZero pr
-    plusZ' zero (negative (succ a) (le x proof)) zZero pr = naughtE (equalityCommutative pr)
-    plusZ' zero (positive zero (le x ())) b pr
-    plusZ' zero (positive (succ a) x) b pr = naughtE (equalityCommutative pr)
-    plusZ' zero zZero (negative zero (le x ())) pr
-    plusZ' zero zZero (negative (succ a) x) pr = naughtE (equalityCommutative pr)
-    plusZ' zero zZero (positive zero (le x ())) pr
-    plusZ' zero zZero (positive (succ a) x) pr = naughtE (equalityCommutative pr)
-    plusZ' zero zZero zZero pr = zZero
-    plusZ' (succ height) (negative zero (le x ())) b pr
-    plusZ' (succ height) (negative (succ a) _) (negative zero (le x ())) pr
-    plusZ' (succ height) (negative (succ a) _) (negative (succ b) _) pr = negative (succ a +N succ b) (succIsPositive _)
-    plusZ' (succ height) (negative (succ a) _) (positive zero (le x ())) pr
-    plusZ' (succ height) (negative (succ zero) _) (positive (succ zero) _) pr = zZero
-    plusZ' (succ height) (negative (succ zero) _) (positive (succ (succ b)) _) pr = positive (succ b) (succIsPositive b)
-    plusZ' (succ height) (negative (succ (succ a)) _) (positive (succ zero) x) pr = negative (succ a) (succIsPositive a)
-    plusZ' (succ zero) (negative (succ (succ a)) _) (positive (succ (succ b)) x) pr = naughtE (equalityCommutative (succInjective pr))
-    plusZ' (succ (succ height)) (negative (succ (succ a)) _) (positive (succ (succ b)) x) pr = plusZ' height (negative (succ a) (succIsPositive _)) (positive (succ b) (succIsPositive _)) ans
-      where
-        h : a +N succ (succ b) ≡ height
-        h = succInjective (succInjective pr)
-        ans : succ (a +N succ b) ≡ height
-        ans rewrite additionNIsCommutative a (succ b) | additionNIsCommutative (succ (succ b)) a = h
-    plusZ' (succ height) (negative (succ a) _) zZero pr = negative (succ a) (succIsPositive a)
-    plusZ' (succ height) (positive zero (le x ())) b pr
-    plusZ' (succ height) (positive (succ a) _) (negative zero (le x ())) pr
-    plusZ' (succ height) (positive (succ zero) _) (negative (succ zero) _) pr = zZero
-    plusZ' (succ height) (positive (succ zero) _) (negative (succ (succ b)) _) pr = negative (succ b) (succIsPositive b)
-    plusZ' (succ height) (positive (succ (succ a)) _) (negative (succ zero) _) pr = positive (succ a) (succIsPositive a)
-    plusZ' (succ zero) (positive (succ (succ a)) _) (negative (succ (succ b)) _) pr = naughtE (equalityCommutative (succInjective pr))
-    plusZ' (succ (succ height)) (positive (succ (succ a)) _) (negative (succ (succ b)) _) pr = plusZ' height (positive (succ a) (succIsPositive a)) (negative (succ b) (succIsPositive b)) ans
-      where
-        h : a +N succ (succ b) ≡ height
-        h = succInjective (succInjective pr)
-        ans : succ (a +N succ b) ≡ height
-        ans rewrite additionNIsCommutative a (succ b) | additionNIsCommutative (succ (succ b)) a = h
-    plusZ' (succ height) (positive (succ a) _) (positive b x) pr = positive (succ a +N b) (succIsPositive (a +N b))
-    plusZ' (succ height) (positive (succ a) _) zZero pr = positive (succ a) (succIsPositive a)
-    plusZ' (succ height) zZero b pr = b
-
-    infix 15 _+Z'_
-    _+Z'_ : ℤSimple → ℤSimple → ℤSimple
-    a +Z' b = plusZ' (depth a +N depth b) a b refl
-
-    castPlusZ' : {de1 de2 : ℕ} → (r s : ℤSimple) → {pr : depth r +N depth s ≡ de1} → {pr2 : depth r +N depth s ≡ de2} → de1 ≡ de2 → plusZ' de1 r s pr ≡ plusZ' de2 r s pr2
-    castPlusZ' {.(depth r +N depth s)} {.(depth r +N depth s)} (r) (s) {refl} {refl} de1=de2 = refl
-
-    canKnockOneOff+Z'' : (a b : ℕ) → {pr1 : 0 <N a} → {pr2 : 0 <N b} → {pr3 : 0 <N succ a} → {pr4 : 0 <N succ b} → plusZ' (succ a +N succ b) (positive (succ a) pr3) (negative (succ b) pr4) refl ≡ (plusZ' (a +N b) (positive a pr1) (negative b pr2) refl)
-    canKnockOneOff+Z'' zero b {le x ()} {pr2}
-    canKnockOneOff+Z'' (succ a) zero {pr1} {le x ()}
-    canKnockOneOff+Z'' (succ a) (succ b) {pr1} {pr2} {pr3} {pr4} rewrite <NRefl (succIsPositive a) pr1 | <NRefl (succIsPositive b) pr2 = castPlusZ' {a +N succ (succ b)} {succ (a +N succ b)} (positive (succ a) pr1) (negative (succ b) pr2) help
-      where
-        help : a +N (succ (succ b)) ≡ succ (a +N succ b)
-        help rewrite additionNIsCommutative a (succ (succ b)) | additionNIsCommutative (succ b) a = refl
-
-    canKnockOneOff+Z''2 : (a b : ℕ) → {pr1 : 0 <N a} → {pr2 : 0 <N b} → {pr3 : 0 <N succ a} → {pr4 : 0 <N succ b} → plusZ' (succ a +N succ b) (negative (succ a) pr3) (positive (succ b) pr4) refl ≡ (plusZ' (a +N b) (negative a pr1) (positive b pr2) refl)
-    canKnockOneOff+Z''2 zero b {le x ()} {pr2}
-    canKnockOneOff+Z''2 (succ a) zero {pr1} {le x ()}
-    canKnockOneOff+Z''2 (succ a) (succ b) {pr1} {pr2} {pr3} {pr4} rewrite <NRefl (succIsPositive a) pr1 | <NRefl (succIsPositive b) pr2 = castPlusZ' {a +N succ (succ b)} {succ (a +N succ b)} (negative (succ a) pr1) (positive (succ b) pr2) help
-      where
-        help : a +N (succ (succ b)) ≡ succ (a +N succ b)
-        help rewrite additionNIsCommutative a (succ (succ b)) | additionNIsCommutative (succ b) a = refl
-
-    lemma' : (x y : ℕ) → succ (x +N succ y) ≡ x +N succ (succ y)
-    lemma' x y = equalityCommutative (succExtracts x (succ y))
-
-    helpPlusIsPlus' : (x y : ℕ) → (pr' : _) → negative (succ x) (succIsPositive x) +Z' positive (succ y) (succIsPositive y) ≡ plusZ' (x +N succ (succ y)) (negative (succ x) (logical<NImpliesLe (record {}))) (positive (succ y) (logical<NImpliesLe (record {}))) pr'
-    helpPlusIsPlus' x y pr = castPlusZ' {succ x +N succ y} {x +N succ (succ y)} (negative (succ x) (succIsPositive x)) (positive (succ y) (succIsPositive y)) {refl} {pr} pr
-
-    helpPlusIsPlus'2 : (x y : ℕ) → (pr' : _) → positive (succ x) (succIsPositive x) +Z' negative (succ y) (succIsPositive y) ≡ plusZ' (succ (x +N succ y)) (positive (succ x) (logical<NImpliesLe (record {}))) (negative (succ y) (logical<NImpliesLe (record {}))) pr'
-    helpPlusIsPlus'2 x y pr = castPlusZ' {_} {_} (positive (succ x) (succIsPositive x)) (negative (succ y) (succIsPositive y)) {refl} {pr} pr
-
-    canKnockOneOff+Z' : (a b : ℕ) → {pr1 : 0 <N a} → {pr2 : 0 <N b} → {pr3 : 0 <N succ a} → {pr4 : 0 <N succ b} → (positive (succ a) pr3) +Z' (negative (succ b) pr4) ≡ (positive a pr1) +Z' (negative b pr2)
-    canKnockOneOff+Z' zero b {le x ()} {pr2} {pr3} {pr4}
-    canKnockOneOff+Z' (succ a) zero {pr1} {le x ()} {pr3} {pr4}
-    canKnockOneOff+Z' (succ a) (succ b) {pr1} {pr2} {pr3} {pr4} = canKnockOneOff+Z'' (succ a) (succ b) {pr1} {pr2} {pr3} {pr4}
-
-    canKnockOneOff+Z'2 : (a b : ℕ) → {pr1 : 0 <N a} → {pr2 : 0 <N b} → {pr3 : 0 <N succ a} → {pr4 : 0 <N succ b} → (negative (succ a) pr3) +Z' (positive (succ b) pr4) ≡ (negative a pr1) +Z' (positive b pr2)
-    canKnockOneOff+Z'2 zero b {le x ()} {pr2} {pr3} {pr4}
-    canKnockOneOff+Z'2 (succ a) zero {pr1} {le x ()} {pr3} {pr4}
-    canKnockOneOff+Z'2 (succ a) (succ b) {pr1} {pr2} {pr3} {pr4} = canKnockOneOff+Z''2 (succ a) (succ b) {pr1} {pr2} {pr3} {pr4}
-
-    plusIsPlus' : (a b : ℤ) → convertZ (a +Z b) ≡ (convertZ a) +Z' (convertZ b)
-    plusIsPlus' (nonneg zero) (nonneg zero) = refl
-    plusIsPlus' (nonneg zero) (nonneg (succ x)) = refl
-    plusIsPlus' (nonneg zero) (negSucc x) = refl
-    plusIsPlus' (nonneg (succ x)) (nonneg zero) rewrite additionNIsCommutative x 0 = refl
-    plusIsPlus' (nonneg (succ x)) (nonneg (succ y)) = refl
-    plusIsPlus' (nonneg (succ zero)) (negSucc zero) = refl
-    plusIsPlus' (nonneg (succ (succ x))) (negSucc zero) = refl
-    plusIsPlus' (nonneg (succ zero)) (negSucc (succ y)) = refl
-    plusIsPlus' (nonneg (succ (succ x))) (negSucc (succ y)) rewrite canKnockOneOff+Z' (succ x) (succ y) {succIsPositive x} {succIsPositive y} {succIsPositive (succ x)} {succIsPositive (succ y)} = identityOfIndiscernablesRight _ _ _ _≡_ (plusIsPlus' (nonneg (succ x)) (negSucc y)) (helpPlusIsPlus'2 x y _)
-    plusIsPlus' (negSucc x) (nonneg zero) = refl
-    plusIsPlus' (negSucc zero) (nonneg (succ zero)) = refl
-    plusIsPlus' (negSucc zero) (nonneg (succ (succ y))) = refl
-    plusIsPlus' (negSucc (succ x)) (nonneg (succ zero)) = refl
-    plusIsPlus' (negSucc (succ x)) (nonneg (succ (succ y))) rewrite equalityCommutative (canKnockOneOff+Z' (succ x) (succ y) {succIsPositive x} {succIsPositive y} {succIsPositive (succ x)} {succIsPositive (succ y)}) = identityOfIndiscernablesRight (convertZ (negSucc x +Z nonneg (succ y))) (negative (succ x) (succIsPositive x) +Z' positive (succ y) (succIsPositive y)) _ _≡_ (plusIsPlus' (negSucc x) (nonneg (succ y))) (helpPlusIsPlus' x y _)
-    plusIsPlus' (negSucc zero) (negSucc zero) = refl
-    plusIsPlus' (negSucc zero) (negSucc (succ y)) = refl
-    plusIsPlus' (negSucc (succ x)) (negSucc y) = refl
-
-    plusIsPlusFirstPos : (a : ℕ) (pr1 : 0 <N a) → (b : ℤSimple) → convertZ' ((positive a pr1) +Z' b) ≡ (convertZ' (positive a pr1)) +Z (convertZ' b)
-    plusIsPlusFirstPos zero (le x ()) b
-    plusIsPlusFirstPos (succ zero) pr1 (negative zero (le x ()))
-    plusIsPlusFirstPos (succ zero) pr1 (negative (succ zero) x) = refl
-    plusIsPlusFirstPos (succ zero) pr1 (negative (succ (succ b)) x) = refl
-    plusIsPlusFirstPos (succ zero) pr1 (positive b x) = refl
-    plusIsPlusFirstPos (succ zero) pr1 zZero = refl
-    plusIsPlusFirstPos (succ (succ a)) pr1 (negative zero (le x ()))
-    plusIsPlusFirstPos (succ (succ a)) pr1 (negative (succ zero) x) = refl
-    plusIsPlusFirstPos (succ (succ a)) pr1 (negative (succ (succ b)) x) rewrite canKnockOneOff+Z' (succ a) (succ b) {succIsPositive a} {succIsPositive b} {pr1} {x} = plusIsPlusFirstPos (succ a) (logical<NImpliesLe (record {})) (negative (succ b) (logical<NImpliesLe (record {})))
-    plusIsPlusFirstPos (succ (succ a)) pr1 (positive zero (le x ()))
-    plusIsPlusFirstPos (succ (succ a)) pr1 (positive (succ zero) x) = refl
-    plusIsPlusFirstPos (succ (succ a)) pr1 (positive (succ (succ b)) x) = refl
-    plusIsPlusFirstPos (succ (succ a)) pr1 zZero rewrite additionNIsCommutative a 0 = refl
-
-    plusIsPlusFirstNeg : (a : ℕ) (pr1 : 0 <N a) → (b : ℤSimple) → convertZ' ((negative a pr1) +Z' b) ≡ (convertZ' (negative a pr1)) +Z (convertZ' b)
-    plusIsPlusFirstNeg zero (le x ()) b
-    plusIsPlusFirstNeg (succ zero) pr (negative zero (le x ()))
-    plusIsPlusFirstNeg (succ zero) pr (negative (succ a) x) = refl
-    plusIsPlusFirstNeg (succ zero) pr (positive zero (le x ()))
-    plusIsPlusFirstNeg (succ zero) pr (positive (succ zero) x) = refl
-    plusIsPlusFirstNeg (succ zero) pr (positive (succ (succ a)) x) = refl
-    plusIsPlusFirstNeg (succ zero) pr zZero = refl
-    plusIsPlusFirstNeg (succ (succ a)) pr (negative zero (le x ()))
-    plusIsPlusFirstNeg (succ (succ a)) pr (negative (succ b) x) = refl
-    plusIsPlusFirstNeg (succ (succ a)) pr (positive zero (le x ()))
-    plusIsPlusFirstNeg (succ (succ a)) pr (positive (succ zero) x) = refl
-    plusIsPlusFirstNeg (succ (succ a)) pr (positive (succ (succ b)) x) rewrite canKnockOneOff+Z'2 (succ a) (succ b) {succIsPositive a} {succIsPositive b} {pr} {x} = plusIsPlusFirstNeg (succ a) (logical<NImpliesLe (record {})) (positive (succ b) (logical<NImpliesLe (record {})))
-    plusIsPlusFirstNeg (succ (succ a)) pr zZero = refl
-
-    plusIsPlus : (a b : ℤSimple) → convertZ' (a +Z' b) ≡ (convertZ' a) +Z (convertZ' b)
-    plusIsPlus (negative a pr) b = plusIsPlusFirstNeg a pr b
-    plusIsPlus (positive a pr) b = plusIsPlusFirstPos a pr b
-    plusIsPlus zZero (negative zero (le x ()))
-    plusIsPlus zZero (negative (succ a) x) = refl
-    plusIsPlus zZero (positive zero (le x ()))
-    plusIsPlus zZero (positive (succ a) x) = refl
-    plusIsPlus zZero zZero = refl
-
-    infix 25 _*Z'_
-    _*Z'_ : ℤSimple → ℤSimple → ℤSimple
-    negative zero (le x ()) *Z' b
-    negative (succ a) x *Z' negative zero (le x₁ ())
-    negative (succ a) x *Z' negative (succ b) prb = positive (succ a *N succ b) (succIsPositive (b +N a *N succ b))
-    negative (succ a) x *Z' positive zero (le x₁ ())
-    negative (succ a) x *Z' positive (succ b) prb = negative (succ a *N succ b) (succIsPositive (b +N a *N succ b))
-    negative (succ a) x *Z' zZero = zZero
-    positive zero (le x ()) *Z' b
-    positive (succ a) x *Z' negative zero (le x₁ ())
-    positive (succ a) x *Z' negative (succ b) prb = negative (succ a *N succ b) (succIsPositive (b +N a *N succ b))
-    positive (succ a) x *Z' positive zero (le x₁ ())
-    positive (succ a) x *Z' positive (succ b) prb = positive (succ a *N succ b) (succIsPositive (b +N a *N succ b))
-    positive (succ a) x *Z' zZero = zZero
-    zZero *Z' b = zZero
-
-    infix 25 _*Z_
-    _*Z_ : ℤ → ℤ → ℤ
-    a *Z b = convertZ' (convertZ a *Z' convertZ b)
-
-    convertZ'DistributesOver*Z : (a b : ℤSimple) → convertZ' (a *Z' b) ≡ (convertZ' a) *Z (convertZ' b)
-    convertZ'DistributesOver*Z (negative zero (le x ())) (negative b prb)
-    convertZ'DistributesOver*Z (negative (succ a) x) (negative zero (le y ()))
-    convertZ'DistributesOver*Z (negative (succ a) x) (negative (succ b) prb) = refl
-    convertZ'DistributesOver*Z (negative zero (le x ())) (positive b prb)
-    convertZ'DistributesOver*Z (negative (succ a) x) (positive zero (le x₁ ()))
-    convertZ'DistributesOver*Z (negative (succ a) x) (positive (succ b) prb) = refl
-    convertZ'DistributesOver*Z (negative zero (le x ())) zZero
-    convertZ'DistributesOver*Z (negative (succ a) x) zZero = refl
-    convertZ'DistributesOver*Z (positive zero (le x ())) b
-    convertZ'DistributesOver*Z (positive (succ a) x) (negative zero (le x₁ ()))
-    convertZ'DistributesOver*Z (positive (succ a) x) (negative (succ b) prb) = refl
-    convertZ'DistributesOver*Z (positive (succ a) x) (positive zero (le x₁ ()))
-    convertZ'DistributesOver*Z (positive (succ a) x) (positive (succ b) prb) = refl
-    convertZ'DistributesOver*Z (positive (succ a) x) zZero = refl
-    convertZ'DistributesOver*Z zZero (negative zero (le x ()))
-    convertZ'DistributesOver*Z zZero (negative (succ a) x) = refl
-    convertZ'DistributesOver*Z zZero (positive zero (le x ()))
-    convertZ'DistributesOver*Z zZero (positive (succ a) x) = refl
-    convertZ'DistributesOver*Z zZero zZero = refl
-
-    infix 5 _<Z_
-    record _<Z_ (a : ℤ) (b : ℤ) : Set where
-      constructor le
-      field
-          x : ℕ
-          proof : (nonneg (succ x)) +Z a ≡ b
-
-    addingNonnegIsHom : (a b : ℕ) → nonneg a +Z nonneg b ≡ nonneg (a +N b)
-    addingNonnegIsHom zero b = refl
-    addingNonnegIsHom (succ a) b = refl
-
-    multiplyingNonnegIsHom : (a b : ℕ) → nonneg a *Z nonneg b ≡ nonneg (a *N b)
-    multiplyingNonnegIsHom zero b = refl
-    multiplyingNonnegIsHom (succ a) zero rewrite multiplicationNIsCommutative a 0 = refl
-    multiplyingNonnegIsHom (succ a) (succ b) = refl
-
-    multiplyWithZero : (a : ℤ) → a *Z nonneg 0 ≡ nonneg 0
-    multiplyWithZero (nonneg zero) rewrite multiplyingNonnegIsHom zero zero = refl
-    multiplyWithZero (nonneg (succ x)) rewrite multiplyingNonnegIsHom (succ x) zero = refl
-    multiplyWithZero (negSucc x) = refl
-
-    multiplyWithZero' : (a : ℤ) → nonneg 0 *Z a ≡ nonneg 0
-    multiplyWithZero' (nonneg x) = refl
-    multiplyWithZero' (negSucc zero) = refl
-    multiplyWithZero' (negSucc (succ x)) = refl
-
-    nonnegInjective : {a b : ℕ} → (nonneg a ≡ nonneg b) → (a ≡ b)
-    nonnegInjective {a} {.a} refl = refl
-
-    lessIsPreservedNToZ : {a b : ℕ} → (a <N b) → ((nonneg a) <Z (nonneg b))
-    _<Z_.x (lessIsPreservedNToZ {a} {b} (le x proof)) = x
-    _<Z_.proof (lessIsPreservedNToZ {a} {.(succ (x +N a))} (le x refl)) = refl
-
-    lessIsPreservedNToZConverse : {a b : ℕ} → ((nonneg a) <Z (nonneg b)) → (a <N b)
-    lessIsPreservedNToZConverse {a} {b} (le x proof) = le x (nonnegInjective proof)
-
-    additionZIsCommutative : (a b : ℤ) → a +Z b ≡ b +Z a
-    additionZIsCommutative (nonneg x) (nonneg y) = splitRight
-      where
-        inN : x +N y ≡ y +N x
-        inN = additionNIsCommutative x y
-        inZ : nonneg (x +N y) ≡ nonneg (y +N x)
-        inZ = applyEquality nonneg inN
-        splitLeft : nonneg x +Z nonneg y ≡ nonneg (y +N x)
-        splitLeft = identityOfIndiscernablesLeft (nonneg (x +N y)) (nonneg (y +N x)) (nonneg x +Z nonneg y) _≡_ inZ (equalityCommutative (addingNonnegIsHom x y))
-        splitRight : nonneg x +Z nonneg y ≡ nonneg y +Z nonneg x
-        splitRight = identityOfIndiscernablesRight (nonneg x +Z nonneg y) (nonneg (y +N x)) (nonneg y +Z nonneg x) _≡_ splitLeft (equalityCommutative (addingNonnegIsHom y x))
-
-    additionZIsCommutative (nonneg zero) (negSucc a) = refl
-    additionZIsCommutative (nonneg (succ x)) (negSucc zero) = refl
-    additionZIsCommutative (nonneg (succ x)) (negSucc (succ a)) = additionZIsCommutative (nonneg x) (negSucc a)
-    additionZIsCommutative (negSucc zero) (nonneg zero) = refl
-    additionZIsCommutative (negSucc (succ a)) (nonneg zero) = refl
-    additionZIsCommutative (negSucc zero) (nonneg (succ x)) = refl
-    additionZIsCommutative (negSucc (succ a)) (nonneg (succ x)) = additionZIsCommutative (negSucc a) (nonneg x)
-    additionZIsCommutative (negSucc zero) (negSucc zero) = refl
-    additionZIsCommutative (negSucc zero) (negSucc (succ b)) = applyEquality negSucc i
-      where
-        h : succ b ≡ b +N succ zero
-        h = succIsAddOne b
-        i : succ (succ b) ≡ succ (b +N succ zero)
-        i = applyEquality succ h
-
-    additionZIsCommutative (negSucc (succ a)) (negSucc zero) = applyEquality negSucc i
-      where
-        i : succ (a +N succ zero) ≡ succ (succ a)
-        i = applyEquality succ (equalityCommutative (succIsAddOne a))
-
-    additionZIsCommutative (negSucc (succ a)) (negSucc (succ b)) = applyEquality negSucc (applyEquality succ j)
-      where
-        m : succ (a +N b) ≡ succ (b +N a)
-        m = applyEquality succ (additionNIsCommutative a b)
-        r : a +N succ b ≡ b +N succ a
-        r = transitivity (succExtracts a b) (transitivity m (equalityCommutative (succExtracts b a)))
-        k : succ (a +N succ b) ≡ succ (b +N succ a)
-        k rewrite additionNIsCommutative a (succ b) | additionNIsCommutative b a | additionNIsCommutative (succ a) b = refl
-        j : a +N succ (succ b) ≡ b +N succ (succ a)
-        j = transitivity (succExtracts a (succ b)) (transitivity k (equalityCommutative (succExtracts b (succ a))))
-
-    additiveInverseExists : (a : ℕ) → (negSucc a +Z nonneg (succ a)) ≡ nonneg 0
-    additiveInverseExists zero = refl
-    additiveInverseExists (succ a) = additiveInverseExists a
-
-    multiplicationZ'IsCommutative : (a b : ℤSimple) → (a *Z' b ≡ b *Z' a)
-    multiplicationZ'IsCommutative (negative zero (le x ())) (negative b prb)
-    multiplicationZ'IsCommutative (negative (succ a) _) (negative zero (le x ()))
-    multiplicationZ'IsCommutative (negative (succ a) x) (negative (succ b) prb) = res (succIsPositive (b +N a *N succ b)) (succIsPositive (a +N b *N succ a))
-      where
-        h : succ a *N succ b ≡ succ b *N succ a
-        h = multiplicationNIsCommutative (succ a) (succ b)
-        res : (pr1 : 0 <N succ b +N a *N succ b) → (pr2 : 0 <N succ a +N b *N succ a) → positive (succ a *N succ b) pr1 ≡ positive (succ b *N succ a) pr2
-        res pr1 pr2 rewrite h = posIsPos pr1 pr2
-    multiplicationZ'IsCommutative (negative zero (le x ())) (positive b prb)
-    multiplicationZ'IsCommutative (negative (succ a) x) (positive zero (le _ ()))
-    multiplicationZ'IsCommutative (negative (succ a) x) (positive (succ b) prb) = res (succIsPositive (b +N a *N succ b)) (succIsPositive (a +N b *N succ a))
-      where
-        h : succ a *N succ b ≡ succ b *N succ a
-        h = multiplicationNIsCommutative (succ a) (succ b)
-        res : (pr1 : 0 <N succ b +N a *N succ b) → (pr2 : 0 <N succ a +N b *N succ a) → negative (succ a *N succ b) pr1 ≡ negative (succ b *N succ a) pr2
-        res pr1 pr2 rewrite h = negIsNeg pr1 pr2
-    multiplicationZ'IsCommutative (negative zero (le x ())) zZero
-    multiplicationZ'IsCommutative (negative (succ a) x) zZero = refl
-    multiplicationZ'IsCommutative (positive zero (le x ())) (negative b prb)
-    multiplicationZ'IsCommutative (positive (succ a) x) (negative zero (le _ ()))
-    multiplicationZ'IsCommutative (positive (succ a) x) (negative (succ b) prb) = res (succIsPositive (b +N a *N succ b)) (succIsPositive (a +N b *N succ a))
-      where
-        h : succ a *N succ b ≡ succ b *N succ a
-        h = multiplicationNIsCommutative (succ a) (succ b)
-        res : (pr1 : 0 <N succ b +N a *N succ b) → (pr2 : 0 <N succ a +N b *N succ a) → negative (succ a *N succ b) pr1 ≡ negative (succ b *N succ a) pr2
-        res pr1 pr2 rewrite h = negIsNeg pr1 pr2
-    multiplicationZ'IsCommutative (positive zero (le x ())) (positive b prb)
-    multiplicationZ'IsCommutative (positive (succ a) x) (positive zero (le x₁ ()))
-    multiplicationZ'IsCommutative (positive (succ a) _) (positive (succ b) _) = res (succIsPositive (b +N a *N succ b)) (succIsPositive (a +N b *N succ a))
-      where
-        h : succ a *N succ b ≡ succ b *N succ a
-        h = multiplicationNIsCommutative (succ a) (succ b)
-        res : (pr1 : 0 <N succ b +N a *N succ b) → (pr2 : 0 <N succ a +N b *N succ a) → positive (succ a *N succ b) pr1 ≡ positive (succ b *N succ a) pr2
-        res pr1 pr2 rewrite h = posIsPos pr1 pr2
-    multiplicationZ'IsCommutative (positive zero (le x ())) zZero
-    multiplicationZ'IsCommutative (positive (succ a) x) zZero = refl
-    multiplicationZ'IsCommutative zZero (negative zero (le x ()))
-    multiplicationZ'IsCommutative zZero (negative (succ a) x) = refl
-    multiplicationZ'IsCommutative zZero (positive zero (le x ()))
-    multiplicationZ'IsCommutative zZero (positive (succ a) x) = refl
-    multiplicationZ'IsCommutative zZero zZero = refl
-
-    multiplicationZIsCommutative : (a b : ℤ) → (a *Z b ≡ b *Z a)
-    multiplicationZIsCommutative a b = res
-      where
-        help : convertZ' (convertZ a *Z' convertZ b) ≡ convertZ' (convertZ b *Z' convertZ a)
-        help = applyEquality convertZ' (multiplicationZ'IsCommutative (convertZ a) (convertZ b))
-        res : a *Z b ≡ b *Z a
-        res rewrite zIsZ a | zIsZ b = help
-
-    negSuccIsNotNonneg : (a b : ℕ) → (negSucc a ≡ nonneg b) → False
-    negSuccIsNotNonneg zero b ()
-    negSuccIsNotNonneg (succ a) b ()
-
-    negSuccInjective : {a b : ℕ} → (negSucc a ≡ negSucc b) → a ≡ b
-    negSuccInjective refl = refl
-
-    zeroMultInZLeft : (a : ℤ) → (nonneg zero) *Z a ≡ (nonneg zero)
-    zeroMultInZLeft a = identityOfIndiscernablesLeft (a *Z nonneg zero) (nonneg zero) (nonneg zero *Z a) _≡_ (multiplyWithZero a) (multiplicationZIsCommutative a (nonneg zero))
-
-    additionZeroDoesNothing : (a : ℤ) → (a +Z nonneg zero ≡ a)
-    additionZeroDoesNothing (nonneg zero) = refl
-    additionZeroDoesNothing (nonneg (succ x)) = applyEquality nonneg (applyEquality succ (addZeroRight x))
-    additionZeroDoesNothing (negSucc x) = refl
-
-    canSubtractOne : (a : ℤ) (b : ℕ) → negSucc zero +Z a ≡ negSucc (succ b) → a ≡ negSucc b
-    canSubtractOne (nonneg zero) b pr = i
-      where
-        simplified : negSucc zero ≡ negSucc (succ b)
-        simplified = identityOfIndiscernablesLeft (negSucc zero +Z nonneg zero) (negSucc (succ b)) (negSucc zero) _≡_ pr refl
-        removeNegsucc : zero ≡ succ b
-        removeNegsucc = negSuccInjective simplified
-        f : False
-        f = succIsNonzero (equalityCommutative removeNegsucc)
-        i : (nonneg zero) ≡ negSucc b
-        i = exFalso f
-    canSubtractOne (nonneg (succ x)) b pr = exFalso (negSuccIsNotNonneg (succ b) x (equalityCommutative pr))
-    canSubtractOne (negSucc x) .x refl = refl
-
-    canAddOne : (a : ℤ) (b : ℕ) → a ≡ negSucc b → negSucc zero +Z a ≡ negSucc (succ b)
-    canAddOne (nonneg x) b ()
-    canAddOne (negSucc x) .x refl = refl
-
-    canAddOneReversed : (a : ℤ) (b : ℕ) → a ≡ negSucc b → a +Z negSucc zero ≡ negSucc (succ b)
-    canAddOneReversed a b pr = identityOfIndiscernablesLeft (negSucc zero +Z a) (negSucc (succ b)) (a +Z negSucc zero) _≡_ (canAddOne a b pr) (additionZIsCommutative (negSucc zero) a)
-
-    addToNegativeSelf : (a : ℕ) → negSucc a +Z nonneg a ≡ negSucc zero
-    addToNegativeSelf zero = refl
-    addToNegativeSelf (succ a) = addToNegativeSelf a
-
-    multiplicativeIdentityOneZNegsucc : (a : ℕ) → (negSucc a *Z nonneg (succ zero) ≡ negSucc a)
-    multiplicativeIdentityOneZNegsucc zero = refl
-    multiplicativeIdentityOneZNegsucc (succ x) rewrite multiplicationZIsCommutative (negSucc (succ x)) (nonneg 1) | additionNIsCommutative x 0 = refl
-
-    multiplicativeIdentityOneZ : (a : ℤ) → (a *Z nonneg (succ zero) ≡ a)
-    multiplicativeIdentityOneZ (nonneg zero) rewrite multiplicationZIsCommutative (nonneg 0) (nonneg 1) = refl
-    multiplicativeIdentityOneZ (nonneg (succ x)) rewrite multiplicationZIsCommutative (nonneg (succ x)) (nonneg 1) | additionNIsCommutative x 0 = refl
-    multiplicativeIdentityOneZ (negSucc x) = multiplicativeIdentityOneZNegsucc (x)
-
-    multiplicativeIdentityOneZLeft : (a : ℤ) → (nonneg (succ zero)) *Z a ≡ a
-    multiplicativeIdentityOneZLeft a = identityOfIndiscernablesLeft (a *Z nonneg (succ zero)) a (nonneg (succ zero) *Z a) _≡_ (multiplicativeIdentityOneZ a) (multiplicationZIsCommutative a (nonneg (succ zero)))
-
-    -- Define the equivalence of negSucc + nonneg = nonneg with the corresponding statements of naturals
-
-    negSuccPlusNonnegNonneg : (a : ℕ) → (b : ℕ) → (c : ℕ) → (negSucc a +Z (nonneg b) ≡ nonneg c) → b ≡ c +N succ a
-    negSuccPlusNonnegNonneg zero zero c ()
-    negSuccPlusNonnegNonneg zero (succ b) .b refl rewrite succExtracts b zero | addZeroRight b = refl
-    negSuccPlusNonnegNonneg (succ a) zero c ()
-    negSuccPlusNonnegNonneg (succ a) (succ b) c pr with negSuccPlusNonnegNonneg a b c pr
-    ... | prev = identityOfIndiscernablesRight (succ b) (succ (c +N succ a)) (c +N succ (succ a)) _≡_ (applyEquality succ prev) (equalityCommutative (succExtracts c (succ a)))
-
-    negSuccPlusNonnegNonnegConverse : (a : ℕ) → (b : ℕ) → (c : ℕ) → (b ≡ c +N succ a) → (negSucc a +Z (nonneg b) ≡ nonneg c)
-    negSuccPlusNonnegNonnegConverse zero zero c pr rewrite succExtracts c zero = naughtE pr
-    negSuccPlusNonnegNonnegConverse zero (succ b) c pr rewrite additionNIsCommutative c 1 with succInjective pr
-    ... | pr' = applyEquality nonneg pr'
-    negSuccPlusNonnegNonnegConverse (succ a) zero c pr rewrite succExtracts c (succ a) = naughtE pr
-    negSuccPlusNonnegNonnegConverse (succ a) (succ b) c pr rewrite succExtracts c (succ a) with succInjective pr
-    ... | pr' = negSuccPlusNonnegNonnegConverse a b c pr'
-
-    -- Define the equivalence of negSucc + nonneg = negSucc with the corresponding statements of naturals
-
-    negSuccPlusNonnegNegsucc : (a b c : ℕ) → (negSucc a +Z (nonneg b) ≡ negSucc c) → c +N b ≡ a
-    negSuccPlusNonnegNegsucc zero zero .0 refl = refl
-    negSuccPlusNonnegNegsucc zero (succ b) c ()
-    negSuccPlusNonnegNegsucc (succ a) zero .(succ a) refl rewrite addZeroRight a = refl
-    negSuccPlusNonnegNegsucc (succ a) (succ b) c pr with negSuccPlusNonnegNegsucc a b c pr
-    ... | pr' = identityOfIndiscernablesLeft (succ (c +N b)) (succ a) (c +N succ b) _≡_ (applyEquality succ pr') (equalityCommutative (succExtracts c b))
-
-    negSuccPlusNonnegNegsuccConverse : (a b c : ℕ) → (c +N b ≡ a) → (negSucc a +Z (nonneg b) ≡ negSucc c)
-    negSuccPlusNonnegNegsuccConverse zero zero c pr rewrite addZeroRight c = applyEquality negSucc (equalityCommutative pr)
-    negSuccPlusNonnegNegsuccConverse zero (succ b) c pr rewrite succExtracts c b = naughtE (equalityCommutative pr)
-    negSuccPlusNonnegNegsuccConverse (succ a) zero c pr rewrite addZeroRight c = applyEquality negSucc (equalityCommutative pr)
-    negSuccPlusNonnegNegsuccConverse (succ a) (succ b) c pr rewrite succExtracts c b = negSuccPlusNonnegNegsuccConverse a b c (succInjective pr)
-
-    -- Define the impossibility of negSucc + negSucc = nonneg
-    negSuccPlusNegSuccIsNegative : (a b c : ℕ) → ((negSucc a) +Z (negSucc b) ≡ nonneg c) → False
-    negSuccPlusNegSuccIsNegative zero b c ()
-    negSuccPlusNegSuccIsNegative (succ a) b c ()
-
-    -- Define the equivalence of negSucc + negSucc = negSucc
-    negSuccPlusNegSuccNegSucc : (a b c : ℕ) → (negSucc a) +Z (negSucc b) ≡ (negSucc c) → succ (a +N b) ≡ c
-    negSuccPlusNegSuccNegSucc zero b .(succ b) refl = refl
-    negSuccPlusNegSuccNegSucc (succ a) b .(succ (a +N succ b)) refl = applyEquality succ (equalityCommutative (succExtracts a b))
-
-    negSuccPlusNegSuccNegSuccConverse : (a b c : ℕ) → succ (a +N b) ≡ c → (negSucc a) +Z (negSucc b) ≡ negSucc c
-    negSuccPlusNegSuccNegSuccConverse zero b c pr = applyEquality negSucc pr
-    negSuccPlusNegSuccNegSuccConverse (succ a) b zero ()
-    negSuccPlusNegSuccNegSuccConverse (succ a) b (succ c) pr rewrite succExtracts a b = applyEquality negSucc pr
-
-    -- Define the equivalence of nonneg + nonneg = nonneg
-    nonnegPlusNonnegNonneg : (a b c : ℕ) → nonneg a +Z nonneg b ≡ nonneg c → a +N b ≡ c
-    nonnegPlusNonnegNonneg a b c pr rewrite addingNonnegIsHom a b = nonnegInj pr
-      where
-        nonnegInj : {x y : ℕ} → (pr : nonneg x ≡ nonneg y) → x ≡ y
-        nonnegInj {x} {.x} refl = refl
-
-    nonnegPlusNonnegNonnegConverse : (a b c : ℕ) → a +N b ≡ c → nonneg a +Z nonneg b ≡ nonneg c
-    nonnegPlusNonnegNonnegConverse a b c pr rewrite addingNonnegIsHom a b = applyEquality nonneg pr
-
-    nonnegIsNotNegsucc : {x y : ℕ} → nonneg x ≡ negSucc y → False
-    nonnegIsNotNegsucc {x} {y} ()
-
-    -- Define the impossibility of nonneg + nonneg = negSucc
-    nonnegPlusNonnegNegsucc : (a b c : ℕ) → nonneg a +Z nonneg b ≡ negSucc c → False
-    nonnegPlusNonnegNegsucc a b c pr rewrite addingNonnegIsHom a b = nonnegIsNotNegsucc pr
-
-    -- Move negSucc to other side of equation
-    moveNegsucc : (a : ℕ) (b c : ℤ) → (negSucc a) +Z b ≡ c → b ≡ c +Z (nonneg (succ a))
-    moveNegsucc a (nonneg x) (nonneg y) pr with (negSuccPlusNonnegNonneg a x y pr)
-    ... | pr' = identityOfIndiscernablesRight (nonneg x) (nonneg (y +N succ a)) (nonneg y +Z nonneg (succ a)) _≡_ (applyEquality nonneg pr') (equalityCommutative (addingNonnegIsHom y (succ a)))
-    moveNegsucc a (nonneg x) (negSucc y) pr with negSuccPlusNonnegNegsucc a x y pr
-    ... | pr' = equalityCommutative (negSuccPlusNonnegNonnegConverse y (succ a) x (g {a} {x} {y} (applyEquality succ pr')))
-      where
-        g : {a x y : ℕ} → succ (y +N x) ≡ succ a → succ a ≡ x +N succ y
-        g {a} {x} {y} p rewrite additionNIsCommutative y x | succExtracts x y = equalityCommutative p
-    moveNegsucc a (negSucc x) (nonneg y) pr = exFalso (negSuccPlusNegSuccIsNegative a x y pr)
-    moveNegsucc a (negSucc x) (negSucc y) pr with negSuccPlusNegSuccNegSucc a x y pr
-    ... | pr' = equalityCommutative (negSuccPlusNonnegNegsuccConverse y (succ a) x g)
-      where
-        g : x +N succ a ≡ y
-        g rewrite succExtracts x a | additionNIsCommutative a x = pr'
 
-    moveNegsuccConverse : (a : ℕ) → (b c : ℤ) → (b ≡ c +Z (nonneg (succ a))) → (negSucc a) +Z b ≡ c
-    moveNegsuccConverse zero (nonneg x) (nonneg y) pr with nonnegPlusNonnegNonneg y 1 x (equalityCommutative pr)
-    ... | pr' rewrite (equalityCommutative (succIsAddOne y)) = g
-      where
-        g : negSucc 0 +Z nonneg x ≡ nonneg y
-        g rewrite equalityCommutative pr' = refl
-    moveNegsuccConverse zero (nonneg x) (negSucc y) pr with moveNegsucc y (nonneg 1) (nonneg x) (equalityCommutative pr)
-    ... | pr' rewrite addingNonnegIsHom x (succ y) = g x y (nonnegInjective pr')
-      where
-        g : (x y : ℕ) → (1 ≡ (x +N succ y)) → negSucc 0 +Z nonneg x ≡ negSucc y
-        g zero zero pr = refl
-        g zero (succ y) ()
-        g (succ x) y pr = naughtE (identityOfIndiscernablesRight zero (x +N succ y) (succ (x +N y)) _≡_ (succInjective pr) (succExtracts x y))
-    moveNegsuccConverse zero (negSucc x) (nonneg y) pr = exFalso (nonnegPlusNonnegNegsucc y 1 x (equalityCommutative pr))
-    moveNegsuccConverse zero (negSucc x) (negSucc y) pr with negSuccPlusNonnegNegsucc y 1 x (equalityCommutative pr)
-    ... | pr' = applyEquality negSucc g
-      where
-        g : succ x ≡ y
-        g rewrite additionNIsCommutative x 1 = pr'
-    moveNegsuccConverse (succ a) (nonneg x) (nonneg y) pr with nonnegPlusNonnegNonneg y (succ (succ a)) x (equalityCommutative pr)
-    ... | pr' = negSuccPlusNonnegNonnegConverse (succ a) x y (equalityCommutative pr')
-    moveNegsuccConverse (succ a) (nonneg x) (negSucc y) pr with negSuccPlusNonnegNonneg y (succ (succ a)) x (equalityCommutative pr)
-    ... | pr' = negSuccPlusNonnegNegsuccConverse (succ a) x y (g a x y pr')
-      where
-        g : (a x y : ℕ) → succ (succ a) ≡ x +N succ y → y +N x ≡ succ a
-        g a x y pr rewrite succExtracts x y | additionNIsCommutative x y = equalityCommutative (succInjective pr)
-    moveNegsuccConverse (succ a) (negSucc x) (nonneg z) pr = exFalso (nonnegPlusNonnegNegsucc z (succ (succ a)) x (equalityCommutative pr))
-    moveNegsuccConverse (succ a) (negSucc x) (negSucc z) pr with negSuccPlusNonnegNegsucc z (succ (succ a)) x (equalityCommutative pr)
-    ... | pr' = applyEquality negSucc (g a x z pr')
-      where
-        g : (a x z : ℕ) → x +N succ (succ a) ≡ z → succ (a +N succ x) ≡ z
-        g a x z pr rewrite succExtracts x (succ a) = identityOfIndiscernablesLeft (succ (x +N succ a)) z (succ (a +N succ x)) _≡_ pr (applyEquality succ (s x a))
-          where
-            s : (x a : ℕ) → x +N succ a ≡ a +N succ x
-            s x a rewrite succCanMove a x = additionNIsCommutative x (succ a)
-
-    -- By this point, any statement about addition can be moved from N into Z and from Z into N by applying moveNegSucc and its converse to eliminate any adding of negSucc.
-
-    lessIsPreservedNToZNegsucc : {a b : ℕ} → (a <N b) → ((negSucc b) <Z negSucc a)
-    lessIsPreservedNToZNegsucc {a} {b} (le x proof) = record { x = x ; proof = pr }
-      where
-        pr : nonneg (succ x) +Z negSucc b ≡ negSucc a
-        pr rewrite additionZIsCommutative (nonneg (succ x)) (negSucc b) = moveNegsuccConverse b (nonneg (succ x)) (negSucc a) (equalityCommutative (moveNegsuccConverse a (nonneg (succ b)) (nonneg (succ x)) (applyEquality nonneg (applyEquality succ proof'))))
-          where
-            proof' : b ≡ x +N succ a
-            proof' rewrite additionNIsCommutative x a | additionNIsCommutative (succ a) x = equalityCommutative proof
-
-    lessLemma : (a x : ℕ) → succ x +N a ≡ a → False
-    lessLemma zero x pr = naughtE (equalityCommutative pr)
-    lessLemma (succ a) x pr = lessLemma a x q
-      where
-        q : succ x +N a ≡ a
-        q rewrite additionNIsCommutative a (succ x) | additionNIsCommutative x a | additionNIsCommutative (succ a) x = succInjective pr
-
-    sumOfNegsucc : (a b : ℕ) → (negSucc a +Z negSucc b) ≡ negSucc (succ (a +N b))
-    sumOfNegsucc a b = negSuccPlusNegSuccNegSuccConverse a b (succ (a +N b)) refl
-
-    additionZInjLemma : {a b c : ℕ} → (nonneg a ≡ (nonneg a +Z nonneg b) +Z nonneg (succ c)) → False
-    additionZInjLemma {a} {b} {c} pr = cannotAddKeepingEquality a (c +N b) pr2''
-      where
-        pr'' : nonneg a ≡ nonneg (a +N b) +Z nonneg (succ c)
-        pr'' = identityOfIndiscernablesRight (nonneg a) ((nonneg a +Z nonneg b) +Z nonneg (succ c)) (nonneg (a +N b) +Z nonneg (succ c)) _≡_ pr (applyEquality (λ i → i +Z nonneg (succ c)) (addingNonnegIsHom a b))
-        pr''' : nonneg a ≡ nonneg ((a +N b) +N succ c)
-        pr''' = identityOfIndiscernablesRight (nonneg a) (nonneg (a +N b) +Z nonneg (succ c)) (nonneg ((a +N b) +N succ c)) _≡_ pr'' (addingNonnegIsHom (a +N b) (succ c))
-        pr2 : a ≡ (a +N b) +N succ c
-        pr2 = nonnegInjective pr'''
-        pr2' : a ≡ a +N (b +N succ c)
-        pr2' = identityOfIndiscernablesRight a ((a +N b) +N succ c) (a +N (b +N succ c)) _≡_ pr2 (additionNIsAssociative a b (succ c))
-        pr2'' : a ≡ a +N succ (c +N b)
-        pr2'' rewrite additionNIsCommutative (succ c) b = pr2'
-
-    additionZInjectiveFirstLemma : (a : ℕ) → (b c : ℤ) → (nonneg a +Z b ≡ nonneg a +Z c) → (b ≡ c)
-    additionZInjectiveFirstLemma a (nonneg b) (nonneg c) pr rewrite (addingNonnegIsHom a b) | (addingNonnegIsHom a c) = applyEquality nonneg (canSubtractFromEqualityLeft {a} pr')
-      where
-        pr' : a +N b ≡ a +N c
-        pr' = nonnegInjective pr
-    additionZInjectiveFirstLemma a (nonneg b) (negSucc c) pr = exFalso (additionZInjLemma pr')
-      where
-        pr' : nonneg a ≡ (nonneg a +Z nonneg b) +Z nonneg (succ c)
-        pr' rewrite additionZIsCommutative (nonneg a) (negSucc c) = moveNegsucc c (nonneg a) (nonneg a +Z nonneg b) (equalityCommutative pr)
-    additionZInjectiveFirstLemma a (negSucc b) (nonneg x) pr = exFalso (additionZInjLemma pr')
-      where
-        pr' : nonneg a ≡ (nonneg a +Z nonneg x) +Z nonneg (succ b)
-        pr' rewrite additionZIsCommutative (nonneg a) (negSucc b) = moveNegsucc b (nonneg a) (nonneg a +Z nonneg x) pr
-    additionZInjectiveFirstLemma zero (negSucc zero) (negSucc x) pr = pr
-    additionZInjectiveFirstLemma zero (negSucc (succ b)) (negSucc x) pr = pr
-    additionZInjectiveFirstLemma (succ a) (negSucc zero) (negSucc x) pr = applyEquality negSucc (equalityCommutative qr'')
-      where
-        pr1 : negSucc x +Z nonneg (succ a) ≡ nonneg a
-        pr1 rewrite additionZIsCommutative (nonneg (succ a)) (negSucc x) = equalityCommutative pr
-        pr' : nonneg a +Z nonneg (succ x) ≡ nonneg (succ a)
-        pr' = equalityCommutative (moveNegsucc x (nonneg (succ a)) (nonneg a) pr1)
-        pr'' : nonneg (a +N succ x) ≡ nonneg (succ a)
-        pr'' rewrite equalityCommutative (addingNonnegIsHom a (succ x)) = pr'
-        pr''' : a +N succ x ≡ succ a
-        pr''' = nonnegInjective pr''
-        pr'''' : succ x +N a ≡ succ a
-        pr'''' rewrite additionNIsCommutative (succ x) a = pr'''
-        qr : succ (a +N x) ≡ succ a
-        qr rewrite additionNIsCommutative a x = pr''''
-        qr' : a +N x ≡ a +N 0
-        qr' rewrite addZeroRight a = succInjective qr
-        qr'' : x ≡ 0
-        qr'' = canSubtractFromEqualityLeft {a} qr'
-    additionZInjectiveFirstLemma (succ a) (negSucc (succ b)) (negSucc zero) pr = naughtE qr
-      where
-        pr' : nonneg a ≡ nonneg a +Z nonneg (succ b)
-        pr' rewrite additionZIsCommutative (nonneg a) (negSucc b) = moveNegsucc b (nonneg a) (nonneg a) pr
-        pr'' : nonneg a ≡ nonneg (a +N succ b)
-        pr'' rewrite equalityCommutative (addingNonnegIsHom a (succ b)) = pr'
-        pr''' : a +N 0 ≡ a +N succ b
-        pr''' rewrite addZeroRight a = nonnegInjective pr''
-        qr : 0 ≡ succ b
-        qr = canSubtractFromEqualityLeft {a} pr'''
-    additionZInjectiveFirstLemma (succ a) (negSucc (succ b)) (negSucc (succ x)) pr = go b x pr''
-      where
-        pr' : negSucc b ≡ negSucc x
-        pr' = additionZInjectiveFirstLemma a (negSucc b) (negSucc x) pr
-        pr'' : b ≡ x
-        pr'' = negSuccInjective pr'
-        go : (b x : ℕ) → (b ≡ x) → negSucc (succ b) ≡ negSucc (succ x)
-        go b .b refl = refl
-
-    additionZInjectiveSecondLemmaLemma : (a : ℕ) (b : ℕ) (c : ℕ) → (negSucc a +Z nonneg b ≡ negSucc a +Z negSucc c) → nonneg b ≡ negSucc c
-    additionZInjectiveSecondLemmaLemma zero zero zero pr = naughtE (negSuccInjective pr)
-    additionZInjectiveSecondLemmaLemma zero zero (succ c) pr = naughtE (negSuccInjective pr)
-    additionZInjectiveSecondLemmaLemma zero (succ b) c pr = exFalso (nonnegIsNotNegsucc pr)
-    additionZInjectiveSecondLemmaLemma (succ a) zero c pr = naughtE (canSubtractFromEqualityLeft {succ a} pr')
-      where
-        pr' : succ a +N zero ≡ succ a +N succ c
-        pr' rewrite addZeroRight (succ a) = negSuccInjective pr
-    additionZInjectiveSecondLemmaLemma (succ a) (succ b) c pr = naughtE r
-      where
-        pr' : negSucc (succ (a +N succ c)) +Z nonneg (succ a) ≡ nonneg b
-        pr' = equalityCommutative (moveNegsucc a (nonneg b) (negSucc (succ (a +N succ c))) pr)
-        pr'' : nonneg (succ a) ≡ nonneg b +Z nonneg (succ (succ (a +N succ c)))
-        pr'' = moveNegsucc (succ (a +N succ c)) (nonneg (succ a)) (nonneg b) pr'
-        pr''' : nonneg (succ a) ≡ nonneg (b +N succ (succ (a +N succ c)))
-        pr''' rewrite equalityCommutative (addingNonnegIsHom b (succ (succ (a +N succ c)))) = pr''
-        pr'''' : succ a ≡ b +N ((succ (succ a)) +N succ c)
-        pr'''' = nonnegInjective pr'''
-        q : succ a ≡ (b +N (succ (succ a))) +N succ c
-        q = identityOfIndiscernablesRight (succ a) (b +N ((succ (succ a)) +N succ c)) ((b +N (succ (succ a))) +N succ c) _≡_ pr'''' (equalityCommutative (additionNIsAssociative b (succ (succ a)) (succ c)))
-        moveSucc : (a b : ℕ) → a +N succ b ≡ succ a +N b
-        moveSucc a b rewrite additionNIsCommutative a (succ b) | additionNIsCommutative a b = refl
-        q' : succ a ≡ (succ b +N succ a) +N succ c
-        q' = identityOfIndiscernablesRight (succ a) ((b +N succ (succ a)) +N succ c) ((succ b +N succ a) +N succ c) _≡_ q (applyEquality (λ t → t +N succ c) (moveSucc b (succ a)))
-        q'' : succ a ≡ (succ a +N succ b) +N succ c
-        q'' = identityOfIndiscernablesRight (succ a) ((succ b +N succ a) +N succ c) ((succ a +N succ b) +N succ c) _≡_ q' (applyEquality (λ t → t +N succ c) (additionNIsCommutative (succ b) (succ a)))
-        q''' : succ a ≡ succ a +N (succ b +N succ c)
-        q''' rewrite equalityCommutative (additionNIsAssociative (succ a) (succ b) (succ c)) = q''
-        q'''' : succ a +N zero ≡ succ a +N (succ b +N succ c)
-        q'''' rewrite addZeroRight (succ a) = q'''
-        r : zero ≡ succ b +N succ c
-        r = canSubtractFromEqualityLeft {succ a} q''''
-
-    additionZInjectiveSecondLemma : (a : ℕ) (b c : ℤ) → (negSucc a +Z b ≡ negSucc a +Z c) → b ≡ c
-    additionZInjectiveSecondLemma zero (nonneg zero) (nonneg zero) pr = refl
-    additionZInjectiveSecondLemma zero (nonneg zero) (nonneg (succ c)) pr = exFalso (nonnegIsNotNegsucc (equalityCommutative pr))
-    additionZInjectiveSecondLemma zero (nonneg (succ b)) (nonneg zero) pr = exFalso (nonnegIsNotNegsucc pr)
-    additionZInjectiveSecondLemma zero (nonneg (succ b)) (nonneg (succ c)) pr rewrite additionZIsCommutative (negSucc zero) (nonneg b) | additionZIsCommutative (negSucc zero) (nonneg c) = applyEquality (λ t → nonneg (succ t)) pr'
-      where
-        pr' : b ≡ c
-        pr' = nonnegInjective pr
-    additionZInjectiveSecondLemma zero (nonneg zero) (negSucc c) pr = naughtE pr'
-      where
-        pr' : zero ≡ succ c
-        pr' = negSuccInjective pr
-    additionZInjectiveSecondLemma zero (negSucc b) (nonneg zero) pr = naughtE (negSuccInjective (equalityCommutative pr))
-    additionZInjectiveSecondLemma zero (negSucc b) (nonneg (succ c)) pr = exFalso (nonnegIsNotNegsucc (equalityCommutative pr))
-    additionZInjectiveSecondLemma zero (negSucc b) (negSucc c) pr = applyEquality negSucc (succInjective pr')
-      where
-        pr' : succ b ≡ succ c
-        pr' = negSuccInjective pr
-    additionZInjectiveSecondLemma zero (nonneg (succ b)) (negSucc c) pr = exFalso (nonnegIsNotNegsucc pr)
-    additionZInjectiveSecondLemma (succ a) (nonneg zero) (nonneg zero) pr = refl
-    additionZInjectiveSecondLemma (succ a) (nonneg zero) (nonneg (succ c)) pr = exFalso (nonnegIsNotNegsucc pr'')
-      where
-        pr' : nonneg c ≡ negSucc (succ a) +Z nonneg (succ a)
-        pr' = moveNegsucc a (nonneg c) (negSucc (succ a)) (equalityCommutative pr)
-        pr'' : nonneg c ≡ negSucc zero
-        pr'' rewrite equalityCommutative (addToNegativeSelf (succ a)) = pr'
-    additionZInjectiveSecondLemma (succ a) (nonneg (succ b)) (nonneg zero) pr = exFalso (nonnegIsNotNegsucc pr'')
-      where
-        pr' : nonneg b ≡ negSucc (succ a) +Z nonneg (succ a)
-        pr' = moveNegsucc a (nonneg b) (negSucc (succ a)) pr
-        pr'' : nonneg b ≡ negSucc zero
-        pr'' rewrite equalityCommutative (addToNegativeSelf (succ a)) = pr'
-    additionZInjectiveSecondLemma (succ a) (nonneg (succ b)) (nonneg (succ c)) pr = applyEquality (λ t → nonneg (succ t)) pr''
-      where
-        pr' : nonneg b ≡ nonneg c
-        pr' = additionZInjectiveSecondLemma a (nonneg b) (nonneg c) pr
-        pr'' : b ≡ c
-        pr'' = nonnegInjective pr'
-    additionZInjectiveSecondLemma (succ a) (nonneg zero) (negSucc c) pr = naughtE pr''
-      where
-        pr' : succ a +N zero ≡ succ a +N succ c
-        pr' rewrite addZeroRight a = negSuccInjective pr
-        pr'' : zero ≡ succ c
-        pr'' = canSubtractFromEqualityLeft {succ a} pr'
-    additionZInjectiveSecondLemma (succ a) (nonneg (succ b)) (negSucc c) pr = additionZInjectiveSecondLemmaLemma (succ a) (succ b) c pr
-    additionZInjectiveSecondLemma (succ a) (negSucc b) (nonneg c) pr = equalityCommutative pr'
-      where
-        pr' : nonneg c ≡ negSucc b
-        pr' = additionZInjectiveSecondLemmaLemma (succ a) c b (equalityCommutative pr)
-    additionZInjectiveSecondLemma (succ a) (negSucc b) (negSucc c) pr = applyEquality negSucc pr'''
-      where
-        pr' : succ a +N succ b ≡ succ a +N succ c
-        pr' = negSuccInjective pr
-        pr'' : succ b ≡ succ c
-        pr'' = canSubtractFromEqualityLeft {succ a} pr'
-        pr''' : b ≡ c
-        pr''' = succInjective pr''
-
-    additionZInjective : (a b c : ℤ) → (a +Z b ≡ a +Z c) → b ≡ c
-    additionZInjective (nonneg a) b c pr = additionZInjectiveFirstLemma a b c pr
-    additionZInjective (negSucc a) b c pr = additionZInjectiveSecondLemma a b c pr
-
-    addNonnegSucc : (a : ℤ) → (b c : ℕ) → (a +Z nonneg b ≡ nonneg c) → a +Z nonneg (succ b) ≡ nonneg (succ c)
-    addNonnegSucc (nonneg x) b c pr rewrite addingNonnegIsHom x (succ b) | addingNonnegIsHom x b = applyEquality nonneg g
-      where
-        p : x +N b ≡ c
-        p = nonnegInjective pr
-        g : x +N succ b ≡ succ c
-        g = identityOfIndiscernablesLeft (succ (x +N b)) (succ c) (x +N succ b) _≡_ (applyEquality succ p) (equalityCommutative (succExtracts x b))
-    addNonnegSucc (negSucc x) b c pr = negSuccPlusNonnegNonnegConverse x (succ b) (succ c) (applyEquality succ p')
-      where
-        p' : b ≡ c +N succ x
-        p' = negSuccPlusNonnegNonneg x b c pr
-
-    addNonnegSuccLemma : (a x d : ℕ) → (negSucc (succ a) +Z nonneg zero ≡ negSucc (succ x) +Z nonneg (succ d)) → negSucc (succ a) +Z nonneg (succ zero) ≡ negSucc (succ x) +Z nonneg (succ (succ d))
-    addNonnegSuccLemma a x d pr = s
-      where
-        p' : negSucc (succ a) +Z nonneg (succ x) ≡ nonneg d
-        p' = equalityCommutative (moveNegsucc x (nonneg d) (negSucc (succ a)) (equalityCommutative pr))
-        p'' : nonneg (succ x) ≡ nonneg d +Z nonneg (succ (succ a))
-        p'' = moveNegsucc (succ a) (nonneg (succ x)) (nonneg d) p'
-        p''' : nonneg (succ x) ≡ nonneg (d +N succ (succ a))
-        p''' rewrite equalityCommutative (addingNonnegIsHom d (succ (succ a))) = p''
-        q : succ x ≡ d +N succ (succ a)
-        q = nonnegInjective p'''
-        q' : succ x ≡ succ (succ a) +N d
-        q' rewrite additionNIsCommutative (succ (succ a)) d = q
-        q'' : succ x ≡ succ d +N succ a
-        q'' rewrite additionNIsCommutative d (succ a) = q'
-        q''' : succ x ≡ succ a +N succ d
-        q''' rewrite additionNIsCommutative (succ a) (succ d) = q''
-        r : nonneg (succ x) ≡ nonneg (succ a +N succ d)
-        r = applyEquality nonneg q'''
-        r' : nonneg (succ x) ≡ nonneg (succ a) +Z nonneg (succ d)
-        r' = identityOfIndiscernablesRight (nonneg (succ x)) (nonneg (succ a +N succ d)) (nonneg (succ a) +Z nonneg (succ d)) _≡_ r (addingNonnegIsHom (succ a) (succ d))
-        r'' : nonneg (succ x) ≡ nonneg (succ d) +Z nonneg (succ a)
-        r'' rewrite additionZIsCommutative (nonneg (succ d)) (nonneg (succ a)) = r'
-        r''' : nonneg (succ d) ≡ negSucc a +Z nonneg (succ x)
-        r''' = equalityCommutative (moveNegsuccConverse a (nonneg (succ x)) (nonneg (succ d)) r'')
-        s : negSucc a ≡ negSucc x +Z nonneg (succ d)
-        s = equalityCommutative (moveNegsuccConverse x (nonneg (succ d)) (negSucc a) r''')
-
-    addNonnegSucc' : (a b : ℤ) → (c d : ℕ) → (a +Z nonneg c ≡ b +Z nonneg d) → a +Z nonneg (succ c) ≡ b +Z nonneg (succ d)
-    addNonnegSucc' a (nonneg x) c d pr rewrite addingNonnegIsHom x (succ d) | addingNonnegIsHom x d | addNonnegSucc a c (x +N d) pr = applyEquality nonneg (equalityCommutative (succExtracts x d))
-    addNonnegSucc' (nonneg a) (negSucc x) c d pr = equalityCommutative (moveNegsuccConverse x (nonneg (succ d)) ((nonneg a) +Z nonneg (succ c)) (equalityCommutative q))
-      where
-        p : ((nonneg a) +Z nonneg c) +Z nonneg (succ x) ≡ nonneg d
-        p = equalityCommutative (moveNegsucc x (nonneg d) ((nonneg a) +Z nonneg c) (equalityCommutative pr))
-        p' : nonneg ((a +N c) +N succ x) ≡ nonneg d
-        p' = identityOfIndiscernablesLeft ((nonneg a +Z nonneg c) +Z nonneg (succ x)) (nonneg d) (nonneg ((a +N c) +N succ x)) _≡_ p g
-          where
-            g : (nonneg a +Z nonneg c) +Z nonneg (succ x) ≡ nonneg ((a +N c) +N succ x)
-            g rewrite addingNonnegIsHom a c | addingNonnegIsHom (a +N c) (succ x) = refl
-        p'' : (a +N c) +N succ x ≡ d
-        p'' = nonnegInjective p'
-        p''' : (a +N succ c) +N succ x ≡ succ d
-        p''' = identityOfIndiscernablesLeft (succ (a +N c) +N succ x) (succ d) ((a +N succ c) +N succ x) _≡_ (applyEquality succ p'') g
-          where
-            g : succ ((a +N c) +N succ x) ≡ (a +N succ c) +N succ x
-            g = applyEquality (λ i → i +N succ x) {succ (a +N c)} {a +N succ c} (equalityCommutative (succExtracts a c))
-        q : (nonneg a +Z nonneg (succ c)) +Z nonneg (succ x) ≡ nonneg (succ d)
-        q rewrite (addingNonnegIsHom a (succ c)) | addingNonnegIsHom (a +N succ c) (succ x) = applyEquality nonneg p'''
-
-    addNonnegSucc' (negSucc a) (negSucc x) c d pr with (inspect (negSucc x +Z nonneg d))
-    addNonnegSucc' (negSucc a) (negSucc x) c d pr | (nonneg int) with≡ p = identityOfIndiscernablesRight (negSucc a +Z nonneg (succ c)) (nonneg (succ int)) (negSucc x +Z nonneg (succ d)) _≡_ (addNonnegSucc (negSucc a) c int (transitivity pr p)) (equalityCommutative (addNonnegSucc (negSucc x) d int p))
-    addNonnegSucc' (negSucc zero) (negSucc zero) c d pr | negSucc int with≡ p = additionZInjective (negSucc zero) (nonneg c) (nonneg d) pr
-      where
-        pr' : nonneg c ≡ (negSucc zero +Z nonneg d) +Z nonneg 1
-        pr' = moveNegsucc zero (nonneg c) (negSucc zero +Z nonneg d) pr
-    addNonnegSucc' (negSucc zero) (negSucc (succ x)) zero d pr | negSucc int with≡ p = equalityCommutative (moveNegsuccConverse x (nonneg d) (nonneg zero) (equalityCommutative (applyEquality nonneg q')))
-      where
-        pr' : nonneg d ≡ (negSucc zero) +Z (nonneg (succ (succ x)))
-        pr' = moveNegsucc (succ x) (nonneg d) (negSucc zero) (equalityCommutative pr)
-        pr'' : nonneg (succ (succ x)) ≡ nonneg d +Z nonneg 1
-        pr'' = moveNegsucc (zero) (nonneg (succ (succ x))) (nonneg d) (equalityCommutative pr')
-        pr''' : nonneg (succ (succ x)) ≡ nonneg (d +N 1)
-        pr''' rewrite equalityCommutative (addingNonnegIsHom d 1) = pr''
-        pr'''' : succ (succ x) ≡ d +N 1
-        pr'''' = nonnegInjective pr'''
-        q : succ (succ x) ≡ succ d
-        q rewrite additionNIsCommutative 1 d = pr''''
-        q' : succ x ≡ d
-        q' = succInjective q
-    addNonnegSucc' (negSucc zero) (negSucc (succ x)) (succ c) zero pr | negSucc int with≡ p = exFalso (nonnegIsNotNegsucc pr)
-    addNonnegSucc' (negSucc zero) (negSucc (succ x)) (succ c) (succ d) pr | negSucc int with≡ p = addNonnegSucc' (nonneg zero) (negSucc x) c d pr
-    addNonnegSucc' (negSucc (succ a)) (negSucc zero) zero d pr | negSucc int with≡ p = naughtE q'
-      where
-        pr' : negSucc (succ a) +Z nonneg 1 ≡ nonneg d
-        pr' = equalityCommutative (moveNegsucc zero (nonneg d) (negSucc (succ a)) (equalityCommutative pr))
-        pr'' : nonneg 1 ≡ nonneg d +Z nonneg (succ (succ a))
-        pr'' = moveNegsucc (succ a) (nonneg 1) (nonneg d) pr'
-        pr''' : nonneg 1 ≡ nonneg (d +N succ (succ a))
-        pr''' rewrite equalityCommutative (addingNonnegIsHom d (succ (succ a))) = pr''
-        q : 1 ≡ succ (succ a) +N d
-        q rewrite additionNIsCommutative (succ (succ a)) d = nonnegInjective pr'''
-        q' : 0 ≡ succ a +N d
-        q' = succInjective q
-    addNonnegSucc' (negSucc (succ a)) (negSucc zero) (succ c) zero pr | negSucc int with≡ p = help
-      where
-        pr' : negSucc zero +Z nonneg (succ a) ≡ nonneg c
-        pr' = equalityCommutative (moveNegsucc a (nonneg c) (negSucc zero) pr)
-        pr'' : nonneg (succ a) ≡ nonneg c +Z nonneg 1
-        pr'' = moveNegsucc zero (nonneg (succ a)) (nonneg c) pr'
-        pr''' : nonneg (succ a) ≡ nonneg (c +N 1)
-        pr''' rewrite equalityCommutative (addingNonnegIsHom c 1) = pr''
-        q : succ a ≡ succ c
-        q rewrite additionNIsCommutative 1 c = nonnegInjective pr'''
-        q' : a ≡ c
-        q' = succInjective q
-        help : negSucc a +Z nonneg (succ c) ≡ nonneg zero
-        help rewrite q' = additiveInverseExists c
-    addNonnegSucc' (negSucc (succ a)) (negSucc zero) (succ c) (succ d) pr | negSucc int with≡ p = moveNegsuccConverse a (nonneg (succ c)) (nonneg (succ d)) q'
-      where
-        pr' : nonneg c ≡ nonneg d +Z nonneg (succ a)
-        pr' = moveNegsucc a (nonneg c) (nonneg d) pr
-        pr'' : nonneg c ≡ nonneg (d +N succ a)
-        pr'' rewrite equalityCommutative (addingNonnegIsHom d (succ a)) = pr'
-        pr''' : c ≡ d +N succ a
-        pr''' = nonnegInjective pr''
-        pr'''' : succ c ≡ succ d +N succ a
-        pr'''' = applyEquality succ pr'''
-        q : nonneg (succ c) ≡ nonneg (succ d +N succ a)
-        q = applyEquality nonneg pr''''
-        q' : nonneg (succ c) ≡ nonneg (succ d) +Z nonneg (succ a)
-        q' rewrite addingNonnegIsHom (succ d) (succ a) = q
-    addNonnegSucc' (negSucc (succ a)) (negSucc (succ x)) zero zero pr | negSucc int with≡ p = applyEquality negSucc (succInjective (negSuccInjective pr))
-    addNonnegSucc' (negSucc (succ a)) (negSucc (succ x)) zero (succ d) pr | negSucc int with≡ p = addNonnegSuccLemma a x d pr
-    addNonnegSucc' (negSucc (succ a)) (negSucc (succ x)) (succ c) zero pr | negSucc int with≡ p = equalityCommutative (addNonnegSuccLemma x a c (equalityCommutative pr))
-    addNonnegSucc' (negSucc (succ a)) (negSucc (succ x)) (succ c) (succ d) pr | negSucc int with≡ p = addNonnegSucc' (negSucc a) (negSucc x) c d pr
-
-    subtractNonnegSucc : (a : ℤ) → (b c : ℕ) → (a +Z nonneg (succ b) ≡ nonneg (succ c)) → a +Z nonneg b ≡ nonneg c
-    subtractNonnegSucc (nonneg x) b c pr rewrite addingNonnegIsHom x (succ b) | addingNonnegIsHom x b = applyEquality nonneg g
-      where
-        p : succ (x +N b) ≡ succ c
-        p rewrite succExtracts x b = nonnegInjective pr
-        g : x +N b ≡ c
-        g = succInjective p
-    subtractNonnegSucc (negSucc x) b c pr = negSuccPlusNonnegNonnegConverse x b c (succInjective p')
-      where
-        p' : succ b ≡ succ (c +N succ x)
-        p' = negSuccPlusNonnegNonneg x (succ b) (succ c) pr
-
-    addNegsuccThenNonneg : (a : ℤ) (b c : ℕ) → (a +Z negSucc b) +Z nonneg (succ (c +N b)) ≡ a +Z nonneg c
-    addNegsuccThenNonneg (nonneg zero) zero c rewrite addZeroRight c = refl
-    addNegsuccThenNonneg (nonneg (succ x)) zero c rewrite addZeroRight c | addingNonnegIsHom x (succ c) = applyEquality nonneg (succExtracts x c)
-    addNegsuccThenNonneg (nonneg zero) (succ b) c = moveNegsuccConverse b (nonneg (c +N succ b)) (nonneg c) (equalityCommutative (addingNonnegIsHom c (succ b)))
-    addNegsuccThenNonneg (nonneg (succ x)) (succ b) c with addNegsuccThenNonneg (nonneg x) b c
-    ... | prev = go
-      where
-        go : (nonneg x +Z negSucc b) +Z nonneg (succ (c +N succ b)) ≡ nonneg (succ (x +N c))
-        go rewrite addingNonnegIsHom x c | succExtracts c b = p
-          where
-            p : (nonneg x +Z negSucc b) +Z nonneg (succ (succ (c +N b))) ≡ nonneg (succ (x +N c))
-            p = addNonnegSucc (nonneg x +Z negSucc b) (succ (c +N b)) (x +N c) prev
-    addNegsuccThenNonneg (negSucc x) zero c rewrite addZeroRight c | sumOfNegsucc x 0 | addZeroRight x = refl
-    addNegsuccThenNonneg (negSucc x) (succ b) c with addNegsuccThenNonneg (negSucc x) b c
-    ... | prev = go
-      where
-        p : nonneg c ≡ ((negSucc x +Z negSucc b) +Z nonneg (succ (c +N b))) +Z nonneg (succ x)
-        p = moveNegsucc x (nonneg c) ((negSucc x +Z negSucc b) +Z nonneg (succ (c +N b))) (equalityCommutative prev)
-        go : (negSucc x +Z negSucc (succ b)) +Z nonneg (succ (c +N succ b)) ≡ negSucc x +Z nonneg c
-        go rewrite sumOfNegsucc x (succ b) | succExtracts c b = identityOfIndiscernablesLeft ((negSucc x +Z negSucc b) +Z nonneg (succ (c +N b))) (negSucc x +Z nonneg c) (negSucc (x +N succ b) +Z nonneg (succ (c +N b))) _≡_ prev (applyEquality (λ t → t +Z nonneg (succ (c +N b))) {negSucc x +Z negSucc b} {negSucc (x +N succ b)} (identityOfIndiscernablesRight (negSucc x +Z negSucc b) (negSucc (succ (x +N b))) (negSucc (x +N succ b)) _≡_ (sumOfNegsucc x b) (applyEquality negSucc (equalityCommutative (succExtracts x b)))))
-
-    addNonnegThenNonneg : (a : ℤ) (b c : ℕ) → (a +Z nonneg b) +Z nonneg c ≡ a +Z nonneg (b +N c)
-    addNonnegThenNonneg (nonneg x) b c rewrite addingNonnegIsHom x b | addingNonnegIsHom x (b +N c) | addingNonnegIsHom (x +N b) c = applyEquality nonneg (additionNIsAssociative x b c)
-    addNonnegThenNonneg (negSucc x) b zero rewrite addZeroRight b | additionZeroDoesNothing (negSucc x +Z nonneg b) = refl
-    addNonnegThenNonneg (negSucc x) b (succ c) with addNonnegThenNonneg (negSucc x) b c
-    ... | prev = prev'
-      where
-        prev' : ((negSucc x +Z nonneg b) +Z nonneg (succ c)) ≡ negSucc x +Z nonneg (b +N succ c)
-        prev' rewrite addNonnegSucc' (negSucc x +Z nonneg b) (negSucc x) c (b +N c) prev | succExtracts b c = refl
-
-    additionZIsAssociativeFirstAndSecondArgNonneg : (a b : ℕ) (c : ℤ) → (nonneg a +Z (nonneg b +Z c)) ≡ ((nonneg a) +Z nonneg b) +Z c
-    additionZIsAssociativeFirstAndSecondArgNonneg zero b c = refl
-    additionZIsAssociativeFirstAndSecondArgNonneg (succ a) b (nonneg zero) = i
-      where
-        h : nonneg (succ a) +Z (nonneg b +Z nonneg zero) ≡ nonneg (succ a) +Z nonneg b
-        h = identityOfIndiscernablesLeft (nonneg (succ a) +Z nonneg b) (nonneg (succ a) +Z nonneg b) (nonneg (succ a) +Z (nonneg b +Z nonneg zero)) _≡_ refl (applyEquality (λ r → nonneg (succ a) +Z r) {nonneg b} {nonneg b +Z nonneg zero} (equalityCommutative (additionZeroDoesNothing (nonneg b))))
-        i : nonneg (succ a) +Z (nonneg b +Z nonneg zero) ≡ (nonneg (succ a) +Z nonneg b) +Z nonneg zero
-        i = identityOfIndiscernablesRight (nonneg (succ a) +Z (nonneg b +Z nonneg zero)) (nonneg (succ a) +Z nonneg b) ((nonneg (succ a) +Z nonneg b) +Z nonneg zero) _≡_ h (equalityCommutative (additionZeroDoesNothing (nonneg (succ a) +Z nonneg b)))
-    additionZIsAssociativeFirstAndSecondArgNonneg (succ x) zero (nonneg (succ c)) = applyEquality nonneg (applyEquality succ (applyEquality (λ n → n +N succ c) {x} {x +N zero} (equalityCommutative (addZeroRight x))))
-    additionZIsAssociativeFirstAndSecondArgNonneg (succ x) (succ b) (nonneg (succ c)) = applyEquality nonneg (applyEquality succ i)
-      where
-        h : x +N (succ b +N succ c) ≡ (x +N succ b) +N succ c
-        h = equalityCommutative (additionNIsAssociative x (succ b) (succ c))
-        i : x +N succ (b +N succ c) ≡ (x +N succ b) +N succ c
-        i = identityOfIndiscernablesLeft (x +N (succ b +N succ c)) ((x +N succ b) +N succ c) (x +N succ (b +N succ c)) _≡_ h refl
-    additionZIsAssociativeFirstAndSecondArgNonneg (succ x) zero (negSucc c) rewrite addZeroRight x = refl
-    additionZIsAssociativeFirstAndSecondArgNonneg (succ x) (succ b) (negSucc zero) rewrite additionNIsCommutative x b | additionNIsCommutative x (succ b) = refl
-    additionZIsAssociativeFirstAndSecondArgNonneg (succ x) (succ b) (negSucc (succ c)) rewrite additionNIsCommutative x (succ b) | additionNIsCommutative b x = additionZIsAssociativeFirstAndSecondArgNonneg (succ x) b (negSucc c)
-
-    additionZIsAssociativeFirstArgNonneg : (a : ℕ) (b c : ℤ) → (nonneg a +Z (b +Z c) ≡ ((nonneg a) +Z b) +Z c)
-    additionZIsAssociativeFirstArgNonneg zero (nonneg b) c = additionZIsAssociativeFirstAndSecondArgNonneg 0 b c
-    additionZIsAssociativeFirstArgNonneg 0 (negSucc b) c = refl
-    additionZIsAssociativeFirstArgNonneg (succ a) (nonneg b) c = additionZIsAssociativeFirstAndSecondArgNonneg (succ a) b c
-    additionZIsAssociativeFirstArgNonneg (succ x) (negSucc zero) (nonneg 0) rewrite addingNonnegIsHom x zero | addZeroRight x = refl
-    additionZIsAssociativeFirstArgNonneg (succ x) (negSucc zero) (nonneg (succ c)) = i
-      where
-        h : nonneg (succ (x +N c)) ≡ nonneg (x +N succ c)
-        s : nonneg (x +N succ c) ≡ nonneg (succ c +N x)
-        t : nonneg (x +N succ c) ≡ nonneg (succ c) +Z nonneg x
-        i : nonneg (succ (x +N c)) ≡ nonneg x +Z nonneg (succ c)
-        h = applyEquality nonneg (equalityCommutative (succExtracts x c))
-        s = applyEquality nonneg (additionNIsCommutative x (succ c))
-        t = transitivity s refl
-        i = transitivity h (equalityCommutative (addingNonnegIsHom x (succ c)))
-    additionZIsAssociativeFirstArgNonneg (succ x) (negSucc (succ b)) (nonneg 0) rewrite additionZIsCommutative (nonneg x +Z negSucc b) (nonneg zero) = refl
-    additionZIsAssociativeFirstArgNonneg (succ x) (negSucc (succ b)) (nonneg (succ c)) = p
-      where
-        p''' : nonneg x +Z (negSucc b +Z nonneg c) ≡ (nonneg x +Z negSucc b) +Z nonneg c
-        p''' = additionZIsAssociativeFirstArgNonneg x (negSucc b) (nonneg c)
-        p'' : (negSucc b +Z nonneg c) +Z nonneg x ≡ (nonneg x +Z negSucc b) +Z nonneg c
-        p'' = identityOfIndiscernablesLeft (nonneg x +Z (negSucc b +Z nonneg c)) ((nonneg x +Z negSucc b) +Z nonneg c) ((negSucc b +Z nonneg c) +Z nonneg x) _≡_ p''' (additionZIsCommutative (nonneg x) (negSucc b +Z nonneg c))
-        p' : (negSucc b +Z nonneg c) +Z nonneg (succ x) ≡ (nonneg x +Z negSucc b) +Z nonneg (succ c)
-        p' = addNonnegSucc' (negSucc b +Z nonneg c) (nonneg x +Z negSucc b) x c p''
-        p : nonneg (succ x) +Z (negSucc b +Z nonneg c) ≡ (nonneg x +Z negSucc b) +Z nonneg (succ c)
-        p = identityOfIndiscernablesLeft ((negSucc b +Z nonneg c) +Z nonneg (succ x)) ((nonneg x +Z negSucc b) +Z nonneg (succ c)) (nonneg (succ x) +Z (negSucc b +Z nonneg c)) _≡_ p' (additionZIsCommutative (negSucc b +Z nonneg c) (nonneg (succ x)))
-    additionZIsAssociativeFirstArgNonneg (succ x) (negSucc zero) (negSucc c) = refl
-    additionZIsAssociativeFirstArgNonneg (succ a) (negSucc (succ b)) (negSucc zero) rewrite additionNIsCommutative b 1 | additionZIsCommutative (nonneg a +Z negSucc b) (negSucc 0) = equalityCommutative (moveNegsuccConverse 0 (nonneg a +Z negSucc b) (nonneg a +Z negSucc (succ b)) q'')
-      where
-        q : nonneg 1 +Z (nonneg a +Z negSucc (succ b)) ≡ (nonneg 1 +Z nonneg a) +Z negSucc (succ b)
-        q = additionZIsAssociativeFirstAndSecondArgNonneg 1 a (negSucc (succ b))
-        q' : (nonneg 1 +Z nonneg a) +Z negSucc (succ b) ≡ (nonneg a +Z negSucc (succ b)) +Z nonneg 1
-        q' rewrite additionZIsCommutative (nonneg a +Z negSucc (succ b)) (nonneg 1) = equalityCommutative q
-        q'' : nonneg (succ a) +Z negSucc (succ b) ≡ (nonneg a +Z negSucc (succ b)) +Z nonneg 1
-        q'' rewrite addingNonnegIsHom 1 a = q'
-    additionZIsAssociativeFirstArgNonneg (succ a) (negSucc (succ b)) (negSucc (succ c)) = ans
-      where
-        ans : nonneg a +Z negSucc (b +N succ (succ c)) ≡ (nonneg a +Z negSucc b) +Z negSucc (succ c)
-        p :   nonneg a +Z (negSucc b +Z negSucc (succ c)) ≡ (nonneg a +Z negSucc b) +Z negSucc (succ c)
-        p = additionZIsAssociativeFirstArgNonneg a (negSucc b) (negSucc (succ c))
-        p' : negSucc (b +N succ (succ c)) ≡ negSucc b +Z negSucc (succ c)
-        p' rewrite additionZIsCommutative (negSucc b) (negSucc (succ c)) | additionNIsCommutative b (succ (succ c)) | additionNIsCommutative c (succ b) | additionNIsCommutative c b  = refl
-        ans rewrite p' = p
-
-    additionZIsAssociative : (a b c : ℤ) → (a +Z (b +Z c)) ≡ (a +Z b) +Z c
-    additionZIsAssociative (nonneg a) b c = additionZIsAssociativeFirstArgNonneg a b c
-    additionZIsAssociative (negSucc a) (nonneg b) c rewrite additionZIsCommutative (negSucc a) (nonneg b) | additionZIsCommutative (negSucc a) (nonneg b +Z c) = p''
-      where
-        p : (nonneg b +Z c) +Z negSucc a ≡ nonneg b +Z (c +Z negSucc a)
-        p = equalityCommutative (additionZIsAssociativeFirstArgNonneg b c (negSucc a))
-        p' : (nonneg b +Z c) +Z negSucc a ≡ nonneg b +Z (negSucc a +Z c)
-        p' rewrite additionZIsCommutative (negSucc a) c = p
-        p'' : (nonneg b +Z c) +Z negSucc a ≡ (nonneg b +Z negSucc a) +Z c
-        p'' rewrite equalityCommutative (additionZIsAssociativeFirstArgNonneg b (negSucc a) c) = p'
-    additionZIsAssociative (negSucc a) (negSucc b) (nonneg c) rewrite additionZIsCommutative (negSucc a +Z negSucc b) (nonneg c) | additionZIsCommutative (negSucc b) (nonneg c) | additionZIsCommutative (negSucc a) (nonneg c +Z negSucc b) = p'
-      where
-        p : (nonneg c +Z negSucc b) +Z negSucc a ≡ nonneg c +Z (negSucc b +Z negSucc a)
-        p = equalityCommutative (additionZIsAssociativeFirstArgNonneg c (negSucc b) (negSucc a))
-        p' : (nonneg c +Z negSucc b) +Z negSucc a ≡ nonneg c +Z (negSucc a +Z negSucc b)
-        p' rewrite additionZIsCommutative (negSucc a) (negSucc b) = p
-    additionZIsAssociative (negSucc zero) (negSucc zero) (negSucc c) = refl
-    additionZIsAssociative (negSucc zero) (negSucc (succ b)) (negSucc c) = refl
-    additionZIsAssociative (negSucc (succ a)) (negSucc zero) (negSucc c) rewrite additionNIsCommutative a 1 | additionNIsCommutative a (succ (succ c)) | additionNIsCommutative a (succ c) = refl
-    additionZIsAssociative (negSucc (succ a)) (negSucc (succ b)) (negSucc zero) rewrite additionNIsCommutative b 1 | additionNIsCommutative (succ ((a +N succ (succ b)))) 1 = applyEquality (λ t → negSucc (succ t)) (p (succ (succ b)))
-      where
-        p : (r : ℕ) → a +N succ r ≡ succ (a +N r)
-        p r rewrite additionNIsCommutative a (succ r) | additionNIsCommutative r a = refl
-    additionZIsAssociative (negSucc (succ a)) (negSucc (succ b)) (negSucc (succ c)) = applyEquality (λ t → negSucc (succ t)) (equalityCommutative (additionNIsAssociative a (succ (succ b)) (succ (succ c))))
-
-    lessZIrreflexive : {a : ℤ} → (a <Z a) → False
-    lessZIrreflexive {nonneg a} (le x proof) = lessLemma a x (nonnegInjective proof)
-    lessZIrreflexive {negSucc a} (le x proof) = naughtE (equalityCommutative q)
-      where
-        pr' : nonneg (succ x) +Z (negSucc a +Z nonneg (succ a)) ≡ negSucc a +Z nonneg (succ a)
-        pr' rewrite additionZIsAssociative (nonneg (succ x)) (negSucc a) (nonneg (succ a)) = applyEquality (λ t → t +Z nonneg (succ a)) proof
-        pr'' : nonneg (succ x) +Z nonneg 0 ≡ nonneg 0
-        pr'' rewrite equalityCommutative (additiveInverseExists a) = identityOfIndiscernablesLeft (nonneg (succ x) +Z (negSucc a +Z nonneg (succ a))) (negSucc a +Z nonneg (succ a)) (nonneg (succ (x +N zero))) _≡_ pr' q
-          where
-            q : nonneg (succ x) +Z (negSucc a +Z nonneg (succ a)) ≡ nonneg (succ (x +N 0))
-            q rewrite additionNIsCommutative x 0 | additiveInverseExists a | additionNIsCommutative x 0 = refl
-        pr''' : succ x +N 0 ≡ 0
-        pr''' rewrite addingNonnegIsHom (succ x) 0 = nonnegInjective pr''
-        q : succ x ≡ 0
-        q rewrite additionNIsCommutative 0 (succ x) = pr'''
-
-    lessNegsuccNonneg : {a b : ℕ} → (negSucc a <Z nonneg b)
-    lessNegsuccNonneg {a} {b} = record { x = x ; proof = pr }
-      where
-        x : ℕ
-        x = a +N b
-        pr' : nonneg (succ (a +N b)) ≡ nonneg b +Z nonneg (succ a)
-        pr' rewrite addingNonnegIsHom b (succ a) | additionNIsCommutative b (succ a) = refl
-        pr : nonneg (succ x) +Z negSucc a ≡ nonneg b
-        pr rewrite additionZIsCommutative (nonneg (succ x)) (negSucc a) = moveNegsuccConverse a (nonneg (succ (a +N b))) (nonneg b) pr'
-
-    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} | inl (inl a<b) = inl (inl (lessIsPreservedNToZ a<b))
-    lessThanTotalZ {nonneg a} {nonneg b} | inl (inr b<a) = inl (inr (lessIsPreservedNToZ 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
-    ... | inl (inl a<b) = inl (inr (lessIsPreservedNToZNegsucc a<b))
-    ... | inl (inr b<a) = inl (inl (lessIsPreservedNToZNegsucc b<a))
-    lessThanTotalZ {negSucc a} {negSucc .a} | inr refl = inr refl
-
-    negSuccPlusNegsuccIsNegsucc : {a b c : ℕ} → (negSucc a +Z negSucc b ≡ nonneg c) → False
-    negSuccPlusNegsuccIsNegsucc {zero} {b} {c} pr = nonnegIsNotNegsucc (equalityCommutative pr)
-    negSuccPlusNegsuccIsNegsucc {succ a} {b} {c} pr = nonnegIsNotNegsucc (equalityCommutative pr)
-
-    multiplicationZ'IsAssociative : (a b c : ℤSimple) → (a *Z' (b *Z' c)) ≡ ((a *Z' b) *Z' c)
-    multiplicationZ'IsAssociative (negative zero (le x ())) b c
-    multiplicationZ'IsAssociative (negative (succ a) x) (negative zero (le x₁ ())) c
-    multiplicationZ'IsAssociative (negative (succ a) x) (negative (succ b) prb) (negative zero (le x₁ ()))
-    multiplicationZ'IsAssociative (negative (succ a) x) (negative ( succ b) prb) (negative (succ c) prc) = res _ _
-      where
-        help : _
-        help = multiplicationNIsAssociative (succ a) (succ b) (succ c)
-        res : (pr1 : 0 <N succ a *N (succ b *N succ c)) → (pr2 : 0 <N (succ a *N succ b) *N succ c) → negative (succ a *N (succ b *N succ c)) pr1 ≡ negative ((succ a *N succ b) *N succ c) pr2
-        res pr1 pr2 rewrite help = negIsNeg pr1 pr2
-    multiplicationZ'IsAssociative (negative (succ a) x) (negative (succ b) prb) (positive zero (le x₁ ()))
-    multiplicationZ'IsAssociative (negative (succ a) x) (negative (succ b) prb) (positive (succ c) prc) = res _ _
-      where
-        help : _
-        help = multiplicationNIsAssociative (succ a) (succ b) (succ c)
-        res : (pr1 : 0 <N succ a *N (succ b *N succ c)) → (pr2 : 0 <N (succ a *N succ b) *N succ c) → positive (succ a *N (succ b *N succ c)) pr1 ≡ positive ((succ a *N succ b) *N succ c) pr2
-        res pr1 pr2 rewrite help = posIsPos pr1 pr2
-    multiplicationZ'IsAssociative (negative (succ a) x) (negative (succ b) prb) zZero = refl
-    multiplicationZ'IsAssociative (negative (succ a) x) (positive zero (le x₁ ())) c
-    multiplicationZ'IsAssociative (negative (succ a) x) (positive (succ b) prb) (negative zero (le x₁ ()))
-    multiplicationZ'IsAssociative (negative (succ a) x) (positive (succ b) prb) (negative (succ c) prc) = res _ _
-      where
-        help : _
-        help = multiplicationNIsAssociative (succ a) (succ b) (succ c)
-        res : (pr1 : 0 <N succ a *N (succ b *N succ c)) → (pr2 : 0 <N (succ a *N succ b) *N succ c) → positive (succ a *N (succ b *N succ c)) pr1 ≡ positive ((succ a *N succ b) *N succ c) pr2
-        res pr1 pr2 rewrite help = posIsPos pr1 pr2
-    multiplicationZ'IsAssociative (negative (succ a) x) (positive (succ b) prb) (positive zero (le x₁ ()))
-    multiplicationZ'IsAssociative (negative (succ a) x) (positive (succ b) prb) (positive (succ c) prc) = res _ _
-      where
-        help : _
-        help = multiplicationNIsAssociative (succ a) (succ b) (succ c)
-        res : (pr1 : 0 <N succ a *N (succ b *N succ c)) → (pr2 : 0 <N (succ a *N succ b) *N succ c) → negative (succ a *N (succ b *N succ c)) pr1 ≡ negative ((succ a *N succ b) *N succ c) pr2
-        res pr1 pr2 rewrite help = negIsNeg pr1 pr2
-    multiplicationZ'IsAssociative (negative (succ a) x) (positive (succ b) prb) zZero = refl
-    multiplicationZ'IsAssociative (negative (succ a) x) zZero c = refl
-    multiplicationZ'IsAssociative (positive zero (le x ())) b c
-    multiplicationZ'IsAssociative (positive (succ a) x) (negative zero (le y ())) c
-    multiplicationZ'IsAssociative (positive (succ a) x) (negative (succ b) prb) (negative zero (le x₁ ()))
-    multiplicationZ'IsAssociative (positive (succ a) x) (negative (succ b) prb) (negative (succ c) prc) = res _ _
-      where
-        help : _
-        help = multiplicationNIsAssociative (succ a) (succ b) (succ c)
-        res : (pr1 : 0 <N succ a *N (succ b *N succ c)) → (pr2 : 0 <N (succ a *N succ b) *N succ c) → positive (succ a *N (succ b *N succ c)) pr1 ≡ positive ((succ a *N succ b) *N succ c) pr2
-        res pr1 pr2 rewrite help = posIsPos pr1 pr2
-    multiplicationZ'IsAssociative (positive (succ a) x) (negative (succ b) prb) (positive zero (le x₁ ()))
-    multiplicationZ'IsAssociative (positive (succ a) x) (negative (succ b) prb) (positive (succ c) prc) = res _ _
-      where
-        help : _
-        help = multiplicationNIsAssociative (succ a) (succ b) (succ c)
-        res : (pr1 : 0 <N succ a *N (succ b *N succ c)) → (pr2 : 0 <N (succ a *N succ b) *N succ c) → negative (succ a *N (succ b *N succ c)) pr1 ≡ negative ((succ a *N succ b) *N succ c) pr2
-        res pr1 pr2 rewrite help = negIsNeg pr1 pr2
-    multiplicationZ'IsAssociative (positive (succ a) x) (negative (succ b) prb) zZero = refl
-    multiplicationZ'IsAssociative (positive (succ a) x) (positive zero (le y ())) c
-    multiplicationZ'IsAssociative (positive (succ a) x) (positive (succ b) prb) (negative zero (le x₁ ()))
-    multiplicationZ'IsAssociative (positive (succ a) x) (positive (succ b) prb) (negative (succ c) prc) = res _ _
-      where
-        help : _
-        help = multiplicationNIsAssociative (succ a) (succ b) (succ c)
-        res : (pr1 : 0 <N succ a *N (succ b *N succ c)) → (pr2 : 0 <N (succ a *N succ b) *N succ c) → negative (succ a *N (succ b *N succ c)) pr1 ≡ negative ((succ a *N succ b) *N succ c) pr2
-        res pr1 pr2 rewrite help = negIsNeg pr1 pr2
-    multiplicationZ'IsAssociative (positive (succ a) x) (positive (succ b) prb) (positive zero (le x₁ ()))
-    multiplicationZ'IsAssociative (positive (succ a) x) (positive (succ b) prb) (positive (succ c) prc) = res _ _
-      where
-        help : _
-        help = multiplicationNIsAssociative (succ a) (succ b) (succ c)
-        res : (pr1 : 0 <N succ a *N (succ b *N succ c)) → (pr2 : 0 <N (succ a *N succ b) *N succ c) → positive (succ a *N (succ b *N succ c)) pr1 ≡ positive ((succ a *N succ b) *N succ c) pr2
-        res pr1 pr2 rewrite help = posIsPos pr1 pr2
-    multiplicationZ'IsAssociative (positive (succ a) x) (positive (succ b) prb) zZero = refl
-    multiplicationZ'IsAssociative (positive (succ a) x) zZero c = refl
-    multiplicationZ'IsAssociative zZero b c = refl
-
-    multiplicationZIsAssociative : (a b c : ℤ) → (a *Z (b *Z c)) ≡ (a *Z b) *Z c
-    multiplicationZIsAssociative a b c = ans
-      where
-        inter : convertZ' (convertZ a *Z' (convertZ b *Z' convertZ c)) ≡ convertZ' ((convertZ a *Z' convertZ b) *Z' convertZ c)
-        inter = applyEquality convertZ' (multiplicationZ'IsAssociative (convertZ a) (convertZ b) (convertZ c))
-        ans : a *Z (b *Z c) ≡ (a *Z b) *Z c
-        ans rewrite convertZ'DistributesOver*Z (convertZ a) (convertZ b *Z' convertZ c) | convertZ'DistributesOver*Z (convertZ b) (convertZ c) | convertZ'DistributesOver*Z (convertZ a *Z' convertZ b) (convertZ c) | convertZ'DistributesOver*Z (convertZ a) (convertZ b) | zIsZ c | zIsZ b | zIsZ a | zIsZ' (convertZ b *Z' convertZ c) | zIsZ' (convertZ a *Z' convertZ b) = inter
-
-    zeroIsAdditiveIdentityRightZ : (a : ℤ) → (a +Z nonneg zero) ≡ a
-    zeroIsAdditiveIdentityRightZ (nonneg x) = identityOfIndiscernablesRight (nonneg x +Z nonneg zero) (nonneg (x +N zero)) (nonneg x) _≡_ (addingNonnegIsHom x zero) ((applyEquality nonneg (addZeroRight x)))
-    zeroIsAdditiveIdentityRightZ (negSucc a) = refl
-
-    additiveInverseZ : (a : ℤ) → ℤ
-    additiveInverseZ (nonneg zero) = nonneg zero
-    additiveInverseZ (nonneg (succ x)) = negSucc x
-    additiveInverseZ (negSucc a) = nonneg (succ a)
-
-    addInverseLeftZ : (a : ℤ) → (additiveInverseZ a +Z a ≡ nonneg zero)
-    addInverseLeftZ (nonneg zero) = refl
-    addInverseLeftZ (nonneg (succ zero)) = refl
-    addInverseLeftZ (nonneg (succ (succ x))) = addInverseLeftZ (nonneg (succ x))
-    addInverseLeftZ (negSucc zero) = refl
-    addInverseLeftZ (negSucc (succ a)) = addInverseLeftZ (negSucc a)
-
-    addInverseRightZ : (a : ℤ) → (a +Z additiveInverseZ a ≡ nonneg zero)
-    addInverseRightZ (nonneg zero) = refl
-    addInverseRightZ (nonneg (succ zero)) = refl
-    addInverseRightZ (nonneg (succ (succ x))) = addInverseRightZ (nonneg (succ x))
-    addInverseRightZ (negSucc zero) = refl
-    addInverseRightZ (negSucc (succ a)) = addInverseRightZ (negSucc a)
-
-    flipSign : (a : ℕ) → negSucc a *Z negSucc 0 ≡ nonneg (succ a)
-    flipSign zero = refl
-    flipSign (succ a) = ans
-      where
-        help : convertZ (negSucc (succ a)) *Z' convertZ (negSucc 0) ≡ convertZ (nonneg (succ (succ a)))
-        help rewrite multiplicationNIsCommutative a 1 | additionNIsCommutative a 0 = refl
-        help' : convertZ' (convertZ (negSucc (succ a)) *Z' convertZ (negSucc 0)) ≡ convertZ' (convertZ (nonneg (succ (succ a))))
-        help' = applyEquality convertZ' help
-        help'' : convertZ' (convertZ (negSucc (succ a))) *Z (convertZ' (convertZ (negSucc 0))) ≡ nonneg (succ (succ a))
-        help'' rewrite convertZ'DistributesOver*Z (convertZ (negSucc (succ a))) (convertZ (negSucc 0)) | zIsZ (nonneg (succ (succ a))) = help'
-        ans : negSucc (succ a) *Z negSucc 0 ≡ nonneg (succ (succ a))
-        ans rewrite zIsZ (negSucc (succ a)) | zIsZ (negSucc 0) = help''
-
-    flipSign' : (a : ℕ) → nonneg (succ a) *Z negSucc 0 ≡ negSucc a
-    flipSign' a = ans
-      where
-        inter : negSucc 0 *Z negSucc 0 ≡ nonneg 1
-        inter = refl
-        ans : nonneg (succ a) *Z negSucc 0 ≡ negSucc a
-        ans rewrite inter | multiplicationNIsCommutative a 1 | additionNIsCommutative a 0 = refl
-
-    additionZ'IsCommutative : (a b : ℤSimple) → a +Z' b ≡ b +Z' a
-    additionZ'IsCommutative a b = ans
-      where
-        help : (convertZ' a) +Z (convertZ' b) ≡ (convertZ' b) +Z (convertZ' a)
-        help = additionZIsCommutative (convertZ' a) (convertZ' b)
-        help' : convertZ ((convertZ' a) +Z (convertZ' b)) ≡ convertZ ((convertZ' b) +Z (convertZ' a))
-        help' = applyEquality convertZ help
-        help'' : convertZ (convertZ' a) +Z' convertZ (convertZ' b) ≡ convertZ (convertZ' b) +Z' convertZ (convertZ' a)
-        help'' rewrite equalityCommutative (plusIsPlus' (convertZ' a) (convertZ' b)) | equalityCommutative (plusIsPlus' (convertZ' b) (convertZ' a)) = help'
-        ans : a +Z' b ≡ b +Z' a
-        ans rewrite equalityCommutative (zIsZ' a) | equalityCommutative (zIsZ' b) = help''
-    additionZ'IsAssociative : (a b c : ℤSimple) → (a +Z' (b +Z' c)) ≡ (a +Z' b) +Z' c
-    additionZ'IsAssociative a b c = identityOfIndiscernablesRight _ _ _ _≡_ helpV''' (applyEquality (λ t → (a +Z' t) +Z' c) (zIsZ' b))
-      where
-        help  : convertZ (convertZ' a +Z (convertZ' b +Z convertZ' c)) ≡ convertZ ((convertZ' a +Z convertZ' b) +Z convertZ' c)
-        help' : convertZ (convertZ' a) +Z' convertZ (convertZ' b +Z convertZ' c) ≡ convertZ (convertZ' a +Z convertZ' b) +Z' convertZ (convertZ' c)
-        help'' : a +Z' convertZ (convertZ' b +Z convertZ' c) ≡ convertZ (convertZ' a +Z convertZ' b) +Z' convertZ (convertZ' c)
-        help''' : a +Z' (convertZ (convertZ' b) +Z' convertZ (convertZ' c)) ≡ convertZ (convertZ' a +Z convertZ' b) +Z' convertZ (convertZ' c)
-        help'''' : a +Z' (b +Z' (convertZ (convertZ' c))) ≡ convertZ (convertZ' a +Z convertZ' b) +Z' convertZ (convertZ' c)
-        helpV : a +Z' (b +Z' c) ≡ convertZ (convertZ' a +Z convertZ' b) +Z' convertZ (convertZ' c)
-        helpV' : a +Z' (b +Z' c) ≡ convertZ (convertZ' a +Z convertZ' b) +Z' c
-        helpV'' : a +Z' (b +Z' c) ≡ (convertZ (convertZ' a) +Z' convertZ (convertZ' b)) +Z' c
-        helpV''' : a +Z' (b +Z' c) ≡ (a +Z' convertZ (convertZ' b)) +Z' c
-        helpV''' = identityOfIndiscernablesRight _ _ _ _≡_ helpV'' (applyEquality (λ t → ((t +Z' convertZ (convertZ' b)) +Z' c)) (zIsZ' a))
-        helpV'' rewrite equalityCommutative (plusIsPlus' (convertZ' a) (convertZ' b)) = helpV'
-        helpV' = identityOfIndiscernablesRight _ _ _ _≡_ helpV (applyEquality (λ t → convertZ (convertZ' a +Z convertZ' b) +Z' t) (zIsZ' c))
-        helpV = identityOfIndiscernablesLeft _ _ _ _≡_ help'''' (applyEquality (λ t → a +Z' (b +Z' t)) (zIsZ' c))
-        help'''' = identityOfIndiscernablesLeft _ _ _ _≡_ help''' (applyEquality (λ t → a +Z' (t +Z' (convertZ (convertZ' c)))) (zIsZ' b))
-        help''' rewrite equalityCommutative (plusIsPlus' (convertZ' b) (convertZ' c)) = help''
-        help'' = identityOfIndiscernablesLeft (convertZ (convertZ' a) +Z' convertZ (convertZ' b +Z convertZ' c)) _ (a +Z' convertZ (convertZ' b +Z convertZ' c)) _≡_ help' (applyEquality (λ t → t +Z' convertZ (convertZ' b +Z convertZ' c)) (zIsZ' a))
-        help = applyEquality convertZ (additionZIsAssociative (convertZ' a) (convertZ' b) (convertZ' c))
-        help' rewrite equalityCommutative (plusIsPlus' (convertZ' a) (convertZ' b +Z convertZ' c)) | equalityCommutative (plusIsPlus' (convertZ' a +Z convertZ' b) (convertZ' c)) = help
-
-    pos+Z'Pos : (a b : ℕ) → {pr : 0 <N a} → {pr2 : 0 <N b} → {pr3 : 0 <N a +N b} → (positive a pr) +Z' (positive b pr2) ≡ positive (a +N b) pr3
-    pos+Z'Pos zero b {le x ()} {pr2} {pr3}
-    pos+Z'Pos (succ a) zero {pr} {le x ()} {pr3}
-    pos+Z'Pos (succ a) (succ b) {pr} {pr2} {pr3} rewrite <NRefl (pr) (succIsPositive a) | <NRefl pr2 (succIsPositive b) | <NRefl pr3 (succIsPositive (a +N succ b)) = refl
-
-    lemma'' : (a b c : ℕ) → (pr : _) → (pr2 : _) → (pr3 : _) → positive (succ ((b +N succ c) +N a *N succ (b +N succ c))) pr ≡ positive (succ (b +N a *N succ b)) pr2 +Z' positive (succ (c +N a *N succ c)) pr3
-    lemma'' a b c pr1 pr2 pr3 = equalityCommutative help'
-      where
-        pr' : succ (b +N a *N succ b) +N succ (c +N a *N succ c) ≡ succ ((b +N succ c) +N a *N succ (b +N succ c))
-        pr' = equalityCommutative (productDistributes (succ a) (succ b) (succ c))
-        pr'' : 0 <N succ (b +N a *N succ b) +N succ (c +N a *N succ c)
-        pr'' rewrite pr' = pr1
-        help : (positive (succ (b +N a *N succ b))) pr2 +Z' (positive (succ (c +N a *N succ c))) pr3 ≡ positive (succ (b +N a *N succ b) +N succ (c +N a *N succ c)) pr''
-        help = pos+Z'Pos (succ (b +N a *N succ b)) (succ (c +N a *N succ c)) {pr2} {pr3} {pr''}
-        help' : (positive (succ (b +N a *N succ b))) pr2 +Z' (positive (succ (c +N a *N succ c))) pr3 ≡ positive (succ ((b +N succ c) +N a *N succ (b +N succ c))) pr1
-        help' rewrite equalityCommutative pr' | <NRefl pr1 (succIsPositive ((b +N a *N succ b) +N succ (c +N a *N succ c))) = refl
-
-    addZZero : (a : ℤSimple) → a +Z' zZero ≡ a
-    addZZero (negative zero (le x ()))
-    addZZero (negative (succ a) x) rewrite additionZ'IsCommutative (negative (succ a) x) zZero = refl
-    addZZero (positive zero (le x ()))
-    addZZero (positive (succ a) x) rewrite additionZ'IsCommutative (positive (succ a) x) zZero = refl
-    addZZero zZero = refl
-
-    negSucc+ZNegSucc : (a b : ℕ) → (negSucc a +Z negSucc b) ≡ negSucc (succ a +N b)
-    negSucc+ZNegSucc zero b = refl
-    negSucc+ZNegSucc (succ a) b rewrite additionNIsCommutative a (succ b) | additionNIsCommutative b a = refl
-
-    oneIsIdentity : (a : ℤ) → convertZ' (positive 1 (succIsPositive 0) *Z' convertZ a) ≡ a
-    oneIsIdentity (nonneg zero) = refl
-    oneIsIdentity (nonneg (succ x)) rewrite additionNIsCommutative x 0 = refl
-    oneIsIdentity (negSucc x) rewrite additionNIsCommutative x 0 = refl
-
-    oneIsIdentity' : (a : ℤSimple) → (positive 1 (succIsPositive 0)) *Z' a ≡ a
-    oneIsIdentity' (negative zero (le x ()))
-    oneIsIdentity' (negative (succ a) x) rewrite additionNIsCommutative a 0 | <NRefl x (logical<NImpliesLe (record {})) = refl
-    oneIsIdentity' (positive zero (le x ()))
-    oneIsIdentity' (positive (succ a) x) rewrite additionNIsCommutative a 0 | <NRefl x (logical<NImpliesLe (record {})) = refl
-    oneIsIdentity' zZero = refl
-
-    canPullOutSuccZ' : (a : ℕ) → (b c : ℤSimple) → (positive (succ (succ a)) (succIsPositive (succ a))) *Z' (b +Z' c) ≡ (b +Z' c) +Z' (positive (succ a) (succIsPositive a)) *Z' (b +Z' c)
-    canPullOutSuccZ' a (negative zero (le x ())) c
-    canPullOutSuccZ' a (negative (succ b) _) (negative zero (le x ()))
-    canPullOutSuccZ' a (negative (succ b) _) (negative (succ c) x) = refl
-    canPullOutSuccZ' a (negative (succ b) _) (positive zero (le x ()))
-    canPullOutSuccZ' a (negative (succ b) y) (positive (succ c) x) with negative (succ b) y +Z' positive (succ c) x
-    canPullOutSuccZ' a (negative (succ b) y) (positive (succ c) x) | negative zero (le x₁ ())
-    canPullOutSuccZ' a (negative (succ b) y) (positive (succ c) x) | negative (succ sum) pr = refl
-    canPullOutSuccZ' a (negative (succ b) y) (positive (succ c) x) | positive zero (le x₁ ())
-    canPullOutSuccZ' a (negative (succ b) y) (positive (succ c) x) | positive (succ sum) pr = refl
-    canPullOutSuccZ' a (negative (succ b) y) (positive (succ c) x) | zZero = refl
-    canPullOutSuccZ' a (negative (succ b) _) zZero = refl
-    canPullOutSuccZ' a (positive zero (le x ())) c
-    canPullOutSuccZ' a (positive (succ b) _) (negative zero (le x ()))
-    canPullOutSuccZ' a (positive (succ b) y) (negative (succ c) x) with positive (succ b) y +Z' negative (succ c) x
-    canPullOutSuccZ' a (positive (succ b) y) (negative (succ c) x) | negative zero (le x₁ ())
-    canPullOutSuccZ' a (positive (succ b) y) (negative (succ c) x) | negative (succ sum) pr = refl
-    canPullOutSuccZ' a (positive (succ b) y) (negative (succ c) x) | positive zero (le x₁ ())
-    canPullOutSuccZ' a (positive (succ b) y) (negative (succ c) x) | positive (succ sum) pr = refl
-    canPullOutSuccZ' a (positive (succ b) y) (negative (succ c) x) | zZero = refl
-    canPullOutSuccZ' a (positive (succ b) _) (positive zero (le x ()))
-    canPullOutSuccZ' a (positive (succ b) _) (positive (succ c) x) = refl
-    canPullOutSuccZ' a (positive (succ b) _) zZero = refl
-    canPullOutSuccZ' a zZero (negative zero (le x ()))
-    canPullOutSuccZ' a zZero (negative (succ c) x) = refl
-    canPullOutSuccZ' a zZero (positive zero (le x ()))
-    canPullOutSuccZ' a zZero (positive (succ c) x) = refl
-    canPullOutSuccZ' a zZero zZero = refl
-
-    canPullOutSuccZ : (a : ℕ) → (b : ℤSimple) → (positive (succ (succ a)) (succIsPositive (succ a))) *Z' b ≡ b +Z' (positive (succ a) (succIsPositive a)) *Z' b
-    canPullOutSuccZ a b = ans b
-      where
-        ans : (b : ℤSimple) → (positive (succ (succ a)) (succIsPositive (succ a))) *Z' b ≡ b +Z' (positive (succ a) (succIsPositive a)) *Z' b
-        ans (negative zero (le x ()))
-        ans (negative (succ b) x) = refl
-        ans (positive zero (le x ()))
-        ans (positive (succ b) x) = refl
-        ans zZero = refl
-
-
-    swapAdds : (a c : ℕ) → (a +N succ c) +N succ (a +N succ c) ≡ (a +N succ a) +N succ (c +N succ c)
-    swapAdds a c rewrite additionNIsAssociative a (succ c) (succ (a +N succ c)) | additionNIsAssociative a (succ a) (succ (c +N succ c)) = applyEquality (λ t → a +N succ t) help'
-      where
-        help' : c +N succ (a +N succ c) ≡ a +N succ (c +N succ c)
-        help' rewrite additionNIsCommutative c (succ (a +N succ c)) | additionNIsCommutative (a +N succ c) c | additionNIsCommutative (succ c) (a +N succ c) | additionNIsAssociative a (succ c) (succ c) = refl
-
-    lemmaDistributive : (a : ℕ) → (b c : ℤSimple) → (positive (succ a) (succIsPositive a)) *Z' (b +Z' c) ≡ positive (succ a) (succIsPositive a) *Z' b +Z' positive (succ a) (succIsPositive a) *Z' c
-    lemmaDistributive zero (negative zero (le x ())) c
-    lemmaDistributive zero (negative (succ b) prB) (negative zero (le x ()))
-    lemmaDistributive zero (negative (succ b) prB) (negative (succ a) x) rewrite additionNIsCommutative a 0 | additionNIsCommutative b 0 | additionNIsCommutative (b +N succ a) 0 = refl
-
-    lemmaDistributive zero (negative (succ b) prB) (positive zero (le x ()))
-    lemmaDistributive zero (negative (succ b) prB) (positive (succ a) x) rewrite oneIsIdentity' (negative (succ b) prB +Z' positive (succ a) x) | additionNIsCommutative b 0 | additionNIsCommutative a 0 | <NRefl x (logical<NImpliesLe (record {})) | <NRefl prB (logical<NImpliesLe (record {})) = refl
-    lemmaDistributive zero (negative (succ b) prB) zZero = refl
-    lemmaDistributive zero (positive zero (le x ())) c
-    lemmaDistributive zero (positive (succ b) prB) (negative zero (le x ()))
-    lemmaDistributive zero (positive (succ b) prB) (negative (succ a) x) rewrite additionNIsCommutative b 0 | additionNIsCommutative a 0 | oneIsIdentity' (positive (succ b) prB +Z' negative (succ a) x) | <NRefl prB (logical<NImpliesLe (record {})) | <NRefl x (logical<NImpliesLe (record {})) = refl
-    lemmaDistributive zero (positive (succ b) prB) (positive zero (le x ()))
-    lemmaDistributive zero (positive (succ b) prB) (positive (succ a) x) rewrite additionNIsCommutative b 0 | additionNIsCommutative a 0 = help2 ((b +N succ a) +N 0) (b +N succ a) (applyEquality succ lem)
-      where
-        help2 : (a b : ℕ) → (pr : succ a ≡ succ b) → positive (succ a) (succIsPositive _) ≡ positive (succ b) (succIsPositive _)
-        help2 a .a refl = refl
-        lem : (b +N succ a) +N 0 ≡ b +N succ a
-        lem rewrite additionNIsCommutative (b +N succ a) 0 = refl
-    lemmaDistributive zero (positive (succ b) prB) zZero = refl
-    lemmaDistributive zero zZero c rewrite oneIsIdentity' (zZero +Z' c) | oneIsIdentity' c = refl
-    lemmaDistributive (succ a) b c = lemmV''
-      where
-        internallemma' : (positive (succ (succ a)) (succIsPositive (succ a))) *Z' (b +Z' c) ≡ (b +Z' c) +Z' (positive (succ a) (succIsPositive a)) *Z' (b +Z' c)
-        internallemma' = canPullOutSuccZ' a b c
-        p : positive (succ (succ a)) (succIsPositive (succ a)) *Z' b ≡ b +Z' positive (succ a) (succIsPositive a) *Z' b
-        p = canPullOutSuccZ a b
-        q : positive (succ (succ a)) (succIsPositive (succ a)) *Z' c ≡ c +Z' positive (succ a) (succIsPositive a) *Z' c
-        q = canPullOutSuccZ a c
-        indHyp : (positive (succ a) (succIsPositive a)) *Z' (b +Z' c) ≡ positive (succ a) (succIsPositive a) *Z' b +Z' positive (succ a) (succIsPositive a) *Z' c
-        indHyp = lemmaDistributive a b c
-        lemm : (positive (succ (succ a)) (succIsPositive (succ a))) *Z' (b +Z' c) ≡ (b +Z' c) +Z' (positive (succ a) (succIsPositive a) *Z' b +Z' positive (succ a) (succIsPositive a) *Z' c)
-        lemm rewrite equalityCommutative indHyp = internallemma'
-        lemm' : (positive (succ (succ a)) (succIsPositive (succ a))) *Z' (b +Z' c) ≡ b +Z' (c +Z' ((positive (succ a) (succIsPositive a) *Z' b +Z' positive (succ a) (succIsPositive a) *Z' c)))
-        lemm' rewrite additionZ'IsAssociative b c (positive (succ a) (succIsPositive a) *Z' b +Z' positive (succ a) (succIsPositive a) *Z' c) = lemm
-        lemm'' : (positive (succ (succ a)) (succIsPositive (succ a))) *Z' (b +Z' c) ≡ b +Z' (((positive (succ a) (succIsPositive a) *Z' b +Z' positive (succ a) (succIsPositive a) *Z' c)) +Z' c)
-        inter : ((positive (succ a) (succIsPositive a) *Z' b +Z' positive (succ a) (succIsPositive a) *Z' c)) +Z' c ≡ positive (succ a) (succIsPositive a) *Z' b +Z' ((positive (succ a) (succIsPositive a) *Z' c) +Z' c)
-        lemm''' : (positive (succ (succ a)) (succIsPositive (succ a))) *Z' (b +Z' c) ≡ b +Z' (positive (succ a) (succIsPositive a) *Z' b +Z' ((positive (succ a) (succIsPositive a) *Z' c) +Z' c))
-        lemm'''' : (positive (succ (succ a)) (succIsPositive (succ a))) *Z' (b +Z' c) ≡ (b +Z' (positive (succ a) (succIsPositive a) *Z' b)) +Z' ((positive (succ a) (succIsPositive a) *Z' c) +Z' c)
-        lemm'''' rewrite equalityCommutative (additionZ'IsAssociative b (positive (succ a) (succIsPositive a) *Z' b) ((positive (succ a) (succIsPositive a) *Z' c) +Z' c)) = lemm'''
-        lemmV : (positive (succ (succ a)) (succIsPositive (succ a))) *Z' (b +Z' c) ≡ (positive (succ (succ a)) (succIsPositive (succ a)) *Z' b) +Z' ((positive (succ a) (succIsPositive a) *Z' c) +Z' c)
-        lemmV rewrite p = lemm''''
-        lemmV' : (positive (succ (succ a)) (succIsPositive (succ a))) *Z' (b +Z' c) ≡ (positive (succ (succ a)) (succIsPositive (succ a)) *Z' b) +Z' (c +Z' (positive (succ a) (succIsPositive a) *Z' c))
-        lemmV' rewrite additionZ'IsCommutative c (positive (succ a) (succIsPositive a) *Z' c) = lemmV
-        lemmV'' : (positive (succ (succ a)) (succIsPositive (succ a))) *Z' (b +Z' c) ≡ (positive (succ (succ a)) (succIsPositive (succ a)) *Z' b) +Z' (positive (succ (succ a)) (succIsPositive (succ a)) *Z' c)
-        lemmV'' rewrite q = lemmV'
-        lemm'' rewrite additionZ'IsCommutative ((positive (succ a) (succIsPositive a) *Z' b +Z' positive (succ a) (succIsPositive a) *Z' c)) c = lemm'
-        inter = equalityCommutative (additionZ'IsAssociative (positive (succ a) (succIsPositive a) *Z' b) (positive (succ a) (succIsPositive a) *Z' c) c)
-        lemm''' rewrite equalityCommutative inter = lemm''
-
-    addIsZero : (a b : ℕ) → {pr1 : 0 <N a} → {pr2 : 0 <N b} → ((positive a pr1) +Z' (negative b pr2) ≡ zZero) → a ≡ b
-    addIsZero zero b {le x ()} {pr2} pr
-    addIsZero (succ a) zero {pr1} {le x ()} pr
-    addIsZero (succ zero) (succ zero) {pr1} {pr2} pr = refl
-    addIsZero (succ zero) (succ (succ b)) {pr1} {pr2} pr = exFalso (f pr)
-      where
-        f : (negative (succ b) (logical<NImpliesLe (record {})) ≡ zZero) → False
-        f ()
-    addIsZero (succ (succ a)) (succ zero) {pr1} {pr2} pr = exFalso (f pr)
-      where
-        f : (positive (succ a) (logical<NImpliesLe (record {})) ≡ zZero) → False
-        f ()
-    addIsZero (succ (succ a)) (succ (succ b)) {pr1} {pr2} pr = applyEquality succ (addIsZero (succ a) (succ b) {succIsPositive a} {succIsPositive b} p)
-      where
-        q : positive (succ (succ a)) pr1 +Z' negative (succ (succ b)) pr2 ≡ positive (succ a) (succIsPositive a) +Z' negative (succ b) (succIsPositive b)
-        q = canKnockOneOff+Z' (succ a) (succ b) {succIsPositive a} {succIsPositive b} {pr1} {pr2}
-        p : positive (succ a) (succIsPositive a) +Z' negative (succ b) (succIsPositive b) ≡ zZero
-        p rewrite equalityCommutative q = pr
-
-    addIsZero' : (a : ℕ) → (negative (succ a) (succIsPositive a)) +Z' (positive (succ a) (succIsPositive a)) ≡ zZero
-    addIsZero' (zero) = refl
-    addIsZero' (succ a) = transitivity q p
-      where
-        p : negative (succ a) (succIsPositive a) +Z' positive (succ a) (succIsPositive a) ≡ zZero
-        p = addIsZero' a
-        q : negative (succ (succ a)) (succIsPositive (succ a)) +Z' positive (succ (succ a)) (succIsPositive (succ a)) ≡ negative (succ a) (succIsPositive a) +Z' positive (succ a) (succIsPositive a)
-        q = canKnockOneOff+Z'2 (succ a) (succ a) {succIsPositive a} {succIsPositive a} {succIsPositive (succ a)} {succIsPositive (succ a)}
-
-    timesNegPosPos : (a b c : ℕ) → (negative (succ a) (succIsPositive a)) *Z' ((positive (succ b) (succIsPositive b)) +Z' (positive (succ c) (succIsPositive c))) ≡ (positive (succ a) (succIsPositive a)) *Z' ((negative (succ b) (succIsPositive b)) +Z' (negative (succ c) (succIsPositive c)))
-    timesNegPosPos a b c = refl
-
-    diffProof : (a b : ℕ) → (sum1 sum2 : ℕ) → (pr1 : succ a +N succ b ≡ sum1) → (pr2 : succ a +N succ b ≡ sum2) → (prSums : sum1 ≡ sum2) → plusZ' sum1 (negative (succ a) (succIsPositive a)) (positive (succ b) (succIsPositive b)) pr1 ≡ plusZ' sum2 (negative (succ a) (succIsPositive a)) (positive (succ b) (succIsPositive b)) pr2
-    diffProof a b .(succ (a +N succ b)) .(succ (a +N succ b)) refl refl refl = refl
-
-    diffProof' : (a b : ℕ) → (sum1 sum2 : ℕ) → (pr1 : succ a +N succ b ≡ sum1) → (pr2 : succ a +N succ b ≡ sum2) → (prSums : sum1 ≡ sum2) → plusZ' sum1 (positive (succ a) (succIsPositive a)) (negative (succ b) (succIsPositive b)) pr1 ≡ plusZ' sum2 (positive (succ a) (succIsPositive a)) (negative (succ b) (succIsPositive b)) pr2
-    diffProof' a b .(succ (a +N succ b)) .(succ (a +N succ b)) refl refl refl = refl
-
-    timesNegPosNeg : (a b c : ℕ) → (negative (succ a) (succIsPositive a)) *Z' ((positive (succ b) (succIsPositive b)) +Z' (negative (succ c) (succIsPositive c))) ≡ (positive (succ a) (succIsPositive a)) *Z' ((negative (succ b) (succIsPositive b)) +Z' (positive (succ c) (succIsPositive c)))
-    timesNegPosNeg zero zero zero = refl
-    timesNegPosNeg zero zero (succ c) = refl
-    timesNegPosNeg zero (succ b) zero = refl
-    timesNegPosNeg zero (succ b) (succ c) = identityOfIndiscernablesRight _ _ _ _≡_ ans'' (applyEquality (λ t → positive 1 _ *Z' t) (knocked'))
-      where
-        knocked : positive (succ (succ b)) (succIsPositive (succ b)) +Z' negative (succ (succ c)) (succIsPositive (succ c)) ≡ positive (succ b) _ +Z' negative (succ c) _
-        knocked = canKnockOneOff+Z' (succ b) (succ c) {succIsPositive b} {succIsPositive c} {succIsPositive (succ b)} {succIsPositive (succ c)}
-        knocked' : negative (succ b) (succIsPositive b) +Z' positive (succ c) (succIsPositive c) ≡ negative (succ (succ b)) (succIsPositive (succ b)) +Z' positive (succ (succ c)) (succIsPositive (succ c))
-        knocked' rewrite additionZ'IsCommutative (negative (succ b) (succIsPositive b)) (positive (succ c) (succIsPositive c)) | additionZ'IsCommutative (negative (succ (succ b)) (succIsPositive (succ b))) (positive (succ (succ c)) (succIsPositive (succ c))) = diffProof' c b (succ (c +N succ b)) (c +N succ (succ b)) refl help (equalityCommutative (succExtracts c (succ b)))
-          where
-            help : (succ (c +N succ b)) ≡ c +N succ (succ b)
-            help = _
-        ans : negative 1 (succIsPositive zero) *Z' (positive (succ b) _ +Z' negative (succ c) _) ≡ positive 1 _ *Z' (negative (succ b) _ +Z' positive (succ c) _)
-        ans = timesNegPosNeg zero b c
-        ans' : negative 1 _ *Z' (positive (succ (succ b)) (succIsPositive (succ b)) +Z' negative (succ (succ c)) (succIsPositive (succ c))) ≡ negative 1 _ *Z' (positive (succ b) _ +Z' negative (succ c) _)
-        ans' = applyEquality (λ t → negative 1 _ *Z' t) knocked
-        ans'' : negative 1 _ *Z' (positive (succ (succ b)) (succIsPositive (succ b)) +Z' negative (succ (succ c)) (succIsPositive (succ c))) ≡ positive 1 _ *Z' (negative (succ b) _ +Z' positive (succ c) _)
-        ans'' = identityOfIndiscernablesRight _ _ _ _≡_ ans' ans
-    timesNegPosNeg (succ a) zero zero = refl
-    timesNegPosNeg (succ a) zero (succ c) = refl
-    timesNegPosNeg (succ a) (succ b) zero = refl
-    timesNegPosNeg (succ a) (succ b) (succ c) = identityOfIndiscernablesRight _ _ _ _≡_ ans'' (applyEquality (λ t → positive (succ (succ a)) (succIsPositive (succ a)) *Z' t) (knocked'))
-      where
-        knocked : positive (succ (succ b)) (succIsPositive (succ b)) +Z' negative (succ (succ c)) (succIsPositive (succ c)) ≡ positive (succ b) _ +Z' negative (succ c) _
-        knocked = canKnockOneOff+Z' (succ b) (succ c) {succIsPositive b} {succIsPositive c} {succIsPositive (succ b)} {succIsPositive (succ c)}
-        knocked' : negative (succ b) (succIsPositive b) +Z' positive (succ c) (succIsPositive c) ≡ negative (succ (succ b)) (succIsPositive (succ b)) +Z' positive (succ (succ c)) (succIsPositive (succ c))
-        knocked' rewrite additionZ'IsCommutative (negative (succ b) (succIsPositive b)) (positive (succ c) (succIsPositive c)) | additionZ'IsCommutative (negative (succ (succ b)) (succIsPositive (succ b))) (positive (succ (succ c)) (succIsPositive (succ c))) = diffProof' c b (succ (c +N succ b)) (c +N succ (succ b)) refl help (equalityCommutative (succExtracts c (succ b)))
-          where
-            help : (succ (c +N succ b)) ≡ c +N succ (succ b)
-            help = _
-        ans : negative (succ (succ a)) (succIsPositive (succ a)) *Z' (positive (succ b) _ +Z' negative (succ c) _) ≡ positive (succ (succ a)) (succIsPositive (succ a)) *Z' (negative (succ b) _ +Z' positive (succ c) _)
-        ans = timesNegPosNeg (succ a) b c
-        ans' : negative (succ (succ a)) (succIsPositive (succ a)) *Z' (positive (succ (succ b)) (succIsPositive (succ b)) +Z' negative (succ (succ c)) (succIsPositive (succ c))) ≡ negative (succ (succ a)) (succIsPositive (succ a)) *Z' (positive (succ b) _ +Z' negative (succ c) _)
-        ans' = applyEquality (λ t → negative (succ (succ a)) (succIsPositive (succ a)) *Z' t) knocked
-        ans'' : negative (succ (succ a)) (succIsPositive (succ a)) *Z' (positive (succ (succ b)) (succIsPositive (succ b)) +Z' negative (succ (succ c)) (succIsPositive (succ c))) ≡ positive (succ (succ a)) (succIsPositive (succ a)) *Z' (negative (succ b) _ +Z' positive (succ c) _)
-        ans'' = identityOfIndiscernablesRight _ _ _ _≡_ ans' ans
-
-    timesNegNegPos : (a b c : ℕ) → (negative (succ a) (succIsPositive a)) *Z' ((negative (succ b) (succIsPositive b)) +Z' (positive (succ c) (succIsPositive c))) ≡ (positive (succ a) (succIsPositive a)) *Z' ((positive (succ b) (succIsPositive b)) +Z' (negative (succ c) (succIsPositive c)))
-    timesNegNegPos a b c rewrite additionZ'IsCommutative (negative (succ b) (succIsPositive b)) (positive (succ c) (succIsPositive c)) | additionZ'IsCommutative (positive (succ b) (succIsPositive b)) (negative (succ c) (succIsPositive c)) = timesNegPosNeg a c b
-
-    additionZ'DistributiveMulZ' : (a b c : ℤSimple) → (a *Z' (b +Z' c)) ≡ (a *Z' b +Z' a *Z' c)
-    additionZ'DistributiveMulZ' (negative zero (le x ())) b c
-    additionZ'DistributiveMulZ' (negative (succ a) x) (negative zero (le y ())) (negative c prC)
-    additionZ'DistributiveMulZ' (negative (succ a) x) (negative (succ b) prB) (negative zero (le y ()))
-    additionZ'DistributiveMulZ' (negative (succ a) x) (negative (succ b) prB) (negative (succ c) prC) = lemmaDistributive a (positive (succ b) prB) (positive (succ c) prC)
-    additionZ'DistributiveMulZ' (negative (succ a) x) (negative zero (le y ())) (positive c prC)
-    additionZ'DistributiveMulZ' (negative (succ a) x) (negative (succ b) prB) (positive zero (le y ()))
-    additionZ'DistributiveMulZ' (negative (succ a) x) (negative (succ b) prB) (positive (succ c) prC) rewrite <NRefl x (succIsPositive a) | <NRefl prB (succIsPositive b) | <NRefl prC (succIsPositive c) = help
-      where
-        inter : (negative (succ a) (succIsPositive a)) *Z' ((negative (succ b) (succIsPositive b)) +Z' (positive (succ c) (succIsPositive c))) ≡ positive (succ a) (succIsPositive a) *Z' (positive (succ b) (succIsPositive b) +Z' negative (succ c) (succIsPositive c))
-        inter = timesNegNegPos a b c
-        lhs : positive (succ a) (succIsPositive a) *Z' (positive (succ b) (succIsPositive b) +Z' negative (succ c) (succIsPositive c)) ≡ positive (succ a) (succIsPositive a) *Z' positive (succ b) (succIsPositive b) +Z' (negative (succ a) (succIsPositive a) *Z' positive (succ c) (succIsPositive c))
-        lhs = lemmaDistributive a (positive (succ b) (succIsPositive b)) (negative (succ c) (succIsPositive c))
-        help : (negative (succ a) (succIsPositive a)) *Z' ((negative (succ b) (succIsPositive b)) +Z' (positive (succ c) (succIsPositive c))) ≡ negative (succ a) (succIsPositive a) *Z' negative (succ b) (succIsPositive b) +Z' (negative (succ a) (succIsPositive a) *Z' positive (succ c) (succIsPositive c))
-        help = transitivity inter lhs
-    additionZ'DistributiveMulZ' (negative (succ a) x) (negative zero (le y ())) zZero
-    additionZ'DistributiveMulZ' (negative (succ a) x) (negative (succ b) prB) zZero = refl
-    additionZ'DistributiveMulZ' (negative (succ a) x) (positive b prB) (negative zero (le y ()))
-    additionZ'DistributiveMulZ' (negative (succ a) x) (positive zero (le y ())) (negative (succ c) prC)
-    additionZ'DistributiveMulZ' (negative (succ a) x) (positive (succ b) prB) (negative (succ c) prC) rewrite <NRefl x (succIsPositive a) | <NRefl prB (succIsPositive b) | <NRefl prC (succIsPositive c) = help
-      where
-        inter : (negative (succ a) (succIsPositive a)) *Z' ((positive (succ b) (succIsPositive b)) +Z' (negative (succ c) (succIsPositive c))) ≡ positive (succ a) (succIsPositive a) *Z' (negative (succ b) (succIsPositive b) +Z' positive (succ c) (succIsPositive c))
-        inter = timesNegPosNeg a b c
-        lhs : positive (succ a) (succIsPositive a) *Z' (negative (succ b) (succIsPositive b) +Z' positive (succ c) (succIsPositive c)) ≡ positive (succ a) (succIsPositive a) *Z' negative (succ b) (succIsPositive b) +Z' (positive (succ a) (succIsPositive a) *Z' positive (succ c) (succIsPositive c))
-        lhs = lemmaDistributive a (negative (succ b) (succIsPositive b)) (positive (succ c) (succIsPositive c))
-        help : (negative (succ a) (succIsPositive a)) *Z' ((positive (succ b) (succIsPositive b)) +Z' (negative (succ c) (succIsPositive c))) ≡ negative (succ a) (succIsPositive a) *Z' positive (succ b) (succIsPositive b) +Z' (negative (succ a) (succIsPositive a) *Z' negative (succ c) (succIsPositive c))
-        help = transitivity inter lhs
-    additionZ'DistributiveMulZ' (negative (succ a) x) (positive b prB) (positive zero (le y ()))
-    additionZ'DistributiveMulZ' (negative (succ a) x) (positive 0 (le y ())) (positive (succ c) prC)
-    additionZ'DistributiveMulZ' (negative (succ a) x) (positive (succ b) prB) (positive (succ c) prC) rewrite timesNegPosPos a b c = applyEquality (λ t → negative (succ t) (succIsPositive t)) help
-       where
-         help : (b +N succ c) +N a *N succ (b +N succ c) ≡ (b +N a *N succ b) +N succ (c +N a *N succ c)
-         help rewrite productDistributes a (succ b) (succ c) | equalityCommutative (additionNIsAssociative (b +N succ c) (a *N succ b) (a *N succ c)) | additionNIsAssociative b (succ c) (a *N succ b) | additionNIsCommutative (succ c) (a *N succ b) | equalityCommutative (additionNIsAssociative b (a *N succ b) (succ c)) | additionNIsAssociative (b +N a *N succ b) (succ c) (a *N succ c) = refl
-    additionZ'DistributiveMulZ' (negative (succ a) x) (positive zero (le y ())) zZero
-    additionZ'DistributiveMulZ' (negative (succ a) x) (positive (succ b) prB) zZero = refl
-    additionZ'DistributiveMulZ' (negative (succ a) x) zZero (negative zero (le y ()))
-    additionZ'DistributiveMulZ' (negative (succ a) x) zZero (negative (succ c) prC) = refl
-    additionZ'DistributiveMulZ' (negative (succ a) x) zZero (positive zero (le y ()))
-    additionZ'DistributiveMulZ' (negative (succ a) x) zZero (positive (succ c) prC) = refl
-    additionZ'DistributiveMulZ' (negative (succ a) x) zZero zZero = refl
-    additionZ'DistributiveMulZ' (positive zero (le x ())) b c
-    additionZ'DistributiveMulZ' (positive (succ a) x) b c rewrite <NRefl x (succIsPositive a) = lemmaDistributive a b c
-    additionZ'DistributiveMulZ' zZero b c = refl
-
-    additionZDistributiveMulZ : (a b c : ℤ) → (a *Z (b +Z c)) ≡ (a *Z b) +Z (a *Z c)
-    additionZDistributiveMulZ a b c = identityOfIndiscernablesRight _ _ _ _≡_ lem12 (applyEquality (λ t → a *Z b +Z (a *Z t)) (zIsZ c))
-      where
-        lem1 : convertZ' ((convertZ a) *Z' ((convertZ b) +Z' (convertZ c))) ≡ convertZ' ((convertZ a *Z' convertZ b) +Z' (convertZ a *Z' convertZ c))
-        lem2 : convertZ' (convertZ a) *Z convertZ' ((convertZ b) +Z' (convertZ c)) ≡ convertZ' ((convertZ a *Z' convertZ b) +Z' (convertZ a *Z' convertZ c))
-        lem3 : a *Z convertZ' ((convertZ b) +Z' (convertZ c)) ≡ convertZ' ((convertZ a *Z' convertZ b) +Z' (convertZ a *Z' convertZ c))
-        lem4 : a *Z (convertZ' (convertZ b) +Z convertZ' (convertZ c)) ≡ convertZ' ((convertZ a *Z' convertZ b) +Z' (convertZ a *Z' convertZ c))
-        lem5 : a *Z (b +Z convertZ' (convertZ c)) ≡ convertZ' ((convertZ a *Z' convertZ b) +Z' (convertZ a *Z' convertZ c))
-        lem6 : a *Z (b +Z c) ≡ convertZ' ((convertZ a *Z' convertZ b) +Z' (convertZ a *Z' convertZ c))
-        lem7 : a *Z (b +Z c) ≡ convertZ' (convertZ a *Z' convertZ b) +Z convertZ' (convertZ a *Z' convertZ c)
-        lem8 : a *Z (b +Z c) ≡ (convertZ' (convertZ a) *Z (convertZ' (convertZ b))) +Z convertZ' (convertZ a *Z' convertZ c)
-        lem9 : a *Z (b +Z c) ≡ (a *Z (convertZ' (convertZ b))) +Z convertZ' (convertZ a *Z' convertZ c)
-        lem10 : a *Z (b +Z c) ≡ (a *Z b) +Z convertZ' (convertZ a *Z' convertZ c)
-        lem11 : a *Z (b +Z c) ≡ (a *Z b) +Z (convertZ' (convertZ a) *Z convertZ' (convertZ c))
-        lem12 : a *Z (b +Z c) ≡ (a *Z b) +Z (a *Z convertZ' (convertZ c))
-        lem12 = identityOfIndiscernablesRight _ _ _ _≡_ lem11 (applyEquality (λ t → a *Z b +Z (t *Z convertZ' (convertZ c))) (zIsZ a))
-        lem11 = identityOfIndiscernablesRight _ _ _ _≡_ lem10 (applyEquality (λ t → a *Z b +Z t) (convertZ'DistributesOver*Z (convertZ a) _))
-        lem10 = identityOfIndiscernablesRight _ _ _ _≡_ lem9 (applyEquality (λ t → a *Z t +Z convertZ' (convertZ a *Z' convertZ c)) (zIsZ b))
-        lem9 = identityOfIndiscernablesRight _ _ _ _≡_ lem8 (applyEquality (λ t → t *Z (convertZ' (convertZ b)) +Z convertZ' (convertZ a *Z' convertZ c)) (zIsZ a))
-        lem8 = identityOfIndiscernablesRight _ _ _ _≡_ lem7 (applyEquality (λ t → t +Z convertZ' (convertZ a *Z' convertZ c)) (convertZ'DistributesOver*Z (convertZ a) _))
-        lem7 = identityOfIndiscernablesRight _ _ _ _≡_ lem6 (plusIsPlus (convertZ a *Z' convertZ b) _)
-        lem6 = identityOfIndiscernablesLeft _ _ _ _≡_ lem5 (applyEquality (λ t → a *Z (b +Z t)) (zIsZ c))
-        lem5 = identityOfIndiscernablesLeft _ _ _ _≡_ lem4 (applyEquality (λ t → a *Z (t +Z convertZ' (convertZ c))) (zIsZ b))
-        lem4 = identityOfIndiscernablesLeft _ _ _ _≡_ lem3 (applyEquality (λ t → a *Z t) (plusIsPlus (convertZ b) _))
-        lem3 = identityOfIndiscernablesLeft _ _ _ _≡_ lem2 (applyEquality (λ t → t *Z (convertZ' ((convertZ b) +Z' convertZ c))) (zIsZ a))
-        lem2 = identityOfIndiscernablesLeft _ _ _ _≡_ lem1 (convertZ'DistributesOver*Z (convertZ a) _)
-        lem1 = applyEquality convertZ' (additionZ'DistributiveMulZ' (convertZ a) (convertZ b) (convertZ c))
-
-    additionZRespectsOrder : (a b c : ℤ) → (a <Z b) → (a +Z c <Z b +Z c)
-    additionZRespectsOrder a b c (le x proof) = le x (identityOfIndiscernablesLeft ((nonneg (succ x) +Z a) +Z c) (b +Z c) (nonneg (succ x) +Z (a +Z c)) _≡_ (applyEquality (λ t → t +Z c) proof) (equalityCommutative (additionZIsAssociative (nonneg (succ x)) a c)))
-
-    nonnegNotLessNegsucc : (a b : ℕ) → (nonneg a <Z negSucc b) → False
-    nonnegNotLessNegsucc a b (le x proof) = nonnegIsNotNegsucc proof
-
-    productOfPositivesIsPositive : (a b : ℤ) → (nonneg zero <Z a) → (nonneg zero <Z b) → (nonneg 0 <Z a *Z b)
-    productOfPositivesIsPositive (nonneg zero) (nonneg b) pr1 pr2 = exFalso (lessZIrreflexive {nonneg 0} pr1)
-    productOfPositivesIsPositive (nonneg (succ a)) (nonneg zero) pr1 pr2 = exFalso (lessZIrreflexive {nonneg 0} pr2)
-    productOfPositivesIsPositive (nonneg (succ a)) (nonneg (succ b)) pr1 pr2 rewrite multiplyingNonnegIsHom (succ a) (succ b) = lessIsPreservedNToZ (succIsPositive (b +N a *N succ b))
-    productOfPositivesIsPositive (nonneg zero) (negSucc b) pr1 pr2 = exFalso (nonnegNotLessNegsucc 0 b pr2)
-    productOfPositivesIsPositive (nonneg (succ a)) (negSucc b) pr1 pr2 = exFalso (nonnegNotLessNegsucc 0 b pr2)
-    productOfPositivesIsPositive (negSucc x) b pr1 pr2 = exFalso (nonnegNotLessNegsucc 0 x pr1)
-
-    lessZTransitive : {a b c : ℤ} → (a <Z b) → (b <Z c) → (a <Z c)
-    lessZTransitive {a} {b} {c} (le d1 pr1) (le d2 pr2) rewrite equalityCommutative pr1 = le (d1 +N succ d2) pr
-      where
-        pr : nonneg (succ (d1 +N succ d2)) +Z a ≡ c
-        pr rewrite additionZIsAssociative (nonneg (succ d2)) (nonneg (succ d1)) a | additionNIsCommutative (succ d2) (succ d1) = pr2
-
-    ℤGroup : Group (reflSetoid ℤ) (_+Z_)
-    Group.wellDefined ℤGroup {a} {b} {.a} {.b} refl refl = refl
-    Group.identity ℤGroup = nonneg zero
-    Group.inverse ℤGroup = additiveInverseZ
-    Group.multAssoc ℤGroup {a} {b} {c} = additionZIsAssociative a b c
-    Group.multIdentLeft ℤGroup {a} = refl
-    Group.multIdentRight ℤGroup {a} = zeroIsAdditiveIdentityRightZ a
-    Group.invLeft ℤGroup {a} = addInverseLeftZ a
-    Group.invRight ℤGroup {a} = addInverseRightZ a
-
-    ℤAbGrp : AbelianGroup ℤGroup
-    ℤAbGrp = record { commutative = λ {a} {b} → additionZIsCommutative a b }
-
-    ℤRing : Ring (reflSetoid ℤ) (_+Z_) (_*Z_)
-    Ring.additiveGroup ℤRing = ℤGroup
-    Ring.multWellDefined ℤRing {r} {s} {.r} {.s} refl refl = refl
-    Ring.1R ℤRing = nonneg (succ zero)
-    Ring.groupIsAbelian ℤRing {a} {b} = additionZIsCommutative a b
-    Ring.multAssoc ℤRing {a} {b} {c} = multiplicationZIsAssociative a b c
-    Ring.multCommutative ℤRing {a} {b} = multiplicationZIsCommutative a b
-    Ring.multDistributes ℤRing {a} {b} {c} = additionZDistributiveMulZ a b c
-    Ring.multIdentIsIdent ℤRing {a} = multiplicativeIdentityOneZLeft a
-
-    negsuccTimesNonneg : {a b : ℕ} → (negSucc a *Z nonneg (succ b)) ≡ nonneg 0 → False
-    negsuccTimesNonneg {a} {b} pr with convertZ (negSucc a)
-    negsuccTimesNonneg {a} {b} () | negative a₁ x
-    negsuccTimesNonneg {a} {b} () | positive a₁ x
-    negsuccTimesNonneg {a} {b} () | zZero
-
-    negsuccTimesNegsucc : {a b : ℕ} → (negSucc a *Z negSucc b) ≡ nonneg 0 → False
-    negsuccTimesNegsucc {a} {b} pr with convertZ (negSucc a)
-    negsuccTimesNegsucc {a} {b} () | negative a₁ x
-    negsuccTimesNegsucc {a} {b} () | positive a₁ x
-    negsuccTimesNegsucc {a} {b} () | zZero
-
-    ℤIntDom : IntegralDomain ℤRing
-    IntegralDomain.intDom ℤIntDom {nonneg zero} {nonneg b} pr = inl refl
-    IntegralDomain.intDom ℤIntDom {nonneg (succ a)} {nonneg zero} pr = inr refl
-    IntegralDomain.intDom ℤIntDom {nonneg (succ a)} {nonneg (succ b)} pr = exFalso (naughtE (nonnegInjective (equalityCommutative (transitivity (equalityCommutative (multiplyingNonnegIsHom (succ a) (succ b))) pr))))
-    IntegralDomain.intDom ℤIntDom {nonneg zero} {negSucc b} pr = inl refl
-    IntegralDomain.intDom ℤIntDom {nonneg (succ a)} {negSucc b} pr = exFalso (negsuccTimesNonneg {b} {a} (transitivity (multiplicationZIsCommutative (negSucc b) (nonneg (succ a))) pr))
-    IntegralDomain.intDom ℤIntDom {negSucc a} {nonneg zero} pr = inr refl
-    IntegralDomain.intDom ℤIntDom {negSucc a} {nonneg (succ b)} pr = exFalso (negsuccTimesNonneg {a} {b} pr)
-    IntegralDomain.intDom ℤIntDom {negSucc a} {negSucc b} pr = exFalso (negsuccTimesNegsucc {a} {b} pr)
-    IntegralDomain.nontrivial ℤIntDom = λ ()
-
-    ℤOrder : TotalOrder ℤ
-    PartialOrder._<_ (TotalOrder.order ℤOrder) = _<Z_
-    TotalOrder.totality ℤOrder a b = lessThanTotalZ {a} {b}
-    PartialOrder.irreflexive (TotalOrder.order ℤOrder) = lessZIrreflexive
-    PartialOrder.transitive (TotalOrder.order ℤOrder) {a} {b} {c} = lessZTransitive
-
-    ℤOrderedRing : OrderedRing ℤRing (totalOrderToSetoidTotalOrder ℤOrder)
-    OrderedRing.orderRespectsAddition ℤOrderedRing {a} {b} a<b c = additionZRespectsOrder a b c a<b
-    OrderedRing.orderRespectsMultiplication ℤOrderedRing {a} {b} a<b = productOfPositivesIsPositive a b a<b
-
-    _-Z_ : ℤ → ℤ → ℤ
-    a -Z b = a +Z (additiveInverseZ b)
+data ℤ : Set where
+  nonneg : ℕ → ℤ
+  negSucc : ℕ → ℤ
+
+data ℤSimple : Set where
+  negative : (a : ℕ) → (0 <N a) → ℤSimple
+  positive : (a : ℕ) → (0 <N a) → ℤSimple
+  zZero : ℤSimple
+
+convertZ : ℤ → ℤSimple
+convertZ (nonneg zero) = zZero
+convertZ (nonneg (succ x)) = positive (succ x) (succIsPositive x)
+convertZ (negSucc x) = negative (succ x) (succIsPositive x)
+
+convertZ' : ℤSimple → ℤ
+convertZ' (negative zero (le x ()))
+convertZ' (negative (succ a) x) = negSucc a
+convertZ' (positive a x) = nonneg a
+convertZ' zZero = nonneg zero
+
+zIsZ : (a : ℤ) → convertZ' (convertZ a) ≡ a
+zIsZ (nonneg zero) = refl
+zIsZ (nonneg (succ x)) = refl
+zIsZ (negSucc x) = refl
+
+zIsZ' : (a : ℤSimple) → convertZ (convertZ' a) ≡ a
+zIsZ' (negative zero (le x ()))
+zIsZ' (negative (succ a) x) = help
+  where
+    eq : (succIsPositive a) ≡ x
+    eq = <NRefl {0} {succ a} (succIsPositive a) x
+    help : negative (succ a) (succIsPositive a) ≡ negative (succ a) x
+    help rewrite eq = refl
+zIsZ' (positive zero (le x ()))
+zIsZ' (positive (succ a) x) = help
+  where
+    eq : (succIsPositive a) ≡ x
+    eq = <NRefl {0} {succ a} (succIsPositive a) x
+    help : positive (succ a) (succIsPositive a) ≡ positive (succ a) x
+    help rewrite eq = refl
+zIsZ' zZero = refl
+
+posIsPos : {a : ℕ} → (pr1 pr2 : 0 <N a) → (positive a pr1 ≡ positive a pr2)
+posIsPos {a} pr1 pr2 rewrite <NRefl pr1 pr2 = refl
+
+negIsNeg : {a : ℕ} → (pr1 pr2 : 0 <N a) → (negative a pr1 ≡ negative a pr2)
+negIsNeg {a} pr1 pr2 rewrite <NRefl pr1 pr2 = refl
+
+infix 15 _+Z_
+_+Z_ : ℤ → ℤ → ℤ
+nonneg zero +Z r = r
+nonneg (succ x) +Z nonneg y = nonneg (succ x +N y)
+nonneg (succ x) +Z negSucc zero = nonneg x
+nonneg (succ x) +Z negSucc (succ a) = nonneg x +Z negSucc a
+negSucc a +Z nonneg zero = negSucc a
+negSucc zero +Z nonneg (succ x) = nonneg x
+negSucc (succ a) +Z nonneg (succ x) = negSucc a +Z nonneg x
+negSucc zero +Z negSucc b = negSucc (succ b)
+negSucc (succ a) +Z negSucc b = negSucc (succ a +N succ b)
+
+depth : ℤSimple → ℕ
+depth (negative a x) = a
+depth (positive a x) = a
+depth zZero = 0
+
+plusZ' : (height : ℕ) → (a : ℤSimple) → (b : ℤSimple) → (depth a +N depth b ≡ height) → ℤSimple
+plusZ' zero (negative zero (le x ())) (negative a₁ x₁) pr
+plusZ' zero (negative (succ a) (le x proof)) (negative a₁ x₁) pr = naughtE (equalityCommutative pr)
+plusZ' zero (negative zero (le x ())) (positive a₁ x₁) pr
+plusZ' zero (negative (succ a) (le x proof)) (positive a₁ x₁) pr = naughtE (equalityCommutative pr)
+plusZ' zero (negative zero (le x ())) zZero pr
+plusZ' zero (negative (succ a) (le x proof)) zZero pr = naughtE (equalityCommutative pr)
+plusZ' zero (positive zero (le x ())) b pr
+plusZ' zero (positive (succ a) x) b pr = naughtE (equalityCommutative pr)
+plusZ' zero zZero (negative zero (le x ())) pr
+plusZ' zero zZero (negative (succ a) x) pr = naughtE (equalityCommutative pr)
+plusZ' zero zZero (positive zero (le x ())) pr
+plusZ' zero zZero (positive (succ a) x) pr = naughtE (equalityCommutative pr)
+plusZ' zero zZero zZero pr = zZero
+plusZ' (succ height) (negative zero (le x ())) b pr
+plusZ' (succ height) (negative (succ a) _) (negative zero (le x ())) pr
+plusZ' (succ height) (negative (succ a) _) (negative (succ b) _) pr = negative (succ a +N succ b) (succIsPositive _)
+plusZ' (succ height) (negative (succ a) _) (positive zero (le x ())) pr
+plusZ' (succ height) (negative (succ zero) _) (positive (succ zero) _) pr = zZero
+plusZ' (succ height) (negative (succ zero) _) (positive (succ (succ b)) _) pr = positive (succ b) (succIsPositive b)
+plusZ' (succ height) (negative (succ (succ a)) _) (positive (succ zero) x) pr = negative (succ a) (succIsPositive a)
+plusZ' (succ zero) (negative (succ (succ a)) _) (positive (succ (succ b)) x) pr = naughtE (equalityCommutative (succInjective pr))
+plusZ' (succ (succ height)) (negative (succ (succ a)) _) (positive (succ (succ b)) x) pr = plusZ' height (negative (succ a) (succIsPositive _)) (positive (succ b) (succIsPositive _)) ans
+  where
+    h : a +N succ (succ b) ≡ height
+    h = succInjective (succInjective pr)
+    ans : succ (a +N succ b) ≡ height
+    ans rewrite Semiring.commutative ℕSemiring a (succ b) | Semiring.commutative ℕSemiring (succ (succ b)) a = h
+plusZ' (succ height) (negative (succ a) _) zZero pr = negative (succ a) (succIsPositive a)
+plusZ' (succ height) (positive zero (le x ())) b pr
+plusZ' (succ height) (positive (succ a) _) (negative zero (le x ())) pr
+plusZ' (succ height) (positive (succ zero) _) (negative (succ zero) _) pr = zZero
+plusZ' (succ height) (positive (succ zero) _) (negative (succ (succ b)) _) pr = negative (succ b) (succIsPositive b)
+plusZ' (succ height) (positive (succ (succ a)) _) (negative (succ zero) _) pr = positive (succ a) (succIsPositive a)
+plusZ' (succ zero) (positive (succ (succ a)) _) (negative (succ (succ b)) _) pr = naughtE (equalityCommutative (succInjective pr))
+plusZ' (succ (succ height)) (positive (succ (succ a)) _) (negative (succ (succ b)) _) pr = plusZ' height (positive (succ a) (succIsPositive a)) (negative (succ b) (succIsPositive b)) ans
+  where
+    h : a +N succ (succ b) ≡ height
+    h = succInjective (succInjective pr)
+    ans : succ (a +N succ b) ≡ height
+    ans rewrite Semiring.commutative ℕSemiring a (succ b) | Semiring.commutative ℕSemiring (succ (succ b)) a = h
+plusZ' (succ height) (positive (succ a) _) (positive b x) pr = positive (succ a +N b) (succIsPositive (a +N b))
+plusZ' (succ height) (positive (succ a) _) zZero pr = positive (succ a) (succIsPositive a)
+plusZ' (succ height) zZero b pr = b
+
+infix 15 _+Z'_
+_+Z'_ : ℤSimple → ℤSimple → ℤSimple
+a +Z' b = plusZ' (depth a +N depth b) a b refl
+
+castPlusZ' : {de1 de2 : ℕ} → (r s : ℤSimple) → {pr : depth r +N depth s ≡ de1} → {pr2 : depth r +N depth s ≡ de2} → de1 ≡ de2 → plusZ' de1 r s pr ≡ plusZ' de2 r s pr2
+castPlusZ' {.(depth r +N depth s)} {.(depth r +N depth s)} (r) (s) {refl} {refl} de1=de2 = refl
+
+canKnockOneOff+Z'' : (a b : ℕ) → {pr1 : 0 <N a} → {pr2 : 0 <N b} → {pr3 : 0 <N succ a} → {pr4 : 0 <N succ b} → plusZ' (succ a +N succ b) (positive (succ a) pr3) (negative (succ b) pr4) refl ≡ (plusZ' (a +N b) (positive a pr1) (negative b pr2) refl)
+canKnockOneOff+Z'' zero b {le x ()} {pr2}
+canKnockOneOff+Z'' (succ a) zero {pr1} {le x ()}
+canKnockOneOff+Z'' (succ a) (succ b) {pr1} {pr2} {pr3} {pr4} rewrite <NRefl (succIsPositive a) pr1 | <NRefl (succIsPositive b) pr2 = castPlusZ' {a +N succ (succ b)} {succ (a +N succ b)} (positive (succ a) pr1) (negative (succ b) pr2) help
+  where
+    help : a +N (succ (succ b)) ≡ succ (a +N succ b)
+    help rewrite Semiring.commutative ℕSemiring a (succ (succ b)) | Semiring.commutative ℕSemiring (succ b) a = refl
+
+canKnockOneOff+Z''2 : (a b : ℕ) → {pr1 : 0 <N a} → {pr2 : 0 <N b} → {pr3 : 0 <N succ a} → {pr4 : 0 <N succ b} → plusZ' (succ a +N succ b) (negative (succ a) pr3) (positive (succ b) pr4) refl ≡ (plusZ' (a +N b) (negative a pr1) (positive b pr2) refl)
+canKnockOneOff+Z''2 zero b {le x ()} {pr2}
+canKnockOneOff+Z''2 (succ a) zero {pr1} {le x ()}
+canKnockOneOff+Z''2 (succ a) (succ b) {pr1} {pr2} {pr3} {pr4} rewrite <NRefl (succIsPositive a) pr1 | <NRefl (succIsPositive b) pr2 = castPlusZ' {a +N succ (succ b)} {succ (a +N succ b)} (negative (succ a) pr1) (positive (succ b) pr2) help
+  where
+    help : a +N (succ (succ b)) ≡ succ (a +N succ b)
+    help rewrite Semiring.commutative ℕSemiring a (succ (succ b)) | Semiring.commutative ℕSemiring (succ b) a = refl
+
+lemma' : (x y : ℕ) → succ (x +N succ y) ≡ x +N succ (succ y)
+lemma' x y rewrite Semiring.commutative ℕSemiring x (succ (succ y)) | Semiring.commutative ℕSemiring (succ y) x = refl
+
+helpPlusIsPlus' : (x y : ℕ) → (pr' : _) → negative (succ x) (succIsPositive x) +Z' positive (succ y) (succIsPositive y) ≡ plusZ' (x +N succ (succ y)) (negative (succ x) (logical<NImpliesLe (record {}))) (positive (succ y) (logical<NImpliesLe (record {}))) pr'
+helpPlusIsPlus' x y pr = castPlusZ' {succ x +N succ y} {x +N succ (succ y)} (negative (succ x) (succIsPositive x)) (positive (succ y) (succIsPositive y)) {refl} {pr} pr
+
+helpPlusIsPlus'2 : (x y : ℕ) → (pr' : _) → positive (succ x) (succIsPositive x) +Z' negative (succ y) (succIsPositive y) ≡ plusZ' (succ (x +N succ y)) (positive (succ x) (logical<NImpliesLe (record {}))) (negative (succ y) (logical<NImpliesLe (record {}))) pr'
+helpPlusIsPlus'2 x y pr = castPlusZ' {_} {_} (positive (succ x) (succIsPositive x)) (negative (succ y) (succIsPositive y)) {refl} {pr} pr
+
+canKnockOneOff+Z' : (a b : ℕ) → {pr1 : 0 <N a} → {pr2 : 0 <N b} → {pr3 : 0 <N succ a} → {pr4 : 0 <N succ b} → (positive (succ a) pr3) +Z' (negative (succ b) pr4) ≡ (positive a pr1) +Z' (negative b pr2)
+canKnockOneOff+Z' zero b {le x ()} {pr2} {pr3} {pr4}
+canKnockOneOff+Z' (succ a) zero {pr1} {le x ()} {pr3} {pr4}
+canKnockOneOff+Z' (succ a) (succ b) {pr1} {pr2} {pr3} {pr4} = canKnockOneOff+Z'' (succ a) (succ b) {pr1} {pr2} {pr3} {pr4}
+
+canKnockOneOff+Z'2 : (a b : ℕ) → {pr1 : 0 <N a} → {pr2 : 0 <N b} → {pr3 : 0 <N succ a} → {pr4 : 0 <N succ b} → (negative (succ a) pr3) +Z' (positive (succ b) pr4) ≡ (negative a pr1) +Z' (positive b pr2)
+canKnockOneOff+Z'2 zero b {le x ()} {pr2} {pr3} {pr4}
+canKnockOneOff+Z'2 (succ a) zero {pr1} {le x ()} {pr3} {pr4}
+canKnockOneOff+Z'2 (succ a) (succ b) {pr1} {pr2} {pr3} {pr4} = canKnockOneOff+Z''2 (succ a) (succ b) {pr1} {pr2} {pr3} {pr4}
+
+plusIsPlus' : (a b : ℤ) → convertZ (a +Z b) ≡ (convertZ a) +Z' (convertZ b)
+plusIsPlus' (nonneg zero) (nonneg zero) = refl
+plusIsPlus' (nonneg zero) (nonneg (succ x)) = refl
+plusIsPlus' (nonneg zero) (negSucc x) = refl
+plusIsPlus' (nonneg (succ x)) (nonneg zero) rewrite Semiring.commutative ℕSemiring x 0 = refl
+plusIsPlus' (nonneg (succ x)) (nonneg (succ y)) = refl
+plusIsPlus' (nonneg (succ zero)) (negSucc zero) = refl
+plusIsPlus' (nonneg (succ (succ x))) (negSucc zero) = refl
+plusIsPlus' (nonneg (succ zero)) (negSucc (succ y)) = refl
+plusIsPlus' (nonneg (succ (succ x))) (negSucc (succ y)) rewrite canKnockOneOff+Z' (succ x) (succ y) {succIsPositive x} {succIsPositive y} {succIsPositive (succ x)} {succIsPositive (succ y)} = identityOfIndiscernablesRight _ _ _ _≡_ (plusIsPlus' (nonneg (succ x)) (negSucc y)) (helpPlusIsPlus'2 x y _)
+plusIsPlus' (negSucc x) (nonneg zero) = refl
+plusIsPlus' (negSucc zero) (nonneg (succ zero)) = refl
+plusIsPlus' (negSucc zero) (nonneg (succ (succ y))) = refl
+plusIsPlus' (negSucc (succ x)) (nonneg (succ zero)) = refl
+plusIsPlus' (negSucc (succ x)) (nonneg (succ (succ y))) rewrite equalityCommutative (canKnockOneOff+Z' (succ x) (succ y) {succIsPositive x} {succIsPositive y} {succIsPositive (succ x)} {succIsPositive (succ y)}) = identityOfIndiscernablesRight (convertZ (negSucc x +Z nonneg (succ y))) (negative (succ x) (succIsPositive x) +Z' positive (succ y) (succIsPositive y)) _ _≡_ (plusIsPlus' (negSucc x) (nonneg (succ y))) (helpPlusIsPlus' x y _)
+plusIsPlus' (negSucc zero) (negSucc zero) = refl
+plusIsPlus' (negSucc zero) (negSucc (succ y)) = refl
+plusIsPlus' (negSucc (succ x)) (negSucc y) = refl
+
+plusIsPlusFirstPos : (a : ℕ) (pr1 : 0 <N a) → (b : ℤSimple) → convertZ' ((positive a pr1) +Z' b) ≡ (convertZ' (positive a pr1)) +Z (convertZ' b)
+plusIsPlusFirstPos zero (le x ()) b
+plusIsPlusFirstPos (succ zero) pr1 (negative zero (le x ()))
+plusIsPlusFirstPos (succ zero) pr1 (negative (succ zero) x) = refl
+plusIsPlusFirstPos (succ zero) pr1 (negative (succ (succ b)) x) = refl
+plusIsPlusFirstPos (succ zero) pr1 (positive b x) = refl
+plusIsPlusFirstPos (succ zero) pr1 zZero = refl
+plusIsPlusFirstPos (succ (succ a)) pr1 (negative zero (le x ()))
+plusIsPlusFirstPos (succ (succ a)) pr1 (negative (succ zero) x) = refl
+plusIsPlusFirstPos (succ (succ a)) pr1 (negative (succ (succ b)) x) rewrite canKnockOneOff+Z' (succ a) (succ b) {succIsPositive a} {succIsPositive b} {pr1} {x} = plusIsPlusFirstPos (succ a) (logical<NImpliesLe (record {})) (negative (succ b) (logical<NImpliesLe (record {})))
+plusIsPlusFirstPos (succ (succ a)) pr1 (positive zero (le x ()))
+plusIsPlusFirstPos (succ (succ a)) pr1 (positive (succ zero) x) = refl
+plusIsPlusFirstPos (succ (succ a)) pr1 (positive (succ (succ b)) x) = refl
+plusIsPlusFirstPos (succ (succ a)) pr1 zZero rewrite Semiring.commutative ℕSemiring a 0 = refl
+
+plusIsPlusFirstNeg : (a : ℕ) (pr1 : 0 <N a) → (b : ℤSimple) → convertZ' ((negative a pr1) +Z' b) ≡ (convertZ' (negative a pr1)) +Z (convertZ' b)
+plusIsPlusFirstNeg zero (le x ()) b
+plusIsPlusFirstNeg (succ zero) pr (negative zero (le x ()))
+plusIsPlusFirstNeg (succ zero) pr (negative (succ a) x) = refl
+plusIsPlusFirstNeg (succ zero) pr (positive zero (le x ()))
+plusIsPlusFirstNeg (succ zero) pr (positive (succ zero) x) = refl
+plusIsPlusFirstNeg (succ zero) pr (positive (succ (succ a)) x) = refl
+plusIsPlusFirstNeg (succ zero) pr zZero = refl
+plusIsPlusFirstNeg (succ (succ a)) pr (negative zero (le x ()))
+plusIsPlusFirstNeg (succ (succ a)) pr (negative (succ b) x) = refl
+plusIsPlusFirstNeg (succ (succ a)) pr (positive zero (le x ()))
+plusIsPlusFirstNeg (succ (succ a)) pr (positive (succ zero) x) = refl
+plusIsPlusFirstNeg (succ (succ a)) pr (positive (succ (succ b)) x) rewrite canKnockOneOff+Z'2 (succ a) (succ b) {succIsPositive a} {succIsPositive b} {pr} {x} = plusIsPlusFirstNeg (succ a) (logical<NImpliesLe (record {})) (positive (succ b) (logical<NImpliesLe (record {})))
+plusIsPlusFirstNeg (succ (succ a)) pr zZero = refl
+
+plusIsPlus : (a b : ℤSimple) → convertZ' (a +Z' b) ≡ (convertZ' a) +Z (convertZ' b)
+plusIsPlus (negative a pr) b = plusIsPlusFirstNeg a pr b
+plusIsPlus (positive a pr) b = plusIsPlusFirstPos a pr b
+plusIsPlus zZero (negative zero (le x ()))
+plusIsPlus zZero (negative (succ a) x) = refl
+plusIsPlus zZero (positive zero (le x ()))
+plusIsPlus zZero (positive (succ a) x) = refl
+plusIsPlus zZero zZero = refl
+
+infix 25 _*Z'_
+_*Z'_ : ℤSimple → ℤSimple → ℤSimple
+negative zero (le x ()) *Z' b
+negative (succ a) x *Z' negative zero (le x₁ ())
+negative (succ a) x *Z' negative (succ b) prb = positive (succ a *N succ b) (succIsPositive (b +N a *N succ b))
+negative (succ a) x *Z' positive zero (le x₁ ())
+negative (succ a) x *Z' positive (succ b) prb = negative (succ a *N succ b) (succIsPositive (b +N a *N succ b))
+negative (succ a) x *Z' zZero = zZero
+positive zero (le x ()) *Z' b
+positive (succ a) x *Z' negative zero (le x₁ ())
+positive (succ a) x *Z' negative (succ b) prb = negative (succ a *N succ b) (succIsPositive (b +N a *N succ b))
+positive (succ a) x *Z' positive zero (le x₁ ())
+positive (succ a) x *Z' positive (succ b) prb = positive (succ a *N succ b) (succIsPositive (b +N a *N succ b))
+positive (succ a) x *Z' zZero = zZero
+zZero *Z' b = zZero
+
+infix 25 _*Z_
+_*Z_ : ℤ → ℤ → ℤ
+a *Z b = convertZ' (convertZ a *Z' convertZ b)
+
+convertZ'DistributesOver*Z : (a b : ℤSimple) → convertZ' (a *Z' b) ≡ (convertZ' a) *Z (convertZ' b)
+convertZ'DistributesOver*Z (negative zero (le x ())) (negative b prb)
+convertZ'DistributesOver*Z (negative (succ a) x) (negative zero (le y ()))
+convertZ'DistributesOver*Z (negative (succ a) x) (negative (succ b) prb) = refl
+convertZ'DistributesOver*Z (negative zero (le x ())) (positive b prb)
+convertZ'DistributesOver*Z (negative (succ a) x) (positive zero (le x₁ ()))
+convertZ'DistributesOver*Z (negative (succ a) x) (positive (succ b) prb) = refl
+convertZ'DistributesOver*Z (negative zero (le x ())) zZero
+convertZ'DistributesOver*Z (negative (succ a) x) zZero = refl
+convertZ'DistributesOver*Z (positive zero (le x ())) b
+convertZ'DistributesOver*Z (positive (succ a) x) (negative zero (le x₁ ()))
+convertZ'DistributesOver*Z (positive (succ a) x) (negative (succ b) prb) = refl
+convertZ'DistributesOver*Z (positive (succ a) x) (positive zero (le x₁ ()))
+convertZ'DistributesOver*Z (positive (succ a) x) (positive (succ b) prb) = refl
+convertZ'DistributesOver*Z (positive (succ a) x) zZero = refl
+convertZ'DistributesOver*Z zZero (negative zero (le x ()))
+convertZ'DistributesOver*Z zZero (negative (succ a) x) = refl
+convertZ'DistributesOver*Z zZero (positive zero (le x ()))
+convertZ'DistributesOver*Z zZero (positive (succ a) x) = refl
+convertZ'DistributesOver*Z zZero zZero = refl
+
+infix 5 _<Z_
+record _<Z_ (a : ℤ) (b : ℤ) : Set where
+  constructor le
+  field
+      x : ℕ
+      proof : (nonneg (succ x)) +Z a ≡ b
+
+addingNonnegIsHom : (a b : ℕ) → nonneg a +Z nonneg b ≡ nonneg (a +N b)
+addingNonnegIsHom zero b = refl
+addingNonnegIsHom (succ a) b = refl
+
+multiplyingNonnegIsHom : (a b : ℕ) → nonneg a *Z nonneg b ≡ nonneg (a *N b)
+multiplyingNonnegIsHom zero b = refl
+multiplyingNonnegIsHom (succ a) zero rewrite multiplicationNIsCommutative a 0 = refl
+multiplyingNonnegIsHom (succ a) (succ b) = refl
+
+multiplyWithZero : (a : ℤ) → a *Z nonneg 0 ≡ nonneg 0
+multiplyWithZero (nonneg zero) rewrite multiplyingNonnegIsHom zero zero = refl
+multiplyWithZero (nonneg (succ x)) rewrite multiplyingNonnegIsHom (succ x) zero = refl
+multiplyWithZero (negSucc x) = refl
+
+multiplyWithZero' : (a : ℤ) → nonneg 0 *Z a ≡ nonneg 0
+multiplyWithZero' (nonneg x) = refl
+multiplyWithZero' (negSucc zero) = refl
+multiplyWithZero' (negSucc (succ x)) = refl
+
+nonnegInjective : {a b : ℕ} → (nonneg a ≡ nonneg b) → (a ≡ b)
+nonnegInjective {a} {.a} refl = refl
+
+lessIsPreservedNToZ : {a b : ℕ} → (a <N b) → ((nonneg a) <Z (nonneg b))
+_<Z_.x (lessIsPreservedNToZ {a} {b} (le x proof)) = x
+_<Z_.proof (lessIsPreservedNToZ {a} {.(succ (x +N a))} (le x refl)) = refl
+
+lessIsPreservedNToZConverse : {a b : ℕ} → ((nonneg a) <Z (nonneg b)) → (a <N b)
+lessIsPreservedNToZConverse {a} {b} (le x proof) = le x (nonnegInjective proof)
+
+additionZIsCommutative : (a b : ℤ) → a +Z b ≡ b +Z a
+additionZIsCommutative (nonneg x) (nonneg y) = splitRight
+  where
+    inN : x +N y ≡ y +N x
+    inN = Semiring.commutative ℕSemiring x y
+    inZ : nonneg (x +N y) ≡ nonneg (y +N x)
+    inZ = applyEquality nonneg inN
+    splitLeft : nonneg x +Z nonneg y ≡ nonneg (y +N x)
+    splitLeft = identityOfIndiscernablesLeft (nonneg (x +N y)) (nonneg (y +N x)) (nonneg x +Z nonneg y) _≡_ inZ (equalityCommutative (addingNonnegIsHom x y))
+    splitRight : nonneg x +Z nonneg y ≡ nonneg y +Z nonneg x
+    splitRight = identityOfIndiscernablesRight (nonneg x +Z nonneg y) (nonneg (y +N x)) (nonneg y +Z nonneg x) _≡_ splitLeft (equalityCommutative (addingNonnegIsHom y x))
+
+additionZIsCommutative (nonneg zero) (negSucc a) = refl
+additionZIsCommutative (nonneg (succ x)) (negSucc zero) = refl
+additionZIsCommutative (nonneg (succ x)) (negSucc (succ a)) = additionZIsCommutative (nonneg x) (negSucc a)
+additionZIsCommutative (negSucc zero) (nonneg zero) = refl
+additionZIsCommutative (negSucc (succ a)) (nonneg zero) = refl
+additionZIsCommutative (negSucc zero) (nonneg (succ x)) = refl
+additionZIsCommutative (negSucc (succ a)) (nonneg (succ x)) = additionZIsCommutative (negSucc a) (nonneg x)
+additionZIsCommutative (negSucc zero) (negSucc zero) = refl
+additionZIsCommutative (negSucc zero) (negSucc (succ b)) = applyEquality negSucc i
+  where
+    h : succ b ≡ b +N succ zero
+    h = equalityCommutative (Semiring.commutative ℕSemiring b 1)
+    i : succ (succ b) ≡ succ (b +N succ zero)
+    i = applyEquality succ h
+
+additionZIsCommutative (negSucc (succ a)) (negSucc zero) = applyEquality negSucc i
+  where
+    i : succ (a +N succ zero) ≡ succ (succ a)
+    i = applyEquality succ (Semiring.commutative ℕSemiring a 1)
+
+additionZIsCommutative (negSucc (succ a)) (negSucc (succ b)) = applyEquality negSucc (applyEquality succ j)
+  where
+    m : succ (a +N b) ≡ succ (b +N a)
+    m = applyEquality succ (Semiring.commutative ℕSemiring a b)
+    r : a +N succ b ≡ b +N succ a
+    r = transitivity (succExtracts a b) (transitivity m (equalityCommutative (succExtracts b a)))
+    k : succ (a +N succ b) ≡ succ (b +N succ a)
+    k rewrite Semiring.commutative ℕSemiring a (succ b) | Semiring.commutative ℕSemiring b a | Semiring.commutative ℕSemiring (succ a) b = refl
+    j : a +N succ (succ b) ≡ b +N succ (succ a)
+    j = transitivity (succExtracts a (succ b)) (transitivity k (equalityCommutative (succExtracts b (succ a))))
+
+additiveInverseExists : (a : ℕ) → (negSucc a +Z nonneg (succ a)) ≡ nonneg 0
+additiveInverseExists zero = refl
+additiveInverseExists (succ a) = additiveInverseExists a
+
+multiplicationZ'IsCommutative : (a b : ℤSimple) → (a *Z' b ≡ b *Z' a)
+multiplicationZ'IsCommutative (negative zero (le x ())) (negative b prb)
+multiplicationZ'IsCommutative (negative (succ a) _) (negative zero (le x ()))
+multiplicationZ'IsCommutative (negative (succ a) x) (negative (succ b) prb) = res (succIsPositive (b +N a *N succ b)) (succIsPositive (a +N b *N succ a))
+  where
+    h : succ a *N succ b ≡ succ b *N succ a
+    h = multiplicationNIsCommutative (succ a) (succ b)
+    res : (pr1 : 0 <N succ b +N a *N succ b) → (pr2 : 0 <N succ a +N b *N succ a) → positive (succ a *N succ b) pr1 ≡ positive (succ b *N succ a) pr2
+    res pr1 pr2 rewrite h = posIsPos pr1 pr2
+multiplicationZ'IsCommutative (negative zero (le x ())) (positive b prb)
+multiplicationZ'IsCommutative (negative (succ a) x) (positive zero (le _ ()))
+multiplicationZ'IsCommutative (negative (succ a) x) (positive (succ b) prb) = res (succIsPositive (b +N a *N succ b)) (succIsPositive (a +N b *N succ a))
+  where
+    h : succ a *N succ b ≡ succ b *N succ a
+    h = multiplicationNIsCommutative (succ a) (succ b)
+    res : (pr1 : 0 <N succ b +N a *N succ b) → (pr2 : 0 <N succ a +N b *N succ a) → negative (succ a *N succ b) pr1 ≡ negative (succ b *N succ a) pr2
+    res pr1 pr2 rewrite h = negIsNeg pr1 pr2
+multiplicationZ'IsCommutative (negative zero (le x ())) zZero
+multiplicationZ'IsCommutative (negative (succ a) x) zZero = refl
+multiplicationZ'IsCommutative (positive zero (le x ())) (negative b prb)
+multiplicationZ'IsCommutative (positive (succ a) x) (negative zero (le _ ()))
+multiplicationZ'IsCommutative (positive (succ a) x) (negative (succ b) prb) = res (succIsPositive (b +N a *N succ b)) (succIsPositive (a +N b *N succ a))
+  where
+    h : succ a *N succ b ≡ succ b *N succ a
+    h = multiplicationNIsCommutative (succ a) (succ b)
+    res : (pr1 : 0 <N succ b +N a *N succ b) → (pr2 : 0 <N succ a +N b *N succ a) → negative (succ a *N succ b) pr1 ≡ negative (succ b *N succ a) pr2
+    res pr1 pr2 rewrite h = negIsNeg pr1 pr2
+multiplicationZ'IsCommutative (positive zero (le x ())) (positive b prb)
+multiplicationZ'IsCommutative (positive (succ a) x) (positive zero (le x₁ ()))
+multiplicationZ'IsCommutative (positive (succ a) _) (positive (succ b) _) = res (succIsPositive (b +N a *N succ b)) (succIsPositive (a +N b *N succ a))
+  where
+    h : succ a *N succ b ≡ succ b *N succ a
+    h = multiplicationNIsCommutative (succ a) (succ b)
+    res : (pr1 : 0 <N succ b +N a *N succ b) → (pr2 : 0 <N succ a +N b *N succ a) → positive (succ a *N succ b) pr1 ≡ positive (succ b *N succ a) pr2
+    res pr1 pr2 rewrite h = posIsPos pr1 pr2
+multiplicationZ'IsCommutative (positive zero (le x ())) zZero
+multiplicationZ'IsCommutative (positive (succ a) x) zZero = refl
+multiplicationZ'IsCommutative zZero (negative zero (le x ()))
+multiplicationZ'IsCommutative zZero (negative (succ a) x) = refl
+multiplicationZ'IsCommutative zZero (positive zero (le x ()))
+multiplicationZ'IsCommutative zZero (positive (succ a) x) = refl
+multiplicationZ'IsCommutative zZero zZero = refl
+
+multiplicationZIsCommutative : (a b : ℤ) → (a *Z b ≡ b *Z a)
+multiplicationZIsCommutative a b = res
+  where
+    help : convertZ' (convertZ a *Z' convertZ b) ≡ convertZ' (convertZ b *Z' convertZ a)
+    help = applyEquality convertZ' (multiplicationZ'IsCommutative (convertZ a) (convertZ b))
+    res : a *Z b ≡ b *Z a
+    res rewrite zIsZ a | zIsZ b = help
+
+negSuccIsNotNonneg : (a b : ℕ) → (negSucc a ≡ nonneg b) → False
+negSuccIsNotNonneg zero b ()
+negSuccIsNotNonneg (succ a) b ()
+
+negSuccInjective : {a b : ℕ} → (negSucc a ≡ negSucc b) → a ≡ b
+negSuccInjective refl = refl
+
+zeroMultInZLeft : (a : ℤ) → (nonneg zero) *Z a ≡ (nonneg zero)
+zeroMultInZLeft a = identityOfIndiscernablesLeft (a *Z nonneg zero) (nonneg zero) (nonneg zero *Z a) _≡_ (multiplyWithZero a) (multiplicationZIsCommutative a (nonneg zero))
+
+additionZeroDoesNothing : (a : ℤ) → (a +Z nonneg zero ≡ a)
+additionZeroDoesNothing (nonneg zero) = refl
+additionZeroDoesNothing (nonneg (succ x)) = applyEquality nonneg (applyEquality succ (addZeroRight x))
+additionZeroDoesNothing (negSucc x) = refl
+
+canSubtractOne : (a : ℤ) (b : ℕ) → negSucc zero +Z a ≡ negSucc (succ b) → a ≡ negSucc b
+canSubtractOne (nonneg zero) b pr = i
+  where
+    simplified : negSucc zero ≡ negSucc (succ b)
+    simplified = identityOfIndiscernablesLeft (negSucc zero +Z nonneg zero) (negSucc (succ b)) (negSucc zero) _≡_ pr refl
+    removeNegsucc : zero ≡ succ b
+    removeNegsucc = negSuccInjective simplified
+    f : False
+    f = succIsNonzero (equalityCommutative removeNegsucc)
+    i : (nonneg zero) ≡ negSucc b
+    i = exFalso f
+canSubtractOne (nonneg (succ x)) b pr = exFalso (negSuccIsNotNonneg (succ b) x (equalityCommutative pr))
+canSubtractOne (negSucc x) .x refl = refl
+
+canAddOne : (a : ℤ) (b : ℕ) → a ≡ negSucc b → negSucc zero +Z a ≡ negSucc (succ b)
+canAddOne (nonneg x) b ()
+canAddOne (negSucc x) .x refl = refl
+
+canAddOneReversed : (a : ℤ) (b : ℕ) → a ≡ negSucc b → a +Z negSucc zero ≡ negSucc (succ b)
+canAddOneReversed a b pr = identityOfIndiscernablesLeft (negSucc zero +Z a) (negSucc (succ b)) (a +Z negSucc zero) _≡_ (canAddOne a b pr) (additionZIsCommutative (negSucc zero) a)
+
+addToNegativeSelf : (a : ℕ) → negSucc a +Z nonneg a ≡ negSucc zero
+addToNegativeSelf zero = refl
+addToNegativeSelf (succ a) = addToNegativeSelf a
+
+multiplicativeIdentityOneZNegsucc : (a : ℕ) → (negSucc a *Z nonneg (succ zero) ≡ negSucc a)
+multiplicativeIdentityOneZNegsucc zero = refl
+multiplicativeIdentityOneZNegsucc (succ x) rewrite multiplicationZIsCommutative (negSucc (succ x)) (nonneg 1) | Semiring.commutative ℕSemiring x 0 = refl
+
+multiplicativeIdentityOneZ : (a : ℤ) → (a *Z nonneg (succ zero) ≡ a)
+multiplicativeIdentityOneZ (nonneg zero) rewrite multiplicationZIsCommutative (nonneg 0) (nonneg 1) = refl
+multiplicativeIdentityOneZ (nonneg (succ x)) rewrite multiplicationZIsCommutative (nonneg (succ x)) (nonneg 1) | Semiring.commutative ℕSemiring x 0 = refl
+multiplicativeIdentityOneZ (negSucc x) = multiplicativeIdentityOneZNegsucc (x)
+
+multiplicativeIdentityOneZLeft : (a : ℤ) → (nonneg (succ zero)) *Z a ≡ a
+multiplicativeIdentityOneZLeft a = identityOfIndiscernablesLeft (a *Z nonneg (succ zero)) a (nonneg (succ zero) *Z a) _≡_ (multiplicativeIdentityOneZ a) (multiplicationZIsCommutative a (nonneg (succ zero)))
+
+-- Define the equivalence of negSucc + nonneg = nonneg with the corresponding statements of naturals
+
+negSuccPlusNonnegNonneg : (a : ℕ) → (b : ℕ) → (c : ℕ) → (negSucc a +Z (nonneg b) ≡ nonneg c) → b ≡ c +N succ a
+negSuccPlusNonnegNonneg zero zero c ()
+negSuccPlusNonnegNonneg zero (succ b) .b refl rewrite succExtracts b zero | addZeroRight b = refl
+negSuccPlusNonnegNonneg (succ a) zero c ()
+negSuccPlusNonnegNonneg (succ a) (succ b) c pr with negSuccPlusNonnegNonneg a b c pr
+... | prev = identityOfIndiscernablesRight (succ b) (succ (c +N succ a)) (c +N succ (succ a)) _≡_ (applyEquality succ prev) (equalityCommutative (succExtracts c (succ a)))
+
+negSuccPlusNonnegNonnegConverse : (a : ℕ) → (b : ℕ) → (c : ℕ) → (b ≡ c +N succ a) → (negSucc a +Z (nonneg b) ≡ nonneg c)
+negSuccPlusNonnegNonnegConverse zero zero c pr rewrite succExtracts c zero = naughtE pr
+negSuccPlusNonnegNonnegConverse zero (succ b) c pr rewrite Semiring.commutative ℕSemiring c 1 with succInjective pr
+... | pr' = applyEquality nonneg pr'
+negSuccPlusNonnegNonnegConverse (succ a) zero c pr rewrite succExtracts c (succ a) = naughtE pr
+negSuccPlusNonnegNonnegConverse (succ a) (succ b) c pr rewrite succExtracts c (succ a) with succInjective pr
+... | pr' = negSuccPlusNonnegNonnegConverse a b c pr'
+
+-- Define the equivalence of negSucc + nonneg = negSucc with the corresponding statements of naturals
+
+negSuccPlusNonnegNegsucc : (a b c : ℕ) → (negSucc a +Z (nonneg b) ≡ negSucc c) → c +N b ≡ a
+negSuccPlusNonnegNegsucc zero zero .0 refl = refl
+negSuccPlusNonnegNegsucc zero (succ b) c ()
+negSuccPlusNonnegNegsucc (succ a) zero .(succ a) refl rewrite addZeroRight a = refl
+negSuccPlusNonnegNegsucc (succ a) (succ b) c pr with negSuccPlusNonnegNegsucc a b c pr
+... | pr' = identityOfIndiscernablesLeft (succ (c +N b)) (succ a) (c +N succ b) _≡_ (applyEquality succ pr') (equalityCommutative (succExtracts c b))
+
+negSuccPlusNonnegNegsuccConverse : (a b c : ℕ) → (c +N b ≡ a) → (negSucc a +Z (nonneg b) ≡ negSucc c)
+negSuccPlusNonnegNegsuccConverse zero zero c pr rewrite addZeroRight c = applyEquality negSucc (equalityCommutative pr)
+negSuccPlusNonnegNegsuccConverse zero (succ b) c pr rewrite succExtracts c b = naughtE (equalityCommutative pr)
+negSuccPlusNonnegNegsuccConverse (succ a) zero c pr rewrite addZeroRight c = applyEquality negSucc (equalityCommutative pr)
+negSuccPlusNonnegNegsuccConverse (succ a) (succ b) c pr rewrite succExtracts c b = negSuccPlusNonnegNegsuccConverse a b c (succInjective pr)
+
+-- Define the impossibility of negSucc + negSucc = nonneg
+negSuccPlusNegSuccIsNegative : (a b c : ℕ) → ((negSucc a) +Z (negSucc b) ≡ nonneg c) → False
+negSuccPlusNegSuccIsNegative zero b c ()
+negSuccPlusNegSuccIsNegative (succ a) b c ()
+
+-- Define the equivalence of negSucc + negSucc = negSucc
+negSuccPlusNegSuccNegSucc : (a b c : ℕ) → (negSucc a) +Z (negSucc b) ≡ (negSucc c) → succ (a +N b) ≡ c
+negSuccPlusNegSuccNegSucc zero b .(succ b) refl = refl
+negSuccPlusNegSuccNegSucc (succ a) b .(succ (a +N succ b)) refl = applyEquality succ (equalityCommutative (succExtracts a b))
+
+negSuccPlusNegSuccNegSuccConverse : (a b c : ℕ) → succ (a +N b) ≡ c → (negSucc a) +Z (negSucc b) ≡ negSucc c
+negSuccPlusNegSuccNegSuccConverse zero b c pr = applyEquality negSucc pr
+negSuccPlusNegSuccNegSuccConverse (succ a) b zero ()
+negSuccPlusNegSuccNegSuccConverse (succ a) b (succ c) pr rewrite succExtracts a b = applyEquality negSucc pr
+
+-- Define the equivalence of nonneg + nonneg = nonneg
+nonnegPlusNonnegNonneg : (a b c : ℕ) → nonneg a +Z nonneg b ≡ nonneg c → a +N b ≡ c
+nonnegPlusNonnegNonneg a b c pr rewrite addingNonnegIsHom a b = nonnegInj pr
+  where
+    nonnegInj : {x y : ℕ} → (pr : nonneg x ≡ nonneg y) → x ≡ y
+    nonnegInj {x} {.x} refl = refl
+
+nonnegPlusNonnegNonnegConverse : (a b c : ℕ) → a +N b ≡ c → nonneg a +Z nonneg b ≡ nonneg c
+nonnegPlusNonnegNonnegConverse a b c pr rewrite addingNonnegIsHom a b = applyEquality nonneg pr
+
+nonnegIsNotNegsucc : {x y : ℕ} → nonneg x ≡ negSucc y → False
+nonnegIsNotNegsucc {x} {y} ()
+
+-- Define the impossibility of nonneg + nonneg = negSucc
+nonnegPlusNonnegNegsucc : (a b c : ℕ) → nonneg a +Z nonneg b ≡ negSucc c → False
+nonnegPlusNonnegNegsucc a b c pr rewrite addingNonnegIsHom a b = nonnegIsNotNegsucc pr
+
+-- Move negSucc to other side of equation
+moveNegsucc : (a : ℕ) (b c : ℤ) → (negSucc a) +Z b ≡ c → b ≡ c +Z (nonneg (succ a))
+moveNegsucc a (nonneg x) (nonneg y) pr with (negSuccPlusNonnegNonneg a x y pr)
+... | pr' = identityOfIndiscernablesRight (nonneg x) (nonneg (y +N succ a)) (nonneg y +Z nonneg (succ a)) _≡_ (applyEquality nonneg pr') (equalityCommutative (addingNonnegIsHom y (succ a)))
+moveNegsucc a (nonneg x) (negSucc y) pr with negSuccPlusNonnegNegsucc a x y pr
+... | pr' = equalityCommutative (negSuccPlusNonnegNonnegConverse y (succ a) x (g {a} {x} {y} (applyEquality succ pr')))
+  where
+    g : {a x y : ℕ} → succ (y +N x) ≡ succ a → succ a ≡ x +N succ y
+    g {a} {x} {y} p rewrite Semiring.commutative ℕSemiring y x | succExtracts x y = equalityCommutative p
+moveNegsucc a (negSucc x) (nonneg y) pr = exFalso (negSuccPlusNegSuccIsNegative a x y pr)
+moveNegsucc a (negSucc x) (negSucc y) pr with negSuccPlusNegSuccNegSucc a x y pr
+... | pr' = equalityCommutative (negSuccPlusNonnegNegsuccConverse y (succ a) x g)
+  where
+    g : x +N succ a ≡ y
+    g rewrite succExtracts x a | Semiring.commutative ℕSemiring a x = pr'
+
+moveNegsuccConverse : (a : ℕ) → (b c : ℤ) → (b ≡ c +Z (nonneg (succ a))) → (negSucc a) +Z b ≡ c
+moveNegsuccConverse zero (nonneg x) (nonneg y) pr with nonnegPlusNonnegNonneg y 1 x (equalityCommutative pr)
+... | pr' rewrite (equalityCommutative (succIsAddOne y)) = g
+  where
+    g : negSucc 0 +Z nonneg x ≡ nonneg y
+    g rewrite equalityCommutative pr' = refl
+moveNegsuccConverse zero (nonneg x) (negSucc y) pr with moveNegsucc y (nonneg 1) (nonneg x) (equalityCommutative pr)
+... | pr' rewrite addingNonnegIsHom x (succ y) = g x y (nonnegInjective pr')
+  where
+    g : (x y : ℕ) → (1 ≡ (x +N succ y)) → negSucc 0 +Z nonneg x ≡ negSucc y
+    g zero zero pr = refl
+    g zero (succ y) ()
+    g (succ x) y pr = naughtE (identityOfIndiscernablesRight zero (x +N succ y) (succ (x +N y)) _≡_ (succInjective pr) (succExtracts x y))
+moveNegsuccConverse zero (negSucc x) (nonneg y) pr = exFalso (nonnegPlusNonnegNegsucc y 1 x (equalityCommutative pr))
+moveNegsuccConverse zero (negSucc x) (negSucc y) pr with negSuccPlusNonnegNegsucc y 1 x (equalityCommutative pr)
+... | pr' = applyEquality negSucc g
+  where
+    g : succ x ≡ y
+    g rewrite Semiring.commutative ℕSemiring x 1 = pr'
+moveNegsuccConverse (succ a) (nonneg x) (nonneg y) pr with nonnegPlusNonnegNonneg y (succ (succ a)) x (equalityCommutative pr)
+... | pr' = negSuccPlusNonnegNonnegConverse (succ a) x y (equalityCommutative pr')
+moveNegsuccConverse (succ a) (nonneg x) (negSucc y) pr with negSuccPlusNonnegNonneg y (succ (succ a)) x (equalityCommutative pr)
+... | pr' = negSuccPlusNonnegNegsuccConverse (succ a) x y (g a x y pr')
+  where
+    g : (a x y : ℕ) → succ (succ a) ≡ x +N succ y → y +N x ≡ succ a
+    g a x y pr rewrite succExtracts x y | Semiring.commutative ℕSemiring x y = equalityCommutative (succInjective pr)
+moveNegsuccConverse (succ a) (negSucc x) (nonneg z) pr = exFalso (nonnegPlusNonnegNegsucc z (succ (succ a)) x (equalityCommutative pr))
+moveNegsuccConverse (succ a) (negSucc x) (negSucc z) pr with negSuccPlusNonnegNegsucc z (succ (succ a)) x (equalityCommutative pr)
+... | pr' = applyEquality negSucc (g a x z pr')
+  where
+    g : (a x z : ℕ) → x +N succ (succ a) ≡ z → succ (a +N succ x) ≡ z
+    g a x z pr rewrite succExtracts x (succ a) = identityOfIndiscernablesLeft (succ (x +N succ a)) z (succ (a +N succ x)) _≡_ pr (applyEquality succ (s x a))
+      where
+        s : (x a : ℕ) → x +N succ a ≡ a +N succ x
+        s x a rewrite succCanMove a x = Semiring.commutative ℕSemiring x (succ a)
+
+-- By this point, any statement about addition can be moved from N into Z and from Z into N by applying moveNegSucc and its converse to eliminate any adding of negSucc.
+
+lessIsPreservedNToZNegsucc : {a b : ℕ} → (a <N b) → ((negSucc b) <Z negSucc a)
+lessIsPreservedNToZNegsucc {a} {b} (le x proof) = record { x = x ; proof = pr }
+  where
+    pr : nonneg (succ x) +Z negSucc b ≡ negSucc a
+    pr rewrite additionZIsCommutative (nonneg (succ x)) (negSucc b) = moveNegsuccConverse b (nonneg (succ x)) (negSucc a) (equalityCommutative (moveNegsuccConverse a (nonneg (succ b)) (nonneg (succ x)) (applyEquality nonneg (applyEquality succ proof'))))
+      where
+        proof' : b ≡ x +N succ a
+        proof' rewrite Semiring.commutative ℕSemiring x a | Semiring.commutative ℕSemiring (succ a) x = equalityCommutative proof
+
+lessLemma : (a x : ℕ) → succ x +N a ≡ a → False
+lessLemma zero x pr = naughtE (equalityCommutative pr)
+lessLemma (succ a) x pr = lessLemma a x q
+  where
+    q : succ x +N a ≡ a
+    q rewrite Semiring.commutative ℕSemiring a (succ x) | Semiring.commutative ℕSemiring x a | Semiring.commutative ℕSemiring (succ a) x = succInjective pr
+
+sumOfNegsucc : (a b : ℕ) → (negSucc a +Z negSucc b) ≡ negSucc (succ (a +N b))
+sumOfNegsucc a b = negSuccPlusNegSuccNegSuccConverse a b (succ (a +N b)) refl
+
+additionZInjLemma : {a b c : ℕ} → (nonneg a ≡ (nonneg a +Z nonneg b) +Z nonneg (succ c)) → False
+additionZInjLemma {a} {b} {c} pr = cannotAddKeepingEquality a (c +N b) pr2''
+  where
+    pr'' : nonneg a ≡ nonneg (a +N b) +Z nonneg (succ c)
+    pr'' = identityOfIndiscernablesRight (nonneg a) ((nonneg a +Z nonneg b) +Z nonneg (succ c)) (nonneg (a +N b) +Z nonneg (succ c)) _≡_ pr (applyEquality (λ i → i +Z nonneg (succ c)) (addingNonnegIsHom a b))
+    pr''' : nonneg a ≡ nonneg ((a +N b) +N succ c)
+    pr''' = identityOfIndiscernablesRight (nonneg a) (nonneg (a +N b) +Z nonneg (succ c)) (nonneg ((a +N b) +N succ c)) _≡_ pr'' (addingNonnegIsHom (a +N b) (succ c))
+    pr2 : a ≡ (a +N b) +N succ c
+    pr2 = nonnegInjective pr'''
+    pr2' : a ≡ a +N (b +N succ c)
+    pr2' = identityOfIndiscernablesRight a ((a +N b) +N succ c) (a +N (b +N succ c)) _≡_ pr2 (additionNIsAssociative a b (succ c))
+    pr2'' : a ≡ a +N succ (c +N b)
+    pr2'' rewrite Semiring.commutative ℕSemiring (succ c) b = pr2'
+
+additionZInjectiveFirstLemma : (a : ℕ) → (b c : ℤ) → (nonneg a +Z b ≡ nonneg a +Z c) → (b ≡ c)
+additionZInjectiveFirstLemma a (nonneg b) (nonneg c) pr rewrite (addingNonnegIsHom a b) | (addingNonnegIsHom a c) = applyEquality nonneg (canSubtractFromEqualityLeft {a} pr')
+  where
+    pr' : a +N b ≡ a +N c
+    pr' = nonnegInjective pr
+additionZInjectiveFirstLemma a (nonneg b) (negSucc c) pr = exFalso (additionZInjLemma pr')
+  where
+    pr' : nonneg a ≡ (nonneg a +Z nonneg b) +Z nonneg (succ c)
+    pr' rewrite additionZIsCommutative (nonneg a) (negSucc c) = moveNegsucc c (nonneg a) (nonneg a +Z nonneg b) (equalityCommutative pr)
+additionZInjectiveFirstLemma a (negSucc b) (nonneg x) pr = exFalso (additionZInjLemma pr')
+  where
+    pr' : nonneg a ≡ (nonneg a +Z nonneg x) +Z nonneg (succ b)
+    pr' rewrite additionZIsCommutative (nonneg a) (negSucc b) = moveNegsucc b (nonneg a) (nonneg a +Z nonneg x) pr
+additionZInjectiveFirstLemma zero (negSucc zero) (negSucc x) pr = pr
+additionZInjectiveFirstLemma zero (negSucc (succ b)) (negSucc x) pr = pr
+additionZInjectiveFirstLemma (succ a) (negSucc zero) (negSucc x) pr = applyEquality negSucc (equalityCommutative qr'')
+  where
+    pr1 : negSucc x +Z nonneg (succ a) ≡ nonneg a
+    pr1 rewrite additionZIsCommutative (nonneg (succ a)) (negSucc x) = equalityCommutative pr
+    pr' : nonneg a +Z nonneg (succ x) ≡ nonneg (succ a)
+    pr' = equalityCommutative (moveNegsucc x (nonneg (succ a)) (nonneg a) pr1)
+    pr'' : nonneg (a +N succ x) ≡ nonneg (succ a)
+    pr'' rewrite equalityCommutative (addingNonnegIsHom a (succ x)) = pr'
+    pr''' : a +N succ x ≡ succ a
+    pr''' = nonnegInjective pr''
+    pr'''' : succ x +N a ≡ succ a
+    pr'''' rewrite Semiring.commutative ℕSemiring (succ x) a = pr'''
+    qr : succ (a +N x) ≡ succ a
+    qr rewrite Semiring.commutative ℕSemiring a x = pr''''
+    qr' : a +N x ≡ a +N 0
+    qr' rewrite addZeroRight a = succInjective qr
+    qr'' : x ≡ 0
+    qr'' = canSubtractFromEqualityLeft {a} qr'
+additionZInjectiveFirstLemma (succ a) (negSucc (succ b)) (negSucc zero) pr = naughtE qr
+  where
+    pr' : nonneg a ≡ nonneg a +Z nonneg (succ b)
+    pr' rewrite additionZIsCommutative (nonneg a) (negSucc b) = moveNegsucc b (nonneg a) (nonneg a) pr
+    pr'' : nonneg a ≡ nonneg (a +N succ b)
+    pr'' rewrite equalityCommutative (addingNonnegIsHom a (succ b)) = pr'
+    pr''' : a +N 0 ≡ a +N succ b
+    pr''' rewrite addZeroRight a = nonnegInjective pr''
+    qr : 0 ≡ succ b
+    qr = canSubtractFromEqualityLeft {a} pr'''
+additionZInjectiveFirstLemma (succ a) (negSucc (succ b)) (negSucc (succ x)) pr = go b x pr''
+  where
+    pr' : negSucc b ≡ negSucc x
+    pr' = additionZInjectiveFirstLemma a (negSucc b) (negSucc x) pr
+    pr'' : b ≡ x
+    pr'' = negSuccInjective pr'
+    go : (b x : ℕ) → (b ≡ x) → negSucc (succ b) ≡ negSucc (succ x)
+    go b .b refl = refl
+
+additionZInjectiveSecondLemmaLemma : (a : ℕ) (b : ℕ) (c : ℕ) → (negSucc a +Z nonneg b ≡ negSucc a +Z negSucc c) → nonneg b ≡ negSucc c
+additionZInjectiveSecondLemmaLemma zero zero zero pr = naughtE (negSuccInjective pr)
+additionZInjectiveSecondLemmaLemma zero zero (succ c) pr = naughtE (negSuccInjective pr)
+additionZInjectiveSecondLemmaLemma zero (succ b) c pr = exFalso (nonnegIsNotNegsucc pr)
+additionZInjectiveSecondLemmaLemma (succ a) zero c pr = naughtE (canSubtractFromEqualityLeft {succ a} pr')
+  where
+    pr' : succ a +N zero ≡ succ a +N succ c
+    pr' rewrite addZeroRight (succ a) = negSuccInjective pr
+additionZInjectiveSecondLemmaLemma (succ a) (succ b) c pr = naughtE r
+  where
+    pr' : negSucc (succ (a +N succ c)) +Z nonneg (succ a) ≡ nonneg b
+    pr' = equalityCommutative (moveNegsucc a (nonneg b) (negSucc (succ (a +N succ c))) pr)
+    pr'' : nonneg (succ a) ≡ nonneg b +Z nonneg (succ (succ (a +N succ c)))
+    pr'' = moveNegsucc (succ (a +N succ c)) (nonneg (succ a)) (nonneg b) pr'
+    pr''' : nonneg (succ a) ≡ nonneg (b +N succ (succ (a +N succ c)))
+    pr''' rewrite equalityCommutative (addingNonnegIsHom b (succ (succ (a +N succ c)))) = pr''
+    pr'''' : succ a ≡ b +N ((succ (succ a)) +N succ c)
+    pr'''' = nonnegInjective pr'''
+    q : succ a ≡ (b +N (succ (succ a))) +N succ c
+    q = identityOfIndiscernablesRight (succ a) (b +N ((succ (succ a)) +N succ c)) ((b +N (succ (succ a))) +N succ c) _≡_ pr'''' (equalityCommutative (additionNIsAssociative b (succ (succ a)) (succ c)))
+    moveSucc : (a b : ℕ) → a +N succ b ≡ succ a +N b
+    moveSucc a b rewrite Semiring.commutative ℕSemiring a (succ b) | Semiring.commutative ℕSemiring a b = refl
+    q' : succ a ≡ (succ b +N succ a) +N succ c
+    q' = identityOfIndiscernablesRight (succ a) ((b +N succ (succ a)) +N succ c) ((succ b +N succ a) +N succ c) _≡_ q (applyEquality (λ t → t +N succ c) (moveSucc b (succ a)))
+    q'' : succ a ≡ (succ a +N succ b) +N succ c
+    q'' = identityOfIndiscernablesRight (succ a) ((succ b +N succ a) +N succ c) ((succ a +N succ b) +N succ c) _≡_ q' (applyEquality (λ t → t +N succ c) (Semiring.commutative ℕSemiring (succ b) (succ a)))
+    q''' : succ a ≡ succ a +N (succ b +N succ c)
+    q''' rewrite equalityCommutative (additionNIsAssociative (succ a) (succ b) (succ c)) = q''
+    q'''' : succ a +N zero ≡ succ a +N (succ b +N succ c)
+    q'''' rewrite addZeroRight (succ a) = q'''
+    r : zero ≡ succ b +N succ c
+    r = canSubtractFromEqualityLeft {succ a} q''''
+
+additionZInjectiveSecondLemma : (a : ℕ) (b c : ℤ) → (negSucc a +Z b ≡ negSucc a +Z c) → b ≡ c
+additionZInjectiveSecondLemma zero (nonneg zero) (nonneg zero) pr = refl
+additionZInjectiveSecondLemma zero (nonneg zero) (nonneg (succ c)) pr = exFalso (nonnegIsNotNegsucc (equalityCommutative pr))
+additionZInjectiveSecondLemma zero (nonneg (succ b)) (nonneg zero) pr = exFalso (nonnegIsNotNegsucc pr)
+additionZInjectiveSecondLemma zero (nonneg (succ b)) (nonneg (succ c)) pr rewrite additionZIsCommutative (negSucc zero) (nonneg b) | additionZIsCommutative (negSucc zero) (nonneg c) = applyEquality (λ t → nonneg (succ t)) pr'
+  where
+    pr' : b ≡ c
+    pr' = nonnegInjective pr
+additionZInjectiveSecondLemma zero (nonneg zero) (negSucc c) pr = naughtE pr'
+  where
+    pr' : zero ≡ succ c
+    pr' = negSuccInjective pr
+additionZInjectiveSecondLemma zero (negSucc b) (nonneg zero) pr = naughtE (negSuccInjective (equalityCommutative pr))
+additionZInjectiveSecondLemma zero (negSucc b) (nonneg (succ c)) pr = exFalso (nonnegIsNotNegsucc (equalityCommutative pr))
+additionZInjectiveSecondLemma zero (negSucc b) (negSucc c) pr = applyEquality negSucc (succInjective pr')
+  where
+    pr' : succ b ≡ succ c
+    pr' = negSuccInjective pr
+additionZInjectiveSecondLemma zero (nonneg (succ b)) (negSucc c) pr = exFalso (nonnegIsNotNegsucc pr)
+additionZInjectiveSecondLemma (succ a) (nonneg zero) (nonneg zero) pr = refl
+additionZInjectiveSecondLemma (succ a) (nonneg zero) (nonneg (succ c)) pr = exFalso (nonnegIsNotNegsucc pr'')
+  where
+    pr' : nonneg c ≡ negSucc (succ a) +Z nonneg (succ a)
+    pr' = moveNegsucc a (nonneg c) (negSucc (succ a)) (equalityCommutative pr)
+    pr'' : nonneg c ≡ negSucc zero
+    pr'' rewrite equalityCommutative (addToNegativeSelf (succ a)) = pr'
+additionZInjectiveSecondLemma (succ a) (nonneg (succ b)) (nonneg zero) pr = exFalso (nonnegIsNotNegsucc pr'')
+  where
+    pr' : nonneg b ≡ negSucc (succ a) +Z nonneg (succ a)
+    pr' = moveNegsucc a (nonneg b) (negSucc (succ a)) pr
+    pr'' : nonneg b ≡ negSucc zero
+    pr'' rewrite equalityCommutative (addToNegativeSelf (succ a)) = pr'
+additionZInjectiveSecondLemma (succ a) (nonneg (succ b)) (nonneg (succ c)) pr = applyEquality (λ t → nonneg (succ t)) pr''
+  where
+    pr' : nonneg b ≡ nonneg c
+    pr' = additionZInjectiveSecondLemma a (nonneg b) (nonneg c) pr
+    pr'' : b ≡ c
+    pr'' = nonnegInjective pr'
+additionZInjectiveSecondLemma (succ a) (nonneg zero) (negSucc c) pr = naughtE pr''
+  where
+    pr' : succ a +N zero ≡ succ a +N succ c
+    pr' rewrite addZeroRight a = negSuccInjective pr
+    pr'' : zero ≡ succ c
+    pr'' = canSubtractFromEqualityLeft {succ a} pr'
+additionZInjectiveSecondLemma (succ a) (nonneg (succ b)) (negSucc c) pr = additionZInjectiveSecondLemmaLemma (succ a) (succ b) c pr
+additionZInjectiveSecondLemma (succ a) (negSucc b) (nonneg c) pr = equalityCommutative pr'
+  where
+    pr' : nonneg c ≡ negSucc b
+    pr' = additionZInjectiveSecondLemmaLemma (succ a) c b (equalityCommutative pr)
+additionZInjectiveSecondLemma (succ a) (negSucc b) (negSucc c) pr = applyEquality negSucc pr'''
+  where
+    pr' : succ a +N succ b ≡ succ a +N succ c
+    pr' = negSuccInjective pr
+    pr'' : succ b ≡ succ c
+    pr'' = canSubtractFromEqualityLeft {succ a} pr'
+    pr''' : b ≡ c
+    pr''' = succInjective pr''
+
+additionZInjective : (a b c : ℤ) → (a +Z b ≡ a +Z c) → b ≡ c
+additionZInjective (nonneg a) b c pr = additionZInjectiveFirstLemma a b c pr
+additionZInjective (negSucc a) b c pr = additionZInjectiveSecondLemma a b c pr
+
+addNonnegSucc : (a : ℤ) → (b c : ℕ) → (a +Z nonneg b ≡ nonneg c) → a +Z nonneg (succ b) ≡ nonneg (succ c)
+addNonnegSucc (nonneg x) b c pr rewrite addingNonnegIsHom x (succ b) | addingNonnegIsHom x b = applyEquality nonneg g
+  where
+    p : x +N b ≡ c
+    p = nonnegInjective pr
+    g : x +N succ b ≡ succ c
+    g = identityOfIndiscernablesLeft (succ (x +N b)) (succ c) (x +N succ b) _≡_ (applyEquality succ p) (equalityCommutative (succExtracts x b))
+addNonnegSucc (negSucc x) b c pr = negSuccPlusNonnegNonnegConverse x (succ b) (succ c) (applyEquality succ p')
+  where
+    p' : b ≡ c +N succ x
+    p' = negSuccPlusNonnegNonneg x b c pr
+
+addNonnegSuccLemma : (a x d : ℕ) → (negSucc (succ a) +Z nonneg zero ≡ negSucc (succ x) +Z nonneg (succ d)) → negSucc (succ a) +Z nonneg (succ zero) ≡ negSucc (succ x) +Z nonneg (succ (succ d))
+addNonnegSuccLemma a x d pr = s
+  where
+    p' : negSucc (succ a) +Z nonneg (succ x) ≡ nonneg d
+    p' = equalityCommutative (moveNegsucc x (nonneg d) (negSucc (succ a)) (equalityCommutative pr))
+    p'' : nonneg (succ x) ≡ nonneg d +Z nonneg (succ (succ a))
+    p'' = moveNegsucc (succ a) (nonneg (succ x)) (nonneg d) p'
+    p''' : nonneg (succ x) ≡ nonneg (d +N succ (succ a))
+    p''' rewrite equalityCommutative (addingNonnegIsHom d (succ (succ a))) = p''
+    q : succ x ≡ d +N succ (succ a)
+    q = nonnegInjective p'''
+    q' : succ x ≡ succ (succ a) +N d
+    q' rewrite Semiring.commutative ℕSemiring (succ (succ a)) d = q
+    q'' : succ x ≡ succ d +N succ a
+    q'' rewrite Semiring.commutative ℕSemiring d (succ a) = q'
+    q''' : succ x ≡ succ a +N succ d
+    q''' rewrite Semiring.commutative ℕSemiring (succ a) (succ d) = q''
+    r : nonneg (succ x) ≡ nonneg (succ a +N succ d)
+    r = applyEquality nonneg q'''
+    r' : nonneg (succ x) ≡ nonneg (succ a) +Z nonneg (succ d)
+    r' = identityOfIndiscernablesRight (nonneg (succ x)) (nonneg (succ a +N succ d)) (nonneg (succ a) +Z nonneg (succ d)) _≡_ r (addingNonnegIsHom (succ a) (succ d))
+    r'' : nonneg (succ x) ≡ nonneg (succ d) +Z nonneg (succ a)
+    r'' rewrite additionZIsCommutative (nonneg (succ d)) (nonneg (succ a)) = r'
+    r''' : nonneg (succ d) ≡ negSucc a +Z nonneg (succ x)
+    r''' = equalityCommutative (moveNegsuccConverse a (nonneg (succ x)) (nonneg (succ d)) r'')
+    s : negSucc a ≡ negSucc x +Z nonneg (succ d)
+    s = equalityCommutative (moveNegsuccConverse x (nonneg (succ d)) (negSucc a) r''')
+
+addNonnegSucc' : (a b : ℤ) → (c d : ℕ) → (a +Z nonneg c ≡ b +Z nonneg d) → a +Z nonneg (succ c) ≡ b +Z nonneg (succ d)
+addNonnegSucc' a (nonneg x) c d pr rewrite addingNonnegIsHom x (succ d) | addingNonnegIsHom x d | addNonnegSucc a c (x +N d) pr = applyEquality nonneg (equalityCommutative (succExtracts x d))
+addNonnegSucc' (nonneg a) (negSucc x) c d pr = equalityCommutative (moveNegsuccConverse x (nonneg (succ d)) ((nonneg a) +Z nonneg (succ c)) (equalityCommutative q))
+  where
+    p : ((nonneg a) +Z nonneg c) +Z nonneg (succ x) ≡ nonneg d
+    p = equalityCommutative (moveNegsucc x (nonneg d) ((nonneg a) +Z nonneg c) (equalityCommutative pr))
+    p' : nonneg ((a +N c) +N succ x) ≡ nonneg d
+    p' = identityOfIndiscernablesLeft ((nonneg a +Z nonneg c) +Z nonneg (succ x)) (nonneg d) (nonneg ((a +N c) +N succ x)) _≡_ p g
+      where
+        g : (nonneg a +Z nonneg c) +Z nonneg (succ x) ≡ nonneg ((a +N c) +N succ x)
+        g rewrite addingNonnegIsHom a c | addingNonnegIsHom (a +N c) (succ x) = refl
+    p'' : (a +N c) +N succ x ≡ d
+    p'' = nonnegInjective p'
+    p''' : (a +N succ c) +N succ x ≡ succ d
+    p''' = identityOfIndiscernablesLeft (succ (a +N c) +N succ x) (succ d) ((a +N succ c) +N succ x) _≡_ (applyEquality succ p'') g
+      where
+        g : succ ((a +N c) +N succ x) ≡ (a +N succ c) +N succ x
+        g = applyEquality (λ i → i +N succ x) {succ (a +N c)} {a +N succ c} (equalityCommutative (succExtracts a c))
+    q : (nonneg a +Z nonneg (succ c)) +Z nonneg (succ x) ≡ nonneg (succ d)
+    q rewrite (addingNonnegIsHom a (succ c)) | addingNonnegIsHom (a +N succ c) (succ x) = applyEquality nonneg p'''
+
+addNonnegSucc' (negSucc a) (negSucc x) c d pr with (inspect (negSucc x +Z nonneg d))
+addNonnegSucc' (negSucc a) (negSucc x) c d pr | (nonneg int) with≡ p = identityOfIndiscernablesRight (negSucc a +Z nonneg (succ c)) (nonneg (succ int)) (negSucc x +Z nonneg (succ d)) _≡_ (addNonnegSucc (negSucc a) c int (transitivity pr p)) (equalityCommutative (addNonnegSucc (negSucc x) d int p))
+addNonnegSucc' (negSucc zero) (negSucc zero) c d pr | negSucc int with≡ p = additionZInjective (negSucc zero) (nonneg c) (nonneg d) pr
+  where
+    pr' : nonneg c ≡ (negSucc zero +Z nonneg d) +Z nonneg 1
+    pr' = moveNegsucc zero (nonneg c) (negSucc zero +Z nonneg d) pr
+addNonnegSucc' (negSucc zero) (negSucc (succ x)) zero d pr | negSucc int with≡ p = equalityCommutative (moveNegsuccConverse x (nonneg d) (nonneg zero) (equalityCommutative (applyEquality nonneg q')))
+  where
+    pr' : nonneg d ≡ (negSucc zero) +Z (nonneg (succ (succ x)))
+    pr' = moveNegsucc (succ x) (nonneg d) (negSucc zero) (equalityCommutative pr)
+    pr'' : nonneg (succ (succ x)) ≡ nonneg d +Z nonneg 1
+    pr'' = moveNegsucc (zero) (nonneg (succ (succ x))) (nonneg d) (equalityCommutative pr')
+    pr''' : nonneg (succ (succ x)) ≡ nonneg (d +N 1)
+    pr''' rewrite equalityCommutative (addingNonnegIsHom d 1) = pr''
+    pr'''' : succ (succ x) ≡ d +N 1
+    pr'''' = nonnegInjective pr'''
+    q : succ (succ x) ≡ succ d
+    q rewrite Semiring.commutative ℕSemiring 1 d = pr''''
+    q' : succ x ≡ d
+    q' = succInjective q
+addNonnegSucc' (negSucc zero) (negSucc (succ x)) (succ c) zero pr | negSucc int with≡ p = exFalso (nonnegIsNotNegsucc pr)
+addNonnegSucc' (negSucc zero) (negSucc (succ x)) (succ c) (succ d) pr | negSucc int with≡ p = addNonnegSucc' (nonneg zero) (negSucc x) c d pr
+addNonnegSucc' (negSucc (succ a)) (negSucc zero) zero d pr | negSucc int with≡ p = naughtE q'
+  where
+    pr' : negSucc (succ a) +Z nonneg 1 ≡ nonneg d
+    pr' = equalityCommutative (moveNegsucc zero (nonneg d) (negSucc (succ a)) (equalityCommutative pr))
+    pr'' : nonneg 1 ≡ nonneg d +Z nonneg (succ (succ a))
+    pr'' = moveNegsucc (succ a) (nonneg 1) (nonneg d) pr'
+    pr''' : nonneg 1 ≡ nonneg (d +N succ (succ a))
+    pr''' rewrite equalityCommutative (addingNonnegIsHom d (succ (succ a))) = pr''
+    q : 1 ≡ succ (succ a) +N d
+    q rewrite Semiring.commutative ℕSemiring (succ (succ a)) d = nonnegInjective pr'''
+    q' : 0 ≡ succ a +N d
+    q' = succInjective q
+addNonnegSucc' (negSucc (succ a)) (negSucc zero) (succ c) zero pr | negSucc int with≡ p = help
+  where
+    pr' : negSucc zero +Z nonneg (succ a) ≡ nonneg c
+    pr' = equalityCommutative (moveNegsucc a (nonneg c) (negSucc zero) pr)
+    pr'' : nonneg (succ a) ≡ nonneg c +Z nonneg 1
+    pr'' = moveNegsucc zero (nonneg (succ a)) (nonneg c) pr'
+    pr''' : nonneg (succ a) ≡ nonneg (c +N 1)
+    pr''' rewrite equalityCommutative (addingNonnegIsHom c 1) = pr''
+    q : succ a ≡ succ c
+    q rewrite Semiring.commutative ℕSemiring 1 c = nonnegInjective pr'''
+    q' : a ≡ c
+    q' = succInjective q
+    help : negSucc a +Z nonneg (succ c) ≡ nonneg zero
+    help rewrite q' = additiveInverseExists c
+addNonnegSucc' (negSucc (succ a)) (negSucc zero) (succ c) (succ d) pr | negSucc int with≡ p = moveNegsuccConverse a (nonneg (succ c)) (nonneg (succ d)) q'
+  where
+    pr' : nonneg c ≡ nonneg d +Z nonneg (succ a)
+    pr' = moveNegsucc a (nonneg c) (nonneg d) pr
+    pr'' : nonneg c ≡ nonneg (d +N succ a)
+    pr'' rewrite equalityCommutative (addingNonnegIsHom d (succ a)) = pr'
+    pr''' : c ≡ d +N succ a
+    pr''' = nonnegInjective pr''
+    pr'''' : succ c ≡ succ d +N succ a
+    pr'''' = applyEquality succ pr'''
+    q : nonneg (succ c) ≡ nonneg (succ d +N succ a)
+    q = applyEquality nonneg pr''''
+    q' : nonneg (succ c) ≡ nonneg (succ d) +Z nonneg (succ a)
+    q' rewrite addingNonnegIsHom (succ d) (succ a) = q
+addNonnegSucc' (negSucc (succ a)) (negSucc (succ x)) zero zero pr | negSucc int with≡ p = applyEquality negSucc (succInjective (negSuccInjective pr))
+addNonnegSucc' (negSucc (succ a)) (negSucc (succ x)) zero (succ d) pr | negSucc int with≡ p = addNonnegSuccLemma a x d pr
+addNonnegSucc' (negSucc (succ a)) (negSucc (succ x)) (succ c) zero pr | negSucc int with≡ p = equalityCommutative (addNonnegSuccLemma x a c (equalityCommutative pr))
+addNonnegSucc' (negSucc (succ a)) (negSucc (succ x)) (succ c) (succ d) pr | negSucc int with≡ p = addNonnegSucc' (negSucc a) (negSucc x) c d pr
+
+subtractNonnegSucc : (a : ℤ) → (b c : ℕ) → (a +Z nonneg (succ b) ≡ nonneg (succ c)) → a +Z nonneg b ≡ nonneg c
+subtractNonnegSucc (nonneg x) b c pr rewrite addingNonnegIsHom x (succ b) | addingNonnegIsHom x b = applyEquality nonneg g
+  where
+    p : succ (x +N b) ≡ succ c
+    p rewrite succExtracts x b = nonnegInjective pr
+    g : x +N b ≡ c
+    g = succInjective p
+subtractNonnegSucc (negSucc x) b c pr = negSuccPlusNonnegNonnegConverse x b c (succInjective p')
+  where
+    p' : succ b ≡ succ (c +N succ x)
+    p' = negSuccPlusNonnegNonneg x (succ b) (succ c) pr
+
+addNegsuccThenNonneg : (a : ℤ) (b c : ℕ) → (a +Z negSucc b) +Z nonneg (succ (c +N b)) ≡ a +Z nonneg c
+addNegsuccThenNonneg (nonneg zero) zero c rewrite addZeroRight c = refl
+addNegsuccThenNonneg (nonneg (succ x)) zero c rewrite addZeroRight c | addingNonnegIsHom x (succ c) = applyEquality nonneg (succExtracts x c)
+addNegsuccThenNonneg (nonneg zero) (succ b) c = moveNegsuccConverse b (nonneg (c +N succ b)) (nonneg c) (equalityCommutative (addingNonnegIsHom c (succ b)))
+addNegsuccThenNonneg (nonneg (succ x)) (succ b) c with addNegsuccThenNonneg (nonneg x) b c
+... | prev = go
+  where
+    go : (nonneg x +Z negSucc b) +Z nonneg (succ (c +N succ b)) ≡ nonneg (succ (x +N c))
+    go rewrite addingNonnegIsHom x c | succExtracts c b = p
+      where
+        p : (nonneg x +Z negSucc b) +Z nonneg (succ (succ (c +N b))) ≡ nonneg (succ (x +N c))
+        p = addNonnegSucc (nonneg x +Z negSucc b) (succ (c +N b)) (x +N c) prev
+addNegsuccThenNonneg (negSucc x) zero c rewrite addZeroRight c | sumOfNegsucc x 0 | addZeroRight x = refl
+addNegsuccThenNonneg (negSucc x) (succ b) c with addNegsuccThenNonneg (negSucc x) b c
+... | prev = go
+  where
+    p : nonneg c ≡ ((negSucc x +Z negSucc b) +Z nonneg (succ (c +N b))) +Z nonneg (succ x)
+    p = moveNegsucc x (nonneg c) ((negSucc x +Z negSucc b) +Z nonneg (succ (c +N b))) (equalityCommutative prev)
+    go : (negSucc x +Z negSucc (succ b)) +Z nonneg (succ (c +N succ b)) ≡ negSucc x +Z nonneg c
+    go rewrite sumOfNegsucc x (succ b) | succExtracts c b = identityOfIndiscernablesLeft ((negSucc x +Z negSucc b) +Z nonneg (succ (c +N b))) (negSucc x +Z nonneg c) (negSucc (x +N succ b) +Z nonneg (succ (c +N b))) _≡_ prev (applyEquality (λ t → t +Z nonneg (succ (c +N b))) {negSucc x +Z negSucc b} {negSucc (x +N succ b)} (identityOfIndiscernablesRight (negSucc x +Z negSucc b) (negSucc (succ (x +N b))) (negSucc (x +N succ b)) _≡_ (sumOfNegsucc x b) (applyEquality negSucc (equalityCommutative (succExtracts x b)))))
+
+addNonnegThenNonneg : (a : ℤ) (b c : ℕ) → (a +Z nonneg b) +Z nonneg c ≡ a +Z nonneg (b +N c)
+addNonnegThenNonneg (nonneg x) b c rewrite addingNonnegIsHom x b | addingNonnegIsHom x (b +N c) | addingNonnegIsHom (x +N b) c = applyEquality nonneg (additionNIsAssociative x b c)
+addNonnegThenNonneg (negSucc x) b zero rewrite addZeroRight b | additionZeroDoesNothing (negSucc x +Z nonneg b) = refl
+addNonnegThenNonneg (negSucc x) b (succ c) with addNonnegThenNonneg (negSucc x) b c
+... | prev = prev'
+  where
+    prev' : ((negSucc x +Z nonneg b) +Z nonneg (succ c)) ≡ negSucc x +Z nonneg (b +N succ c)
+    prev' rewrite addNonnegSucc' (negSucc x +Z nonneg b) (negSucc x) c (b +N c) prev | succExtracts b c = refl
+
+additionZIsAssociativeFirstAndSecondArgNonneg : (a b : ℕ) (c : ℤ) → (nonneg a +Z (nonneg b +Z c)) ≡ ((nonneg a) +Z nonneg b) +Z c
+additionZIsAssociativeFirstAndSecondArgNonneg zero b c = refl
+additionZIsAssociativeFirstAndSecondArgNonneg (succ a) b (nonneg zero) = i
+  where
+    h : nonneg (succ a) +Z (nonneg b +Z nonneg zero) ≡ nonneg (succ a) +Z nonneg b
+    h = identityOfIndiscernablesLeft (nonneg (succ a) +Z nonneg b) (nonneg (succ a) +Z nonneg b) (nonneg (succ a) +Z (nonneg b +Z nonneg zero)) _≡_ refl (applyEquality (λ r → nonneg (succ a) +Z r) {nonneg b} {nonneg b +Z nonneg zero} (equalityCommutative (additionZeroDoesNothing (nonneg b))))
+    i : nonneg (succ a) +Z (nonneg b +Z nonneg zero) ≡ (nonneg (succ a) +Z nonneg b) +Z nonneg zero
+    i = identityOfIndiscernablesRight (nonneg (succ a) +Z (nonneg b +Z nonneg zero)) (nonneg (succ a) +Z nonneg b) ((nonneg (succ a) +Z nonneg b) +Z nonneg zero) _≡_ h (equalityCommutative (additionZeroDoesNothing (nonneg (succ a) +Z nonneg b)))
+additionZIsAssociativeFirstAndSecondArgNonneg (succ x) zero (nonneg (succ c)) = applyEquality nonneg (applyEquality succ (applyEquality (λ n → n +N succ c) {x} {x +N zero} (equalityCommutative (addZeroRight x))))
+additionZIsAssociativeFirstAndSecondArgNonneg (succ x) (succ b) (nonneg (succ c)) = applyEquality nonneg (applyEquality succ i)
+  where
+    h : x +N (succ b +N succ c) ≡ (x +N succ b) +N succ c
+    h = equalityCommutative (additionNIsAssociative x (succ b) (succ c))
+    i : x +N succ (b +N succ c) ≡ (x +N succ b) +N succ c
+    i = identityOfIndiscernablesLeft (x +N (succ b +N succ c)) ((x +N succ b) +N succ c) (x +N succ (b +N succ c)) _≡_ h refl
+additionZIsAssociativeFirstAndSecondArgNonneg (succ x) zero (negSucc c) rewrite addZeroRight x = refl
+additionZIsAssociativeFirstAndSecondArgNonneg (succ x) (succ b) (negSucc zero) rewrite Semiring.commutative ℕSemiring x b | Semiring.commutative ℕSemiring x (succ b) = refl
+additionZIsAssociativeFirstAndSecondArgNonneg (succ x) (succ b) (negSucc (succ c)) rewrite Semiring.commutative ℕSemiring x (succ b) | Semiring.commutative ℕSemiring b x = additionZIsAssociativeFirstAndSecondArgNonneg (succ x) b (negSucc c)
+
+additionZIsAssociativeFirstArgNonneg : (a : ℕ) (b c : ℤ) → (nonneg a +Z (b +Z c) ≡ ((nonneg a) +Z b) +Z c)
+additionZIsAssociativeFirstArgNonneg zero (nonneg b) c = additionZIsAssociativeFirstAndSecondArgNonneg 0 b c
+additionZIsAssociativeFirstArgNonneg 0 (negSucc b) c = refl
+additionZIsAssociativeFirstArgNonneg (succ a) (nonneg b) c = additionZIsAssociativeFirstAndSecondArgNonneg (succ a) b c
+additionZIsAssociativeFirstArgNonneg (succ x) (negSucc zero) (nonneg 0) rewrite addingNonnegIsHom x zero | addZeroRight x = refl
+additionZIsAssociativeFirstArgNonneg (succ x) (negSucc zero) (nonneg (succ c)) = i
+  where
+    h : nonneg (succ (x +N c)) ≡ nonneg (x +N succ c)
+    s : nonneg (x +N succ c) ≡ nonneg (succ c +N x)
+    t : nonneg (x +N succ c) ≡ nonneg (succ c) +Z nonneg x
+    i : nonneg (succ (x +N c)) ≡ nonneg x +Z nonneg (succ c)
+    h = applyEquality nonneg (equalityCommutative (succExtracts x c))
+    s = applyEquality nonneg (Semiring.commutative ℕSemiring x (succ c))
+    t = transitivity s refl
+    i = transitivity h (equalityCommutative (addingNonnegIsHom x (succ c)))
+additionZIsAssociativeFirstArgNonneg (succ x) (negSucc (succ b)) (nonneg 0) rewrite additionZIsCommutative (nonneg x +Z negSucc b) (nonneg zero) = refl
+additionZIsAssociativeFirstArgNonneg (succ x) (negSucc (succ b)) (nonneg (succ c)) = p
+  where
+    p''' : nonneg x +Z (negSucc b +Z nonneg c) ≡ (nonneg x +Z negSucc b) +Z nonneg c
+    p''' = additionZIsAssociativeFirstArgNonneg x (negSucc b) (nonneg c)
+    p'' : (negSucc b +Z nonneg c) +Z nonneg x ≡ (nonneg x +Z negSucc b) +Z nonneg c
+    p'' = identityOfIndiscernablesLeft (nonneg x +Z (negSucc b +Z nonneg c)) ((nonneg x +Z negSucc b) +Z nonneg c) ((negSucc b +Z nonneg c) +Z nonneg x) _≡_ p''' (additionZIsCommutative (nonneg x) (negSucc b +Z nonneg c))
+    p' : (negSucc b +Z nonneg c) +Z nonneg (succ x) ≡ (nonneg x +Z negSucc b) +Z nonneg (succ c)
+    p' = addNonnegSucc' (negSucc b +Z nonneg c) (nonneg x +Z negSucc b) x c p''
+    p : nonneg (succ x) +Z (negSucc b +Z nonneg c) ≡ (nonneg x +Z negSucc b) +Z nonneg (succ c)
+    p = identityOfIndiscernablesLeft ((negSucc b +Z nonneg c) +Z nonneg (succ x)) ((nonneg x +Z negSucc b) +Z nonneg (succ c)) (nonneg (succ x) +Z (negSucc b +Z nonneg c)) _≡_ p' (additionZIsCommutative (negSucc b +Z nonneg c) (nonneg (succ x)))
+additionZIsAssociativeFirstArgNonneg (succ x) (negSucc zero) (negSucc c) = refl
+additionZIsAssociativeFirstArgNonneg (succ a) (negSucc (succ b)) (negSucc zero) rewrite Semiring.commutative ℕSemiring b 1 | additionZIsCommutative (nonneg a +Z negSucc b) (negSucc 0) = equalityCommutative (moveNegsuccConverse 0 (nonneg a +Z negSucc b) (nonneg a +Z negSucc (succ b)) q'')
+  where
+    q : nonneg 1 +Z (nonneg a +Z negSucc (succ b)) ≡ (nonneg 1 +Z nonneg a) +Z negSucc (succ b)
+    q = additionZIsAssociativeFirstAndSecondArgNonneg 1 a (negSucc (succ b))
+    q' : (nonneg 1 +Z nonneg a) +Z negSucc (succ b) ≡ (nonneg a +Z negSucc (succ b)) +Z nonneg 1
+    q' rewrite additionZIsCommutative (nonneg a +Z negSucc (succ b)) (nonneg 1) = equalityCommutative q
+    q'' : nonneg (succ a) +Z negSucc (succ b) ≡ (nonneg a +Z negSucc (succ b)) +Z nonneg 1
+    q'' rewrite addingNonnegIsHom 1 a = q'
+additionZIsAssociativeFirstArgNonneg (succ a) (negSucc (succ b)) (negSucc (succ c)) = ans
+  where
+    ans : nonneg a +Z negSucc (b +N succ (succ c)) ≡ (nonneg a +Z negSucc b) +Z negSucc (succ c)
+    p :   nonneg a +Z (negSucc b +Z negSucc (succ c)) ≡ (nonneg a +Z negSucc b) +Z negSucc (succ c)
+    p = additionZIsAssociativeFirstArgNonneg a (negSucc b) (negSucc (succ c))
+    p' : negSucc (b +N succ (succ c)) ≡ negSucc b +Z negSucc (succ c)
+    p' rewrite additionZIsCommutative (negSucc b) (negSucc (succ c)) | Semiring.commutative ℕSemiring b (succ (succ c)) | Semiring.commutative ℕSemiring c (succ b) | Semiring.commutative ℕSemiring c b  = refl
+    ans rewrite p' = p
+
+additionZIsAssociative : (a b c : ℤ) → (a +Z (b +Z c)) ≡ (a +Z b) +Z c
+additionZIsAssociative (nonneg a) b c = additionZIsAssociativeFirstArgNonneg a b c
+additionZIsAssociative (negSucc a) (nonneg b) c rewrite additionZIsCommutative (negSucc a) (nonneg b) | additionZIsCommutative (negSucc a) (nonneg b +Z c) = p''
+  where
+    p : (nonneg b +Z c) +Z negSucc a ≡ nonneg b +Z (c +Z negSucc a)
+    p = equalityCommutative (additionZIsAssociativeFirstArgNonneg b c (negSucc a))
+    p' : (nonneg b +Z c) +Z negSucc a ≡ nonneg b +Z (negSucc a +Z c)
+    p' rewrite additionZIsCommutative (negSucc a) c = p
+    p'' : (nonneg b +Z c) +Z negSucc a ≡ (nonneg b +Z negSucc a) +Z c
+    p'' rewrite equalityCommutative (additionZIsAssociativeFirstArgNonneg b (negSucc a) c) = p'
+additionZIsAssociative (negSucc a) (negSucc b) (nonneg c) rewrite additionZIsCommutative (negSucc a +Z negSucc b) (nonneg c) | additionZIsCommutative (negSucc b) (nonneg c) | additionZIsCommutative (negSucc a) (nonneg c +Z negSucc b) = p'
+  where
+    p : (nonneg c +Z negSucc b) +Z negSucc a ≡ nonneg c +Z (negSucc b +Z negSucc a)
+    p = equalityCommutative (additionZIsAssociativeFirstArgNonneg c (negSucc b) (negSucc a))
+    p' : (nonneg c +Z negSucc b) +Z negSucc a ≡ nonneg c +Z (negSucc a +Z negSucc b)
+    p' rewrite additionZIsCommutative (negSucc a) (negSucc b) = p
+additionZIsAssociative (negSucc zero) (negSucc zero) (negSucc c) = refl
+additionZIsAssociative (negSucc zero) (negSucc (succ b)) (negSucc c) = refl
+additionZIsAssociative (negSucc (succ a)) (negSucc zero) (negSucc c) rewrite Semiring.commutative ℕSemiring a 1 | Semiring.commutative ℕSemiring a (succ (succ c)) | Semiring.commutative ℕSemiring a (succ c) = refl
+additionZIsAssociative (negSucc (succ a)) (negSucc (succ b)) (negSucc zero) rewrite Semiring.commutative ℕSemiring b 1 | Semiring.commutative ℕSemiring (succ ((a +N succ (succ b)))) 1 = applyEquality (λ t → negSucc (succ t)) (p (succ (succ b)))
+  where
+    p : (r : ℕ) → a +N succ r ≡ succ (a +N r)
+    p r rewrite Semiring.commutative ℕSemiring a (succ r) | Semiring.commutative ℕSemiring r a = refl
+additionZIsAssociative (negSucc (succ a)) (negSucc (succ b)) (negSucc (succ c)) = applyEquality (λ t → negSucc (succ t)) (equalityCommutative (additionNIsAssociative a (succ (succ b)) (succ (succ c))))
+
+lessZIrreflexive : {a : ℤ} → (a <Z a) → False
+lessZIrreflexive {nonneg a} (le x proof) = lessLemma a x (nonnegInjective proof)
+lessZIrreflexive {negSucc a} (le x proof) = naughtE (equalityCommutative q)
+  where
+    pr' : nonneg (succ x) +Z (negSucc a +Z nonneg (succ a)) ≡ negSucc a +Z nonneg (succ a)
+    pr' rewrite additionZIsAssociative (nonneg (succ x)) (negSucc a) (nonneg (succ a)) = applyEquality (λ t → t +Z nonneg (succ a)) proof
+    pr'' : nonneg (succ x) +Z nonneg 0 ≡ nonneg 0
+    pr'' rewrite equalityCommutative (additiveInverseExists a) = identityOfIndiscernablesLeft (nonneg (succ x) +Z (negSucc a +Z nonneg (succ a))) (negSucc a +Z nonneg (succ a)) (nonneg (succ (x +N zero))) _≡_ pr' q
+      where
+        q : nonneg (succ x) +Z (negSucc a +Z nonneg (succ a)) ≡ nonneg (succ (x +N 0))
+        q rewrite Semiring.commutative ℕSemiring x 0 | additiveInverseExists a | Semiring.commutative ℕSemiring x 0 = refl
+    pr''' : succ x +N 0 ≡ 0
+    pr''' rewrite addingNonnegIsHom (succ x) 0 = nonnegInjective pr''
+    q : succ x ≡ 0
+    q rewrite Semiring.commutative ℕSemiring 0 (succ x) = pr'''
+
+lessNegsuccNonneg : {a b : ℕ} → (negSucc a <Z nonneg b)
+lessNegsuccNonneg {a} {b} = record { x = x ; proof = pr }
+  where
+    x : ℕ
+    x = a +N b
+    pr' : nonneg (succ (a +N b)) ≡ nonneg b +Z nonneg (succ a)
+    pr' rewrite addingNonnegIsHom b (succ a) | Semiring.commutative ℕSemiring b (succ a) = refl
+    pr : nonneg (succ x) +Z negSucc a ≡ nonneg b
+    pr rewrite additionZIsCommutative (nonneg (succ x)) (negSucc a) = moveNegsuccConverse a (nonneg (succ (a +N b))) (nonneg b) pr'
+
+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} | inl (inl a<b) = inl (inl (lessIsPreservedNToZ a<b))
+lessThanTotalZ {nonneg a} {nonneg b} | inl (inr b<a) = inl (inr (lessIsPreservedNToZ 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
+... | inl (inl a<b) = inl (inr (lessIsPreservedNToZNegsucc a<b))
+... | inl (inr b<a) = inl (inl (lessIsPreservedNToZNegsucc b<a))
+lessThanTotalZ {negSucc a} {negSucc .a} | inr refl = inr refl
+
+negSuccPlusNegsuccIsNegsucc : {a b c : ℕ} → (negSucc a +Z negSucc b ≡ nonneg c) → False
+negSuccPlusNegsuccIsNegsucc {zero} {b} {c} pr = nonnegIsNotNegsucc (equalityCommutative pr)
+negSuccPlusNegsuccIsNegsucc {succ a} {b} {c} pr = nonnegIsNotNegsucc (equalityCommutative pr)
+
+multiplicationZ'IsAssociative : (a b c : ℤSimple) → (a *Z' (b *Z' c)) ≡ ((a *Z' b) *Z' c)
+multiplicationZ'IsAssociative (negative zero (le x ())) b c
+multiplicationZ'IsAssociative (negative (succ a) x) (negative zero (le x₁ ())) c
+multiplicationZ'IsAssociative (negative (succ a) x) (negative (succ b) prb) (negative zero (le x₁ ()))
+multiplicationZ'IsAssociative (negative (succ a) x) (negative ( succ b) prb) (negative (succ c) prc) = res _ _
+  where
+    help : _
+    help = Semiring.*Associative ℕSemiring (succ a) (succ b) (succ c)
+    res : (pr1 : 0 <N succ a *N (succ b *N succ c)) → (pr2 : 0 <N (succ a *N succ b) *N succ c) → negative (succ a *N (succ b *N succ c)) pr1 ≡ negative ((succ a *N succ b) *N succ c) pr2
+    res pr1 pr2 rewrite help = negIsNeg pr1 pr2
+multiplicationZ'IsAssociative (negative (succ a) x) (negative (succ b) prb) (positive zero (le x₁ ()))
+multiplicationZ'IsAssociative (negative (succ a) x) (negative (succ b) prb) (positive (succ c) prc) = res _ _
+  where
+    help : _
+    help = Semiring.*Associative ℕSemiring (succ a) (succ b) (succ c)
+    res : (pr1 : 0 <N succ a *N (succ b *N succ c)) → (pr2 : 0 <N (succ a *N succ b) *N succ c) → positive (succ a *N (succ b *N succ c)) pr1 ≡ positive ((succ a *N succ b) *N succ c) pr2
+    res pr1 pr2 rewrite help = posIsPos pr1 pr2
+multiplicationZ'IsAssociative (negative (succ a) x) (negative (succ b) prb) zZero = refl
+multiplicationZ'IsAssociative (negative (succ a) x) (positive zero (le x₁ ())) c
+multiplicationZ'IsAssociative (negative (succ a) x) (positive (succ b) prb) (negative zero (le x₁ ()))
+multiplicationZ'IsAssociative (negative (succ a) x) (positive (succ b) prb) (negative (succ c) prc) = res _ _
+  where
+    help : _
+    help = Semiring.*Associative ℕSemiring (succ a) (succ b) (succ c)
+    res : (pr1 : 0 <N succ a *N (succ b *N succ c)) → (pr2 : 0 <N (succ a *N succ b) *N succ c) → positive (succ a *N (succ b *N succ c)) pr1 ≡ positive ((succ a *N succ b) *N succ c) pr2
+    res pr1 pr2 rewrite help = posIsPos pr1 pr2
+multiplicationZ'IsAssociative (negative (succ a) x) (positive (succ b) prb) (positive zero (le x₁ ()))
+multiplicationZ'IsAssociative (negative (succ a) x) (positive (succ b) prb) (positive (succ c) prc) = res _ _
+  where
+    help : _
+    help = Semiring.*Associative ℕSemiring (succ a) (succ b) (succ c)
+    res : (pr1 : 0 <N succ a *N (succ b *N succ c)) → (pr2 : 0 <N (succ a *N succ b) *N succ c) → negative (succ a *N (succ b *N succ c)) pr1 ≡ negative ((succ a *N succ b) *N succ c) pr2
+    res pr1 pr2 rewrite help = negIsNeg pr1 pr2
+multiplicationZ'IsAssociative (negative (succ a) x) (positive (succ b) prb) zZero = refl
+multiplicationZ'IsAssociative (negative (succ a) x) zZero c = refl
+multiplicationZ'IsAssociative (positive zero (le x ())) b c
+multiplicationZ'IsAssociative (positive (succ a) x) (negative zero (le y ())) c
+multiplicationZ'IsAssociative (positive (succ a) x) (negative (succ b) prb) (negative zero (le x₁ ()))
+multiplicationZ'IsAssociative (positive (succ a) x) (negative (succ b) prb) (negative (succ c) prc) = res _ _
+  where
+    help : _
+    help = Semiring.*Associative ℕSemiring (succ a) (succ b) (succ c)
+    res : (pr1 : 0 <N succ a *N (succ b *N succ c)) → (pr2 : 0 <N (succ a *N succ b) *N succ c) → positive (succ a *N (succ b *N succ c)) pr1 ≡ positive ((succ a *N succ b) *N succ c) pr2
+    res pr1 pr2 rewrite help = posIsPos pr1 pr2
+multiplicationZ'IsAssociative (positive (succ a) x) (negative (succ b) prb) (positive zero (le x₁ ()))
+multiplicationZ'IsAssociative (positive (succ a) x) (negative (succ b) prb) (positive (succ c) prc) = res _ _
+  where
+    help : _
+    help = Semiring.*Associative ℕSemiring (succ a) (succ b) (succ c)
+    res : (pr1 : 0 <N succ a *N (succ b *N succ c)) → (pr2 : 0 <N (succ a *N succ b) *N succ c) → negative (succ a *N (succ b *N succ c)) pr1 ≡ negative ((succ a *N succ b) *N succ c) pr2
+    res pr1 pr2 rewrite help = negIsNeg pr1 pr2
+multiplicationZ'IsAssociative (positive (succ a) x) (negative (succ b) prb) zZero = refl
+multiplicationZ'IsAssociative (positive (succ a) x) (positive zero (le y ())) c
+multiplicationZ'IsAssociative (positive (succ a) x) (positive (succ b) prb) (negative zero (le x₁ ()))
+multiplicationZ'IsAssociative (positive (succ a) x) (positive (succ b) prb) (negative (succ c) prc) = res _ _
+  where
+    help : _
+    help = Semiring.*Associative ℕSemiring (succ a) (succ b) (succ c)
+    res : (pr1 : 0 <N succ a *N (succ b *N succ c)) → (pr2 : 0 <N (succ a *N succ b) *N succ c) → negative (succ a *N (succ b *N succ c)) pr1 ≡ negative ((succ a *N succ b) *N succ c) pr2
+    res pr1 pr2 rewrite help = negIsNeg pr1 pr2
+multiplicationZ'IsAssociative (positive (succ a) x) (positive (succ b) prb) (positive zero (le x₁ ()))
+multiplicationZ'IsAssociative (positive (succ a) x) (positive (succ b) prb) (positive (succ c) prc) = res _ _
+  where
+    help : _
+    help = Semiring.*Associative ℕSemiring (succ a) (succ b) (succ c)
+    res : (pr1 : 0 <N succ a *N (succ b *N succ c)) → (pr2 : 0 <N (succ a *N succ b) *N succ c) → positive (succ a *N (succ b *N succ c)) pr1 ≡ positive ((succ a *N succ b) *N succ c) pr2
+    res pr1 pr2 rewrite help = posIsPos pr1 pr2
+multiplicationZ'IsAssociative (positive (succ a) x) (positive (succ b) prb) zZero = refl
+multiplicationZ'IsAssociative (positive (succ a) x) zZero c = refl
+multiplicationZ'IsAssociative zZero b c = refl
+
+multiplicationZIsAssociative : (a b c : ℤ) → (a *Z (b *Z c)) ≡ (a *Z b) *Z c
+multiplicationZIsAssociative a b c = ans
+  where
+    inter : convertZ' (convertZ a *Z' (convertZ b *Z' convertZ c)) ≡ convertZ' ((convertZ a *Z' convertZ b) *Z' convertZ c)
+    inter = applyEquality convertZ' (multiplicationZ'IsAssociative (convertZ a) (convertZ b) (convertZ c))
+    ans : a *Z (b *Z c) ≡ (a *Z b) *Z c
+    ans rewrite convertZ'DistributesOver*Z (convertZ a) (convertZ b *Z' convertZ c) | convertZ'DistributesOver*Z (convertZ b) (convertZ c) | convertZ'DistributesOver*Z (convertZ a *Z' convertZ b) (convertZ c) | convertZ'DistributesOver*Z (convertZ a) (convertZ b) | zIsZ c | zIsZ b | zIsZ a | zIsZ' (convertZ b *Z' convertZ c) | zIsZ' (convertZ a *Z' convertZ b) = inter
+
+zeroIsAdditiveIdentityRightZ : (a : ℤ) → (a +Z nonneg zero) ≡ a
+zeroIsAdditiveIdentityRightZ (nonneg x) = identityOfIndiscernablesRight (nonneg x +Z nonneg zero) (nonneg (x +N zero)) (nonneg x) _≡_ (addingNonnegIsHom x zero) ((applyEquality nonneg (addZeroRight x)))
+zeroIsAdditiveIdentityRightZ (negSucc a) = refl
+
+additiveInverseZ : (a : ℤ) → ℤ
+additiveInverseZ (nonneg zero) = nonneg zero
+additiveInverseZ (nonneg (succ x)) = negSucc x
+additiveInverseZ (negSucc a) = nonneg (succ a)
+
+addInverseLeftZ : (a : ℤ) → (additiveInverseZ a +Z a ≡ nonneg zero)
+addInverseLeftZ (nonneg zero) = refl
+addInverseLeftZ (nonneg (succ zero)) = refl
+addInverseLeftZ (nonneg (succ (succ x))) = addInverseLeftZ (nonneg (succ x))
+addInverseLeftZ (negSucc zero) = refl
+addInverseLeftZ (negSucc (succ a)) = addInverseLeftZ (negSucc a)
+
+addInverseRightZ : (a : ℤ) → (a +Z additiveInverseZ a ≡ nonneg zero)
+addInverseRightZ (nonneg zero) = refl
+addInverseRightZ (nonneg (succ zero)) = refl
+addInverseRightZ (nonneg (succ (succ x))) = addInverseRightZ (nonneg (succ x))
+addInverseRightZ (negSucc zero) = refl
+addInverseRightZ (negSucc (succ a)) = addInverseRightZ (negSucc a)
+
+flipSign : (a : ℕ) → negSucc a *Z negSucc 0 ≡ nonneg (succ a)
+flipSign zero = refl
+flipSign (succ a) = ans
+  where
+    help : convertZ (negSucc (succ a)) *Z' convertZ (negSucc 0) ≡ convertZ (nonneg (succ (succ a)))
+    help rewrite multiplicationNIsCommutative a 1 | Semiring.commutative ℕSemiring a 0 = refl
+    help' : convertZ' (convertZ (negSucc (succ a)) *Z' convertZ (negSucc 0)) ≡ convertZ' (convertZ (nonneg (succ (succ a))))
+    help' = applyEquality convertZ' help
+    help'' : convertZ' (convertZ (negSucc (succ a))) *Z (convertZ' (convertZ (negSucc 0))) ≡ nonneg (succ (succ a))
+    help'' rewrite convertZ'DistributesOver*Z (convertZ (negSucc (succ a))) (convertZ (negSucc 0)) | zIsZ (nonneg (succ (succ a))) = help'
+    ans : negSucc (succ a) *Z negSucc 0 ≡ nonneg (succ (succ a))
+    ans rewrite zIsZ (negSucc (succ a)) | zIsZ (negSucc 0) = help''
+
+flipSign' : (a : ℕ) → nonneg (succ a) *Z negSucc 0 ≡ negSucc a
+flipSign' a = ans
+  where
+    inter : negSucc 0 *Z negSucc 0 ≡ nonneg 1
+    inter = refl
+    ans : nonneg (succ a) *Z negSucc 0 ≡ negSucc a
+    ans rewrite inter | multiplicationNIsCommutative a 1 | Semiring.commutative ℕSemiring a 0 = refl
+
+additionZ'IsCommutative : (a b : ℤSimple) → a +Z' b ≡ b +Z' a
+additionZ'IsCommutative a b = ans
+  where
+    help : (convertZ' a) +Z (convertZ' b) ≡ (convertZ' b) +Z (convertZ' a)
+    help = additionZIsCommutative (convertZ' a) (convertZ' b)
+    help' : convertZ ((convertZ' a) +Z (convertZ' b)) ≡ convertZ ((convertZ' b) +Z (convertZ' a))
+    help' = applyEquality convertZ help
+    help'' : convertZ (convertZ' a) +Z' convertZ (convertZ' b) ≡ convertZ (convertZ' b) +Z' convertZ (convertZ' a)
+    help'' rewrite equalityCommutative (plusIsPlus' (convertZ' a) (convertZ' b)) | equalityCommutative (plusIsPlus' (convertZ' b) (convertZ' a)) = help'
+    ans : a +Z' b ≡ b +Z' a
+    ans rewrite equalityCommutative (zIsZ' a) | equalityCommutative (zIsZ' b) = help''
+additionZ'IsAssociative : (a b c : ℤSimple) → (a +Z' (b +Z' c)) ≡ (a +Z' b) +Z' c
+additionZ'IsAssociative a b c = identityOfIndiscernablesRight _ _ _ _≡_ helpV''' (applyEquality (λ t → (a +Z' t) +Z' c) (zIsZ' b))
+  where
+    help  : convertZ (convertZ' a +Z (convertZ' b +Z convertZ' c)) ≡ convertZ ((convertZ' a +Z convertZ' b) +Z convertZ' c)
+    help' : convertZ (convertZ' a) +Z' convertZ (convertZ' b +Z convertZ' c) ≡ convertZ (convertZ' a +Z convertZ' b) +Z' convertZ (convertZ' c)
+    help'' : a +Z' convertZ (convertZ' b +Z convertZ' c) ≡ convertZ (convertZ' a +Z convertZ' b) +Z' convertZ (convertZ' c)
+    help''' : a +Z' (convertZ (convertZ' b) +Z' convertZ (convertZ' c)) ≡ convertZ (convertZ' a +Z convertZ' b) +Z' convertZ (convertZ' c)
+    help'''' : a +Z' (b +Z' (convertZ (convertZ' c))) ≡ convertZ (convertZ' a +Z convertZ' b) +Z' convertZ (convertZ' c)
+    helpV : a +Z' (b +Z' c) ≡ convertZ (convertZ' a +Z convertZ' b) +Z' convertZ (convertZ' c)
+    helpV' : a +Z' (b +Z' c) ≡ convertZ (convertZ' a +Z convertZ' b) +Z' c
+    helpV'' : a +Z' (b +Z' c) ≡ (convertZ (convertZ' a) +Z' convertZ (convertZ' b)) +Z' c
+    helpV''' : a +Z' (b +Z' c) ≡ (a +Z' convertZ (convertZ' b)) +Z' c
+    helpV''' = identityOfIndiscernablesRight _ _ _ _≡_ helpV'' (applyEquality (λ t → ((t +Z' convertZ (convertZ' b)) +Z' c)) (zIsZ' a))
+    helpV'' rewrite equalityCommutative (plusIsPlus' (convertZ' a) (convertZ' b)) = helpV'
+    helpV' = identityOfIndiscernablesRight _ _ _ _≡_ helpV (applyEquality (λ t → convertZ (convertZ' a +Z convertZ' b) +Z' t) (zIsZ' c))
+    helpV = identityOfIndiscernablesLeft _ _ _ _≡_ help'''' (applyEquality (λ t → a +Z' (b +Z' t)) (zIsZ' c))
+    help'''' = identityOfIndiscernablesLeft _ _ _ _≡_ help''' (applyEquality (λ t → a +Z' (t +Z' (convertZ (convertZ' c)))) (zIsZ' b))
+    help''' rewrite equalityCommutative (plusIsPlus' (convertZ' b) (convertZ' c)) = help''
+    help'' = identityOfIndiscernablesLeft (convertZ (convertZ' a) +Z' convertZ (convertZ' b +Z convertZ' c)) _ (a +Z' convertZ (convertZ' b +Z convertZ' c)) _≡_ help' (applyEquality (λ t → t +Z' convertZ (convertZ' b +Z convertZ' c)) (zIsZ' a))
+    help = applyEquality convertZ (additionZIsAssociative (convertZ' a) (convertZ' b) (convertZ' c))
+    help' rewrite equalityCommutative (plusIsPlus' (convertZ' a) (convertZ' b +Z convertZ' c)) | equalityCommutative (plusIsPlus' (convertZ' a +Z convertZ' b) (convertZ' c)) = help
+
+pos+Z'Pos : (a b : ℕ) → {pr : 0 <N a} → {pr2 : 0 <N b} → {pr3 : 0 <N a +N b} → (positive a pr) +Z' (positive b pr2) ≡ positive (a +N b) pr3
+pos+Z'Pos zero b {le x ()} {pr2} {pr3}
+pos+Z'Pos (succ a) zero {pr} {le x ()} {pr3}
+pos+Z'Pos (succ a) (succ b) {pr} {pr2} {pr3} rewrite <NRefl (pr) (succIsPositive a) | <NRefl pr2 (succIsPositive b) | <NRefl pr3 (succIsPositive (a +N succ b)) = refl
+
+lemma'' : (a b c : ℕ) → (pr : _) → (pr2 : _) → (pr3 : _) → positive (succ ((b +N succ c) +N a *N succ (b +N succ c))) pr ≡ positive (succ (b +N a *N succ b)) pr2 +Z' positive (succ (c +N a *N succ c)) pr3
+lemma'' a b c pr1 pr2 pr3 = equalityCommutative help'
+  where
+    pr' : succ (b +N a *N succ b) +N succ (c +N a *N succ c) ≡ succ ((b +N succ c) +N a *N succ (b +N succ c))
+    pr' = equalityCommutative (Semiring.+DistributesOver* ℕSemiring (succ a) (succ b) (succ c))
+    pr'' : 0 <N succ (b +N a *N succ b) +N succ (c +N a *N succ c)
+    pr'' rewrite pr' = pr1
+    help : (positive (succ (b +N a *N succ b))) pr2 +Z' (positive (succ (c +N a *N succ c))) pr3 ≡ positive (succ (b +N a *N succ b) +N succ (c +N a *N succ c)) pr''
+    help = pos+Z'Pos (succ (b +N a *N succ b)) (succ (c +N a *N succ c)) {pr2} {pr3} {pr''}
+    help' : (positive (succ (b +N a *N succ b))) pr2 +Z' (positive (succ (c +N a *N succ c))) pr3 ≡ positive (succ ((b +N succ c) +N a *N succ (b +N succ c))) pr1
+    help' rewrite equalityCommutative pr' | <NRefl pr1 (succIsPositive ((b +N a *N succ b) +N succ (c +N a *N succ c))) = refl
+
+addZZero : (a : ℤSimple) → a +Z' zZero ≡ a
+addZZero (negative zero (le x ()))
+addZZero (negative (succ a) x) rewrite additionZ'IsCommutative (negative (succ a) x) zZero = refl
+addZZero (positive zero (le x ()))
+addZZero (positive (succ a) x) rewrite additionZ'IsCommutative (positive (succ a) x) zZero = refl
+addZZero zZero = refl
+
+negSucc+ZNegSucc : (a b : ℕ) → (negSucc a +Z negSucc b) ≡ negSucc (succ a +N b)
+negSucc+ZNegSucc zero b = refl
+negSucc+ZNegSucc (succ a) b rewrite Semiring.commutative ℕSemiring a (succ b) | Semiring.commutative ℕSemiring b a = refl
+
+oneIsIdentity : (a : ℤ) → convertZ' (positive 1 (succIsPositive 0) *Z' convertZ a) ≡ a
+oneIsIdentity (nonneg zero) = refl
+oneIsIdentity (nonneg (succ x)) rewrite Semiring.commutative ℕSemiring x 0 = refl
+oneIsIdentity (negSucc x) rewrite Semiring.commutative ℕSemiring x 0 = refl
+
+oneIsIdentity' : (a : ℤSimple) → (positive 1 (succIsPositive 0)) *Z' a ≡ a
+oneIsIdentity' (negative zero (le x ()))
+oneIsIdentity' (negative (succ a) x) rewrite Semiring.commutative ℕSemiring a 0 | <NRefl x (logical<NImpliesLe (record {})) = refl
+oneIsIdentity' (positive zero (le x ()))
+oneIsIdentity' (positive (succ a) x) rewrite Semiring.commutative ℕSemiring a 0 | <NRefl x (logical<NImpliesLe (record {})) = refl
+oneIsIdentity' zZero = refl
+
+canPullOutSuccZ' : (a : ℕ) → (b c : ℤSimple) → (positive (succ (succ a)) (succIsPositive (succ a))) *Z' (b +Z' c) ≡ (b +Z' c) +Z' (positive (succ a) (succIsPositive a)) *Z' (b +Z' c)
+canPullOutSuccZ' a (negative zero (le x ())) c
+canPullOutSuccZ' a (negative (succ b) _) (negative zero (le x ()))
+canPullOutSuccZ' a (negative (succ b) _) (negative (succ c) x) = refl
+canPullOutSuccZ' a (negative (succ b) _) (positive zero (le x ()))
+canPullOutSuccZ' a (negative (succ b) y) (positive (succ c) x) with negative (succ b) y +Z' positive (succ c) x
+canPullOutSuccZ' a (negative (succ b) y) (positive (succ c) x) | negative zero (le x₁ ())
+canPullOutSuccZ' a (negative (succ b) y) (positive (succ c) x) | negative (succ sum) pr = refl
+canPullOutSuccZ' a (negative (succ b) y) (positive (succ c) x) | positive zero (le x₁ ())
+canPullOutSuccZ' a (negative (succ b) y) (positive (succ c) x) | positive (succ sum) pr = refl
+canPullOutSuccZ' a (negative (succ b) y) (positive (succ c) x) | zZero = refl
+canPullOutSuccZ' a (negative (succ b) _) zZero = refl
+canPullOutSuccZ' a (positive zero (le x ())) c
+canPullOutSuccZ' a (positive (succ b) _) (negative zero (le x ()))
+canPullOutSuccZ' a (positive (succ b) y) (negative (succ c) x) with positive (succ b) y +Z' negative (succ c) x
+canPullOutSuccZ' a (positive (succ b) y) (negative (succ c) x) | negative zero (le x₁ ())
+canPullOutSuccZ' a (positive (succ b) y) (negative (succ c) x) | negative (succ sum) pr = refl
+canPullOutSuccZ' a (positive (succ b) y) (negative (succ c) x) | positive zero (le x₁ ())
+canPullOutSuccZ' a (positive (succ b) y) (negative (succ c) x) | positive (succ sum) pr = refl
+canPullOutSuccZ' a (positive (succ b) y) (negative (succ c) x) | zZero = refl
+canPullOutSuccZ' a (positive (succ b) _) (positive zero (le x ()))
+canPullOutSuccZ' a (positive (succ b) _) (positive (succ c) x) = refl
+canPullOutSuccZ' a (positive (succ b) _) zZero = refl
+canPullOutSuccZ' a zZero (negative zero (le x ()))
+canPullOutSuccZ' a zZero (negative (succ c) x) = refl
+canPullOutSuccZ' a zZero (positive zero (le x ()))
+canPullOutSuccZ' a zZero (positive (succ c) x) = refl
+canPullOutSuccZ' a zZero zZero = refl
+
+canPullOutSuccZ : (a : ℕ) → (b : ℤSimple) → (positive (succ (succ a)) (succIsPositive (succ a))) *Z' b ≡ b +Z' (positive (succ a) (succIsPositive a)) *Z' b
+canPullOutSuccZ a b = ans b
+  where
+    ans : (b : ℤSimple) → (positive (succ (succ a)) (succIsPositive (succ a))) *Z' b ≡ b +Z' (positive (succ a) (succIsPositive a)) *Z' b
+    ans (negative zero (le x ()))
+    ans (negative (succ b) x) = refl
+    ans (positive zero (le x ()))
+    ans (positive (succ b) x) = refl
+    ans zZero = refl
+
+
+swapAdds : (a c : ℕ) → (a +N succ c) +N succ (a +N succ c) ≡ (a +N succ a) +N succ (c +N succ c)
+swapAdds a c rewrite additionNIsAssociative a (succ c) (succ (a +N succ c)) | additionNIsAssociative a (succ a) (succ (c +N succ c)) = applyEquality (λ t → a +N succ t) help'
+  where
+    help' : c +N succ (a +N succ c) ≡ a +N succ (c +N succ c)
+    help' rewrite Semiring.commutative ℕSemiring c (succ (a +N succ c)) | Semiring.commutative ℕSemiring (a +N succ c) c | Semiring.commutative ℕSemiring (succ c) (a +N succ c) | additionNIsAssociative a (succ c) (succ c) = refl
+
+lemmaDistributive : (a : ℕ) → (b c : ℤSimple) → (positive (succ a) (succIsPositive a)) *Z' (b +Z' c) ≡ positive (succ a) (succIsPositive a) *Z' b +Z' positive (succ a) (succIsPositive a) *Z' c
+lemmaDistributive zero (negative zero (le x ())) c
+lemmaDistributive zero (negative (succ b) prB) (negative zero (le x ()))
+lemmaDistributive zero (negative (succ b) prB) (negative (succ a) x) rewrite Semiring.commutative ℕSemiring a 0 | Semiring.commutative ℕSemiring b 0 | Semiring.commutative ℕSemiring (b +N succ a) 0 = refl
+
+lemmaDistributive zero (negative (succ b) prB) (positive zero (le x ()))
+lemmaDistributive zero (negative (succ b) prB) (positive (succ a) x) rewrite oneIsIdentity' (negative (succ b) prB +Z' positive (succ a) x) | Semiring.commutative ℕSemiring b 0 | Semiring.commutative ℕSemiring a 0 | <NRefl x (logical<NImpliesLe (record {})) | <NRefl prB (logical<NImpliesLe (record {})) = refl
+lemmaDistributive zero (negative (succ b) prB) zZero = refl
+lemmaDistributive zero (positive zero (le x ())) c
+lemmaDistributive zero (positive (succ b) prB) (negative zero (le x ()))
+lemmaDistributive zero (positive (succ b) prB) (negative (succ a) x) rewrite Semiring.commutative ℕSemiring b 0 | Semiring.commutative ℕSemiring a 0 | oneIsIdentity' (positive (succ b) prB +Z' negative (succ a) x) | <NRefl prB (logical<NImpliesLe (record {})) | <NRefl x (logical<NImpliesLe (record {})) = refl
+lemmaDistributive zero (positive (succ b) prB) (positive zero (le x ()))
+lemmaDistributive zero (positive (succ b) prB) (positive (succ a) x) rewrite Semiring.commutative ℕSemiring b 0 | Semiring.commutative ℕSemiring a 0 = help2 ((b +N succ a) +N 0) (b +N succ a) (applyEquality succ lem)
+  where
+    help2 : (a b : ℕ) → (pr : succ a ≡ succ b) → positive (succ a) (succIsPositive _) ≡ positive (succ b) (succIsPositive _)
+    help2 a .a refl = refl
+    lem : (b +N succ a) +N 0 ≡ b +N succ a
+    lem rewrite Semiring.commutative ℕSemiring (b +N succ a) 0 = refl
+lemmaDistributive zero (positive (succ b) prB) zZero = refl
+lemmaDistributive zero zZero c rewrite oneIsIdentity' (zZero +Z' c) | oneIsIdentity' c = refl
+lemmaDistributive (succ a) b c = lemmV''
+  where
+    internallemma' : (positive (succ (succ a)) (succIsPositive (succ a))) *Z' (b +Z' c) ≡ (b +Z' c) +Z' (positive (succ a) (succIsPositive a)) *Z' (b +Z' c)
+    internallemma' = canPullOutSuccZ' a b c
+    p : positive (succ (succ a)) (succIsPositive (succ a)) *Z' b ≡ b +Z' positive (succ a) (succIsPositive a) *Z' b
+    p = canPullOutSuccZ a b
+    q : positive (succ (succ a)) (succIsPositive (succ a)) *Z' c ≡ c +Z' positive (succ a) (succIsPositive a) *Z' c
+    q = canPullOutSuccZ a c
+    indHyp : (positive (succ a) (succIsPositive a)) *Z' (b +Z' c) ≡ positive (succ a) (succIsPositive a) *Z' b +Z' positive (succ a) (succIsPositive a) *Z' c
+    indHyp = lemmaDistributive a b c
+    lemm : (positive (succ (succ a)) (succIsPositive (succ a))) *Z' (b +Z' c) ≡ (b +Z' c) +Z' (positive (succ a) (succIsPositive a) *Z' b +Z' positive (succ a) (succIsPositive a) *Z' c)
+    lemm rewrite equalityCommutative indHyp = internallemma'
+    lemm' : (positive (succ (succ a)) (succIsPositive (succ a))) *Z' (b +Z' c) ≡ b +Z' (c +Z' ((positive (succ a) (succIsPositive a) *Z' b +Z' positive (succ a) (succIsPositive a) *Z' c)))
+    lemm' rewrite additionZ'IsAssociative b c (positive (succ a) (succIsPositive a) *Z' b +Z' positive (succ a) (succIsPositive a) *Z' c) = lemm
+    lemm'' : (positive (succ (succ a)) (succIsPositive (succ a))) *Z' (b +Z' c) ≡ b +Z' (((positive (succ a) (succIsPositive a) *Z' b +Z' positive (succ a) (succIsPositive a) *Z' c)) +Z' c)
+    inter : ((positive (succ a) (succIsPositive a) *Z' b +Z' positive (succ a) (succIsPositive a) *Z' c)) +Z' c ≡ positive (succ a) (succIsPositive a) *Z' b +Z' ((positive (succ a) (succIsPositive a) *Z' c) +Z' c)
+    lemm''' : (positive (succ (succ a)) (succIsPositive (succ a))) *Z' (b +Z' c) ≡ b +Z' (positive (succ a) (succIsPositive a) *Z' b +Z' ((positive (succ a) (succIsPositive a) *Z' c) +Z' c))
+    lemm'''' : (positive (succ (succ a)) (succIsPositive (succ a))) *Z' (b +Z' c) ≡ (b +Z' (positive (succ a) (succIsPositive a) *Z' b)) +Z' ((positive (succ a) (succIsPositive a) *Z' c) +Z' c)
+    lemm'''' rewrite equalityCommutative (additionZ'IsAssociative b (positive (succ a) (succIsPositive a) *Z' b) ((positive (succ a) (succIsPositive a) *Z' c) +Z' c)) = lemm'''
+    lemmV : (positive (succ (succ a)) (succIsPositive (succ a))) *Z' (b +Z' c) ≡ (positive (succ (succ a)) (succIsPositive (succ a)) *Z' b) +Z' ((positive (succ a) (succIsPositive a) *Z' c) +Z' c)
+    lemmV rewrite p = lemm''''
+    lemmV' : (positive (succ (succ a)) (succIsPositive (succ a))) *Z' (b +Z' c) ≡ (positive (succ (succ a)) (succIsPositive (succ a)) *Z' b) +Z' (c +Z' (positive (succ a) (succIsPositive a) *Z' c))
+    lemmV' rewrite additionZ'IsCommutative c (positive (succ a) (succIsPositive a) *Z' c) = lemmV
+    lemmV'' : (positive (succ (succ a)) (succIsPositive (succ a))) *Z' (b +Z' c) ≡ (positive (succ (succ a)) (succIsPositive (succ a)) *Z' b) +Z' (positive (succ (succ a)) (succIsPositive (succ a)) *Z' c)
+    lemmV'' rewrite q = lemmV'
+    lemm'' rewrite additionZ'IsCommutative ((positive (succ a) (succIsPositive a) *Z' b +Z' positive (succ a) (succIsPositive a) *Z' c)) c = lemm'
+    inter = equalityCommutative (additionZ'IsAssociative (positive (succ a) (succIsPositive a) *Z' b) (positive (succ a) (succIsPositive a) *Z' c) c)
+    lemm''' rewrite equalityCommutative inter = lemm''
+
+addIsZero : (a b : ℕ) → {pr1 : 0 <N a} → {pr2 : 0 <N b} → ((positive a pr1) +Z' (negative b pr2) ≡ zZero) → a ≡ b
+addIsZero zero b {le x ()} {pr2} pr
+addIsZero (succ a) zero {pr1} {le x ()} pr
+addIsZero (succ zero) (succ zero) {pr1} {pr2} pr = refl
+addIsZero (succ zero) (succ (succ b)) {pr1} {pr2} pr = exFalso (f pr)
+  where
+    f : (negative (succ b) (logical<NImpliesLe (record {})) ≡ zZero) → False
+    f ()
+addIsZero (succ (succ a)) (succ zero) {pr1} {pr2} pr = exFalso (f pr)
+  where
+    f : (positive (succ a) (logical<NImpliesLe (record {})) ≡ zZero) → False
+    f ()
+addIsZero (succ (succ a)) (succ (succ b)) {pr1} {pr2} pr = applyEquality succ (addIsZero (succ a) (succ b) {succIsPositive a} {succIsPositive b} p)
+  where
+    q : positive (succ (succ a)) pr1 +Z' negative (succ (succ b)) pr2 ≡ positive (succ a) (succIsPositive a) +Z' negative (succ b) (succIsPositive b)
+    q = canKnockOneOff+Z' (succ a) (succ b) {succIsPositive a} {succIsPositive b} {pr1} {pr2}
+    p : positive (succ a) (succIsPositive a) +Z' negative (succ b) (succIsPositive b) ≡ zZero
+    p rewrite equalityCommutative q = pr
+
+addIsZero' : (a : ℕ) → (negative (succ a) (succIsPositive a)) +Z' (positive (succ a) (succIsPositive a)) ≡ zZero
+addIsZero' (zero) = refl
+addIsZero' (succ a) = transitivity q p
+  where
+    p : negative (succ a) (succIsPositive a) +Z' positive (succ a) (succIsPositive a) ≡ zZero
+    p = addIsZero' a
+    q : negative (succ (succ a)) (succIsPositive (succ a)) +Z' positive (succ (succ a)) (succIsPositive (succ a)) ≡ negative (succ a) (succIsPositive a) +Z' positive (succ a) (succIsPositive a)
+    q = canKnockOneOff+Z'2 (succ a) (succ a) {succIsPositive a} {succIsPositive a} {succIsPositive (succ a)} {succIsPositive (succ a)}
+
+timesNegPosPos : (a b c : ℕ) → (negative (succ a) (succIsPositive a)) *Z' ((positive (succ b) (succIsPositive b)) +Z' (positive (succ c) (succIsPositive c))) ≡ (positive (succ a) (succIsPositive a)) *Z' ((negative (succ b) (succIsPositive b)) +Z' (negative (succ c) (succIsPositive c)))
+timesNegPosPos a b c = refl
+
+diffProof : (a b : ℕ) → (sum1 sum2 : ℕ) → (pr1 : succ a +N succ b ≡ sum1) → (pr2 : succ a +N succ b ≡ sum2) → (prSums : sum1 ≡ sum2) → plusZ' sum1 (negative (succ a) (succIsPositive a)) (positive (succ b) (succIsPositive b)) pr1 ≡ plusZ' sum2 (negative (succ a) (succIsPositive a)) (positive (succ b) (succIsPositive b)) pr2
+diffProof a b .(succ (a +N succ b)) .(succ (a +N succ b)) refl refl refl = refl
+
+diffProof' : (a b : ℕ) → (sum1 sum2 : ℕ) → (pr1 : succ a +N succ b ≡ sum1) → (pr2 : succ a +N succ b ≡ sum2) → (prSums : sum1 ≡ sum2) → plusZ' sum1 (positive (succ a) (succIsPositive a)) (negative (succ b) (succIsPositive b)) pr1 ≡ plusZ' sum2 (positive (succ a) (succIsPositive a)) (negative (succ b) (succIsPositive b)) pr2
+diffProof' a b .(succ (a +N succ b)) .(succ (a +N succ b)) refl refl refl = refl
+
+timesNegPosNeg : (a b c : ℕ) → (negative (succ a) (succIsPositive a)) *Z' ((positive (succ b) (succIsPositive b)) +Z' (negative (succ c) (succIsPositive c))) ≡ (positive (succ a) (succIsPositive a)) *Z' ((negative (succ b) (succIsPositive b)) +Z' (positive (succ c) (succIsPositive c)))
+timesNegPosNeg zero zero zero = refl
+timesNegPosNeg zero zero (succ c) = refl
+timesNegPosNeg zero (succ b) zero = refl
+timesNegPosNeg zero (succ b) (succ c) = identityOfIndiscernablesRight _ _ _ _≡_ ans'' (applyEquality (λ t → positive 1 _ *Z' t) (knocked'))
+  where
+    knocked : positive (succ (succ b)) (succIsPositive (succ b)) +Z' negative (succ (succ c)) (succIsPositive (succ c)) ≡ positive (succ b) _ +Z' negative (succ c) _
+    knocked = canKnockOneOff+Z' (succ b) (succ c) {succIsPositive b} {succIsPositive c} {succIsPositive (succ b)} {succIsPositive (succ c)}
+    knocked' : negative (succ b) (succIsPositive b) +Z' positive (succ c) (succIsPositive c) ≡ negative (succ (succ b)) (succIsPositive (succ b)) +Z' positive (succ (succ c)) (succIsPositive (succ c))
+    knocked' rewrite additionZ'IsCommutative (negative (succ b) (succIsPositive b)) (positive (succ c) (succIsPositive c)) | additionZ'IsCommutative (negative (succ (succ b)) (succIsPositive (succ b))) (positive (succ (succ c)) (succIsPositive (succ c))) = diffProof' c b (succ (c +N succ b)) (c +N succ (succ b)) refl help (equalityCommutative (succExtracts c (succ b)))
+      where
+        help : (succ (c +N succ b)) ≡ c +N succ (succ b)
+        help = _
+    ans : negative 1 (succIsPositive zero) *Z' (positive (succ b) _ +Z' negative (succ c) _) ≡ positive 1 _ *Z' (negative (succ b) _ +Z' positive (succ c) _)
+    ans = timesNegPosNeg zero b c
+    ans' : negative 1 _ *Z' (positive (succ (succ b)) (succIsPositive (succ b)) +Z' negative (succ (succ c)) (succIsPositive (succ c))) ≡ negative 1 _ *Z' (positive (succ b) _ +Z' negative (succ c) _)
+    ans' = applyEquality (λ t → negative 1 _ *Z' t) knocked
+    ans'' : negative 1 _ *Z' (positive (succ (succ b)) (succIsPositive (succ b)) +Z' negative (succ (succ c)) (succIsPositive (succ c))) ≡ positive 1 _ *Z' (negative (succ b) _ +Z' positive (succ c) _)
+    ans'' = identityOfIndiscernablesRight _ _ _ _≡_ ans' ans
+timesNegPosNeg (succ a) zero zero = refl
+timesNegPosNeg (succ a) zero (succ c) = refl
+timesNegPosNeg (succ a) (succ b) zero = refl
+timesNegPosNeg (succ a) (succ b) (succ c) = identityOfIndiscernablesRight _ _ _ _≡_ ans'' (applyEquality (λ t → positive (succ (succ a)) (succIsPositive (succ a)) *Z' t) (knocked'))
+  where
+    knocked : positive (succ (succ b)) (succIsPositive (succ b)) +Z' negative (succ (succ c)) (succIsPositive (succ c)) ≡ positive (succ b) _ +Z' negative (succ c) _
+    knocked = canKnockOneOff+Z' (succ b) (succ c) {succIsPositive b} {succIsPositive c} {succIsPositive (succ b)} {succIsPositive (succ c)}
+    knocked' : negative (succ b) (succIsPositive b) +Z' positive (succ c) (succIsPositive c) ≡ negative (succ (succ b)) (succIsPositive (succ b)) +Z' positive (succ (succ c)) (succIsPositive (succ c))
+    knocked' rewrite additionZ'IsCommutative (negative (succ b) (succIsPositive b)) (positive (succ c) (succIsPositive c)) | additionZ'IsCommutative (negative (succ (succ b)) (succIsPositive (succ b))) (positive (succ (succ c)) (succIsPositive (succ c))) = diffProof' c b (succ (c +N succ b)) (c +N succ (succ b)) refl help (equalityCommutative (succExtracts c (succ b)))
+      where
+        help : (succ (c +N succ b)) ≡ c +N succ (succ b)
+        help = _
+    ans : negative (succ (succ a)) (succIsPositive (succ a)) *Z' (positive (succ b) _ +Z' negative (succ c) _) ≡ positive (succ (succ a)) (succIsPositive (succ a)) *Z' (negative (succ b) _ +Z' positive (succ c) _)
+    ans = timesNegPosNeg (succ a) b c
+    ans' : negative (succ (succ a)) (succIsPositive (succ a)) *Z' (positive (succ (succ b)) (succIsPositive (succ b)) +Z' negative (succ (succ c)) (succIsPositive (succ c))) ≡ negative (succ (succ a)) (succIsPositive (succ a)) *Z' (positive (succ b) _ +Z' negative (succ c) _)
+    ans' = applyEquality (λ t → negative (succ (succ a)) (succIsPositive (succ a)) *Z' t) knocked
+    ans'' : negative (succ (succ a)) (succIsPositive (succ a)) *Z' (positive (succ (succ b)) (succIsPositive (succ b)) +Z' negative (succ (succ c)) (succIsPositive (succ c))) ≡ positive (succ (succ a)) (succIsPositive (succ a)) *Z' (negative (succ b) _ +Z' positive (succ c) _)
+    ans'' = identityOfIndiscernablesRight _ _ _ _≡_ ans' ans
+
+timesNegNegPos : (a b c : ℕ) → (negative (succ a) (succIsPositive a)) *Z' ((negative (succ b) (succIsPositive b)) +Z' (positive (succ c) (succIsPositive c))) ≡ (positive (succ a) (succIsPositive a)) *Z' ((positive (succ b) (succIsPositive b)) +Z' (negative (succ c) (succIsPositive c)))
+timesNegNegPos a b c rewrite additionZ'IsCommutative (negative (succ b) (succIsPositive b)) (positive (succ c) (succIsPositive c)) | additionZ'IsCommutative (positive (succ b) (succIsPositive b)) (negative (succ c) (succIsPositive c)) = timesNegPosNeg a c b
+
+additionZ'DistributiveMulZ' : (a b c : ℤSimple) → (a *Z' (b +Z' c)) ≡ (a *Z' b +Z' a *Z' c)
+additionZ'DistributiveMulZ' (negative zero (le x ())) b c
+additionZ'DistributiveMulZ' (negative (succ a) x) (negative zero (le y ())) (negative c prC)
+additionZ'DistributiveMulZ' (negative (succ a) x) (negative (succ b) prB) (negative zero (le y ()))
+additionZ'DistributiveMulZ' (negative (succ a) x) (negative (succ b) prB) (negative (succ c) prC) = lemmaDistributive a (positive (succ b) prB) (positive (succ c) prC)
+additionZ'DistributiveMulZ' (negative (succ a) x) (negative zero (le y ())) (positive c prC)
+additionZ'DistributiveMulZ' (negative (succ a) x) (negative (succ b) prB) (positive zero (le y ()))
+additionZ'DistributiveMulZ' (negative (succ a) x) (negative (succ b) prB) (positive (succ c) prC) rewrite <NRefl x (succIsPositive a) | <NRefl prB (succIsPositive b) | <NRefl prC (succIsPositive c) = help
+  where
+    inter : (negative (succ a) (succIsPositive a)) *Z' ((negative (succ b) (succIsPositive b)) +Z' (positive (succ c) (succIsPositive c))) ≡ positive (succ a) (succIsPositive a) *Z' (positive (succ b) (succIsPositive b) +Z' negative (succ c) (succIsPositive c))
+    inter = timesNegNegPos a b c
+    lhs : positive (succ a) (succIsPositive a) *Z' (positive (succ b) (succIsPositive b) +Z' negative (succ c) (succIsPositive c)) ≡ positive (succ a) (succIsPositive a) *Z' positive (succ b) (succIsPositive b) +Z' (negative (succ a) (succIsPositive a) *Z' positive (succ c) (succIsPositive c))
+    lhs = lemmaDistributive a (positive (succ b) (succIsPositive b)) (negative (succ c) (succIsPositive c))
+    help : (negative (succ a) (succIsPositive a)) *Z' ((negative (succ b) (succIsPositive b)) +Z' (positive (succ c) (succIsPositive c))) ≡ negative (succ a) (succIsPositive a) *Z' negative (succ b) (succIsPositive b) +Z' (negative (succ a) (succIsPositive a) *Z' positive (succ c) (succIsPositive c))
+    help = transitivity inter lhs
+additionZ'DistributiveMulZ' (negative (succ a) x) (negative zero (le y ())) zZero
+additionZ'DistributiveMulZ' (negative (succ a) x) (negative (succ b) prB) zZero = refl
+additionZ'DistributiveMulZ' (negative (succ a) x) (positive b prB) (negative zero (le y ()))
+additionZ'DistributiveMulZ' (negative (succ a) x) (positive zero (le y ())) (negative (succ c) prC)
+additionZ'DistributiveMulZ' (negative (succ a) x) (positive (succ b) prB) (negative (succ c) prC) rewrite <NRefl x (succIsPositive a) | <NRefl prB (succIsPositive b) | <NRefl prC (succIsPositive c) = help
+  where
+    inter : (negative (succ a) (succIsPositive a)) *Z' ((positive (succ b) (succIsPositive b)) +Z' (negative (succ c) (succIsPositive c))) ≡ positive (succ a) (succIsPositive a) *Z' (negative (succ b) (succIsPositive b) +Z' positive (succ c) (succIsPositive c))
+    inter = timesNegPosNeg a b c
+    lhs : positive (succ a) (succIsPositive a) *Z' (negative (succ b) (succIsPositive b) +Z' positive (succ c) (succIsPositive c)) ≡ positive (succ a) (succIsPositive a) *Z' negative (succ b) (succIsPositive b) +Z' (positive (succ a) (succIsPositive a) *Z' positive (succ c) (succIsPositive c))
+    lhs = lemmaDistributive a (negative (succ b) (succIsPositive b)) (positive (succ c) (succIsPositive c))
+    help : (negative (succ a) (succIsPositive a)) *Z' ((positive (succ b) (succIsPositive b)) +Z' (negative (succ c) (succIsPositive c))) ≡ negative (succ a) (succIsPositive a) *Z' positive (succ b) (succIsPositive b) +Z' (negative (succ a) (succIsPositive a) *Z' negative (succ c) (succIsPositive c))
+    help = transitivity inter lhs
+additionZ'DistributiveMulZ' (negative (succ a) x) (positive b prB) (positive zero (le y ()))
+additionZ'DistributiveMulZ' (negative (succ a) x) (positive 0 (le y ())) (positive (succ c) prC)
+additionZ'DistributiveMulZ' (negative (succ a) x) (positive (succ b) prB) (positive (succ c) prC) rewrite timesNegPosPos a b c = applyEquality (λ t → negative (succ t) (succIsPositive t)) help
+    where
+      help : (b +N succ c) +N a *N succ (b +N succ c) ≡ (b +N a *N succ b) +N succ (c +N a *N succ c)
+      help rewrite Semiring.+DistributesOver* ℕSemiring a (succ b) (succ c) | Semiring.+Associative ℕSemiring (b +N succ c) (a *N succ b) (a *N succ c) | additionNIsAssociative b (succ c) (a *N succ b) | Semiring.commutative ℕSemiring (succ c) (a *N succ b) | equalityCommutative (additionNIsAssociative b (a *N succ b) (succ c)) | additionNIsAssociative (b +N a *N succ b) (succ c) (a *N succ c) = refl
+additionZ'DistributiveMulZ' (negative (succ a) x) (positive zero (le y ())) zZero
+additionZ'DistributiveMulZ' (negative (succ a) x) (positive (succ b) prB) zZero = refl
+additionZ'DistributiveMulZ' (negative (succ a) x) zZero (negative zero (le y ()))
+additionZ'DistributiveMulZ' (negative (succ a) x) zZero (negative (succ c) prC) = refl
+additionZ'DistributiveMulZ' (negative (succ a) x) zZero (positive zero (le y ()))
+additionZ'DistributiveMulZ' (negative (succ a) x) zZero (positive (succ c) prC) = refl
+additionZ'DistributiveMulZ' (negative (succ a) x) zZero zZero = refl
+additionZ'DistributiveMulZ' (positive zero (le x ())) b c
+additionZ'DistributiveMulZ' (positive (succ a) x) b c rewrite <NRefl x (succIsPositive a) = lemmaDistributive a b c
+additionZ'DistributiveMulZ' zZero b c = refl
+
+additionZDistributiveMulZ : (a b c : ℤ) → (a *Z (b +Z c)) ≡ (a *Z b) +Z (a *Z c)
+additionZDistributiveMulZ a b c = identityOfIndiscernablesRight _ _ _ _≡_ lem12 (applyEquality (λ t → a *Z b +Z (a *Z t)) (zIsZ c))
+  where
+    lem1 : convertZ' ((convertZ a) *Z' ((convertZ b) +Z' (convertZ c))) ≡ convertZ' ((convertZ a *Z' convertZ b) +Z' (convertZ a *Z' convertZ c))
+    lem2 : convertZ' (convertZ a) *Z convertZ' ((convertZ b) +Z' (convertZ c)) ≡ convertZ' ((convertZ a *Z' convertZ b) +Z' (convertZ a *Z' convertZ c))
+    lem3 : a *Z convertZ' ((convertZ b) +Z' (convertZ c)) ≡ convertZ' ((convertZ a *Z' convertZ b) +Z' (convertZ a *Z' convertZ c))
+    lem4 : a *Z (convertZ' (convertZ b) +Z convertZ' (convertZ c)) ≡ convertZ' ((convertZ a *Z' convertZ b) +Z' (convertZ a *Z' convertZ c))
+    lem5 : a *Z (b +Z convertZ' (convertZ c)) ≡ convertZ' ((convertZ a *Z' convertZ b) +Z' (convertZ a *Z' convertZ c))
+    lem6 : a *Z (b +Z c) ≡ convertZ' ((convertZ a *Z' convertZ b) +Z' (convertZ a *Z' convertZ c))
+    lem7 : a *Z (b +Z c) ≡ convertZ' (convertZ a *Z' convertZ b) +Z convertZ' (convertZ a *Z' convertZ c)
+    lem8 : a *Z (b +Z c) ≡ (convertZ' (convertZ a) *Z (convertZ' (convertZ b))) +Z convertZ' (convertZ a *Z' convertZ c)
+    lem9 : a *Z (b +Z c) ≡ (a *Z (convertZ' (convertZ b))) +Z convertZ' (convertZ a *Z' convertZ c)
+    lem10 : a *Z (b +Z c) ≡ (a *Z b) +Z convertZ' (convertZ a *Z' convertZ c)
+    lem11 : a *Z (b +Z c) ≡ (a *Z b) +Z (convertZ' (convertZ a) *Z convertZ' (convertZ c))
+    lem12 : a *Z (b +Z c) ≡ (a *Z b) +Z (a *Z convertZ' (convertZ c))
+    lem12 = identityOfIndiscernablesRight _ _ _ _≡_ lem11 (applyEquality (λ t → a *Z b +Z (t *Z convertZ' (convertZ c))) (zIsZ a))
+    lem11 = identityOfIndiscernablesRight _ _ _ _≡_ lem10 (applyEquality (λ t → a *Z b +Z t) (convertZ'DistributesOver*Z (convertZ a) _))
+    lem10 = identityOfIndiscernablesRight _ _ _ _≡_ lem9 (applyEquality (λ t → a *Z t +Z convertZ' (convertZ a *Z' convertZ c)) (zIsZ b))
+    lem9 = identityOfIndiscernablesRight _ _ _ _≡_ lem8 (applyEquality (λ t → t *Z (convertZ' (convertZ b)) +Z convertZ' (convertZ a *Z' convertZ c)) (zIsZ a))
+    lem8 = identityOfIndiscernablesRight _ _ _ _≡_ lem7 (applyEquality (λ t → t +Z convertZ' (convertZ a *Z' convertZ c)) (convertZ'DistributesOver*Z (convertZ a) _))
+    lem7 = identityOfIndiscernablesRight _ _ _ _≡_ lem6 (plusIsPlus (convertZ a *Z' convertZ b) _)
+    lem6 = identityOfIndiscernablesLeft _ _ _ _≡_ lem5 (applyEquality (λ t → a *Z (b +Z t)) (zIsZ c))
+    lem5 = identityOfIndiscernablesLeft _ _ _ _≡_ lem4 (applyEquality (λ t → a *Z (t +Z convertZ' (convertZ c))) (zIsZ b))
+    lem4 = identityOfIndiscernablesLeft _ _ _ _≡_ lem3 (applyEquality (λ t → a *Z t) (plusIsPlus (convertZ b) _))
+    lem3 = identityOfIndiscernablesLeft _ _ _ _≡_ lem2 (applyEquality (λ t → t *Z (convertZ' ((convertZ b) +Z' convertZ c))) (zIsZ a))
+    lem2 = identityOfIndiscernablesLeft _ _ _ _≡_ lem1 (convertZ'DistributesOver*Z (convertZ a) _)
+    lem1 = applyEquality convertZ' (additionZ'DistributiveMulZ' (convertZ a) (convertZ b) (convertZ c))
+
+additionZRespectsOrder : (a b c : ℤ) → (a <Z b) → (a +Z c <Z b +Z c)
+additionZRespectsOrder a b c (le x proof) = le x (identityOfIndiscernablesLeft ((nonneg (succ x) +Z a) +Z c) (b +Z c) (nonneg (succ x) +Z (a +Z c)) _≡_ (applyEquality (λ t → t +Z c) proof) (equalityCommutative (additionZIsAssociative (nonneg (succ x)) a c)))
+
+nonnegNotLessNegsucc : (a b : ℕ) → (nonneg a <Z negSucc b) → False
+nonnegNotLessNegsucc a b (le x proof) = nonnegIsNotNegsucc proof
+
+productOfPositivesIsPositive : (a b : ℤ) → (nonneg zero <Z a) → (nonneg zero <Z b) → (nonneg 0 <Z a *Z b)
+productOfPositivesIsPositive (nonneg zero) (nonneg b) pr1 pr2 = exFalso (lessZIrreflexive {nonneg 0} pr1)
+productOfPositivesIsPositive (nonneg (succ a)) (nonneg zero) pr1 pr2 = exFalso (lessZIrreflexive {nonneg 0} pr2)
+productOfPositivesIsPositive (nonneg (succ a)) (nonneg (succ b)) pr1 pr2 rewrite multiplyingNonnegIsHom (succ a) (succ b) = lessIsPreservedNToZ (succIsPositive (b +N a *N succ b))
+productOfPositivesIsPositive (nonneg zero) (negSucc b) pr1 pr2 = exFalso (nonnegNotLessNegsucc 0 b pr2)
+productOfPositivesIsPositive (nonneg (succ a)) (negSucc b) pr1 pr2 = exFalso (nonnegNotLessNegsucc 0 b pr2)
+productOfPositivesIsPositive (negSucc x) b pr1 pr2 = exFalso (nonnegNotLessNegsucc 0 x pr1)
+
+lessZTransitive : {a b c : ℤ} → (a <Z b) → (b <Z c) → (a <Z c)
+lessZTransitive {a} {b} {c} (le d1 pr1) (le d2 pr2) rewrite equalityCommutative pr1 = le (d1 +N succ d2) pr
+  where
+    pr : nonneg (succ (d1 +N succ d2)) +Z a ≡ c
+    pr rewrite additionZIsAssociative (nonneg (succ d2)) (nonneg (succ d1)) a | Semiring.commutative ℕSemiring (succ d2) (succ d1) = pr2
+
+ℤGroup : Group (reflSetoid ℤ) (_+Z_)
+Group.wellDefined ℤGroup {a} {b} {.a} {.b} refl refl = refl
+Group.identity ℤGroup = nonneg zero
+Group.inverse ℤGroup = additiveInverseZ
+Group.multAssoc ℤGroup {a} {b} {c} = additionZIsAssociative a b c
+Group.multIdentLeft ℤGroup {a} = refl
+Group.multIdentRight ℤGroup {a} = zeroIsAdditiveIdentityRightZ a
+Group.invLeft ℤGroup {a} = addInverseLeftZ a
+Group.invRight ℤGroup {a} = addInverseRightZ a
+
+ℤAbGrp : AbelianGroup ℤGroup
+ℤAbGrp = record { commutative = λ {a} {b} → additionZIsCommutative a b }
+
+ℤRing : Ring (reflSetoid ℤ) (_+Z_) (_*Z_)
+Ring.additiveGroup ℤRing = ℤGroup
+Ring.multWellDefined ℤRing {r} {s} {.r} {.s} refl refl = refl
+Ring.1R ℤRing = nonneg (succ zero)
+Ring.groupIsAbelian ℤRing {a} {b} = additionZIsCommutative a b
+Ring.multAssoc ℤRing {a} {b} {c} = multiplicationZIsAssociative a b c
+Ring.multCommutative ℤRing {a} {b} = multiplicationZIsCommutative a b
+Ring.multDistributes ℤRing {a} {b} {c} = additionZDistributiveMulZ a b c
+Ring.multIdentIsIdent ℤRing {a} = multiplicativeIdentityOneZLeft a
+
+negsuccTimesNonneg : {a b : ℕ} → (negSucc a *Z nonneg (succ b)) ≡ nonneg 0 → False
+negsuccTimesNonneg {a} {b} pr with convertZ (negSucc a)
+negsuccTimesNonneg {a} {b} () | negative a₁ x
+negsuccTimesNonneg {a} {b} () | positive a₁ x
+negsuccTimesNonneg {a} {b} () | zZero
+
+negsuccTimesNegsucc : {a b : ℕ} → (negSucc a *Z negSucc b) ≡ nonneg 0 → False
+negsuccTimesNegsucc {a} {b} pr with convertZ (negSucc a)
+negsuccTimesNegsucc {a} {b} () | negative a₁ x
+negsuccTimesNegsucc {a} {b} () | positive a₁ x
+negsuccTimesNegsucc {a} {b} () | zZero
+
+ℤIntDom : IntegralDomain ℤRing
+IntegralDomain.intDom ℤIntDom {nonneg zero} {nonneg b} pr = inl refl
+IntegralDomain.intDom ℤIntDom {nonneg (succ a)} {nonneg zero} pr = inr refl
+IntegralDomain.intDom ℤIntDom {nonneg (succ a)} {nonneg (succ b)} pr = exFalso (naughtE (nonnegInjective (equalityCommutative (transitivity (equalityCommutative (multiplyingNonnegIsHom (succ a) (succ b))) pr))))
+IntegralDomain.intDom ℤIntDom {nonneg zero} {negSucc b} pr = inl refl
+IntegralDomain.intDom ℤIntDom {nonneg (succ a)} {negSucc b} pr = exFalso (negsuccTimesNonneg {b} {a} (transitivity (multiplicationZIsCommutative (negSucc b) (nonneg (succ a))) pr))
+IntegralDomain.intDom ℤIntDom {negSucc a} {nonneg zero} pr = inr refl
+IntegralDomain.intDom ℤIntDom {negSucc a} {nonneg (succ b)} pr = exFalso (negsuccTimesNonneg {a} {b} pr)
+IntegralDomain.intDom ℤIntDom {negSucc a} {negSucc b} pr = exFalso (negsuccTimesNegsucc {a} {b} pr)
+IntegralDomain.nontrivial ℤIntDom = λ ()
+
+ℤOrder : TotalOrder ℤ
+PartialOrder._<_ (TotalOrder.order ℤOrder) = _<Z_
+TotalOrder.totality ℤOrder a b = lessThanTotalZ {a} {b}
+PartialOrder.irreflexive (TotalOrder.order ℤOrder) = lessZIrreflexive
+PartialOrder.transitive (TotalOrder.order ℤOrder) {a} {b} {c} = lessZTransitive
+
+ℤOrderedRing : OrderedRing ℤRing (totalOrderToSetoidTotalOrder ℤOrder)
+OrderedRing.orderRespectsAddition ℤOrderedRing {a} {b} a<b c = additionZRespectsOrder a b c a<b
+OrderedRing.orderRespectsMultiplication ℤOrderedRing {a} {b} a<b = productOfPositivesIsPositive a b a<b
+
+_-Z_ : ℤ → ℤ → ℤ
+a -Z b = a +Z (additiveInverseZ b)
diff --git a/Numbers/Naturals/Addition.agda b/Numbers/Naturals/Addition.agda
new file mode 100644
index 0000000..4f6a515
--- /dev/null
+++ b/Numbers/Naturals/Addition.agda
@@ -0,0 +1,43 @@
+{-# OPTIONS --warning=error --safe --without-K #-}
+
+open import LogicalFormulae
+open import Numbers.Naturals.Definition
+
+module Numbers.Naturals.Addition where
+
+infix 15 _+N_
+_+N_ : ℕ → ℕ → ℕ
+zero +N y = y
+succ x +N y = succ (x +N y)
+
+addzeroLeft : (x : ℕ) → (zero +N x) ≡ x
+addzeroLeft x = refl
+
+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)
+
+succCanMove : (x y : ℕ) → (x +N succ y) ≡ (succ x +N y)
+succCanMove x y = transitivity (succExtracts x y) refl
+
+additionNIsCommutative : (x y : ℕ) → (x +N y) ≡ (y +N x)
+additionNIsCommutative zero y = transitivity (addzeroLeft y) (equalityCommutative (addZeroRight y))
+additionNIsCommutative (succ x) zero = transitivity (addZeroRight (succ x)) refl
+additionNIsCommutative (succ x) (succ y) = transitivity refl (applyEquality succ (transitivity (succCanMove x y) (additionNIsCommutative (succ x) y)))
+
+addingPreservesEqualityRight : {a b : ℕ} (c : ℕ) → (a ≡ b) → (a +N c ≡ b +N c)
+addingPreservesEqualityRight {a} {b} c pr = applyEquality (λ n -> n +N c) pr
+addingPreservesEqualityLeft : {a b : ℕ} (c : ℕ) → (a ≡ b) → (c +N a ≡ c +N b)
+addingPreservesEqualityLeft {a} {b} c pr = applyEquality (λ n -> c +N n) pr
+
+additionNIsAssociative : (a b c : ℕ) → ((a +N b) +N c) ≡ (a +N (b +N c))
+additionNIsAssociative zero b c = refl
+additionNIsAssociative (succ a) zero c = transitivity (transitivity (applyEquality (λ n → n +N c) (applyEquality succ (addZeroRight a))) refl) (transitivity refl refl)
+additionNIsAssociative (succ a) (succ b) c = transitivity refl (transitivity refl (transitivity (applyEquality succ (additionNIsAssociative a (succ b) c)) refl))
+
+succIsAddOne : (a : ℕ) → succ a ≡ a +N succ zero
+succIsAddOne a = equalityCommutative (transitivity (additionNIsCommutative a (succ zero)) refl)
diff --git a/Numbers/Naturals/Definition.agda b/Numbers/Naturals/Definition.agda
new file mode 100644
index 0000000..d12fd99
--- /dev/null
+++ b/Numbers/Naturals/Definition.agda
@@ -0,0 +1,16 @@
+{-# OPTIONS --warning=error --safe --without-K #-}
+
+open import LogicalFormulae
+
+module Numbers.Naturals.Definition where
+
+data ℕ : Set where
+  zero : ℕ
+  succ : ℕ → ℕ
+
+infix 100 succ
+
+{-# BUILTIN NATURAL ℕ #-}
+
+succInjective : {a b : ℕ} → (succ a ≡ succ b) → a ≡ b
+succInjective {a} {.a} refl = refl
diff --git a/Numbers/Naturals/Multiplication.agda b/Numbers/Naturals/Multiplication.agda
new file mode 100644
index 0000000..fa877e8
--- /dev/null
+++ b/Numbers/Naturals/Multiplication.agda
@@ -0,0 +1,82 @@
+{-# OPTIONS --warning=error --safe --without-K #-}
+
+open import LogicalFormulae
+open import Numbers.Naturals.Definition
+open import Numbers.Naturals.Addition
+
+module Numbers.Naturals.Multiplication where
+
+infix 25 _*N_
+_*N_ : ℕ → ℕ → ℕ
+zero *N y = zero
+(succ x) *N y = y +N (x *N y)
+
+productZeroIsZeroLeft : (a : ℕ) → (zero *N a ≡ zero)
+productZeroIsZeroLeft a = refl
+
+productZeroIsZeroRight : (a : ℕ) → (a *N zero ≡ zero)
+productZeroIsZeroRight zero = refl
+productZeroIsZeroRight (succ a) = productZeroIsZeroRight a
+
+productWithOneLeft : (a : ℕ) → ((succ zero) *N a) ≡ a
+productWithOneLeft a = transitivity refl (transitivity (applyEquality (λ { m -> a +N m }) refl) (additionNIsCommutative a zero))
+
+productWithOneRight : (a : ℕ) → a *N succ zero ≡ a
+productWithOneRight zero = refl
+productWithOneRight (succ a) = transitivity refl (addingPreservesEqualityLeft (succ zero) (productWithOneRight a))
+
+productDistributes : (a b c : ℕ) → (a *N (b +N c)) ≡ a *N b +N a *N c
+productDistributes zero b c = refl
+productDistributes (succ a) b c = transitivity refl
+  (transitivity (addingPreservesEqualityLeft (b +N c) (productDistributes a b c))
+    (transitivity (equalityCommutative (additionNIsAssociative (b +N c) (a *N b) (a *N c)))
+      (transitivity (addingPreservesEqualityRight (a *N c) (additionNIsCommutative (b +N c) (a *N b)))
+        (transitivity (addingPreservesEqualityRight (a *N c) (equalityCommutative (additionNIsAssociative (a *N b) b c)))
+          (transitivity (addingPreservesEqualityRight (a *N c) (addingPreservesEqualityRight c (additionNIsCommutative (a *N b) b)))
+            (transitivity (addingPreservesEqualityRight (a *N c) (addingPreservesEqualityRight {b +N a *N b} {(succ a) *N b} c (refl)))
+              (transitivity (additionNIsAssociative ((succ a) *N b) c (a *N c))
+                (transitivity (addingPreservesEqualityLeft (succ a *N b) refl)
+                  refl)
+            )
+        ))))))
+
+productPreservesEqualityLeft : (a : ℕ) → {b c : ℕ} → b ≡ c → a *N b ≡ a *N c
+productPreservesEqualityLeft a {b} {.b} refl = refl
+
+aSucB : (a b : ℕ) → a *N succ b ≡ a *N b +N a
+aSucB a b = transitivity {_} {ℕ} {a *N succ b} {a *N (b +N succ zero)} (productPreservesEqualityLeft a (succIsAddOne b)) (transitivity {_} {ℕ} {a *N (b +N succ zero)} {a *N b +N a *N succ zero} (productDistributes a b (succ zero)) (addingPreservesEqualityLeft (a *N b) (productWithOneRight a)))
+
+aSucBRight : (a b : ℕ) → (succ a) *N b ≡ a *N b +N b
+aSucBRight a b = additionNIsCommutative b (a *N b)
+
+multiplicationNIsCommutative : (a b : ℕ) → (a *N b) ≡ (b *N a)
+multiplicationNIsCommutative zero b = transitivity (productZeroIsZeroLeft b) (equalityCommutative (productZeroIsZeroRight b))
+multiplicationNIsCommutative (succ a) zero = multiplicationNIsCommutative a zero
+multiplicationNIsCommutative (succ a) (succ b) = transitivity refl
+  (transitivity (addingPreservesEqualityLeft (succ b) (aSucB a b))
+    (transitivity (additionNIsCommutative (succ b) (a *N b +N a))
+      (transitivity (additionNIsAssociative (a *N b) a (succ b))
+        (transitivity (addingPreservesEqualityLeft (a *N b) (succCanMove a b))
+          (transitivity (addingPreservesEqualityLeft (a *N b) (additionNIsCommutative (succ a) b))
+            (transitivity (equalityCommutative (additionNIsAssociative (a *N b) b (succ a)))
+              (transitivity (addingPreservesEqualityRight (succ a) (equalityCommutative (aSucBRight a b)))
+                (transitivity (addingPreservesEqualityRight (succ a) (multiplicationNIsCommutative (succ a) b))
+                  (transitivity (additionNIsCommutative (b *N (succ a)) (succ a))
+                    refl
+                )))))))))
+
+productDistributes' : (a b c : ℕ) → (a +N b) *N c ≡ a *N c +N b *N c
+productDistributes' a b c rewrite multiplicationNIsCommutative (a +N b) c | productDistributes c a b | multiplicationNIsCommutative c a | multiplicationNIsCommutative c b = refl
+
+flipProductsWithinSum : (a b c : ℕ) → (c *N a +N c *N b ≡ a *N c +N b *N c)
+flipProductsWithinSum a b c = transitivity (addingPreservesEqualityRight (c *N b) (multiplicationNIsCommutative c a)) ((addingPreservesEqualityLeft (a *N c) (multiplicationNIsCommutative c b)))
+
+productDistributesRight : (a b c : ℕ) → (a +N b) *N c ≡ a *N c +N b *N c
+productDistributesRight a b c = transitivity (multiplicationNIsCommutative (a +N b) c) (transitivity (productDistributes c a b) (flipProductsWithinSum a b c))
+
+multiplicationNIsAssociative : (a b c : ℕ) → (a *N (b *N c)) ≡ ((a *N b) *N c)
+multiplicationNIsAssociative zero b c = refl
+multiplicationNIsAssociative (succ a) b c =
+    transitivity refl
+      (transitivity refl
+        (transitivity (applyEquality ((λ x → b *N c +N x)) (multiplicationNIsAssociative a b c)) (transitivity (equalityCommutative (productDistributesRight b (a *N b) c)) refl)))
diff --git a/Numbers/Naturals.agda b/Numbers/Naturals/Naturals.agda
similarity index 80%
rename from Numbers/Naturals.agda
rename to Numbers/Naturals/Naturals.agda
index c115b4c..34ad67d 100644
--- a/Numbers/Naturals.agda
+++ b/Numbers/Naturals/Naturals.agda
@@ -5,196 +5,31 @@ 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.Order
+open import Numbers.Naturals.Multiplication
+open import Semirings.Definition
+open import Monoids.Definition
 
-module Numbers.Naturals where
-  data ℕ : Set where
-      zero : ℕ
-      succ : ℕ → ℕ
+module Numbers.Naturals.Naturals where
 
-  {-# BUILTIN NATURAL ℕ #-}
+  open Numbers.Naturals.Definition using (ℕ ; zero ; succ; succInjective) public
+  open Numbers.Naturals.Addition using (_+N_) public
+  open Numbers.Naturals.Multiplication using (_*N_ ; multiplicationNIsCommutative) public
+  open Numbers.Naturals.Order using (_<N_ ; le; succPreservesInequality) public
 
-  infix 15 _+N_
-  infix 100 succ
-  _+N_ : ℕ → ℕ → ℕ
-  zero +N y = y
-  succ x +N y = succ (x +N y)
-
-  infix 25 _*N_
-  _*N_ : ℕ → ℕ → ℕ
-  zero *N y = zero
-  (succ x) *N y = y +N (x *N y)
-
-  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
-    constructor le
-    field
-      x : ℕ
-      proof : (succ x) +N a ≡ b
-
-  infix 5 _≤N_
-  _≤N_ : ℕ → ℕ → Set
-  a ≤N b = (a <N b) || (a ≡ b)
-
-  addzeroLeft : (x : ℕ) → (zero +N x) ≡ x
-  addzeroLeft x = refl
-
-  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)
-
-  succCanMove : (x y : ℕ) → (x +N succ y) ≡ (succ x +N y)
-  succCanMove x y = transitivity (succExtracts x y) refl
-
-  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
-
-  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)
-
-  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)
-
-  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))
-
-  canRemoveSuccFrom<N : {a b : ℕ} → (succ a <N succ b) → (a <N b)
-  canRemoveSuccFrom<N {a} {b} prAB = logical<NImpliesLe (leImpliesLogical<N prAB)
-
-  succPreservesInequality : {a b : ℕ} → (a <N b) → (succ a <N succ b)
-  succPreservesInequality {a} {b} prAB = logical<NImpliesLe (succPreservesInequalityLogical {a} {b} (leImpliesLogical<N prAB))
-
-  lessIrreflexive : {a : ℕ} → (a <N a) → False
-  lessIrreflexive {zero} pr = leImpliesLogical<N pr
-  lessIrreflexive {succ a} pr = lessIrreflexive {a} (logical<NImpliesLe {a} {a} (leImpliesLogical<N {succ a} {succ a} pr))
-
-  additionNIsCommutative : (x y : ℕ) → (x +N y) ≡ (y +N x)
-  additionNIsCommutative zero y = transitivity (addzeroLeft y) (equalityCommutative (addZeroRight y))
-  additionNIsCommutative (succ x) zero = transitivity (addZeroRight (succ x)) refl
-  additionNIsCommutative (succ x) (succ y) =
-      transitivity refl (applyEquality succ (transitivity (succCanMove x y) (additionNIsCommutative (succ x) y)))
-
-  succInjective : {a b : ℕ} → (succ a ≡ succ b) → a ≡ b
-  succInjective {a} {.a} refl = refl
-
-  addingPreservesEqualityRight : {a b : ℕ} (c : ℕ) → (a ≡ b) → (a +N c ≡ b +N c)
-  addingPreservesEqualityRight {a} {b} c pr = applyEquality (λ n -> n +N c) pr
-  addingPreservesEqualityLeft : {a b : ℕ} (c : ℕ) → (a ≡ b) → (c +N a ≡ c +N b)
-  addingPreservesEqualityLeft {a} {b} c pr = applyEquality (λ n -> c +N n) pr
-
-  additionNIsAssociative : (a b c : ℕ) → ((a +N b) +N c) ≡ (a +N (b +N c))
-  additionNIsAssociative zero b c = refl
-  additionNIsAssociative (succ a) zero c = transitivity (transitivity (applyEquality (λ n → n +N c) (applyEquality succ (addZeroRight a))) refl) (transitivity refl refl)
-  additionNIsAssociative (succ a) (succ b) c = transitivity refl (transitivity refl (transitivity (applyEquality succ (additionNIsAssociative a (succ b) c)) refl))
-
-  productZeroIsZeroLeft : (a : ℕ) → (zero *N a ≡ zero)
-  productZeroIsZeroLeft a = refl
-
-  productZeroIsZeroRight : (a : ℕ) → (a *N zero ≡ zero)
-  productZeroIsZeroRight zero = refl
-  productZeroIsZeroRight (succ a) = productZeroIsZeroRight a
-
-  productWithOneLeft : (a : ℕ) → ((succ zero) *N a) ≡ a
-  productWithOneLeft a = transitivity refl (transitivity (applyEquality (λ { m -> a +N m }) refl) (additionNIsCommutative a zero))
-
-  productWithOneRight : (a : ℕ) → a *N succ zero ≡ a
-  productWithOneRight zero = refl
-  productWithOneRight (succ a) = transitivity refl (addingPreservesEqualityLeft (succ zero) (productWithOneRight a))
-
-  productDistributes : (a b c : ℕ) → (a *N (b +N c)) ≡ a *N b +N a *N c
-  productDistributes zero b c = refl
-  productDistributes (succ a) b c = transitivity refl
-    (transitivity (addingPreservesEqualityLeft (b +N c) (productDistributes a b c))
-      (transitivity (equalityCommutative (additionNIsAssociative (b +N c) (a *N b) (a *N c)))
-        (transitivity (addingPreservesEqualityRight (a *N c) (additionNIsCommutative (b +N c) (a *N b)))
-          (transitivity (addingPreservesEqualityRight (a *N c) (equalityCommutative (additionNIsAssociative (a *N b) b c)))
-            (transitivity (addingPreservesEqualityRight (a *N c) (addingPreservesEqualityRight c (additionNIsCommutative (a *N b) b)))
-              (transitivity (addingPreservesEqualityRight (a *N c) (addingPreservesEqualityRight {b +N a *N b} {(succ a) *N b} c (refl)))
-                (transitivity (additionNIsAssociative ((succ a) *N b) c (a *N c))
-                  (transitivity (addingPreservesEqualityLeft (succ a *N b) refl)
-                    refl)
-              )
-          ))))))
-
-  succIsAddOne : (a : ℕ) → succ a ≡ a +N succ zero
-  succIsAddOne a = equalityCommutative (transitivity (additionNIsCommutative a (succ zero)) refl)
-
-  productPreservesEqualityLeft : (a : ℕ) → {b c : ℕ} → b ≡ c → a *N b ≡ a *N c
-  productPreservesEqualityLeft a {b} {.b} refl = refl
-
-  aSucB : (a b : ℕ) → a *N succ b ≡ a *N b +N a
-  aSucB a b = transitivity {_} {ℕ} {a *N succ b} {a *N (b +N succ zero)} (productPreservesEqualityLeft a (succIsAddOne b)) (transitivity {_} {ℕ} {a *N (b +N succ zero)} {a *N b +N a *N succ zero} (productDistributes a b (succ zero)) (addingPreservesEqualityLeft (a *N b) (productWithOneRight a)))
-
-  aSucBRight : (a b : ℕ) → (succ a) *N b ≡ a *N b +N b
-  aSucBRight a b = additionNIsCommutative b (a *N b)
-
-  multiplicationNIsCommutative : (a b : ℕ) → (a *N b) ≡ (b *N a)
-  multiplicationNIsCommutative zero b = transitivity (productZeroIsZeroLeft b) (equalityCommutative (productZeroIsZeroRight b))
-  multiplicationNIsCommutative (succ a) zero = multiplicationNIsCommutative a zero
-  multiplicationNIsCommutative (succ a) (succ b) = transitivity refl
-    (transitivity (addingPreservesEqualityLeft (succ b) (aSucB a b))
-      (transitivity (additionNIsCommutative (succ b) (a *N b +N a))
-        (transitivity (additionNIsAssociative (a *N b) a (succ b))
-          (transitivity (addingPreservesEqualityLeft (a *N b) (succCanMove a b))
-            (transitivity (addingPreservesEqualityLeft (a *N b) (additionNIsCommutative (succ a) b))
-              (transitivity (equalityCommutative (additionNIsAssociative (a *N b) b (succ a)))
-                (transitivity (addingPreservesEqualityRight (succ a) (equalityCommutative (aSucBRight a b)))
-                  (transitivity (addingPreservesEqualityRight (succ a) (multiplicationNIsCommutative (succ a) b))
-                    (transitivity (additionNIsCommutative (b *N (succ a)) (succ a))
-                      refl
-                  )))))))))
-
-  productDistributes' : (a b c : ℕ) → (a +N b) *N c ≡ a *N c +N b *N c
-  productDistributes' a b c rewrite multiplicationNIsCommutative (a +N b) c | productDistributes c a b | multiplicationNIsCommutative c a | multiplicationNIsCommutative c b = refl
-
-  flipProductsWithinSum : (a b c : ℕ) → (c *N a +N c *N b ≡ a *N c +N b *N c)
-  flipProductsWithinSum a b c = transitivity (addingPreservesEqualityRight (c *N b) (multiplicationNIsCommutative c a)) ((addingPreservesEqualityLeft (a *N c) (multiplicationNIsCommutative c b)))
-
-  productDistributesRight : (a b c : ℕ) → (a +N b) *N c ≡ a *N c +N b *N c
-  productDistributesRight a b c = transitivity (multiplicationNIsCommutative (a +N b) c) (transitivity (productDistributes c a b) (flipProductsWithinSum a b c))
-
-  multiplicationNIsAssociative : (a b c : ℕ) → (a *N (b *N c)) ≡ ((a *N b) *N c)
-  multiplicationNIsAssociative zero b c = refl
-  multiplicationNIsAssociative (succ a) b c =
-      transitivity refl
-        (transitivity refl
-          (transitivity (applyEquality ((λ x → b *N c +N x)) (multiplicationNIsAssociative a b c)) (transitivity (equalityCommutative (productDistributesRight b (a *N b) c)) refl)))
+  ℕ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
 
   canAddZeroOnLeft : {a b : ℕ} → (a <N b) → (a +N zero) <N b
   canAddZeroOnLeft {a} {b} prAB = identityOfIndiscernablesLeft a b (a +N zero) (λ x y -> x <N y) prAB (equalityCommutative (addZeroRight a))
diff --git a/Numbers/Naturals/Order.agda b/Numbers/Naturals/Order.agda
new file mode 100644
index 0000000..152c60a
--- /dev/null
+++ b/Numbers/Naturals/Order.agda
@@ -0,0 +1,73 @@
+{-# OPTIONS --warning=error --safe --without-K #-}
+
+open import LogicalFormulae
+open import Numbers.Naturals.Definition
+open import Numbers.Naturals.Addition
+
+module Numbers.Naturals.Order where
+
+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
+  constructor le
+  field
+    x : ℕ
+    proof : (succ x) +N a ≡ b
+
+infix 5 _≤N_
+_≤N_ : ℕ → ℕ → Set
+a ≤N b = (a <N b) || (a ≡ b)
+
+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
+
+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)
+
+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)
+
+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))
+
+lessIrreflexive : {a : ℕ} → (a <N a) → False
+lessIrreflexive {zero} pr = leImpliesLogical<N pr
+lessIrreflexive {succ a} pr = lessIrreflexive {a} (logical<NImpliesLe {a} {a} (leImpliesLogical<N {succ a} {succ a} pr))
+
+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} prAB = logical<NImpliesLe (leImpliesLogical<N prAB)
diff --git a/Numbers/NaturalsWithK.agda b/Numbers/Naturals/WithK.agda
similarity index 88%
rename from Numbers/NaturalsWithK.agda
rename to Numbers/Naturals/WithK.agda
index a0ebd22..c22e8fa 100644
--- a/Numbers/NaturalsWithK.agda
+++ b/Numbers/Naturals/WithK.agda
@@ -5,9 +5,9 @@ open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
 open import WellFoundedInduction
 open import Functions
 open import Orders
-open import Numbers.Naturals
+open import Numbers.Naturals.Naturals
 
-module Numbers.NaturalsWithK where
+module Numbers.Naturals.WithK where
 
 <NRefl : {a b : ℕ} → (p1 p2 : a <N b) → (p1 ≡ p2)
 <NRefl {a} {.(succ (p1 +N a))} (le p1 refl) (le p2 proof2) = help p1=p2 proof2
diff --git a/Numbers/Rationals.agda b/Numbers/Rationals.agda
index c865e32..ed3c06b 100644
--- a/Numbers/Rationals.agda
+++ b/Numbers/Rationals.agda
@@ -1,10 +1,10 @@
 {-# OPTIONS --safe --warning=error #-}
 
 open import LogicalFormulae
-open import Numbers.Naturals
+open import Numbers.Naturals.Naturals
 open import Numbers.Integers
 open import Groups.Groups
-open import Groups.GroupDefinition
+open import Groups.Definition
 open import Rings.Definition
 open import Fields.Fields
 open import PrimeNumbers
diff --git a/Numbers/RationalsLemmas.agda b/Numbers/RationalsLemmas.agda
index c5f0b55..5380c13 100644
--- a/Numbers/RationalsLemmas.agda
+++ b/Numbers/RationalsLemmas.agda
@@ -1,12 +1,12 @@
 {-# OPTIONS --safe --warning=error #-}
 
 open import LogicalFormulae
-open import Numbers.Naturals
+open import Numbers.Naturals.Naturals
 open import Numbers.Integers
 open import Numbers.Rationals
 open import Groups.Groups
-open import Groups.GroupsLemmas
-open import Groups.GroupDefinition
+open import Groups.Lemmas
+open import Groups.Definition
 open import Rings.Definition
 open import Fields.Fields
 open import PrimeNumbers
diff --git a/Orders.agda b/Orders.agda
index 1c66348..ad2cec9 100644
--- a/Orders.agda
+++ b/Orders.agda
@@ -33,6 +33,9 @@ module Orders where
     max a b | inl (inr b<a) = a
     max a b | inr a=b = b
 
+    irreflexive = PartialOrder.irreflexive order
+    transitive = PartialOrder.transitive order
+
   equivMin : {a b : _} {A : Set a} → (order : TotalOrder {a} {b} A) → {x y : A} → (TotalOrder._<_ order x y) → TotalOrder.min order x y ≡ x
   equivMin order {x} {y} x<y with TotalOrder.totality order x y
   equivMin order {x} {y} x<y | inl (inl x₁) = refl
diff --git a/PrimeNumbers.agda b/PrimeNumbers.agda
index 9d49fd5..cdb2195 100644
--- a/PrimeNumbers.agda
+++ b/PrimeNumbers.agda
@@ -1,8 +1,11 @@
 {-# OPTIONS --warning=error --safe #-}
 
 open import LogicalFormulae
-open import Numbers.Naturals
-open import Numbers.NaturalsWithK
+open import Numbers.Naturals.Naturals
+open import Numbers.Naturals.Addition -- TODO - remove this dependency
+open import Numbers.Naturals.Multiplication -- TODO - remove this dependency
+open import Numbers.Naturals.Order -- TODO - remove this dependency
+open import Numbers.Naturals.WithK
 open import WellFoundedInduction
 open import KeyValue
 open import KeyValueWithDomain
@@ -10,6 +13,7 @@ open import Orders
 open import Vectors
 open import Maybe
 open import WithK
+open import Semirings.Definition
 
 module PrimeNumbers where
 
@@ -22,15 +26,15 @@ module PrimeNumbers where
         quotSmall : (0 <N a) || ((0 ≡ a) && (quot ≡ 0))
 
     divAlgLessLemma : (a b : ℕ) → (0 <N a) → (r : divisionAlgResult a b) → (divisionAlgResult.quot r ≡ 0) || (divisionAlgResult.rem r <N b)
-    divAlgLessLemma zero b pr _ = exFalso (lessIrreflexive pr)
+    divAlgLessLemma zero b pr _ = exFalso (TotalOrder.irreflexive ℕTotalOrder pr)
     divAlgLessLemma (succ a) b _ record { quot = zero ; rem = a%b ; pr = pr ; remIsSmall = remIsSmall } = inl refl
     divAlgLessLemma (succ a) b _ record { quot = (succ a/b) ; rem = a%b ; pr = pr ; remIsSmall = remIsSmall } = inr record { x = a/b +N a *N succ (a/b) ; proof = pr }
 
     modUniqueLemma : {rem1 rem2 a : ℕ} → (quot1 quot2 : ℕ) → rem1 <N a → rem2 <N a → a *N quot1 +N rem1 ≡ a *N quot2 +N rem2 → rem1 ≡ rem2
-    modUniqueLemma {rem1} {rem2} {a} zero zero rem1<a rem2<a pr rewrite productZeroIsZeroRight a = pr
-    modUniqueLemma {rem1} {rem2} {a} zero (succ quot2) rem1<a rem2<a pr rewrite productZeroIsZeroRight a | pr | multiplicationNIsCommutative a (succ quot2) | additionNIsAssociative a (quot2 *N a) rem2 = exFalso (cannotAddAndEnlarge' {a} {quot2 *N a +N rem2} rem1<a)
-    modUniqueLemma {rem1} {rem2} {a} (succ quot1) zero rem1<a rem2<a pr rewrite productZeroIsZeroRight a | equalityCommutative pr | multiplicationNIsCommutative a (succ quot1) | additionNIsAssociative a (quot1 *N a) rem1 = exFalso (cannotAddAndEnlarge' {a} {quot1 *N a +N rem1} rem2<a)
-    modUniqueLemma {rem1} {rem2} {a} (succ quot1) (succ quot2) rem1<a rem2<a pr rewrite multiplicationNIsCommutative a (succ quot1) | multiplicationNIsCommutative a (succ quot2) | additionNIsAssociative a (quot1 *N a) rem1 | additionNIsAssociative a (quot2 *N a) rem2 = modUniqueLemma {rem1} {rem2} {a} quot1 quot2 rem1<a rem2<a (go {a}{quot1}{rem1}{quot2}{rem2} pr)
+    modUniqueLemma {rem1} {rem2} {a} zero zero rem1<a rem2<a pr rewrite Semiring.productZeroRight ℕSemiring a = pr
+    modUniqueLemma {rem1} {rem2} {a} zero (succ quot2) rem1<a rem2<a pr rewrite Semiring.productZeroRight ℕSemiring a | pr | multiplicationNIsCommutative a (succ quot2) | equalityCommutative (Semiring.+Associative ℕSemiring a (quot2 *N a) rem2) = exFalso (cannotAddAndEnlarge' {a} {quot2 *N a +N rem2} rem1<a)
+    modUniqueLemma {rem1} {rem2} {a} (succ quot1) zero rem1<a rem2<a pr rewrite Semiring.productZeroRight ℕSemiring a | equalityCommutative pr | multiplicationNIsCommutative a (succ quot1) | equalityCommutative (Semiring.+Associative ℕSemiring a (quot1 *N a) rem1) = exFalso (cannotAddAndEnlarge' {a} {quot1 *N a +N rem1} rem2<a)
+    modUniqueLemma {rem1} {rem2} {a} (succ quot1) (succ quot2) rem1<a rem2<a pr rewrite multiplicationNIsCommutative a (succ quot1) | multiplicationNIsCommutative a (succ quot2) | equalityCommutative (Semiring.+Associative ℕSemiring a (quot1 *N a) rem1) | equalityCommutative (Semiring.+Associative ℕSemiring a (quot2 *N a) rem2) = modUniqueLemma {rem1} {rem2} {a} quot1 quot2 rem1<a rem2<a (go {a}{quot1}{rem1}{quot2}{rem2} pr)
       where
         go : {a quot1 rem1 quot2 rem2 : ℕ} → (a +N (quot1 *N a +N rem1) ≡ a +N (quot2 *N a +N rem2)) → a *N quot1 +N rem1 ≡ a *N quot2 +N rem2
         go {a} {quot1} {rem1} {quot2} {rem2} pr rewrite multiplicationNIsCommutative quot1 a | multiplicationNIsCommutative quot2 a = canSubtractFromEqualityLeft {a} pr
@@ -42,16 +46,16 @@ module PrimeNumbers where
     modIsUnique {succ a} {b} record { quot = quot1 ; rem = rem1 ; pr = pr1 ; remIsSmall = remIsSmall1 } record { quot = quot ; rem = rem ; pr = pr ; remIsSmall = (inr ()) }
 
     transferAddition : (a b c : ℕ) → (a +N b) +N c ≡ (a +N c) +N b
-    transferAddition a b c rewrite (additionNIsAssociative a b c) = p a b c
+    transferAddition a b c rewrite equalityCommutative (Semiring.+Associative ℕSemiring a b c) = p a b c
       where
         p : (a b c : ℕ) → a +N (b +N c) ≡ (a +N c) +N b
-        p a b c rewrite (additionNIsCommutative b c) = equalityCommutative (additionNIsAssociative a c b)
+        p a b c = transitivity (applyEquality (a +N_) (Semiring.commutative ℕSemiring b c)) (Semiring.+Associative ℕSemiring a c b)
 
     divisionAlgLemma : (x b : ℕ) → x *N zero +N b ≡ b
-    divisionAlgLemma x b rewrite (productZeroIsZeroRight x) = refl
+    divisionAlgLemma x b rewrite (Semiring.productZeroRight ℕSemiring x) = refl
 
     divisionAlgLemma2 : (x b : ℕ) → (x ≡ b) → x *N succ zero +N zero ≡ b
-    divisionAlgLemma2 x b pr rewrite (productWithOneRight x) = equalityCommutative (transitivity (equalityCommutative pr) (equalityCommutative (addZeroRight x)))
+    divisionAlgLemma2 x b pr rewrite (Semiring.productOneRight ℕSemiring x) = equalityCommutative (transitivity (equalityCommutative pr) (equalityCommutative (Semiring.sumZeroRight ℕSemiring x)))
 
     divisionAlgLemma3 : {a x : ℕ} → (p : succ a <N succ x) → (subtractionNResult.result (-N (inl p))) <N (succ x)
     divisionAlgLemma3 {a} {x} p = -NIsDecreasing {a} {succ x} p
@@ -225,7 +229,7 @@ module PrimeNumbers where
 
     numberLessThanOrder : (n : ℕ) → TotalOrder (numberLessThan n)
     PartialOrder._<_ (TotalOrder.order (numberLessThanOrder n)) = λ a b → (numberLessThan.a a) <N numberLessThan.a b
-    PartialOrder.irreflexive (TotalOrder.order (numberLessThanOrder n)) pr = lessIrreflexive pr
+    PartialOrder.irreflexive (TotalOrder.order (numberLessThanOrder n)) pr = TotalOrder.irreflexive ℕTotalOrder pr
     PartialOrder.transitive (TotalOrder.order (numberLessThanOrder n)) pr1 pr2 = orderIsTransitive pr1 pr2
     TotalOrder.totality (numberLessThanOrder n) a b with TotalOrder.totality ℕTotalOrder (numberLessThan.a a) (numberLessThan.a b)
     TotalOrder.totality (numberLessThanOrder n) a b | inl (inl x) = inl (inl x)
diff --git a/Rings/Definition.agda b/Rings/Definition.agda
index 50efc64..0365df5 100644
--- a/Rings/Definition.agda
+++ b/Rings/Definition.agda
@@ -2,8 +2,8 @@
 
 open import LogicalFormulae
 open import Groups.Groups
-open import Groups.GroupDefinition
-open import Numbers.Naturals
+open import Groups.Definition
+open import Numbers.Naturals.Naturals
 open import Setoids.Orders
 open import Setoids.Setoids
 open import Functions
diff --git a/Rings/Examples/Examples.agda b/Rings/Examples/Examples.agda
index 8e4395d..93966c1 100644
--- a/Rings/Examples/Examples.agda
+++ b/Rings/Examples/Examples.agda
@@ -3,7 +3,7 @@
 open import LogicalFormulae
 open import Groups.Groups
 open import Functions
-open import Numbers.Naturals
+open import Numbers.Naturals.Naturals
 open import Numbers.Integers
 open import IntegersModN
 open import Rings.Examples.Proofs
diff --git a/Rings/Examples/Proofs.agda b/Rings/Examples/Proofs.agda
index e07e46a..b50ab59 100644
--- a/Rings/Examples/Proofs.agda
+++ b/Rings/Examples/Proofs.agda
@@ -3,10 +3,10 @@
 open import LogicalFormulae
 open import Functions
 open import Groups.Groups
-open import Groups.GroupDefinition
+open import Groups.Definition
 open import Orders
 open import Rings.Definition
-open import Numbers.Naturals
+open import Numbers.Naturals.Naturals
 open import Numbers.Integers
 open import PrimeNumbers
 open import IntegersModN
diff --git a/Rings/IntegralDomains.agda b/Rings/IntegralDomains.agda
index 87e89e8..79e2b37 100644
--- a/Rings/IntegralDomains.agda
+++ b/Rings/IntegralDomains.agda
@@ -2,8 +2,8 @@
 
 open import LogicalFormulae
 open import Groups.Groups
-open import Groups.GroupDefinition
-open import Numbers.Naturals
+open import Groups.Definition
+open import Numbers.Naturals.Naturals
 open import Orders
 open import Setoids.Setoids
 open import Functions
diff --git a/Rings/Lemmas.agda b/Rings/Lemmas.agda
index 81f0cba..9d90a65 100644
--- a/Rings/Lemmas.agda
+++ b/Rings/Lemmas.agda
@@ -3,8 +3,8 @@
 open import LogicalFormulae
 open import Functions
 open import Groups.Groups
-open import Groups.GroupDefinition
-open import Groups.GroupsLemmas
+open import Groups.Definition
+open import Groups.Lemmas
 open import Rings.Definition
 open import Setoids.Setoids
 open import Setoids.Orders
diff --git a/Semirings/Definition.agda b/Semirings/Definition.agda
new file mode 100644
index 0000000..6e5d0b2
--- /dev/null
+++ b/Semirings/Definition.agda
@@ -0,0 +1,23 @@
+{-# OPTIONS --safe --warning=error --without-K #-}
+
+open import LogicalFormulae
+open import Functions
+open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
+open import Monoids.Definition
+
+module Semirings.Definition where
+
+record Semiring {a : _} {A : Set a} (Zero One : A) (_+_ : A → A → A) (_*_ : A → A → A) : Set a where
+  field
+    monoid : Monoid Zero _+_
+    commutative : (a b : A) → a + b ≡ b + a
+    multMonoid : Monoid One _*_
+    productZeroLeft : (a : A) → Zero * a ≡ Zero
+    productZeroRight : (a : A) → a * Zero ≡ Zero
+    +DistributesOver* : (a b c : A) → a * (b + c) ≡ (a * b) + (a * c)
+  +Associative = Monoid.associative monoid
+  *Associative = Monoid.associative multMonoid
+  productOneLeft = Monoid.idLeft multMonoid
+  productOneRight = Monoid.idRight multMonoid
+  sumZeroLeft = Monoid.idLeft monoid
+  sumZeroRight = Monoid.idRight monoid
diff --git a/Setoids/Lists.agda b/Setoids/Lists.agda
index 829b642..cd7c68b 100644
--- a/Setoids/Lists.agda
+++ b/Setoids/Lists.agda
@@ -1,7 +1,7 @@
 {-# OPTIONS --safe --warning=error --without-K #-}
 
 open import LogicalFormulae
-open import Numbers.Naturals
+open import Numbers.Naturals.Naturals
 open import Lists.Lists
 open import Setoids.Setoids
 open import Functions
diff --git a/Sets/Cardinality.agda b/Sets/Cardinality.agda
index 159b2d0..24eb169 100644
--- a/Sets/Cardinality.agda
+++ b/Sets/Cardinality.agda
@@ -4,8 +4,9 @@ open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
 
 open import LogicalFormulae
 open import Functions
-open import Numbers.Naturals
+open import Numbers.Naturals.Naturals
 open import Sets.FinSet
+open import Semirings.Definition
 
 module Sets.Cardinality where
   record CountablyInfiniteSet {a : _} (A : Set a) : Set a where
@@ -25,13 +26,13 @@ module Sets.Cardinality where
 
   evenCannotBeOdd : (a b : ℕ) → 2 *N a ≡ succ (2 *N b) → False
   evenCannotBeOdd zero b ()
-  evenCannotBeOdd (succ a) zero pr rewrite additionNIsCommutative a 0 | additionNIsCommutative a (succ a) = naughtE (equalityCommutative (succInjective pr))
+  evenCannotBeOdd (succ a) zero pr rewrite Semiring.commutative ℕSemiring a 0 | Semiring.commutative ℕSemiring a (succ a) = naughtE (equalityCommutative (succInjective pr))
   evenCannotBeOdd (succ a) (succ b) pr = evenCannotBeOdd a b pr''
     where
       pr' : a +N a ≡ (b +N succ b)
-      pr' rewrite additionNIsCommutative a 0 | additionNIsCommutative b 0 | additionNIsCommutative a (succ a) = succInjective (succInjective pr)
+      pr' rewrite Semiring.commutative ℕSemiring a 0 | Semiring.commutative ℕSemiring b 0 | Semiring.commutative ℕSemiring a (succ a) = succInjective (succInjective pr)
       pr'' : 2 *N a ≡ succ (2 *N b)
-      pr'' rewrite additionNIsCommutative a 0 | additionNIsCommutative b 0 | additionNIsCommutative (succ b) b = pr'
+      pr'' rewrite Semiring.commutative ℕSemiring a 0 | Semiring.commutative ℕSemiring b 0 | Semiring.commutative ℕSemiring (succ b) b = pr'
 
   aMod2 : (a : ℕ) → Sg ℕ (λ i → (2 *N i ≡ a) || (succ (2 *N i) ≡ a))
   aMod2 zero = (0 , inl refl)
@@ -40,7 +41,7 @@ module Sets.Cardinality where
   aMod2 (succ a) | b , inr x = (succ b) , inl pr
     where
       pr : succ (b +N succ (b +N 0)) ≡ succ a
-      pr rewrite additionNIsCommutative b (succ (b +N 0)) | additionNIsCommutative (b +N 0) b = applyEquality succ x
+      pr rewrite Semiring.commutative ℕSemiring b (succ (b +N 0)) | Semiring.commutative ℕSemiring (b +N 0) b = applyEquality succ x
 
   sqrtFloor : (a : ℕ) → Sg (ℕ && ℕ) (λ pair → ((_&&_.fst pair) *N (_&&_.fst pair) +N (_&&_.snd pair) ≡ a) && ((_&&_.snd pair) <N 2 *N (_&&_.fst pair) +N 1))
   sqrtFloor zero = (0 ,, 0) , (refl ,, le zero refl)
@@ -49,16 +50,16 @@ module Sets.Cardinality where
   sqrtFloor (succ n) | (a ,, b) , pr | inl (inl x) = (a ,, succ b) , (p ,, q)
     where
       p : a *N a +N succ b ≡ succ n
-      p rewrite additionNIsCommutative (a *N a) (succ b) | additionNIsCommutative b (a *N a) = applyEquality succ (_&&_.fst pr)
+      p rewrite Semiring.commutative ℕSemiring (a *N a) (succ b) | Semiring.commutative ℕSemiring b (a *N a) = applyEquality succ (_&&_.fst pr)
       q : succ b <N (a +N (a +N 0)) +N 1
-      q rewrite additionNIsCommutative (a +N (a +N 0)) (succ 0) | additionNIsCommutative a 0 = succPreservesInequality x
-  sqrtFloor (succ n) | (a ,, b) , (_ ,, pr) | inl (inr x) rewrite additionNIsCommutative (a +N (a +N 0)) (succ 0) = exFalso (noIntegersBetweenXAndSuccX (a +N (a +N 0)) x pr)
+      q rewrite Semiring.commutative ℕSemiring (a +N (a +N 0)) (succ 0) | Semiring.commutative ℕSemiring a 0 = succPreservesInequality x
+  sqrtFloor (succ n) | (a ,, b) , (_ ,, pr) | inl (inr x) rewrite Semiring.commutative ℕSemiring (a +N (a +N 0)) (succ 0) = exFalso (noIntegersBetweenXAndSuccX (a +N (a +N 0)) x pr)
   sqrtFloor (succ n) | (a ,, b) , pr | inr x = (succ a ,, 0) , (q ,, succIsPositive _)
     where
       p : a +N a *N succ a ≡ n
-      p rewrite x | additionNIsCommutative a 0 | additionNIsCommutative (a +N a) (succ 0) | additionNIsCommutative (a *N a) (succ a +N a) | multiplicationNIsCommutative a (succ a) | additionNIsCommutative (a *N a) (a +N a) | additionNIsAssociative a a (a *N a) = _&&_.fst pr
+      p rewrite x | Semiring.commutative ℕSemiring a 0 | Semiring.commutative ℕSemiring (a +N a) (succ 0) | Semiring.commutative ℕSemiring (a *N a) (succ a +N a) | multiplicationNIsCommutative a (succ a) | Semiring.commutative ℕSemiring (a *N a) (a +N a) | Semiring.+Associative ℕSemiring a a (a *N a) = _&&_.fst pr
       q : succ ((a +N a *N succ a) +N 0) ≡ succ n
-      q rewrite additionNIsCommutative (a +N a *N succ a) 0 = applyEquality succ p
+      q rewrite Semiring.commutative ℕSemiring (a +N a *N succ a) 0 = applyEquality succ p
 
 {-
   triangle : (a : ℕ) → ℕ
@@ -69,11 +70,11 @@ module Sets.Cardinality where
   cantorPairing' a b zero pr = 0
   cantorPairing' zero zero (succ s) ()
   cantorPairing' zero (succ b) (succ s) pr = succ (cantorPairing' 1 b (succ s) pr)
-  cantorPairing' (succ a) zero (succ s) pr = succ (cantorPairing' 0 a s (succInjective (identityOfIndiscernablesRight _ _ _ _≡_ pr (applyEquality (λ i → succ i) (identityOfIndiscernablesLeft _ _ _ _≡_ (additionNIsCommutative a 0) refl)))))
+  cantorPairing' (succ a) zero (succ s) pr = succ (cantorPairing' 0 a s (succInjective (identityOfIndiscernablesRight _ _ _ _≡_ pr (applyEquality (λ i → succ i) (identityOfIndiscernablesLeft _ _ _ _≡_ (Semiring.commutative ℕSemiring a 0) refl)))))
   cantorPairing' (succ a) (succ b) (succ zero) pr = naughtE f
     where
       f : 0 ≡ succ b +N a
-      f rewrite additionNIsCommutative (succ b) a = succInjective pr
+      f rewrite Semiring.commutative ℕSemiring (succ b) a = succInjective pr
   cantorPairing' (succ a) (succ b) (succ (succ s)) pr = succ (cantorPairing' (succ (succ a)) b (succ (succ s)) (identityOfIndiscernablesRight _ _ _ _≡_ pr (applyEquality succ (succExtracts a b))))
 
   cantorPairing'Zero : (x y s : ℕ) → (pr : s ≡ x +N y) → cantorPairing' x y s pr ≡ 0 → (x ≡ 0) && (y ≡ 0)
@@ -81,7 +82,7 @@ module Sets.Cardinality where
   cantorPairing'Zero zero zero (succ s) () pr'
   cantorPairing'Zero zero (succ y) (succ s) pr ()
   cantorPairing'Zero (succ x) zero (succ s) pr ()
-  cantorPairing'Zero (succ x) (succ y) (succ zero) pr pr' = naughtE (identityOfIndiscernablesRight _ _ _ _≡_ (succInjective pr) (additionNIsCommutative x (succ y)))
+  cantorPairing'Zero (succ x) (succ y) (succ zero) pr pr' = naughtE (identityOfIndiscernablesRight _ _ _ _≡_ (succInjective pr) (Semiring.commutative ℕSemiring x (succ y)))
   cantorPairing'Zero (succ x) (succ y) (succ (succ s)) pr ()
 
   cantorPairingInj' : (s1 s2 : ℕ) → (x1 x2 y1 y2 : ℕ) → (pr1 : s1 ≡ x1 +N y1) → (pr2 : s2 ≡ x2 +N y2) → (cantorPairing' x1 y1 s1 pr1) ≡ (cantorPairing' x2 y2 s2 pr2) → (x1 ≡ x2) && (y1 ≡ y2)
@@ -130,7 +131,7 @@ module Sets.Cardinality where
       rec = succInjective injF
       rec' : (1 ≡ zero)
       rec' = _&&_.fst (cantorPairingInj' (succ s1) s2 1 zero s1 x2 refl _ rec)
-  cantorPairingInj' (succ s1) (succ zero) zero (succ x2) (succ .s1) (succ y2) refl pr2 injF = naughtE (identityOfIndiscernablesRight _ _ _ _≡_ (succInjective pr2) (additionNIsCommutative x2 (succ y2)))
+  cantorPairingInj' (succ s1) (succ zero) zero (succ x2) (succ .s1) (succ y2) refl pr2 injF = naughtE (identityOfIndiscernablesRight _ _ _ _≡_ (succInjective pr2) (Semiring.commutative ℕSemiring x2 (succ y2)))
   cantorPairingInj' (succ s1) (succ (succ s2)) zero (succ x2) (succ .s1) (succ y2) refl pr2 injF = naughtE (succInjective rec')
     where
       rec : cantorPairing' 1 s1 (succ s1) refl ≡ cantorPairing' (succ (succ x2)) y2 (succ (succ s2)) _
@@ -178,7 +179,7 @@ module Sets.Cardinality where
   pairUnionIsCountable : {a b : _} {A : Set a} {B : Set b} → (X : CountablyInfiniteSet A) → (Y : CountablyInfiniteSet B) → CountablyInfiniteSet (A || B)
   CountablyInfiniteSet.counting (pairUnionIsCountable X Y) (inl r) = 2 *N (CountablyInfiniteSet.counting X r)
   CountablyInfiniteSet.counting (pairUnionIsCountable X Y) (inr s) = succ (2 *N (CountablyInfiniteSet.counting Y s))
-  Injection.property (Bijection.inj (CountablyInfiniteSet.countingIsBij (pairUnionIsCountable X Y))) {inl x} {inl y} pr rewrite additionNIsCommutative (CountablyInfiniteSet.counting X x) 0 | additionNIsCommutative (CountablyInfiniteSet.counting X y) 0 | doubleIsAddTwo (CountablyInfiniteSet.counting X x) | doubleIsAddTwo (CountablyInfiniteSet.counting X y) = applyEquality inl (Injection.property (Bijection.inj (CountablyInfiniteSet.countingIsBij X)) inter)
+  Injection.property (Bijection.inj (CountablyInfiniteSet.countingIsBij (pairUnionIsCountable X Y))) {inl x} {inl y} pr rewrite Semiring.commutative ℕSemiring (CountablyInfiniteSet.counting X x) 0 | Semiring.commutative ℕSemiring (CountablyInfiniteSet.counting X y) 0 | doubleIsAddTwo (CountablyInfiniteSet.counting X x) | doubleIsAddTwo (CountablyInfiniteSet.counting X y) = applyEquality inl (Injection.property (Bijection.inj (CountablyInfiniteSet.countingIsBij X)) inter)
     where
       inter : CountablyInfiniteSet.counting X x ≡ CountablyInfiniteSet.counting X y
       inter = doubleLemma (CountablyInfiniteSet.counting X x) (CountablyInfiniteSet.counting X y) pr
diff --git a/Sets/FinSet.agda b/Sets/FinSet.agda
index 0948521..6b5d7b2 100644
--- a/Sets/FinSet.agda
+++ b/Sets/FinSet.agda
@@ -3,7 +3,9 @@
 open import Functions
 open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
 open import LogicalFormulae
-open import Numbers.Naturals
+open import Numbers.Naturals.Naturals
+open import Numbers.Naturals.Definition
+open import Numbers.Naturals.Order
 open import Orders
 
 module Sets.FinSet where
diff --git a/Sets/FinSetWithK.agda b/Sets/FinSetWithK.agda
index 7afa896..5ede2e4 100644
--- a/Sets/FinSetWithK.agda
+++ b/Sets/FinSetWithK.agda
@@ -1,9 +1,10 @@
 {-# OPTIONS --safe --warning=error #-}
 
-open import Numbers.Naturals
+open import Numbers.Naturals.Naturals
+open import Numbers.Naturals.Order
 open import Sets.FinSet
 open import LogicalFormulae
-open import Numbers.NaturalsWithK
+open import Numbers.Naturals.WithK
 
 module Sets.FinSetWithK where
 
diff --git a/Vectors.agda b/Vectors.agda
index bff90bd..552eaf7 100644
--- a/Vectors.agda
+++ b/Vectors.agda
@@ -1,9 +1,11 @@
 {-# OPTIONS --warning=error --safe #-}
 
 open import LogicalFormulae
-open import Numbers.Naturals
-open import Numbers.NaturalsWithK
+open import Numbers.Naturals.Naturals
+open import Numbers.Naturals.Order
+open import Numbers.Naturals.WithK
 open import Functions
+open import Semirings.Definition
 
 data Vec {a : _} (X : Set a) : ℕ -> Set a where
   [] : Vec X zero
@@ -67,7 +69,7 @@ vecSolelyContains {m} n record { index = zero ; index<m = _ ; isHere = isHere }
 vecSolelyContains {m} n record { index = (succ index) ; index<m = (le x proof) ; isHere = isHere } = exFalso (f {x} {index} proof)
   where
     f : {x index : ℕ} → succ (x +N succ index) ≡ 1 → False
-    f {x} {index} pr rewrite additionNIsCommutative x (succ index) = naughtE (equalityCommutative (succInjective pr))
+    f {x} {index} pr rewrite Semiring.commutative ℕSemiring x (succ index) = naughtE (equalityCommutative (succInjective pr))
 
 vecChop : {a : _} {X : Set a} (m : ℕ) {n : ℕ} → Vec X (m +N n) → Vec X m && Vec X n
 _&&_.fst (vecChop zero xs) = []