Move things around, add more to fields (#16)

Fields/FieldOfFractions.agda

@@ -1,16 +1,19 @@
 {-# OPTIONS --safe --warning=error #-}
 
 open import LogicalFormulae
-open import Groups
-open import Rings
-open import IntegralDomains
-open import Fields
+open import Groups.Groups
+open import Groups.GroupsLemmas
+open import Rings.RingDefinition
+open import Rings.RingLemmas
+open import Rings.IntegralDomains
+open import Fields.Fields
 open import Functions
-open import Setoids
+open import Setoids.Setoids
+open import Setoids.Orders
 
 open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
 
-module FieldOfFractions where
+module Fields.FieldOfFractions where
   fieldOfFractionsSet : {a b : _} {A : Set a} {S : Setoid {a} {b} A} {_+_ : A → A → A} {_*_ : A → A → A} → {R : Ring S _+_ _*_} → IntegralDomain R → Set (a ⊔ b)
   fieldOfFractionsSet {A = A} {S = S} {R = R} I = (A && (Sg A (λ a → (Setoid._∼_ S a (Ring.0R R) → False))))
 
@@ -226,3 +229,39 @@ module FieldOfFractions where
       open Reflexive (Equivalence.reflexiveEq (Setoid.eq S))
       open Transitive (Equivalence.transitiveEq (Setoid.eq S))
       open Symmetric (Equivalence.symmetricEq (Setoid.eq S))
+
+  fieldOfFractionsNonnegDenom : {a b c : _} {A : Set a} {S : Setoid {a} {b} A} {_+_ : A → A → A} {_*_ : A → A → A} {R : Ring S _+_ _*_} {_<_ : Rel {_} {c} A} {pOrder : SetoidPartialOrder S _<_} {tOrder : SetoidTotalOrder pOrder} (I : IntegralDomain R) → (order : OrderedRing R tOrder) → (a1 : fieldOfFractionsSet I) → Sg (fieldOfFractionsSet I) (λ b1 → (Setoid._∼_ (fieldOfFractionsSetoid I) a1 b1) && ((Ring.0R R) < underlying (_&&_.snd b1)))
+  fieldOfFractionsNonnegDenom {R = R} {tOrder = tOrder} I order (num ,, (denom , denom!=0)) with SetoidTotalOrder.totality tOrder (Ring.0R R) denom
+  fieldOfFractionsNonnegDenom {R = R} {tOrder = tOrder} I order (num ,, (denom , denom!=0)) | inl (inl 0<denom) = (num ,, (denom , denom!=0)) , ((Ring.multCommutative R) ,, 0<denom)
+  fieldOfFractionsNonnegDenom {S = S} {R = R} {_<_ = _<_} {pOrder = pOrder} {tOrder = tOrder} I order (num ,, (denom , denom!=0)) | inl (inr denom<0) = ((Group.inverse (Ring.additiveGroup R) num ,, (Group.inverse (Ring.additiveGroup R) denom , λ p → denom!=0 (Symmetric.symmetric (Equivalence.symmetricEq (Setoid.eq S)) (transitive (symmetric (Group.invLeft (Ring.additiveGroup R) {denom})) (transitive (Group.wellDefined (Ring.additiveGroup R) p reflexive) (Group.multIdentLeft (Ring.additiveGroup R)))))))) , (transitive (ringMinusExtracts R) (transitive (inverseWellDefined (Ring.additiveGroup R) (Ring.multCommutative R)) (symmetric (ringMinusExtracts R))) ,, ringMinusFlipsOrder' order (SetoidPartialOrder.wellDefined pOrder (symmetric (invInv (Ring.additiveGroup R))) reflexive denom<0))
+    where
+      open Transitive (Equivalence.transitiveEq (Setoid.eq S))
+      open Symmetric (Equivalence.symmetricEq (Setoid.eq S))
+      open Reflexive (Equivalence.reflexiveEq (Setoid.eq S))
+      open Ring R
+      open Group additiveGroup
+  fieldOfFractionsNonnegDenom {S = S} {R = R} {tOrder = tOrder} I order (num ,, (denom , denom!=0)) | inr 0=denom = exFalso (denom!=0 (Symmetric.symmetric (Equivalence.symmetricEq (Setoid.eq S)) 0=denom))
+
+  fieldOfFractionsComparison : {a b c : _} {A : Set a} {S : Setoid {a} {b} A} {_+_ : A → A → A} {_*_ : A → A → A} {R : Ring S _+_ _*_} {_<_ : Rel {_} {c} A} {pOrder : SetoidPartialOrder S _<_} {tOrder : SetoidTotalOrder pOrder} (I : IntegralDomain R) → (order : OrderedRing R tOrder) → Rel (fieldOfFractionsSet I)
+  fieldOfFractionsComparison {_*_ = _*_} {R = R} {_<_ = _<_} {tOrder = tOrder} I oring x y with fieldOfFractionsNonnegDenom I oring x
+  fieldOfFractionsComparison {_*_ = _*_} {R} {_<_} {tOrder = tOrder} I oring x y | (numA ,, (denomA , _)) , b with fieldOfFractionsNonnegDenom I oring y
+  fieldOfFractionsComparison {_*_ = _*_} {R} {_<_} {tOrder = tOrder} I oring x y | (numA ,, (denomA , _)) , prA | (numB ,, (denomB , _)) , prB = (numA * denomB) < (numB * denomA)
+
+  fieldOfFractionsOrder : {a b c : _} {A : Set a} {S : Setoid {a} {b} A} {_+_ : A → A → A} {_*_ : A → A → A} {R : Ring S _+_ _*_} {_<_ : Rel {_} {c} A} {pOrder : SetoidPartialOrder S _<_} {tOrder : SetoidTotalOrder pOrder} (I : IntegralDomain R) → (order : OrderedRing R tOrder) → SetoidPartialOrder (fieldOfFractionsSetoid I) (fieldOfFractionsComparison I order)
+  SetoidPartialOrder.wellDefined (fieldOfFractionsOrder {S = S} {_+_ = _+_} {_*_ = _*_} {_<_ = _<_} I order) {w} {x} {y} {z} a~b c~d a<c with fieldOfFractionsNonnegDenom I order x
+  SetoidPartialOrder.wellDefined (fieldOfFractionsOrder {S = S} {_+_} {_*_} {_<_ = _<_} I order) {w} {x} {y} {z} a~b c~d a<c | (numX ,, (denomX , denomX!=0)) , (x~numX/denomX ,, 0<denomX) with fieldOfFractionsNonnegDenom I order z
+  SetoidPartialOrder.wellDefined (fieldOfFractionsOrder {S = S} {_+_} {_*_} {_<_ = _<_} I order) {w} {x} {y} {z} a~b c~d a<c | (numX ,, (denomX , denomX!=0)) , (x~numX/denomX ,, 0<denomX) | (numZ ,, (denomZ , denomZ!=0)) , (numZ/denomZ ,, 0<denomZ) with fieldOfFractionsNonnegDenom I order w
+  SetoidPartialOrder.wellDefined (fieldOfFractionsOrder {S = S} {_+_} {_*_} {_<_ = _<_} I order) {w} {x} {y} {z} a~b c~d a<c | (numX ,, (denomX , denomX!=0)) , (x~numX/denomX ,, 0<denomX) | (numZ ,, (denomZ , denomZ!=0)) , (numZ/denomZ ,, 0<denomZ) | (numW ,, (denomW , denomW!=0)) , (numW/denomW ,, 0<denomW) with fieldOfFractionsNonnegDenom I order y
+  SetoidPartialOrder.wellDefined (fieldOfFractionsOrder {S = S} {_+_} {_*_} {_<_ = _<_} I order) {numW' ,, (denomW' , denomW'!=0)} {numX' ,, (denomX' , denomX'!=0)} {numY' ,, (denomY' , denomY'!=0)} {numZ' ,, (denomZ' , denomZ'!=0)} a~b c~d a<c | (numX ,, (denomX , denomX!=0)) , (x~numX/denomX ,, 0<denomX) | (numZ ,, (denomZ , denomZ!=0)) , (numZ/denomZ ,, 0<denomZ) | (numW ,, (denomW , denomW!=0)) , (numW/denomW ,, 0<denomW) | (numY ,, (denomY , denomY!=0)) , (numY/denomY ,, 0<denomY) = {!!}
+
+  SetoidPartialOrder.irreflexive (fieldOfFractionsOrder {S = S} {R = R} {pOrder = pOrder} {tOrder = tOrder} I oRing) {x} x<x with fieldOfFractionsNonnegDenom I oRing x
+  SetoidPartialOrder.irreflexive (fieldOfFractionsOrder {S = S} {_*_ = _*_} {R = R} {_<_ = _<_} {pOrder = pOrder} {tOrder} I oRing) {x} x<x | (numA ,, (denomA , _)) , pr with fieldOfFractionsNonnegDenom I oRing x
+  SetoidPartialOrder.irreflexive (fieldOfFractionsOrder {S = S} {_*_ = _*_} {R} {_<_} {pOrder} {tOrder} I oRing) {fst₁ ,, (a , a!=0)} x<x | (numA ,, (denomA , _)) , (fst₂ ,, 0<denomA) | (numA' ,, (denomA' , _)) , (fst ,, 0<denomA') = {!!}
+  SetoidPartialOrder.transitive (fieldOfFractionsOrder {S = S} {_+_ = _+_} {_*_ = _*_} {R = R} {_<_ = _<_} {pOrder = pOrder} {tOrder = tOrder} I order) {numA ,, (denomA , _)} {(numB ,, (denomB , _))} {numC ,, (denomC , _)} a<b b<c = {!!}
+
+  fieldOfFractionsTotalOrder : {a b c : _} {A : Set a} {S : Setoid {a} {b} A} {_+_ : A → A → A} {_*_ : A → A → A} {R : Ring S _+_ _*_} {_<_ : Rel {_} {c} A} {pOrder : SetoidPartialOrder S _<_} {tOrder : SetoidTotalOrder pOrder} (I : IntegralDomain R) → (order : OrderedRing R tOrder) → SetoidTotalOrder (fieldOfFractionsOrder I order)
+  fieldOfFractionsTotalOrder I order = {!!}
+
+  fieldOfFractionsOrderedRing : {a b c : _} {A : Set a} {S : Setoid {a} {b} A} {_+_ : A → A → A} {_*_ : A → A → A} {R : Ring S _+_ _*_} {_<_ : Rel {_} {c} A} {pOrder : SetoidPartialOrder S _<_} {tOrder : SetoidTotalOrder pOrder} (I : IntegralDomain R) → (order : OrderedRing R tOrder) → OrderedRing (fieldOfFractionsRing I) (fieldOfFractionsTotalOrder I order)
+  OrderedRing.orderRespectsAddition (fieldOfFractionsOrderedRing I order) a<b c = {!!}
+  OrderedRing.orderRespectsMultiplication (fieldOfFractionsOrderedRing {_+_ = _+_} {_*_ = _*_} {_<_ = _<_} I order) {numA ,, (denomA , _)} {numB ,, (denomB , _)} 0<a 0<b = {!!}

Fields/Fields.agda

@@ -1,16 +1,16 @@
 {-# OPTIONS --safe --warning=error #-}
 
 open import LogicalFormulae
-open import Groups
-open import Rings
-open import Setoids
+open import Groups.Groups
+open import Rings.RingDefinition
+open import Setoids.Setoids
 open import Orders
-open import IntegralDomains
+open import Rings.IntegralDomains
 open import Functions
 
 open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
 
-module Fields where
+module Fields.Fields where
   record Field {m n : _} {A : Set m} {S : Setoid {m} {n} A} {_+_ : A → A → A} {_*_ : A → A → A} (R : Ring S _+_ _*_) : Set (lsuc m ⊔ n) where
     open Ring R
     open Group additiveGroup

Groups/Groups.agda

@@ -1,13 +1,13 @@
 {-# 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 FinSet
+open import Numbers.Naturals
+open import Sets.FinSet
 
-module Groups where
+module Groups.Groups where
     record Group {lvl1 lvl2} {A : Set lvl1} (S : Setoid {lvl1} {lvl2} A) (_·_ : A → A → A) : Set (lsuc lvl1 ⊔ lvl2) where
       open Setoid S
       field

Groups/Groups2.agda

@@ -1,8 +1,8 @@
 {-# OPTIONS --safe --warning=error #-}
 
-open import Groups
+open import Groups.Groups
 open import Orders
-open import Integers
+open import Numbers.Integers
 open import Setoids
 open import LogicalFormulae
 open import FinSet
@@ -14,7 +14,7 @@ open import PrimeNumbers
 
 open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
 
-module Groups2 where
+module Groups.Groups2 where
 
   data GroupHomImageElement {a b c d : _} {A : Set a} {B : Set b} {S : Setoid {a} {c} A} {T : Setoid {b} {d} B} {_+A_ : A → A → A} {_+B_ : B → B → B} {G : Group S _+A_} {H : Group T _+B_} {f : A → B} (fHom : GroupHom G H f) : Set (a ⊔ b ⊔ c ⊔ d) where
     ofElt : (x : A) → GroupHomImageElement fHom

Groups/GroupsLemmas.agda

@@ -0,0 +1,25 @@
+{-# OPTIONS --safe --warning=error #-}
+
+open import LogicalFormulae
+open import Setoids.Setoids
+open import Functions
+open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
+open import Numbers.Naturals
+open import Groups.Groups
+
+module Groups.GroupsLemmas 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
+      open Setoid S
+      open Group G
+      open Equivalence eq
+      open Symmetric symmetricEq
+
+  invIdent : {a b : _} → {A : Set a} → {_·_ : A → A → A} → {S : Setoid {a} {b} A} → (G : Group S _·_) → Setoid._∼_ S (Group.inverse G (Group.identity G)) (Group.identity G)
+  invIdent {S = S} G = symmetric (transferToRight' G (Group.multIdentLeft G))
+    where
+      open Setoid S
+      open Group G
+      open Equivalence eq
+      open Symmetric symmetricEq

KeyValue.agda

@@ -6,7 +6,7 @@ open import Maybe
 open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
 open import Vectors
 
-open import Naturals
+open import Numbers.Naturals
 
 module KeyValue where
   record ReducedMap {a b c : _} (keys : Set a) (values : Set b) (keyOrder : TotalOrder {_} {c} keys) (min : keys) : Set (a ⊔ b ⊔ c)

KeyValueWithDomain.agda

@@ -7,7 +7,7 @@ open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
 open import KeyValue
 open import Vectors
 
-open import Naturals
+open import Numbers.Naturals
 
 module KeyValueWithDomain where
 

Numbers/Integers.agda

@@ -1,15 +1,16 @@
 {-# OPTIONS --safe --warning=error #-}
 
 open import LogicalFormulae
-open import Naturals
-open import Groups
-open import Rings
+open import Numbers.Naturals
+open import Groups.Groups
+open import Rings.RingDefinition
 open import Functions
 open import Orders
-open import Setoids
-open import IntegralDomains
+open import Setoids.Setoids
+open import Setoids.Orders
+open import Rings.IntegralDomains
 
-module Integers where
+module Numbers.Integers where
     data ℤ : Set where
       nonneg : ℕ → ℤ
       negSucc : ℕ → ℤ
@@ -1552,12 +1553,13 @@ module Integers where
     IntegralDomain.intDom ℤIntDom {negSucc a} {negSucc b} pr = exFalso (negsuccTimesNegsucc {a} {b} pr)
     IntegralDomain.nontrivial ℤIntDom = λ ()
 
-    ℤOrderedRing : OrderedRing (reflSetoid ℤ) (_+Z_) (_*Z_)
-    PartialOrder._<_ (TotalOrder.order (OrderedRing.order ℤOrderedRing)) = _<Z_
-    PartialOrder.irreflexive (TotalOrder.order (OrderedRing.order ℤOrderedRing)) = lessZIrreflexive
-    PartialOrder.transitive (TotalOrder.order (OrderedRing.order ℤOrderedRing)) {a} {b} {c} = lessZTransitive
-    TotalOrder.totality (OrderedRing.order ℤOrderedRing) a b = lessThanTotalZ
-    OrderedRing.ring ℤOrderedRing = ℤRing
+    ℤ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
 

Numbers/Naturals.agda

@@ -6,7 +6,7 @@ open import WellFoundedInduction
 open import Functions
 open import Orders
 
-module Naturals where
+module Numbers.Naturals where
   data ℕ : Set where
       zero : ℕ
       succ : ℕ → ℕ

Numbers/Rationals.agda

@@ -1,17 +1,17 @@
 {-# OPTIONS --safe --warning=error #-}
 
 open import LogicalFormulae
-open import Naturals
-open import Integers
-open import Groups
-open import Rings
-open import Fields
+open import Numbers.Naturals
+open import Numbers.Integers
+open import Groups.Groups
+open import Rings.RingDefinition
+open import Fields.Fields
 open import PrimeNumbers
-open import Setoids
+open import Setoids.Setoids
 open import Functions
-open import FieldOfFractions
+open import Fields.FieldOfFractions
 
-module Rationals where
+module Numbers.Rationals where
 
   ℚ : Set
   ℚ = fieldOfFractionsSet ℤIntDom
@@ -27,3 +27,6 @@ module Rationals where
 
   ℚField : Field ℚRing
   ℚField = fieldOfFractions ℤIntDom
+
+  ℚField : OrderedRing ℚRing (fieldOfFractionsTotalOrder ℤIntDom ℤOrderedRing)
+  ℚField = fieldOfFractionsOrderedRing ℤIntDom ℤOrderedRing

Numbers/Reals.agda

@@ -0,0 +1,32 @@
+{-# OPTIONS --safe --warning=error #-}
+
+open import Fields
+open import Rings
+open import Functions
+open import Orders
+open import LogicalFormulae
+open import Rationals
+open import Naturals
+
+open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
+
+module Reals where
+  record Subset {m n : _} (A : Set m) (B : Set n) : Set (m ⊔ n) where
+    field
+      inj : A → B
+      injInj : Injection inj
+
+  --record RealField {n : _} {A : Set n} {R : Ring A} {F : Field R} : Set _ where
+  --  field
+  --    orderedField : OrderedField F
+  --  open OrderedField orderedField
+  --  open TotalOrder ord
+  --  open Ring R
+  --  field
+  --    complete : {c : _} {C : Set c} → (S : Subset C A) → (upperBound : A) → ({s : C} → (Subset.inj S s) < upperBound) → Sg A (λ lub → ({s : C} → (Subset.inj S s) < lub) && ({s : C} → (Subset.inj S s) < upperBound → (Subset.inj S s) < lub))
+
+
+  record Real : Set where
+    field
+      f : ℕ → ℚ
+      converges : {ε : ℚ} → Sg ℕ (λ x → {y : ℕ} → x <N y → (f x) +Q (f y) <Q ε)

PrimeNumbers.agda

@@ -1,7 +1,7 @@
 {-# OPTIONS --warning=error --safe #-}
 
 open import LogicalFormulae
-open import Naturals
+open import Numbers.Naturals
 open import WellFoundedInduction
 open import KeyValue
 open import KeyValueWithDomain

Reals.agda

@@ -1,24 +0,0 @@
-{-# OPTIONS --safe --warning=error #-}
-
-open import Fields
-open import Rings
-open import Functions
-open import Orders
-open import LogicalFormulae
-
-open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
-
-module Reals where
-  record Subset {m n : _} (A : Set m) (B : Set n) : Set (m ⊔ n) where
-    field
-      inj : A → B
-      injInj : Injection inj
-
-  record RealField {n : _} {A : Set n} {R : Ring A} {F : Field R} : Set _ where
-    field
-      orderedField : OrderedField F
-    open OrderedField orderedField
-    open TotalOrder ord
-    open Ring R
-    field
-      complete : {c : _} {C : Set c} → (S : Subset C A) → (upperBound : A) → ({s : C} → (Subset.inj S s) < upperBound) → Sg A (λ lub → ({s : C} → (Subset.inj S s) < lub) && ({s : C} → (Subset.inj S s) < upperBound → (Subset.inj S s) < lub))

Rings/IntegralDomains.agda

@@ -1,16 +1,17 @@
 {-# OPTIONS --safe --warning=error #-}
 
 open import LogicalFormulae
-open import Groups
-open import Naturals
+open import Groups.Groups
+open import Numbers.Naturals
 open import Orders
-open import Setoids
+open import Setoids.Setoids
 open import Functions
-open import Rings
+open import Rings.RingDefinition
+open import Rings.RingLemmas
 
 open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
 
-module IntegralDomains where
+module Rings.IntegralDomains where
   record IntegralDomain {n m : _} {A : Set n} {S : Setoid {n} {m} A} {_+_ : A → A → A} {_*_ : A → A → A} (R : Ring S _+_ _*_) : Set (lsuc m ⊔ n) where
     field
       intDom : {a b : A} → Setoid._∼_ S (a * b) (Ring.0R R) → (Setoid._∼_ S a (Ring.0R R)) || (Setoid._∼_ S b (Ring.0R R))

Rings/RingDefinition.agda

@@ -1,16 +1,16 @@
 {-# OPTIONS --safe --warning=error #-}
 
 open import LogicalFormulae
-open import Groups
-open import Naturals
-open import Orders
-open import Setoids
+open import Groups.Groups
+open import Numbers.Naturals
+open import Setoids.Orders
+open import Setoids.Setoids
 open import Functions
 
 open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
 
 -- Following Part IB's course Groups, Rings, and Modules, we take rings to be commutative with one.
-module Rings where
+module Rings.RingDefinition where
   record Ring {n m} {A : Set n} (S : Setoid {n} {m} A) (_+_ : A → A → A) (_*_ : A → A → A) : Set (lsuc n ⊔ m) where
     field
       additiveGroup : Group S _+_
@@ -27,15 +27,10 @@ module Rings where
       multDistributes : {a b c : A} → a * (b + c) ∼ (a * b) + (a * c)
       multIdentIsIdent : {a : A} → 1R * a ∼ a
 
-  record OrderedRing {n m o} {A : Set n} (S : Setoid {n} {m} A) (_+_ : A → A → A) (_*_ : A → A → A) : Set (lsuc n ⊔ m ⊔ lsuc o) where
-    field
-      ring : Ring S _+_ _*_
-    open Ring ring
+  record OrderedRing {n m p} {A : Set n} {S : Setoid {n} {m} A} {_+_ : A → A → A} {_*_ : A → A → A} {_<_ : Rel {_} {p} A} {pOrder : SetoidPartialOrder S _<_} (R : Ring S _+_ _*_) (order : SetoidTotalOrder pOrder) : Set (lsuc n ⊔ m ⊔ p) where
+    open Ring R
     open Group additiveGroup
     open Setoid S
-    field
-      order : TotalOrder {_} {o} A
-    _<_ = TotalOrder._<_ order
     field
       orderRespectsAddition : {a b : A} → (a < b) → (c : A) → (a + c) < (b + c)
       orderRespectsMultiplication : {a b : A} → (0R < a) → (0R < b) → (0R < (a * b))
@@ -65,18 +60,3 @@ module Rings where
   --    ringHom : RingHom R S f
   --    bijective : Bijection f
 
-  ringTimesZero : {a b : _} {A : Set a} {S : Setoid {a} {b} A} {_+_ : A → A → A} {_*_ : A → A → A} (R : Ring S _+_ _*_) → {x : A} → Setoid._∼_ S (x * (Ring.0R R)) (Ring.0R R)
-  ringTimesZero {S = S} {_+_ = _+_} {_*_ = _*_} R {x} = symmetric (transitive blah'' (transitive (Group.multAssoc additiveGroup) (transitive (wellDefined invLeft reflexive) multIdentLeft)))
-    where
-      open Ring R
-      open Group additiveGroup
-      open Setoid S
-      open Transitive (Equivalence.transitiveEq (Setoid.eq S))
-      open Reflexive (Equivalence.reflexiveEq (Setoid.eq S))
-      open Symmetric (Equivalence.symmetricEq (Setoid.eq S))
-      blah : (x * 0R) ∼ (x * 0R) + (x * 0R)
-      blah = transitive (multWellDefined reflexive (symmetric multIdentRight)) multDistributes
-      blah' : (inverse (x * 0R)) + (x * 0R) ∼ (inverse (x * 0R)) + ((x * 0R) + (x * 0R))
-      blah' = wellDefined reflexive blah
-      blah'' : 0R ∼ (inverse (x * 0R)) + ((x * 0R) + (x * 0R))
-      blah'' = transitive (symmetric invLeft) blah'

Rings/RingLemmas.agda

@@ -0,0 +1,88 @@
+{-# OPTIONS --safe --warning=error #-}
+
+open import LogicalFormulae
+open import Functions
+open import Groups.Groups
+open import Groups.GroupsLemmas
+open import Rings.RingDefinition
+open import Setoids.Setoids
+open import Setoids.Orders
+
+module Rings.RingLemmas where
+  ringTimesZero : {a b : _} {A : Set a} {S : Setoid {a} {b} A} {_+_ : A → A → A} {_*_ : A → A → A} (R : Ring S _+_ _*_) → {x : A} → Setoid._∼_ S (x * (Ring.0R R)) (Ring.0R R)
+  ringTimesZero {S = S} {_+_ = _+_} {_*_ = _*_} R {x} = symmetric (transitive blah'' (transitive (Group.multAssoc additiveGroup) (transitive (wellDefined invLeft reflexive) multIdentLeft)))
+    where
+      open Ring R
+      open Group additiveGroup
+      open Setoid S
+      open Transitive (Equivalence.transitiveEq (Setoid.eq S))
+      open Reflexive (Equivalence.reflexiveEq (Setoid.eq S))
+      open Symmetric (Equivalence.symmetricEq (Setoid.eq S))
+      blah : (x * 0R) ∼ (x * 0R) + (x * 0R)
+      blah = transitive (multWellDefined reflexive (symmetric multIdentRight)) multDistributes
+      blah' : (inverse (x * 0R)) + (x * 0R) ∼ (inverse (x * 0R)) + ((x * 0R) + (x * 0R))
+      blah' = wellDefined reflexive blah
+      blah'' : 0R ∼ (inverse (x * 0R)) + ((x * 0R) + (x * 0R))
+      blah'' = transitive (symmetric invLeft) blah'
+
+  ringMinusExtracts : {a b : _} {A : Set a} {S : Setoid {a} {b} A} {_+_ : A → A → A} {_*_ : A → A → A} (R : Ring S _+_ _*_) → {x y : A} → Setoid._∼_ S (x * Group.inverse (Ring.additiveGroup R) y) (Group.inverse (Ring.additiveGroup R) (x * y))
+  ringMinusExtracts {S = S} {_+_ = _+_} {_*_ = _*_} R {x = x} {y} = transferToRight' additiveGroup (transitive (symmetric multDistributes) (transitive (multWellDefined reflexive invLeft) (ringTimesZero R)))
+    where
+      open Setoid S
+      open Transitive (Equivalence.transitiveEq (Setoid.eq S))
+      open Reflexive (Equivalence.reflexiveEq (Setoid.eq S))
+      open Symmetric (Equivalence.symmetricEq (Setoid.eq S))
+      open Ring R
+      open Group additiveGroup
+
+  ringAddInequalities : {a b c : _} {A : Set a} {S : Setoid {a} {b} A} {_+_ : A → A → A} {_*_ : A → A → A} {R : Ring S _+_ _*_} {_<_ : Rel {_} {c} A} {pOrder : SetoidPartialOrder S _<_} {tOrder : SetoidTotalOrder pOrder} (oRing : OrderedRing R tOrder) → {w x y z : A} → w < x → y < z → (w + y) < (x + z)
+  ringAddInequalities {S = S} {_+_ = _+_} {R = R} {_<_ = _<_} {pOrder = pOrder} oRing {w = w} {x} {y} {z} w<x y<z = transitive (orderRespectsAddition w<x y) (wellDefined groupIsAbelian groupIsAbelian (orderRespectsAddition y<z x))
+    where
+      open SetoidPartialOrder pOrder
+      open OrderedRing oRing
+      open Ring R
+
+  groupLemmaMoveIdentity : {a b : _} → {A : Set a} → {_·_ : A → A → A} → {S : Setoid {a} {b} A} → (G : Group S _·_) → {x : A} → (Setoid._∼_ S (Group.identity G) (Group.inverse G x)) → Setoid._∼_ S x (Group.identity G)
+  groupLemmaMoveIdentity {S = S} G {x} pr = transitive (symmetric (invInv G)) (transitive (symmetric p) (invIdent G))
+    where
+      open Group G
+      open Setoid S
+      open Transitive (Equivalence.transitiveEq (Setoid.eq S))
+      open Reflexive (Equivalence.reflexiveEq (Setoid.eq S))
+      open Symmetric (Equivalence.symmetricEq (Setoid.eq S))
+      p : inverse identity ∼ inverse (inverse x)
+      p = inverseWellDefined G pr
+
+  groupLemmaMoveIdentity' : {a b : _} → {A : Set a} → {_·_ : A → A → A} → {S : Setoid {a} {b} A} → (G : Group S _·_) → {x : A} → Setoid._∼_ S x (Group.identity G) → (Setoid._∼_ S (Group.identity G) (Group.inverse G x))
+  groupLemmaMoveIdentity' {S = S} G {x} pr = transferToRight' G (transitive multIdentLeft pr)
+    where
+      open Group G
+      open Setoid S
+      open Transitive (Equivalence.transitiveEq (Setoid.eq S))
+      open Reflexive (Equivalence.reflexiveEq (Setoid.eq S))
+      open Symmetric (Equivalence.symmetricEq (Setoid.eq S))
+
+  ringMinusFlipsOrder : {a b c : _} {A : Set a} {S : Setoid {a} {b} A} {_+_ : A → A → A} {_*_ : A → A → A} {R : Ring S _+_ _*_} {_<_ : Rel {_} {c} A} {pOrder : SetoidPartialOrder S _<_} {tOrder : SetoidTotalOrder pOrder} (oRing : OrderedRing R tOrder) → {x : A} → (Ring.0R R) < x → (Group.inverse (Ring.additiveGroup R) x) < (Ring.0R R)
+  ringMinusFlipsOrder {S = S} {_+_ = _+_} {R = R} {_<_ = _<_} {pOrder = pOrder} {tOrder = tOrder} oRing {x = x} 0<x with SetoidTotalOrder.totality tOrder (Ring.0R R) (Group.inverse (Ring.additiveGroup R) x)
+  ringMinusFlipsOrder {S = S} {_+_} {R = R} {_<_} {pOrder} {tOrder} oRing {x} 0<x | inl (inl 0<inv) = exFalso (SetoidPartialOrder.irreflexive pOrder bad')
+    where
+      bad : (Group.identity (Ring.additiveGroup R) + Group.identity (Ring.additiveGroup R)) < (x + Group.inverse (Ring.additiveGroup R) x)
+      bad = ringAddInequalities oRing 0<x 0<inv
+      bad' : (Group.identity (Ring.additiveGroup R)) < (Group.identity (Ring.additiveGroup R))
+      bad' = SetoidPartialOrder.wellDefined pOrder (Group.multIdentRight (Ring.additiveGroup R)) (Group.invRight (Ring.additiveGroup R)) bad
+  ringMinusFlipsOrder {S = S} {_+_} {R = R} {_<_} {pOrder} {tOrder} oRing {x} 0<x | inl (inr inv<0) = inv<0
+  ringMinusFlipsOrder {S = S} {_+_} {R = R} {_<_} {pOrder} {tOrder} oRing {x} 0<x | inr 0=inv = exFalso (SetoidPartialOrder.irreflexive pOrder (SetoidPartialOrder.wellDefined pOrder (Reflexive.reflexive (Equivalence.reflexiveEq (Setoid.eq S))) (groupLemmaMoveIdentity (Ring.additiveGroup R) 0=inv) 0<x))
+
+  ringMinusFlipsOrder' : {a b c : _} {A : Set a} {S : Setoid {a} {b} A} {_+_ : A → A → A} {_*_ : A → A → A} {R : Ring S _+_ _*_} {_<_ : Rel {_} {c} A} {pOrder : SetoidPartialOrder S _<_} {tOrder : SetoidTotalOrder pOrder} (oRing : OrderedRing R tOrder) → {x : A} → (Group.inverse (Ring.additiveGroup R) x) < (Ring.0R R) → (Ring.0R R) < x
+  ringMinusFlipsOrder' {R = R} {_<_ = _<_} {tOrder = tOrder} oRing {x} -x<0 with SetoidTotalOrder.totality tOrder (Ring.0R R) x
+  ringMinusFlipsOrder' {R = R} {_<_} {tOrder = tOrder} oRing {x} -x<0 | inl (inl 0<x) = 0<x
+  ringMinusFlipsOrder' {_+_ = _+_} {R = R} {_<_} {pOrder = pOrder} {tOrder = tOrder} oRing {x} -x<0 | inl (inr x<0) = exFalso (SetoidPartialOrder.irreflexive pOrder (SetoidPartialOrder.wellDefined pOrder (Group.invLeft (Ring.additiveGroup R)) (Group.multIdentRight (Ring.additiveGroup R)) bad))
+    where
+      bad : ((Group.inverse (Ring.additiveGroup R) x) + x) < (Group.identity (Ring.additiveGroup R) + Group.identity (Ring.additiveGroup R))
+      bad = ringAddInequalities oRing -x<0 x<0
+  ringMinusFlipsOrder' {S = S} {R = R} {_<_} {pOrder = pOrder} {tOrder = tOrder} oRing {x} -x<0 | inr 0=x = exFalso (SetoidPartialOrder.irreflexive pOrder (SetoidPartialOrder.wellDefined pOrder (symmetric (groupLemmaMoveIdentity' (Ring.additiveGroup R) (symmetric 0=x))) (Reflexive.reflexive (Equivalence.reflexiveEq (Setoid.eq S))) -x<0))
+    where
+      open Setoid S
+      open Transitive (Equivalence.transitiveEq (Setoid.eq S))
+      open Reflexive (Equivalence.reflexiveEq (Setoid.eq S))
+      open Symmetric (Equivalence.symmetricEq (Setoid.eq S))

Setoids/Orders.agda

@@ -0,0 +1,40 @@
+{-# OPTIONS --safe --warning=error #-}
+
+open import LogicalFormulae
+open import Orders
+open import Setoids.Setoids
+open import Functions
+
+open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
+
+module Setoids.Orders where
+
+  record SetoidPartialOrder {a b c : _} {A : Set a} (S : Setoid {a} {b} A) (_<_ : Rel {a} {c} A) : Set (a ⊔ b ⊔ c) where
+    open Setoid S
+    field
+      wellDefined : {a b c d : A} → (a ∼ b) → (c ∼ d) → a < c → b < d
+      irreflexive : {x : A} → (x < x) → False
+      transitive : {a b c : A} → (a < b) → (b < c) → (a < c)
+
+  record SetoidTotalOrder {a b c : _} {A : Set a} {S : Setoid {a} {b} A} {_<_ : Rel {a} {c} A} (P : SetoidPartialOrder S _<_) : Set (a ⊔ b ⊔ c) where
+    open Setoid S
+    field
+      totality : (a b : A) → ((a < b) || (b < a)) || (a ∼ b)
+    min : A → A → A
+    min a b with totality a b
+    min a b | inl (inl a<b) = a
+    min a b | inl (inr b<a) = b
+    min a b | inr a=b = a
+    max : A → A → A
+    max a b with totality a b
+    max a b | inl (inl a<b) = b
+    max a b | inl (inr b<a) = a
+    max a b | inr a=b = b
+
+  partialOrderToSetoidPartialOrder : {a b : _} {A : Set a} (P : PartialOrder {a} {b} A) → SetoidPartialOrder (reflSetoid A) (PartialOrder._<_ P)
+  SetoidPartialOrder.wellDefined (partialOrderToSetoidPartialOrder P) a=b c=d a<c rewrite a=b | c=d = a<c
+  SetoidPartialOrder.irreflexive (partialOrderToSetoidPartialOrder P) = PartialOrder.irreflexive P
+  SetoidPartialOrder.transitive (partialOrderToSetoidPartialOrder P) = PartialOrder.transitive P
+
+  totalOrderToSetoidTotalOrder : {a b : _} {A : Set a} (T : TotalOrder {a} {b} A) → SetoidTotalOrder (partialOrderToSetoidPartialOrder (TotalOrder.order T))
+  SetoidTotalOrder.totality (totalOrderToSetoidTotalOrder T) = TotalOrder.totality T

Setoids/Setoids.agda

@@ -4,7 +4,7 @@ open import Functions
 open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
 open import LogicalFormulae
 
-module Setoids where
+module Setoids.Setoids where
   record Setoid {a} {b} (A : Set a) : Set (a ⊔ lsuc b) where
     infix 1 _∼_
     field

Sets/FinSet.agda

@@ -3,10 +3,10 @@
 open import Functions
 open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
 open import LogicalFormulae
-open import Naturals
+open import Numbers.Naturals
 open import Orders
 
-module FinSet where
+module Sets.FinSet where
   data FinSet : (n : ℕ) → Set where
     fzero : {n : ℕ} → FinSet (succ n)
     fsucc : {n : ℕ} → FinSet n → FinSet (succ n)

Vectors.agda

@@ -1,7 +1,7 @@
 {-# OPTIONS --warning=error --safe #-}
 
 open import LogicalFormulae
-open import Naturals
+open import Numbers.Naturals
 open import Functions
 
 data Vec {a : _} (X : Set a) : ℕ -> Set a where