Move equiv rels (#46)

2025-10-12 07:08:40 +00:00 · 2019-09-28 22:24:41 +01:00
parent b92e6b2dd8
commit 00ce1dfdf8
20 changed files with 455 additions and 769 deletions
--- a/Rings/IntegralDomains.agda
+++ b/Rings/IntegralDomains.agda
@@ -9,6 +9,7 @@ open import Setoids.Setoids
 open import Functions
 open import Rings.Definition
 open import Rings.Lemmas
+open import Sets.EquivalenceRelations

 open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)

@@ -22,9 +23,7 @@ module Rings.IntegralDomains where
  cancelIntDom {S = S} {_+_ = _+_} {_*_ = _*_} {R = R} I {a} {b} {c} ab=ac = t4
    where
      open Setoid S
-      open Reflexive (Equivalence.reflexiveEq (Setoid.eq S))
-      open Symmetric (Equivalence.symmetricEq (Setoid.eq S))
-      open Transitive (Equivalence.transitiveEq (Setoid.eq S))
+      open Equivalence eq
      t1 : (a * b) + Group.inverse (Ring.additiveGroup R) (a * c) ∼ Ring.0R R
      t1 = transferToRight'' (Ring.additiveGroup R) ab=ac
      t2 : a * (b + Group.inverse (Ring.additiveGroup R) c) ∼ Ring.0R R
--- a/Rings/Lemmas.agda
+++ b/Rings/Lemmas.agda
@@ -8,6 +8,7 @@ open import Groups.Lemmas
 open import Rings.Definition
 open import Setoids.Setoids
 open import Setoids.Orders
+open import Sets.EquivalenceRelations

 module Rings.Lemmas 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)
@@ -16,9 +17,7 @@ module Rings.Lemmas 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))
+      open Equivalence eq
      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))
@@ -30,9 +29,7 @@ module Rings.Lemmas where
  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 Equivalence eq
      open Ring R
      open Group additiveGroup

@@ -48,9 +45,7 @@ module Rings.Lemmas where
    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))
+      open Equivalence eq
      p : inverse identity ∼ inverse (inverse x)
      p = inverseWellDefined G pr

@@ -59,9 +54,7 @@ module Rings.Lemmas where
    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))
+      open Equivalence eq

  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)
@@ -72,7 +65,7 @@ module Rings.Lemmas where
      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 {S = S} {_+_} {R = R} {_<_} {pOrder} {tOrder} oRing {x} 0<x | inr 0=inv = exFalso (SetoidPartialOrder.irreflexive pOrder (SetoidPartialOrder.wellDefined pOrder (Equivalence.reflexive (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
@@ -81,26 +74,22 @@ module Rings.Lemmas where
    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))
+  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))) (Equivalence.reflexive (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))
+      open Equivalence eq

  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} → x < (Ring.0R R) → (Ring.0R R) < Group.inverse (Ring.additiveGroup R) x
-  ringMinusFlipsOrder'' {S = S} {R = R} {pOrder = pOrder} oRing {x} x<0 = ringMinusFlipsOrder' oRing (SetoidPartialOrder.wellDefined pOrder {x} {Group.inverse (Ring.additiveGroup R) (Group.inverse (Ring.additiveGroup R) x)} {Ring.0R R} {Ring.0R R} (Symmetric.symmetric (Equivalence.symmetricEq (Setoid.eq S)) (invInv (Ring.additiveGroup R))) (Reflexive.reflexive (Equivalence.reflexiveEq (Setoid.eq S))) x<0)
+  ringMinusFlipsOrder'' {S = S} {R = R} {pOrder = pOrder} oRing {x} x<0 = ringMinusFlipsOrder' oRing (SetoidPartialOrder.wellDefined pOrder {x} {Group.inverse (Ring.additiveGroup R) (Group.inverse (Ring.additiveGroup R) x)} {Ring.0R R} {Ring.0R R} (Equivalence.symmetric (Setoid.eq S) (invInv (Ring.additiveGroup R))) (Equivalence.reflexive (Setoid.eq S)) x<0)

  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) < (Group.inverse (Ring.additiveGroup R) x) → x < (Ring.0R R)
-  ringMinusFlipsOrder''' {S = S} {R = R} {pOrder = pOrder} oRing {x} 0<-x = SetoidPartialOrder.wellDefined pOrder (invInv (Ring.additiveGroup R)) (Reflexive.reflexive (Equivalence.reflexiveEq (Setoid.eq S))) (ringMinusFlipsOrder oRing 0<-x)
+  ringMinusFlipsOrder''' {S = S} {R = R} {pOrder = pOrder} oRing {x} 0<-x = SetoidPartialOrder.wellDefined pOrder (invInv (Ring.additiveGroup R)) (Equivalence.reflexive (Setoid.eq S)) (ringMinusFlipsOrder oRing 0<-x)

  ringCanMultiplyByPositive : {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 y c : A} → (Ring.0R R) < c → x < y → (x * c) < (y * c)
  ringCanMultiplyByPositive {S = S} {_+_ = _+_} {_*_ = _*_} {R = R} {_<_ = _<_} {pOrder = pOrder} {tOrder = tOrder} oRing {x} {y} {c} 0<c x<y = SetoidPartialOrder.wellDefined pOrder reflexive (Group.multIdentRight additiveGroup) q'
    where
      open Ring R
-      open Transitive (Equivalence.transitiveEq (Setoid.eq S))
-      open Reflexive (Equivalence.reflexiveEq (Setoid.eq S))
-      open Symmetric (Equivalence.symmetricEq (Setoid.eq S))
+      open Equivalence (Setoid.eq S)
      have : 0R < (y + Group.inverse additiveGroup x)
      have = SetoidPartialOrder.wellDefined pOrder (Group.invRight additiveGroup) reflexive (OrderedRing.orderRespectsAddition oRing x<y (Group.inverse additiveGroup x))
      p : 0R < ((y * c) + ((Group.inverse additiveGroup x) * c))
@@ -117,9 +106,7 @@ module Rings.Lemmas where
    where
      open Ring R
      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 Equivalence (Setoid.eq S)
      have : 0R < ((y * c) + (Group.inverse additiveGroup (x * c)))
      have = SetoidPartialOrder.wellDefined pOrder (Group.invRight additiveGroup) reflexive (OrderedRing.orderRespectsAddition oRing xc<yc (Group.inverse additiveGroup _))
      p : 0R < ((y * c) + ((Group.inverse additiveGroup x) * c))
@@ -161,9 +148,7 @@ module Rings.Lemmas where
    where
      open Ring R
      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 Equivalence eq
      t : ((Group.inverse additiveGroup x) + y) < ((Group.inverse additiveGroup y) + y)
      t = OrderedRing.orderRespectsAddition oRing -x<-y y
      u : (y + (Group.inverse additiveGroup x)) < 0R
@@ -176,9 +161,7 @@ module Rings.Lemmas where
    where
      open Ring R
      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 Equivalence eq
      p : (c + Group.inverse additiveGroup c) < (0R + Group.inverse additiveGroup c)
      p = OrderedRing.orderRespectsAddition oRing c<0 _
      0<-c : 0R < (Group.inverse additiveGroup c)
@@ -194,9 +177,7 @@ module Rings.Lemmas where
      open Ring R
      open Setoid S
      open Group additiveGroup
-      open Transitive (Equivalence.transitiveEq (Setoid.eq S))
-      open Reflexive (Equivalence.reflexiveEq (Setoid.eq S))
-      open Symmetric (Equivalence.symmetricEq (Setoid.eq S))
+      open Equivalence eq
      p : 0R < ((y * c) + inverse (x * c))
      p = SetoidPartialOrder.wellDefined pOrder invRight reflexive (OrderedRing.orderRespectsAddition oRing xc<yc (inverse (x * c)))
      p1 : 0R < ((y * c) + ((inverse x) * c))