From 0b8ce43ed12e14437f07097cb7b188c282c79b62 Mon Sep 17 00:00:00 2001
From: Lorenzo Molena <lorenzo.molena8@gmail.com>
Date: Thu, 2 Apr 2026 20:15:31 +0200
Subject: [PATCH 01/19] add properties of OCR and OCR-morphisms, including
 univalence and canonical embedding from the integers

---
 .../Algebra/CommRing/Instances/Fast/Int.agda  | 114 +++
 Cubical/Algebra/OrderedCommRing.agda          |   1 +
 Cubical/Algebra/OrderedCommRing/Base.agda     |  40 +-
 .../OrderedCommRing/Instances/Fast/Int.agda   |  97 +++
 .../Algebra/OrderedCommRing/Morphisms.agda    | 360 +++++++++
 .../Algebra/OrderedCommRing/Properties.agda   | 683 ++++++++++++++++++
 .../Algebra/OrderedCommRing/Univalence.agda   |  78 ++
 Cubical/Algebra/Ring/Properties.agda          |  11 +
 8 files changed, 1379 insertions(+), 5 deletions(-)
 create mode 100644 Cubical/Algebra/OrderedCommRing/Morphisms.agda
 create mode 100644 Cubical/Algebra/OrderedCommRing/Properties.agda
 create mode 100644 Cubical/Algebra/OrderedCommRing/Univalence.agda

diff --git a/Cubical/Algebra/CommRing/Instances/Fast/Int.agda b/Cubical/Algebra/CommRing/Instances/Fast/Int.agda
index e01dde2d62..eddd1e13e9 100644
--- a/Cubical/Algebra/CommRing/Instances/Fast/Int.agda
+++ b/Cubical/Algebra/CommRing/Instances/Fast/Int.agda
@@ -1,8 +1,12 @@
 module Cubical.Algebra.CommRing.Instances.Fast.Int where
 
 open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Function
 
+open import Cubical.Algebra.Ring
 open import Cubical.Algebra.CommRing
+
+open import Cubical.Data.Nat as ℕ using (ℕ ; zero ; suc)
 open import Cubical.Data.Fast.Int as Int renaming (_+_ to _+ℤ_; _·_ to _·ℤ_ ; -_ to -ℤ_)
 
 open CommRingStr using (0r ; 1r ; _+_ ; _·_ ; -_ ; isCommRing)
@@ -21,3 +25,113 @@ isCommRing (snd ℤCommRing) = isCommRingℤ
     isCommRingℤ = makeIsCommRing isSetℤ Int.+Assoc +IdR
                                  -Cancel Int.+Comm Int.·Assoc
                                  Int.·IdR ·DistR+ Int.·Comm
+
+private
+  variable
+    ℓ : Level
+
+module CanonicalHomFromℤ (R : CommRing ℓ) where
+
+  private
+    module R where
+      open CommRingStr (snd R) public
+      open RingTheory (CommRing→Ring R) public
+
+  suc-fromℕ : ∀ x → R.fromℕ (suc x) ≡ R.1r R.+ R.fromℕ x
+  suc-fromℕ zero    = sym (R.+IdR R.1r)
+  suc-fromℕ (suc x) = refl
+
+  fromℕ-pres+ : (x y : ℕ) → R.fromℕ (x ℕ.+ y) ≡ R.fromℕ x R.+ R.fromℕ y
+  fromℕ-pres+ zero          y = sym (R.+IdL _)
+  fromℕ-pres+ (suc zero)    y = suc-fromℕ y
+  fromℕ-pres+ (suc (suc x)) y = cong (R.1r R.+_) (fromℕ-pres+ (suc x) y) ∙ R.+Assoc _ _ _
+
+  fromℤ-pres- : (x : ℤ) → R.fromℤ (-ℤ x) ≡ R.- R.fromℤ x
+  fromℤ-pres- (pos zero)    = sym R.0Selfinverse
+  fromℤ-pres- (pos (suc n)) = refl
+  fromℤ-pres- (negsuc n)    = sym (R.-Idempotent _)
+
+  suc-fromℤ : ∀ z → R.fromℤ (1 +ℤ z) ≡ R.1r R.+ R.fromℤ (z)
+  suc-fromℤ (pos n)          = suc-fromℕ n
+  suc-fromℤ (negsuc zero)    = sym (R.+InvR R.1r)
+  suc-fromℤ (negsuc (suc n)) =
+       sym (cong (R._+ (R.- R.fromℕ (suc n))) (R.+InvR _) ∙ R.+IdL _)
+    ∙∙ sym (R.+Assoc _ _ _)
+    ∙∙ cong (R.1r R.+_) (R.-Dist _ _)
+
+  fromℤ-pres+' : (n m : ℕ) →
+    R.fromℤ (pos n +ℤ negsuc m) ≡
+    R.fromℤ (pos n) R.+ R.fromℤ (negsuc m)
+  fromℤ-pres+' zero    m = sym (R.+IdL _)
+  fromℤ-pres+' (suc n) m =
+      (cong R.fromℤ (sym (+Assoc 1 (pos n) (negsuc m)))
+    ∙ suc-fromℤ (pos n +ℤ negsuc m))
+    ∙∙ cong (R.1r R.+_) (fromℤ-pres+' n m)
+    ∙∙ R.+Assoc _ _ _
+    ∙ cong (R._+ R.fromℤ (negsuc m))
+     (sym (suc-fromℕ n))
+
+  fromℤ-pres+ : (x y : ℤ) → R.fromℤ (x +ℤ y) ≡ R.fromℤ x R.+ R.fromℤ y
+  fromℤ-pres+ (pos n)    (pos m)    = fromℕ-pres+  n m
+  fromℤ-pres+ (pos n)    (negsuc m) = fromℤ-pres+' n m
+  fromℤ-pres+ (negsuc n) (pos m)    = fromℤ-pres+' m n ∙ R.+Comm _ _
+  fromℤ-pres+ (negsuc n) (negsuc m) =
+      cong (R.-_)
+      (cong (R.1r R.+_) (cong R.fromℕ (sym (ℕ.+-suc n m)))
+        ∙ sym (suc-fromℕ (n ℕ.+ suc m))
+        ∙ fromℕ-pres+ (suc n) (suc m))
+    ∙ sym (R.-Dist _ _)
+
+  fromℕ-pres· : (x y : ℕ) → R.fromℕ (x ℕ.· y) ≡ R.fromℕ x R.· R.fromℕ y
+  fromℕ-pres· zero y    = sym (R.0LeftAnnihilates _)
+  fromℕ-pres· (suc x) y =
+      fromℕ-pres+ y (x ℕ.· y)
+    ∙∙ cong₂ (R._+_) (sym (R.·IdL _)) (fromℕ-pres· x y)
+    ∙∙ sym (R.·DistL+ _ _ _)
+    ∙ cong (R._· R.fromℕ y) (sym (suc-fromℕ x))
+  fromℤ-pres· : (x y : ℤ) → R.fromℤ (x ·ℤ y) ≡ R.fromℤ x R.· R.fromℤ y
+  fromℤ-pres· (pos n) (pos m)    = fromℕ-pres· n m
+  fromℤ-pres· (pos n) (negsuc m) =
+      cong R.fromℤ (sym (-DistR· (pos n) (pos (suc m))))
+    ∙∙ (fromℤ-pres- (pos (n ℕ.· suc m))
+      ∙ cong R.-_ (fromℕ-pres· n (suc m)))
+    ∙∙ sym (R.-DistR· _ _)
+  fromℤ-pres· (negsuc n) (pos m) =
+      cong R.fromℤ (sym (-DistL· (pos (suc n)) (pos m)))
+    ∙∙ (fromℤ-pres- (pos ((suc n) ℕ.· m))
+      ∙ cong R.-_ (fromℕ-pres· (suc n) m))
+    ∙∙ sym (R.-DistL· _ _)
+  fromℤ-pres· (negsuc n) (negsuc m) =
+       fromℕ-pres· (suc n) (suc m)
+    ∙∙ cong₂ R._·_ (sym (R.-Idempotent _)) refl
+    ∙∙ R.-Swap· _ _
+
+  isHomFromℤ : IsCommRingHom (ℤCommRing .snd) R.fromℤ (R .snd)
+  isHomFromℤ .IsCommRingHom.pres0 = refl
+  isHomFromℤ .IsCommRingHom.pres1 = refl
+  isHomFromℤ .IsCommRingHom.pres+ = fromℤ-pres+
+  isHomFromℤ .IsCommRingHom.pres· = fromℤ-pres·
+  isHomFromℤ .IsCommRingHom.pres- = fromℤ-pres-
+
+  fromℤHom : CommRingHom ℤCommRing R
+  fst fromℤHom = R.fromℤ
+  snd fromℤHom = isHomFromℤ
+
+  module _ (φ : CommRingHom ℤCommRing R) where
+
+    open IsCommRingHom (snd φ)
+
+    isUniqueFromℕ : ∀ n → R.fromℕ n ≡ φ $cr pos n
+    isUniqueFromℕ zero            = sym pres0
+    isUniqueFromℕ (suc zero)      = sym pres1
+    isUniqueFromℕ (suc k@(suc n)) = cong₂ R._+_ (sym pres1) (isUniqueFromℕ k)
+                                  ∙ sym (pres+ 1 (pos k))
+
+    isUniqueFromℤ : ∀ n → R.fromℤ n ≡ φ $cr n
+    isUniqueFromℤ (pos n)    = isUniqueFromℕ n
+    isUniqueFromℤ (negsuc n) = cong R.-_ (isUniqueFromℕ (suc n))
+                             ∙ sym (pres- (pos (suc n)))
+
+  isContrHom[ℤCR,-] : isContr (CommRingHom ℤCommRing R)
+  fst isContrHom[ℤCR,-] = fromℤHom
+  snd isContrHom[ℤCR,-] = CommRingHom≡ ∘ funExt ∘ isUniqueFromℤ
diff --git a/Cubical/Algebra/OrderedCommRing.agda b/Cubical/Algebra/OrderedCommRing.agda
index 2aca413aff..ba0a384be4 100644
--- a/Cubical/Algebra/OrderedCommRing.agda
+++ b/Cubical/Algebra/OrderedCommRing.agda
@@ -1,3 +1,4 @@
 module Cubical.Algebra.OrderedCommRing where
 
 open import Cubical.Algebra.OrderedCommRing.Base public
+open import Cubical.Algebra.OrderedCommRing.Properties public
diff --git a/Cubical/Algebra/OrderedCommRing/Base.agda b/Cubical/Algebra/OrderedCommRing/Base.agda
index 29cd5dbb4b..0bf5ca7948 100644
--- a/Cubical/Algebra/OrderedCommRing/Base.agda
+++ b/Cubical/Algebra/OrderedCommRing/Base.agda
@@ -4,20 +4,25 @@ module Cubical.Algebra.OrderedCommRing.Base where
 -}
 
 open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Function
 open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.HLevels
 open import Cubical.Foundations.SIP
 
+open import Cubical.Algebra.CommRing.Base
+
 import Cubical.Functions.Logic as L
 
-open import Cubical.Relation.Nullary.Base
+open import Cubical.HITs.PropositionalTruncation as PT
 
-open import Cubical.Algebra.CommRing.Base
+open import Cubical.Reflection.RecordEquiv
 
 open import Cubical.Relation.Binary.Base
-open import Cubical.Relation.Binary.Order.Poset hiding (isPseudolattice)
-open import Cubical.Relation.Binary.Order.StrictOrder
-
+open import Cubical.Relation.Binary.Order.Poset hiding (
+  isPseudolattice ; isPropIsPseudolattice)
 open import Cubical.Relation.Binary.Order.Pseudolattice
+open import Cubical.Relation.Binary.Order.StrictOrder
+open import Cubical.Relation.Nullary
 
 open BinaryRelation
 
@@ -53,6 +58,8 @@ record IsOrderedCommRing
                                                                 ; _∧l_ to _⊓_ ; _∨l_ to _⊔_) public
   open IsStrictOrder isStrictOrder hiding (is-set) renaming (is-prop-valued to is-prop-valued< ; is-trans to is-trans<) public
 
+unquoteDecl IsOrderedCommRingIsoΣ = declareRecordIsoΣ IsOrderedCommRingIsoΣ (quote IsOrderedCommRing)
+
 record OrderedCommRingStr (ℓ' : Level) (R : Type ℓ) : Type (ℓ-suc (ℓ-max ℓ ℓ')) where
   constructor orderedcommringstr
   field
@@ -134,3 +141,26 @@ OrderedCommRing→CommRing : OrderedCommRing ℓ ℓ' → CommRing ℓ
 OrderedCommRing→CommRing R .fst = R .fst
 OrderedCommRing→CommRing R .snd = commringstr _ _ _ _ _ isCommRing where
   open OrderedCommRingStr (str R)
+
+isPropIsOrderedCommRing : {R : Type ℓ}
+                          → (0r 1r : R)
+                          → (_+_ _·_ : R → R → R) (-_ : R → R)
+                          → (_<_ _≤_ : R → R → Type ℓ')
+                          → isProp (IsOrderedCommRing 0r 1r _+_ _·_ -_ _<_ _≤_)
+isPropIsOrderedCommRing 0r 1r _+_ _·_ -_ _<_ _≤_ = isOfHLevelRetractFromIso 1
+  IsOrderedCommRingIsoΣ $
+    isPropΣ (isPropIsCommRing _ _ _ _ _) λ isCR →
+    isPropΣ (isPropIsPseudolattice _) λ isPL →
+    isPropΣ (isPropIsStrictOrder _) λ isSO →
+    isProp× (isPropΠ3 λ _ _ _ → isPL .IsPseudolattice.is-prop-valued _ _) $
+    isProp× (isPropΠ2 λ x y → isOfHLevel≃ 1
+      (IsPoset.is-prop-valued (IsPseudolattice.isPoset isPL) x y)
+      (isProp¬ (y < x))) $
+    isProp× (isPropΠ4 λ _ _ _ _ → isPL .IsPseudolattice.is-prop-valued _ _) $
+    isProp× (isPropΠ4 λ _ _ _ _ → isSO .IsStrictOrder.is-prop-valued _ _) $
+    isProp× (isPropΠ3 λ _ _ _ → PT.squash₁) $
+    isProp× (isPropΠ5 λ _ _ _ _ _ → isSO .IsStrictOrder.is-prop-valued _ _) $
+    isProp× (isPropΠ5 λ _ _ _ _ _ → isSO .IsStrictOrder.is-prop-valued _ _) $
+    isProp× (isPropΠ5 λ _ _ _ _ _ → isPL .IsPseudolattice.is-prop-valued _ _) $
+    isProp× (isPropΠ5 λ _ _ _ _ _ → isSO .IsStrictOrder.is-prop-valued _ _)
+            (isSO .IsStrictOrder.is-prop-valued _ _)
diff --git a/Cubical/Algebra/OrderedCommRing/Instances/Fast/Int.agda b/Cubical/Algebra/OrderedCommRing/Instances/Fast/Int.agda
index 45a38d41c6..cb25a0bd4b 100644
--- a/Cubical/Algebra/OrderedCommRing/Instances/Fast/Int.agda
+++ b/Cubical/Algebra/OrderedCommRing/Instances/Fast/Int.agda
@@ -8,15 +8,20 @@ open import Cubical.Data.Empty as ⊥
 
 open import Cubical.HITs.PropositionalTruncation
 
+open import Cubical.Data.Nat as ℕ using (ℕ ; zero ; suc)
+open import Cubical.Data.Nat.Order as ℕ using () renaming (_≤_ to _≤ℕ_ ; _<_ to _<ℕ_)
+import Cubical.Data.Nat.Order.Inductive as ℕ
 open import Cubical.Data.Fast.Int as ℤ
   renaming (_+_ to _+ℤ_ ; _-_ to _-ℤ_; -_ to -ℤ_ ; _·_ to _·ℤ_)
 open import Cubical.Data.Fast.Int.Order
   renaming (_<_ to _<ℤ_ ; _≤_ to _≤ℤ_)
 
+open import Cubical.Algebra.Ring
 open import Cubical.Algebra.CommRing
 open import Cubical.Algebra.CommRing.Instances.Fast.Int
 
 open import Cubical.Algebra.OrderedCommRing
+open import Cubical.Algebra.OrderedCommRing.Morphisms
 
 open import Cubical.Relation.Nullary
 
@@ -64,3 +69,95 @@ isOrderedCommRing (snd ℤOrderedCommRing) = isOrderedCommRingℤ
     isOrderedCommRingℤ .·MonoR≤         = λ _ _ _ → 0≤o→≤-·o
     isOrderedCommRingℤ .·MonoR<         = λ _ _ _ → 0<o→<-·o
     isOrderedCommRingℤ .0<1             = zero-<possuc
+
+private
+  variable
+    ℓ ℓ' : Level
+
+module CanonicalMonoFromℤ (R : OrderedCommRing ℓ ℓ') where
+
+  open CanonicalHomFromℤ (OrderedCommRing→CommRing R)
+  open OrderedCommRingTheory R
+  open OrderedCommRingReasoning R
+
+  private
+    module R where
+      open OrderedCommRingStr (snd R) public
+      open RingTheory (OrderedCommRing→Ring R) using (fromℕ ; fromℤ) public
+
+  1≤fromℕsuc : ∀ n → R.1r R.≤ R.fromℕ (suc n)
+  1≤fromℕsuc zero    = R.is-refl R.1r
+  1≤fromℕsuc (suc n) =
+    subst (R._≤ R.fromℕ (suc (suc n))) (R.+IdL R.1r) (+Mono≤ _ _ _ _ 0≤1 (1≤fromℕsuc n))
+
+  0<fromℕsuc : ∀ n → R.0r R.< R.fromℕ (suc n)
+  0<fromℕsuc n = R.<-≤-trans _ _ _ R.0<1 (1≤fromℕsuc n)
+
+  0≤fromℕ : ∀ n → R.0r R.≤ R.fromℕ n
+  0≤fromℕ zero    = R.is-refl R.0r
+  0≤fromℕ (suc n) = R.<-≤-weaken _ _ (0<fromℕsuc n)
+
+  fromℕ-pres≤ᵗ : ∀ m n → m ℕ.≤ᵗ n → R.fromℕ m R.≤ R.fromℕ n
+  fromℕ-pres≤ᵗ zero          n             t = 0≤fromℕ n
+  fromℕ-pres≤ᵗ (suc zero)    (suc n)       t = 1≤fromℕsuc n
+  fromℕ-pres≤ᵗ (suc (suc m)) (suc (suc n)) t =
+    +MonoL≤ _ _ _ (fromℕ-pres≤ᵗ (suc m) (suc n) t)
+
+  fromℕ-pres≤ : ∀ m n → m ≤ℕ n → R.fromℕ m R.≤ R.fromℕ n
+  fromℕ-pres≤ m n = fromℕ-pres≤ᵗ m n ∘ ℕ.≤→≤ᵇ
+
+  fromℕ-pres<ᵗ : ∀ m n → m ℕ.<ᵗ n → R.fromℕ m R.< R.fromℕ n
+  fromℕ-pres<ᵗ zero          (suc n)       t = 0<fromℕsuc n
+  fromℕ-pres<ᵗ (suc zero)    (suc (suc n)) t = <SumLeftPos R.1r _ (0<fromℕsuc n)
+  fromℕ-pres<ᵗ (suc (suc m)) (suc (suc n)) t =
+    +MonoL< _ _ _ (fromℕ-pres<ᵗ (suc m) (suc n) t)
+
+  fromℕ-pres< : ∀ m n → m <ℕ n → R.fromℕ m R.< R.fromℕ n
+  fromℕ-pres< m n = fromℕ-pres<ᵗ m n ∘ ℕ.<→<ᵇ
+
+  fromℤ-pres≤ : ∀ m n → m ≤ℤ n → R.fromℤ m R.≤ R.fromℤ n
+  fromℤ-pres≤ (pos m)    (pos n)    (pos≤pos p)       = fromℕ-pres≤ᵗ m n p
+  fromℤ-pres≤ (negsuc m) (pos n)    negsuc≤pos        =
+    R.is-trans≤ _ _ _ (0≤→-≤0 _ (0≤fromℕ (suc m))) (0≤fromℕ n)
+  fromℤ-pres≤ (negsuc m) (negsuc n) (negsuc≤negsuc p) =
+    -Flip≤ _ _ (fromℕ-pres≤ᵗ (suc n) (suc m) p)
+
+  fromℤ-pres< : ∀ m n → m <ℤ n → R.fromℤ m R.< R.fromℤ n
+  fromℤ-pres< (pos m)    (pos n)    (pos<pos p)       = fromℕ-pres<ᵗ m n p
+  fromℤ-pres< (negsuc m) (pos n)    negsuc<pos        =
+    R.<-≤-trans _ _ _ (0<→-<0 _ (0<fromℕsuc m)) (0≤fromℕ n)
+  fromℤ-pres< (negsuc m) (negsuc n) (negsuc<negsuc p) =
+    -Flip< _ _ (fromℕ-pres<ᵗ (suc n) (suc m) p)
+
+  fromℤ-reflect< : ∀ m n → R.fromℤ m R.< R.fromℤ n → m <ℤ n
+  fromℤ-reflect< m n fm<fn with m ≟ n
+  ... | lt m<n = m<n
+  ... | eq m≡n = ⊥.rec (R.is-irrefl _ (subst (R._< _) (cong R.fromℤ m≡n) fm<fn))
+  ... | gt m>n = ⊥.rec (R.is-asym _ _ fm<fn (fromℤ-pres< n m m>n))
+
+  isOCRHomFromℤ : IsOrderedCommRingHom (snd ℤOrderedCommRing) R.fromℤ (snd R)
+  isOCRHomFromℤ .IsOrderedCommRingHom.isCommRingHom = isHomFromℤ
+  isOCRHomFromℤ .IsOrderedCommRingHom.pres≤         = fromℤ-pres≤
+  isOCRHomFromℤ .IsOrderedCommRingHom.reflect<      = fromℤ-reflect<
+
+  isOCRMonoFromℤ : IsOrderedCommRingMono (snd ℤOrderedCommRing) R.fromℤ (snd R)
+  isOCRMonoFromℤ .IsOrderedCommRingMono.isOrderedCommRingHom = isOCRHomFromℤ
+  isOCRMonoFromℤ .IsOrderedCommRingMono.pres<                = fromℤ-pres<
+
+  fromℤOCR : OrderedCommRingHom ℤOrderedCommRing R
+  fst fromℤOCR = R.fromℤ
+  snd fromℤOCR = isOCRHomFromℤ
+
+  fromℤOCRMono : OrderedCommRingMono ℤOrderedCommRing R
+  fst fromℤOCRMono = R.fromℤ
+  snd fromℤOCRMono = isOCRMonoFromℤ
+
+  isContrHom[ℤOCR,-] : isContr (OrderedCommRingHom ℤOrderedCommRing R)
+  fst isContrHom[ℤOCR,-] = fromℤOCR
+  snd isContrHom[ℤOCR,-] =
+    OrderedCommRingHom≡ ∘ funExt ∘ isUniqueFromℤ ∘ OrderedCommRingHom→CommRingHom
+
+  isContrMono[ℤOCR,-] : isContr (OrderedCommRingMono ℤOrderedCommRing R)
+  fst isContrMono[ℤOCR,-] = fromℤOCRMono
+  snd isContrMono[ℤOCR,-] =
+    OrderedCommRingMono≡ ∘ funExt ∘ isUniqueFromℤ ∘ OrderedCommRingMono→CommRingHom
diff --git a/Cubical/Algebra/OrderedCommRing/Morphisms.agda b/Cubical/Algebra/OrderedCommRing/Morphisms.agda
new file mode 100644
index 0000000000..4e74bb721e
--- /dev/null
+++ b/Cubical/Algebra/OrderedCommRing/Morphisms.agda
@@ -0,0 +1,360 @@
+module Cubical.Algebra.OrderedCommRing.Morphisms where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.SIP
+
+open import Cubical.Algebra.CommRing.Base
+open import Cubical.Algebra.OrderedCommRing.Base
+
+open import Cubical.Data.Sigma
+
+open import Cubical.Reflection.RecordEquiv
+
+private
+  variable
+    ℓ ℓ' ℓ<≤ ℓ<≤' : Level
+
+record IsOrderedCommRingHom {A : Type ℓ} {B : Type ℓ'}
+  (R : OrderedCommRingStr ℓ<≤ A)
+  (f : A → B)
+  (S : OrderedCommRingStr ℓ<≤' B)
+  : Type (ℓ-max ℓ (ℓ-max ℓ' (ℓ-max ℓ<≤ ℓ<≤')))
+  where
+  no-eta-equality
+  private
+    module R = OrderedCommRingStr R
+    module S = OrderedCommRingStr S
+    Rcring = str (OrderedCommRing→CommRing (_ , R))
+    Scring = str (OrderedCommRing→CommRing (_ , S))
+
+  field
+    isCommRingHom : IsCommRingHom Rcring f Scring
+    pres≤         : ∀ x y → x R.≤ y → f x S.≤ f y
+    reflect<      : ∀ x y → f x S.< f y → x R.< y
+
+  open IsCommRingHom isCommRingHom public
+
+unquoteDecl IsOrderedCommRingHomIsoΣ = declareRecordIsoΣ IsOrderedCommRingHomIsoΣ (quote IsOrderedCommRingHom)
+
+OrderedCommRingHom : OrderedCommRing ℓ ℓ<≤ → OrderedCommRing ℓ' ℓ<≤' → Type _
+OrderedCommRingHom R S =
+  Σ[ f ∈ (⟨ R ⟩ → ⟨ S ⟩) ] IsOrderedCommRingHom (R .snd) f (S .snd)
+
+isPropIsOrderedCommRingHom : {A : Type ℓ} {B : Type ℓ'}
+                           → (R : OrderedCommRingStr ℓ<≤ A)
+                           → (f : A → B)
+                           → (S : OrderedCommRingStr ℓ<≤' B)
+                           → isProp (IsOrderedCommRingHom R f S)
+isPropIsOrderedCommRingHom R f S = isOfHLevelRetractFromIso 1
+  IsOrderedCommRingHomIsoΣ $
+  isProp×2 (isPropIsCommRingHom _ f _)
+           (isPropΠ2 λ _ _ → isProp→ (S.is-prop-valued≤ _ _))
+           (isPropΠ2 λ _ _ → isProp→ (R.is-prop-valued< _ _))
+  where
+    open module R = OrderedCommRingStr R
+    open module S = OrderedCommRingStr S
+
+isSetOrderedCommRingHom : (R : OrderedCommRing ℓ ℓ<≤) (S : OrderedCommRing ℓ' ℓ<≤')
+                        → isSet (OrderedCommRingHom R S)
+isSetOrderedCommRingHom R S = isSetΣSndProp (isSetΠ λ _ → is-set) (λ f →
+  isPropIsOrderedCommRingHom (snd R) f (snd S))
+    where open OrderedCommRingStr (str S) using (is-set)
+
+module _
+  {R : OrderedCommRing ℓ  ℓ<≤}
+  {S : OrderedCommRing ℓ' ℓ<≤'}
+  {f : ⟨ R ⟩ → ⟨ S ⟩} where
+
+  private
+    module R = OrderedCommRingStr (str R)
+    module S = OrderedCommRingStr (str S)
+    RCR = OrderedCommRing→CommRing R
+    SCR = OrderedCommRing→CommRing S
+
+  module _
+    (p1  : f R.1r ≡ S.1r)
+    (p+  : ∀ x y → f (x R.+ y) ≡ f x S.+ f y)
+    (p·  : ∀ x y → f (x R.· y) ≡ f x S.· f y)
+    (p<⁻ : ∀ x y → f x S.< f y → x R.< y)
+    where
+
+    open IsOrderedCommRingHom
+
+    private
+      p≤ : ∀ x y → x R.≤ y → f x S.≤ f y
+      p≤ x y = invEq (S.≤≃¬> (f x) (f y)) ∘ (_∘ p<⁻ y x) ∘ equivFun (R.≤≃¬> x y)
+
+    makeIsOrderedCommRingHom : IsOrderedCommRingHom (str R) f (str S)
+    makeIsOrderedCommRingHom .isCommRingHom = makeIsCommRingHom p1 p+ p·
+    makeIsOrderedCommRingHom .pres≤         = p≤
+    makeIsOrderedCommRingHom .reflect<      = p<⁻
+
+  module _ (isHomf : IsOrderedCommRingHom (str R) f (str S)) where
+
+    isOrderedCommRingHom→IsCommRingHom : IsCommRingHom (str RCR) f (str SCR)
+    isOrderedCommRingHom→IsCommRingHom = isCommRingHom
+      where open IsOrderedCommRingHom isHomf
+
+OrderedCommRingHom→CommRingHom : {A : OrderedCommRing ℓ  ℓ<≤}
+                               → {B : OrderedCommRing ℓ' ℓ<≤'}
+                               → OrderedCommRingHom A B
+                               → CommRingHom
+                                  (OrderedCommRing→CommRing A)
+                                  (OrderedCommRing→CommRing B)
+fst (OrderedCommRingHom→CommRingHom f) = fst f
+snd (OrderedCommRingHom→CommRingHom f) = isOrderedCommRingHom→IsCommRingHom (snd f)
+
+_$ocr_ : {R : OrderedCommRing ℓ ℓ<≤} {S : OrderedCommRing ℓ' ℓ<≤'}
+       → (φ : OrderedCommRingHom R S) → (x : ⟨ R ⟩) → ⟨ S ⟩
+φ $ocr x = φ .fst x
+
+opaque
+  OrderedCommRingHom≡ : {R : OrderedCommRing ℓ ℓ<≤} {S : OrderedCommRing ℓ' ℓ<≤'}
+                      → {φ ψ : OrderedCommRingHom R S}
+                      → fst φ ≡ fst ψ
+                      → φ ≡ ψ
+  OrderedCommRingHom≡ = Σ≡Prop λ f → isPropIsOrderedCommRingHom _ f _
+
+  OrderedCommRingHomPathP : (R : OrderedCommRing ℓ ℓ<≤) (S T : OrderedCommRing ℓ' ℓ<≤')
+                          → (p : S ≡ T)
+                          → (φ : OrderedCommRingHom R S)
+                          → (ψ : OrderedCommRingHom R T)
+                          → PathP (λ i → R .fst → p i .fst) (φ .fst) (ψ .fst)
+                          → PathP (λ i → OrderedCommRingHom R (p i)) φ ψ
+  OrderedCommRingHomPathP R S T p φ ψ q = ΣPathP (q , isProp→PathP (λ _ →
+    isPropIsOrderedCommRingHom _ _ _) _ _)
+
+record IsOrderedCommRingMono {A : Type ℓ} {B : Type ℓ'}
+  (R : OrderedCommRingStr ℓ<≤ A)
+  (f : A → B)
+  (S : OrderedCommRingStr ℓ<≤' B)
+  : Type (ℓ-max ℓ (ℓ-max ℓ' (ℓ-max ℓ<≤ ℓ<≤')))
+  where
+  no-eta-equality
+  private
+    module R = OrderedCommRingStr R
+    module S = OrderedCommRingStr S
+
+  field
+    isOrderedCommRingHom : IsOrderedCommRingHom R f S
+    pres<                : (x y : A) → x R.< y → f x S.< f y
+
+  open IsOrderedCommRingHom isOrderedCommRingHom public
+
+unquoteDecl IsOrderedCommRingMonoIsoΣ = declareRecordIsoΣ IsOrderedCommRingMonoIsoΣ (quote IsOrderedCommRingMono)
+
+OrderedCommRingMono : OrderedCommRing ℓ ℓ<≤ → OrderedCommRing ℓ' ℓ<≤' → Type _
+OrderedCommRingMono R S =
+  Σ[ f ∈ (⟨ R ⟩ → ⟨ S ⟩) ] IsOrderedCommRingMono (R .snd) f (S .snd)
+
+OrderedCommRingMono→OrderedCommRingHom : {A : OrderedCommRing ℓ  ℓ<≤}
+                                       → {B : OrderedCommRing ℓ' ℓ<≤'}
+                                       → OrderedCommRingMono A B
+                                       → OrderedCommRingHom A B
+fst (OrderedCommRingMono→OrderedCommRingHom f) = fst f
+snd (OrderedCommRingMono→OrderedCommRingHom f) = isOrderedCommRingHom
+  where open IsOrderedCommRingMono (snd f)
+
+OrderedCommRingMono→CommRingHom : {A : OrderedCommRing ℓ  ℓ<≤}
+                                → {B : OrderedCommRing ℓ' ℓ<≤'}
+                                → OrderedCommRingMono A B
+                                → CommRingHom
+                                   (OrderedCommRing→CommRing A)
+                                   (OrderedCommRing→CommRing B)
+OrderedCommRingMono→CommRingHom =
+  OrderedCommRingHom→CommRingHom ∘ OrderedCommRingMono→OrderedCommRingHom
+
+isPropIsOrderedCommRingMono : {A : Type ℓ} {B : Type ℓ'}
+                            → (R : OrderedCommRingStr ℓ<≤ A)
+                            → (f : A → B)
+                            → (S : OrderedCommRingStr ℓ<≤' B)
+                            → isProp (IsOrderedCommRingMono R f S)
+isPropIsOrderedCommRingMono R f S = isOfHLevelRetractFromIso 1
+  IsOrderedCommRingMonoIsoΣ $
+  isProp× (isPropIsOrderedCommRingHom R f S)
+          (isPropΠ2 λ _ _ → isProp→ (S.is-prop-valued< _ _))
+  where
+    open module S = OrderedCommRingStr S
+
+isSetOrderedCommRingMono : (R : OrderedCommRing ℓ ℓ<≤) (S : OrderedCommRing ℓ' ℓ<≤')
+                         → isSet (OrderedCommRingMono R S)
+isSetOrderedCommRingMono R S = isSetΣSndProp (isSetΠ λ _ → is-set) (λ f →
+  isPropIsOrderedCommRingMono (snd R) f (snd S))
+    where open OrderedCommRingStr (str S) using (is-set)
+
+module _
+  {R : OrderedCommRing ℓ  ℓ<≤}
+  {S : OrderedCommRing ℓ' ℓ<≤'}
+  {f : ⟨ R ⟩ → ⟨ S ⟩} where
+
+  private
+    module R = OrderedCommRingStr (str R)
+    module S = OrderedCommRingStr (str S)
+
+  module _
+    (p1  : f R.1r ≡ S.1r)
+    (p+  : ∀ x y → f (x R.+ y) ≡ f x S.+ f y)
+    (p·  : ∀ x y → f (x R.· y) ≡ f x S.· f y)
+    (p<  : ∀ x y → x R.< y → f x S.< f y)
+    (p<⁻ : ∀ x y → f x S.< f y → x R.< y)
+    where
+
+    open IsOrderedCommRingMono
+
+    makeIsOrderedCommRingMono : IsOrderedCommRingMono (str R) f (str S)
+    makeIsOrderedCommRingMono .isOrderedCommRingHom = makeIsOrderedCommRingHom p1 p+ p· p<⁻
+    makeIsOrderedCommRingMono .pres< = p<
+
+  module _ (isMonof : IsOrderedCommRingMono (str R) f (str S)) where
+
+    isOrderedCommRingMono→reflect≤ : ∀ x y → f x S.≤ f y → x R.≤ y
+    isOrderedCommRingMono→reflect≤ x y =
+      invEq (R.≤≃¬> x y) ∘ (_∘ pres< y x) ∘ equivFun (S.≤≃¬> (f x) (f y))
+      where open IsOrderedCommRingMono isMonof
+
+    isOrderedCommRingMono→isOrderedCommRingHom : IsOrderedCommRingHom (str R) f (str S)
+    isOrderedCommRingMono→isOrderedCommRingHom = isOrderedCommRingHom
+      where open IsOrderedCommRingMono isMonof
+
+    isOrderedCommRingMono→isInjective : ∀ x y → f x ≡ f y → x ≡ y
+    isOrderedCommRingMono→isInjective x y fx≡fy = R.is-antisym x y
+      (isOrderedCommRingMono→reflect≤ x y (subst (S._≤_ (f x)) fx≡fy (S.is-refl _)))
+      (isOrderedCommRingMono→reflect≤ y x (subst (S._≤_ (f y)) (sym fx≡fy) (S.is-refl _)))
+
+opaque
+  OrderedCommRingMono≡ : {R : OrderedCommRing ℓ ℓ<≤} {S : OrderedCommRing ℓ' ℓ<≤'}
+                       → {φ ψ : OrderedCommRingMono R S}
+                       → fst φ ≡ fst ψ
+                       → φ ≡ ψ
+  OrderedCommRingMono≡ = Σ≡Prop λ f → isPropIsOrderedCommRingMono _ f _
+
+  OrderedCommRingMonoPathP : (R : OrderedCommRing ℓ ℓ<≤) (S T : OrderedCommRing ℓ' ℓ<≤')
+                           → (p : S ≡ T)
+                           → (φ : OrderedCommRingMono R S)
+                           → (ψ : OrderedCommRingMono R T)
+                           → PathP (λ i → R .fst → p i .fst) (φ .fst) (ψ .fst)
+                           → PathP (λ i → OrderedCommRingMono R (p i)) φ ψ
+  OrderedCommRingMonoPathP R S T p φ ψ q = ΣPathP (q , isProp→PathP (λ _ →
+    isPropIsOrderedCommRingMono _ _ _) _ _)
+
+record IsOrderedCommRingEquiv {A : Type ℓ} {B : Type ℓ'}
+  (R : OrderedCommRingStr ℓ<≤ A) (e : A ≃ B) (S : OrderedCommRingStr ℓ<≤' B)
+  : Type (ℓ-max (ℓ-max (ℓ-max ℓ ℓ<≤) ℓ') ℓ<≤')
+  where
+  no-eta-equality
+  private
+    module R = OrderedCommRingStr R
+    module S = OrderedCommRingStr S
+    Rcring = str (OrderedCommRing→CommRing (_ , R))
+    Scring = str (OrderedCommRing→CommRing (_ , S))
+    f = equivFun e
+
+  field
+    pres0 : f R.0r ≡ S.0r
+    pres1 : f R.1r ≡ S.1r
+    pres+ : (x y : A) → f (x R.+ y) ≡ f x S.+ f y
+    pres· : (x y : A) → f (x R.· y) ≡ f x S.· f y
+    pres- : (x : A) → f (R.- x) ≡ S.- (f x)
+    pres≤ : (x y : A) → (x R.≤ y) ≃ (f x S.≤ f y)
+    pres< : (x y : A) → (x R.< y) ≃ (f x S.< f y)
+
+unquoteDecl IsOrderedCommRingEquivIsoΣ = declareRecordIsoΣ IsOrderedCommRingEquivIsoΣ (quote IsOrderedCommRingEquiv)
+
+OrderedCommRingEquiv : OrderedCommRing ℓ ℓ<≤ → OrderedCommRing ℓ' ℓ<≤' → Type _
+OrderedCommRingEquiv R S =
+  Σ[ e ∈ (R .fst ≃ S .fst) ] IsOrderedCommRingEquiv (R .snd) e (S .snd)
+
+
+OrderedCommRingEquiv→OrderedCommRingMono : {A : OrderedCommRing ℓ  ℓ<≤}
+                                         → {B : OrderedCommRing ℓ' ℓ<≤'}
+                                         → OrderedCommRingEquiv A B
+                                         → OrderedCommRingMono A B
+fst (OrderedCommRingEquiv→OrderedCommRingMono e) = equivFun (fst e)
+snd (OrderedCommRingEquiv→OrderedCommRingMono e) = isOCRMono
+  where
+    module E = IsOrderedCommRingEquiv (snd e)
+    open IsCommRingHom
+    open IsOrderedCommRingHom  renaming (isCommRingHom to isCRHom)
+    open IsOrderedCommRingMono renaming (isOrderedCommRingHom to isOCRHom)
+
+    isOCRMono : IsOrderedCommRingMono _ _ _
+    isOCRMono .isOCRHom .isCRHom .pres0 = E.pres0
+    isOCRMono .isOCRHom .isCRHom .pres1 = E.pres1
+    isOCRMono .isOCRHom .isCRHom .pres+ = E.pres+
+    isOCRMono .isOCRHom .isCRHom .pres· = E.pres·
+    isOCRMono .isOCRHom .isCRHom .pres- = E.pres-
+    isOCRMono .isOCRHom .pres≤          = λ x y → equivFun (E.pres≤ x y)
+    isOCRMono .isOCRHom .reflect<       = λ x y → invEq (E.pres< x y)
+    isOCRMono .pres<                    = λ x y → equivFun (E.pres< x y)
+
+OrderedCommRingEquiv→OrderedCommRingHom : {A : OrderedCommRing ℓ  ℓ<≤}
+                                        → {B : OrderedCommRing ℓ' ℓ<≤'}
+                                        → OrderedCommRingEquiv A B
+                                        → OrderedCommRingHom A B
+OrderedCommRingEquiv→OrderedCommRingHom =
+  OrderedCommRingMono→OrderedCommRingHom ∘ OrderedCommRingEquiv→OrderedCommRingMono
+
+OrderedCommRingEquiv→CommRingHom : {A : OrderedCommRing ℓ  ℓ<≤}
+                                 → {B : OrderedCommRing ℓ' ℓ<≤'}
+                                 → OrderedCommRingEquiv A B
+                                 → CommRingHom
+                                    (OrderedCommRing→CommRing A)
+                                    (OrderedCommRing→CommRing B)
+OrderedCommRingEquiv→CommRingHom =
+  OrderedCommRingHom→CommRingHom ∘ OrderedCommRingEquiv→OrderedCommRingHom
+
+isPropIsOrderedCommRingEquiv : {A : Type ℓ} {B : Type ℓ'}
+                             → (R : OrderedCommRingStr ℓ<≤ A)
+                             → (e : A ≃ B)
+                             → (S : OrderedCommRingStr ℓ<≤' B)
+                             → isProp (IsOrderedCommRingEquiv R e S)
+isPropIsOrderedCommRingEquiv R e S = isOfHLevelRetractFromIso 1
+  IsOrderedCommRingEquivIsoΣ $
+  isProp× (S.is-set _ _) $
+  isProp× (S.is-set _ _) $
+  isProp× (isPropΠ2 λ _ _ → S.is-set _ _) $
+  isProp× (isPropΠ2 λ _ _ → S.is-set _ _) $
+  isProp× (isPropΠ  λ _   → S.is-set _ _) $
+  isProp× (isPropΠ2 λ _ _ → isOfHLevel≃ 1 (R.is-prop-valued≤ _ _) (S.is-prop-valued≤ _ _))
+          (isPropΠ2 λ _ _ → isOfHLevel≃ 1 (R.is-prop-valued< _ _) (S.is-prop-valued< _ _))
+  where
+    open module R = OrderedCommRingStr R
+    open module S = OrderedCommRingStr S
+
+isSetOrderedCommRingEquiv : (R : OrderedCommRing ℓ ℓ<≤) (S : OrderedCommRing ℓ' ℓ<≤')
+                          → isSet (OrderedCommRingEquiv R S)
+isSetOrderedCommRingEquiv R S = isSetΣSndProp (isOfHLevel≃ 2 R.is-set S.is-set) (λ e →
+  isPropIsOrderedCommRingEquiv (snd R) e (snd S))
+    where
+      open module R = OrderedCommRingStr (str R)
+      open module S = OrderedCommRingStr (str S)
+
+-- an easier way of establishing an equivalence of ordered commutative rings
+module _ {R : OrderedCommRing ℓ ℓ<≤} {S : OrderedCommRing ℓ' ℓ<≤'} (e : ⟨ R ⟩ ≃ ⟨ S ⟩)
+  where
+  private
+    module R = OrderedCommRingStr (str R)
+    module S = OrderedCommRingStr (str S)
+
+  module _ (isMono : IsOrderedCommRingMono (str R) (equivFun e) (str S)) where
+
+    private
+      module M = IsOrderedCommRingMono isMono
+
+    open IsOrderedCommRingEquiv
+
+    makeIsOrderedCommRingEquiv : IsOrderedCommRingEquiv (str R) e (str S)
+    makeIsOrderedCommRingEquiv .pres0 = M.pres0
+    makeIsOrderedCommRingEquiv .pres1 = M.pres1
+    makeIsOrderedCommRingEquiv .pres+ = M.pres+
+    makeIsOrderedCommRingEquiv .pres· = M.pres·
+    makeIsOrderedCommRingEquiv .pres- = M.pres-
+    makeIsOrderedCommRingEquiv .pres≤ = λ x y → propBiimpl→Equiv
+      (R.is-prop-valued≤ _ _) (S.is-prop-valued≤ _ _)
+      (M.pres≤ x y) (isOrderedCommRingMono→reflect≤ isMono x y)
+    makeIsOrderedCommRingEquiv .pres< = λ x y → propBiimpl→Equiv
+      (R.is-prop-valued< _ _) (S.is-prop-valued< _ _)
+      (M.pres< x y) (M.reflect< x y)
diff --git a/Cubical/Algebra/OrderedCommRing/Properties.agda b/Cubical/Algebra/OrderedCommRing/Properties.agda
new file mode 100644
index 0000000000..1a9a11c117
--- /dev/null
+++ b/Cubical/Algebra/OrderedCommRing/Properties.agda
@@ -0,0 +1,683 @@
+module Cubical.Algebra.OrderedCommRing.Properties where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Structure
+
+open import Cubical.Algebra.CommMonoid
+open import Cubical.Algebra.CommRing
+open import Cubical.Algebra.CommSemiring
+open import Cubical.Algebra.OrderedCommRing.Base
+open import Cubical.Algebra.Ring
+open import Cubical.Algebra.Semigroup
+
+open import Cubical.Data.Empty as ⊥
+open import Cubical.Data.Sigma
+open import Cubical.Data.Sum
+
+open import Cubical.HITs.PropositionalTruncation as PT
+
+open import Cubical.Relation.Binary.Order.Apartness
+open import Cubical.Relation.Binary.Order.Poset hiding (isPseudolattice)
+open import Cubical.Relation.Binary.Order.Pseudolattice
+open import Cubical.Relation.Binary.Order.Quoset
+open import Cubical.Relation.Binary.Order.QuosetReasoning
+open import Cubical.Relation.Binary.Order.StrictOrder
+
+open import Cubical.Relation.Nullary
+
+open import Cubical.Tactics.CommRingSolver
+
+private
+  variable
+    ℓ ℓ' ℓ'' : Level
+
+OrderedCommRing→StrictOrder : OrderedCommRing ℓ ℓ' → StrictOrder ℓ ℓ'
+OrderedCommRing→StrictOrder R .fst = R .fst
+OrderedCommRing→StrictOrder R .snd = strictorderstr _ isStrictOrder where
+  open OrderedCommRingStr (str R)
+
+OrderedCommRing→Ring : OrderedCommRing ℓ ℓ' → Ring ℓ
+OrderedCommRing→Ring = CommRing→Ring ∘ OrderedCommRing→CommRing
+
+OrderedCommRing→Poset : OrderedCommRing ℓ ℓ' → Poset ℓ ℓ'
+OrderedCommRing→Poset = Pseudolattice→Poset ∘ OrderedCommRing→PseudoLattice
+
+OrderedCommRing→Quoset : OrderedCommRing ℓ ℓ' → Quoset ℓ ℓ'
+OrderedCommRing→Quoset = StrictOrder→Quoset ∘ OrderedCommRing→StrictOrder
+
+OrderedCommRing→Apartness : OrderedCommRing ℓ ℓ' → Apartness ℓ ℓ'
+OrderedCommRing→Apartness = StrictOrder→Apartness ∘ OrderedCommRing→StrictOrder
+
+module _ (R' : OrderedCommRing ℓ ℓ') where
+  private
+    R = fst R'
+    RCR = OrderedCommRing→CommRing R'
+  open RingTheory (OrderedCommRing→Ring R')
+  open OrderedCommRingStr (snd R')
+  open PseudolatticeTheory (OrderedCommRing→PseudoLattice R') public renaming (
+      L≤∨ to L≤⊔ ; R≤∨ to R≤⊔ ; ∨Comm to ⊔Comm ; ∨Idem to ⊔Idem ; ∨LUB to ⊔LUB
+    ; ∧≤L to ⊓≤L ; ∧≤R to ⊓≤R ; ∧Comm to ⊓Comm ; ∧Idem to ⊓Idem ; ∧GLB to ⊓GLB)
+
+  module OrderedCommRingReasoning where
+    open <-≤-Reasoning
+      (fst R')
+      (str (OrderedCommRing→Poset  R'))
+      (str (OrderedCommRing→Quoset R'))
+      (λ x {y} {z} → <-≤-trans x y z)
+      (λ x {y} {z} → ≤-<-trans x y z)
+      (λ   {x} {y} → <-≤-weaken x y)
+      public
+
+    open <-syntax public
+    open ≤-syntax public
+    open ≡-syntax public
+
+    _<+[_] : ∀ {x y} → x < y → ∀ z → x + z < y + z
+    _<+[_] x<y z = +MonoR< _ _ z x<y
+
+    [_]+<_ : ∀ {x y} z → x < y → z + x < z + y
+    [_]+<_ z = subst2 _<_ (+Comm _ z) (+Comm _ z) ∘ +MonoR< _ _ z
+
+    _≤+[_] : ∀ {x y} → x ≤ y → ∀ z → x + z ≤ y + z
+    _≤+[_] x≤y z = +MonoR≤ _ _ z x≤y
+
+    [_]+≤_ : ∀ {x y} z → x ≤ y → z + x ≤ z + y
+    [_]+≤_ z = subst2 _≤_ (+Comm _ z) (+Comm _ z) ∘ +MonoR≤ _ _ z
+
+    _<·[_,_] : ∀ {x y} → x < y → ∀ z → 0r < z → x · z < y · z
+    _<·[_,_] x<y z 0<z = ·MonoR< _ _ z 0<z x<y
+
+    [_,_]·<_ : ∀ {x y} z → 0r < z → x < y → z · x < z · y
+    [_,_]·<_ z = (subst2 _<_ (·Comm _ z) (·Comm _ z) ∘_) ∘ ·MonoR< _ _ z
+
+    _≤·[_,_] : ∀ {x y} → x ≤ y → ∀ z → 0r ≤ z → x · z ≤ y · z
+    _≤·[_,_] x≤y z 0≤z = ·MonoR≤ _ _ z 0≤z x≤y
+
+    [_,_]·≤_ : ∀ {x y} z → 0r ≤ z → x ≤ y → z · x ≤ z · y
+    [_,_]·≤_ z = (subst2 _≤_ (·Comm _ z) (·Comm _ z) ∘_) ∘ ·MonoR≤ _ _ z
+
+    private
+      example : ∀ a b c d e f g
+              → (0r < f) → a < (b + c) → b ≤ d → (d + c) < (e · f) → e < g
+              → a < (g · f)
+      example a b c d e f g 0<f a<b+c b≤d d+c<e·f e<g = begin<
+        a     <⟨ a<b+c ⟩
+        b + c ≤⟨ b≤d ≤+[ c ] ⟩
+        d + c <⟨ d+c<e·f ⟩
+        e · f <⟨ e<g <·[ f , 0<f ] ⟩
+        g · f ◾
+
+  open OrderedCommRingReasoning
+
+  module OrderedCommRingTheory where
+    open ApartnessStr (str (OrderedCommRing→Apartness R')) using (_#_) public
+
+    0≤1 : 0r ≤ 1r
+    0≤1 = <-≤-weaken 0r 1r 0<1
+
+    ≤→¬> : ∀ x y → x ≤ y → ¬ (y < x)
+    ≤→¬> x y = equivFun (≤≃¬> x y)
+
+    ¬<→≥ : ∀ x y → ¬ (x < y) → y ≤ x
+    ¬<→≥ x y = invEq (≤≃¬> y x)
+
+    +MonoL< : ∀ x y z → x < y → z + x < z + y
+    +MonoL< x y z = subst2 _<_ (+Comm _ _) (+Comm _ _) ∘ +MonoR< x y z
+
+    +Mono< : ∀ x y z w → x < y → z < w → x + z < y + w
+    +Mono< x y z w x<y z<w = is-trans< _ _ _ (+MonoR< _ _ _ x<y) (+MonoL< _ _ _ z<w)
+
+    +MonoL≤ : ∀ x y z → x ≤ y → z + x ≤ z + y
+    +MonoL≤ x y z = subst2 _≤_ (+Comm _ _) (+Comm _ _) ∘ +MonoR≤ x y z
+
+    +Mono≤ : ∀ x y z w → x ≤ y → z ≤ w → x + z ≤ y + w
+    +Mono≤ x y z w x≤y z≤w = is-trans≤ _ _ _ (+MonoR≤ _ _ _ x≤y) (+MonoL≤ _ _ _ z≤w)
+
+    ·MonoL< : ∀ x y z → 0r < z → x < y → z · x < z · y
+    ·MonoL< x y z = (subst2 _<_ (·Comm _ _) (·Comm _ _) ∘_) ∘ ·MonoR< _ _ _
+
+    ·MonoL≤ : ∀ x y z → 0r ≤ z → x ≤ y → z · x ≤ z · y
+    ·MonoL≤ x y z = (subst2 _≤_ (·Comm _ _) (·Comm _ _) ∘_) ∘ ·MonoR≤ _ _ _
+
+    ·CancelL≤ : ∀ x y z → 0r < z → z · x ≤ z · y → x ≤ y
+    ·CancelL≤ x y z 0<z zx≤zy = ¬<→≥ y x $ ≤→¬> _ _ zx≤zy ∘ ·MonoL< _ _ z 0<z
+
+    ·CancelR≤ : ∀ x y z → 0r < z → x · z ≤ y · z → x ≤ y
+    ·CancelR≤ x y z 0<z zx≤zy = ¬<→≥ y x $ ≤→¬> _ _ zx≤zy ∘ ·MonoR< _ _ z 0<z
+
+    -- NOTE:
+    -- It's to not clear if the properties commented below are derivable.
+    -- Note that we can prove their double negations, so they are classically valid;
+    -- moreover, in a Ordered Heyting Field (where elements are invertible iff they
+    -- are apart form zero) we can prove them by multiplying both sides by z⁻¹
+    --
+    -- ·CancelL< : ∀ x y z → 0r < z → z · x < z · y → x < y
+    -- ·CancelL< = ?
+    --
+    -- ·CancelR< : ∀ x y z → 0r < z → x · z < y · z → x < y
+    -- ·CancelR< = ?
+
+    ¬¬·CancelL< : ∀ x y z → 0r < z → z · x < z · y → ¬ ¬ (x < y)
+    ¬¬·CancelL< x y z 0<z zx<zy ¬x<y =
+      ≤→¬> _ _ (·MonoL≤ _ _ z (<-≤-weaken 0r z 0<z) (¬<→≥ _ _ ¬x<y)) zx<zy
+
+    ¬¬·CancelR< : ∀ x y z → 0r < z → x · z < y · z → ¬ ¬ (x < y)
+    ¬¬·CancelR< x y z 0<z xz<yz ¬x<y =
+      ≤→¬> _ _ (·MonoR≤ _ _ z (<-≤-weaken 0r z 0<z) (¬<→≥ _ _ ¬x<y)) xz<yz
+
+    ≥Using< : ∀ x y → (x < y → y ≤ x) → y ≤ x
+    ≥Using< x y <→≥ = ¬<→≥ x y (∘diag (≤→¬> y x ∘ <→≥))
+
+    abs ∣_∣ : R → R
+    abs z = z ⊔ (- z)
+    ∣_∣ = abs
+
+    <SumLeftPos : ∀ x y → 0r < y → x < x + y
+    <SumLeftPos x y = subst (_< x + y) (+IdR x) ∘ +MonoL< 0r y x
+
+    <SumRightPos : ∀ x y → 0r < y → x < y + x
+    <SumRightPos x y = subst (_< y + x) (+IdL x) ∘ +MonoR< 0r y x
+
+    ≤SumLeftNonNeg : ∀ x y → 0r ≤ y → x ≤ x + y
+    ≤SumLeftNonNeg x y = subst (_≤ x + y) (+IdR x) ∘ +MonoL≤ 0r y x
+
+    ≤SumRightNonNeg : ∀ x y → 0r ≤ y → x ≤ y + x
+    ≤SumRightNonNeg x y = subst (_≤ y + x) (+IdL x) ∘ +MonoR≤ 0r y x
+
+    -Flip< : ∀ x y → x < y → - y < - x
+    -Flip< x y x<y = begin<
+      - y           ≡→≤⟨ solve! RCR ⟩
+      x + (- x - y)   <⟨ x<y <+[ - x - y ] ⟩
+      y + (- x - y) ≡→≤⟨ solve! RCR ⟩
+      - x             ◾
+
+    -Flip≤ : ∀ x y → x ≤ y → - y ≤ - x
+    -Flip≤ x y x≤y = begin≤
+      - y           ≡→≤⟨ solve! RCR ⟩
+      x + (- x - y)   ≤⟨ x≤y ≤+[ - x - y ] ⟩
+      y + (- x - y) ≡→≤⟨ solve! RCR ⟩
+      - x             ◾
+
+    0<→-<0 : ∀ x → 0r < x → - x < 0r
+    0<→-<0 x = subst (- x <_) (solve! RCR) ∘ -Flip< 0r x
+
+    <0→0<- : ∀ x → x < 0r → 0r < - x
+    <0→0<- x = subst (_< - x) (solve! RCR) ∘ -Flip< x 0r
+
+    0≤→-≤0 : ∀ x → 0r ≤ x → - x ≤ 0r
+    0≤→-≤0 x = subst (- x ≤_) (solve! RCR) ∘ -Flip≤ 0r x
+
+    ≤0→0≤- : ∀ x → x ≤ 0r → 0r ≤ - x
+    ≤0→0≤- x = subst (_≤ - x) (solve! RCR) ∘ -Flip≤ x 0r
+
+    <→0<Δ : ∀ x y → x < y → 0r < y - x
+    <→0<Δ x y = subst (_< (y - x)) (+InvR x) ∘ +MonoR< x y (- x)
+
+    ≤→0≤Δ : ∀ x y → x ≤ y → 0r ≤ y - x
+    ≤→0≤Δ x y = subst (_≤ (y - x)) (+InvR x) ∘ +MonoR≤ x y (- x)
+
+    0<Δ→< : ∀ x y → 0r < y - x → x < y
+    0<Δ→< x y = subst2 _<_ (solve! RCR) (solve! RCR) ∘ +MonoR< 0r (y - x) x
+
+    0≤Δ→≤ : ∀ x y → 0r ≤ y - x → x ≤ y
+    0≤Δ→≤ x y = subst2 _≤_ (solve! RCR) (solve! RCR) ∘ +MonoR≤ 0r (y - x) x
+
+    0≤² : ∀ x → 0r ≤ x · x
+    0≤² x = ≥Using< (x · x) 0r λ x²<0 →
+      let
+        0≤x : 0r ≤ x
+        0≤x = ¬<→≥ x 0r λ x<0 → is-irrefl 0r $ begin<
+          0r             ≡→≤⟨ sym $ 0LeftAnnihilates (- x) ⟩
+          0r · (- x)       <⟨ ∘diag (·MonoR< _ _ _) (<0→0<- x x<0) ⟩
+          (- x) · (- x)  ≡→≤⟨ solve! RCR ⟩
+          x · x            <⟨ x²<0 ⟩
+          0r               ◾
+      in
+        subst (_≤ x · x) (solve! RCR) (∘diag (·MonoR≤ _ _ _) 0≤x)
+
+    #→0<² : ∀ x → x # 0r → 0r < x · x
+    #→0<² x (inl x<0) =
+      subst2 _<_ (solve! RCR) (solve! RCR) (∘diag (·MonoR< _ _ _) (<0→0<- x x<0))
+    #→0<² x (inr 0<x) =
+      subst (_< x · x) (solve! RCR) (∘diag (·MonoR< _ _ _) 0<x)
+
+    ≤abs : ∀ z → z ≤ abs z
+    ≤abs z = L≤⊔
+
+    -≤abs : ∀ z → - z ≤ abs z
+    -≤abs z = R≤⊔
+
+    0≤abs : ∀ z → 0r ≤ abs z
+    0≤abs z = ¬<→≥ (abs z) 0r λ ∣z∣<0 → is-irrefl 0r $ begin<
+      0r      ≡→≤⟨ solve! RCR ⟩
+      - 0r      <⟨ -Flip< _ _ ∣z∣<0 ⟩
+      - abs z   ≤⟨ -Flip≤ _ _ (≤abs z) ⟩
+      - z       ≤⟨ -≤abs z ⟩
+      abs z     <⟨ ∣z∣<0 ⟩
+      0r        ◾
+
+    abs≤0→≡0 : ∀ z → abs z ≤ 0r → z ≡ 0r
+    abs≤0→≡0 z ∣z∣≤0 = is-antisym z 0r
+      (begin≤
+        z     ≤⟨ ≤abs z ⟩
+        abs z ≤⟨ ∣z∣≤0 ⟩
+        0r         ◾)
+      (begin≤
+        0r        ≡→≤⟨ solve! RCR ⟩
+        - 0r        ≤⟨ -Flip≤ _ _ ∣z∣≤0 ⟩
+        - (abs z)   ≤⟨ -Flip≤ _ _ $ -≤abs z ⟩
+        - - z     ≡→≤⟨ solve! RCR ⟩
+        z           ◾)
+
+    #→0<abs : ∀ z → z # 0r → 0r < abs z
+    #→0<abs z (inl z<0) = begin<
+      0r    ≡→≤⟨ solve! RCR ⟩
+      - 0r    <⟨ -Flip< z 0r z<0 ⟩
+      - z     ≤⟨ -≤abs _ ⟩
+      abs z   ◾
+    #→0<abs z (inr 0<z) = begin<
+      0r    <⟨ 0<z ⟩
+      z     ≤⟨ ≤abs _ ⟩
+      abs z ◾
+
+    abs- : ∀ x → abs (- x) ≡ abs x
+    abs- x = cong ((- x) ⊔_) (solve! RCR) ∙ ⊔Comm
+
+    0≤→abs≡id : ∀ x → 0r ≤ x → abs x ≡ x
+    0≤→abs≡id x 0≤x = is-antisym (abs x) x
+      (⊔LUB (is-refl x) (begin≤ - x ≤⟨ 0≤→-≤0 x 0≤x ⟩ 0r ≤⟨ 0≤x ⟩ x ◾))
+      (≤abs x)
+
+    ≤0→abs≡- : ∀ x → x ≤ 0r → abs x ≡ - x
+    ≤0→abs≡- x x≤0 = sym (abs- x) ∙ 0≤→abs≡id (- x) (≤0→0≤- x x≤0)
+
+    0<→abs≡id : ∀ x → 0r < x → abs x ≡ x
+    0<→abs≡id x = 0≤→abs≡id x ∘ <-≤-weaken 0r x
+
+    <0→abs≡- : ∀ x → x < 0r → abs x ≡ - x
+    <0→abs≡- x = ≤0→abs≡- x ∘ <-≤-weaken x 0r
+
+    ²∘abs≡² : ∀ x → abs x · abs x ≡ x · x
+    ²∘abs≡² x = is-antisym (abs x · abs x) (x · x)
+      (¬<→≥ (x · x) (abs x · abs x) λ x²<∣x∣² →
+        let
+          0≤x : 0r ≤ x
+          0≤x = ¬<→≥ x 0r λ x<0 → is-irrefl (x · x) (begin<
+            x · x           <⟨ x²<∣x∣² ⟩
+            abs x · abs x ≡→≤⟨ cong (∘diag _·_) (<0→abs≡- x x<0) ∙ solve! RCR ⟩
+            x · x           ◾)
+        in
+          is-irrefl (x · x) (begin<
+            x · x           <⟨ x²<∣x∣² ⟩
+            abs x · abs x ≡→≤⟨ cong (∘diag _·_) (0≤→abs≡id x 0≤x) ⟩
+            x · x           ◾))
+      (0≤Δ→≤ (x · x) (abs x · abs x) (begin≤
+        0r                          ≡→≤⟨ solve! RCR ⟩
+        0r · (abs x - - x)            ≤⟨ ·MonoR≤ 0r _ _ (≤→0≤Δ _ _ (-≤abs x))
+                                                        (≤→0≤Δ _ _ (≤abs x)) ⟩
+        (abs x - x) · (abs x - - x) ≡→≤⟨ solve! RCR ⟩
+        abs x · abs x - x · x         ◾))
+
+    abs∘²≡² : ∀ x → abs(x · x) ≡ x · x
+    abs∘²≡² x = 0≤→abs≡id (x · x) (0≤² x)
+
+    triangularInequality ▵≤ : ∀ x y → abs (x + y) ≤ abs x + abs y
+    triangularInequality x y = ⊔LUB
+      (begin≤
+        x     + y     ≤⟨ +Mono≤ _ _ _ _ (≤abs x) (≤abs y) ⟩
+        abs x + abs y ◾)
+      (begin≤
+        - (x + y)    ≡→≤⟨ solve! RCR ⟩
+        (- x) - y      ≤⟨ +Mono≤ _ _ _ _ (-≤abs x) (-≤abs y) ⟩
+        abs x + abs y ◾)
+
+    ▵≤ = triangularInequality
+
+    triangularInequality- ▵≤- : ∀ x y z → abs (x - y) ≤ abs (x - z) + abs (z - y)
+    triangularInequality- x y z = begin≤
+      abs (x - y)               ≡→≤⟨ cong abs (solve! RCR) ⟩
+      abs ((x - z) + (z - y))     ≤⟨ triangularInequality (x - z) (z - y) ⟩
+      abs (x - z) + abs (z - y)   ◾
+
+    ▵≤- = triangularInequality-
+
+    abs-Comm : ∀ x y → abs (x - y) ≡ abs (y - x)
+    abs-Comm x y =
+      abs (x - y)             ≡⟨⟩
+      (x - y) ⊔ (- (x - y))   ≡⟨ ⊔Comm ⟩
+      (- (x - y)) ⊔ (x - y)   ≡⟨ cong₂ _⊔_ (solve! RCR) (solve! RCR) ⟩
+      (y - x) ⊔ (- (y - x))   ≡⟨⟩
+      abs (y - x)             ∎
+
+    abs0 : abs 0r ≡ 0r
+    abs0 = 0≤→abs≡id 0r (is-refl 0r)
+
+    abs1 : abs 1r ≡ 1r
+    abs1 = 0≤→abs≡id 1r 0≤1
+
+  open OrderedCommRingTheory
+
+  module AdditiveSubType
+    (P : R → Type ℓ'')
+    (P-prop : ∀ x → isProp (P x))
+    (+Closed : (x y : R) → P x → P y → P (x + y))
+    where
+
+    subtype = Σ[ x ∈ R ] P x
+
+    isSetSubtype : isSet subtype
+    isSetSubtype = isSetΣSndProp is-set P-prop
+
+    ι : subtype → R
+    ι = fst
+
+    subtype≡ : ∀ {x y} → ι x ≡ ι y → x ≡ y
+    subtype≡ = Σ≡Prop P-prop
+
+    _+subtype_ : subtype → subtype → subtype
+    (x +subtype y) .fst = fst x + fst y
+    (x +subtype y) .snd = +Closed (fst x) (fst y) (snd x) (snd y)
+
+    _-subtype_ : subtype → subtype → R
+    _-subtype_ x y = ι x - ι y
+
+    _<subtype_ : subtype → subtype → Type ℓ'
+    _<subtype_ x y = ι x < ι y
+
+    _≤subtype_ : subtype → subtype → Type ℓ'
+    _≤subtype_ x y = ι x ≤ ι y
+
+    infixl 6 _+subtype_ _-subtype_
+    infix  4 _<subtype_ _≤subtype_
+
+  module AdditiveAndMultiplicativeSubType
+    (P : R → Type ℓ'')
+    (P-prop : ∀ x → isProp (P x))
+    (+Closed : (x y : R) → P x → P y → P (x + y))
+    (·Closed : (x y : R) → P x → P y → P (x · y))
+    where
+    open AdditiveSubType P P-prop +Closed public
+
+    _·subtype_ : subtype → subtype → subtype
+    (x ·subtype y) .fst = fst x · fst y
+    (x ·subtype y) .snd = ·Closed (fst x) (fst y) (snd x) (snd y)
+
+    infixl 7 _·subtype_
+
+  -- Of course 0<+Closed and 0<·Closed are derivable, but for concrete instances
+  -- (like the rationals) it's more efficient to use alternative proofs
+  module Positive
+    (0<+Closed : (x y : R) → 0r < x → 0r < y → 0r < x + y)
+    (0<·Closed : (x y : R) → 0r < x → 0r < y → 0r < x · y)
+    where
+    open AdditiveAndMultiplicativeSubType
+      (0r <_) (is-prop-valued< 0r) 0<+Closed 0<·Closed public renaming (
+        subtype to R₊ ; isSetSubtype to isSetR₊ ; ι to ⟨_⟩₊ ; subtype≡ to R₊≡
+      ; _+subtype_ to _+₊_ ; _·subtype_ to _·₊_ ; _-subtype_ to _-₊_
+      ; _≤subtype_ to _≤₊_ ; _<subtype_ to _<₊_)
+
+    R₊AdditiveSemigroup : Semigroup _
+    fst R₊AdditiveSemigroup = R₊
+    SemigroupStr._·_ (snd R₊AdditiveSemigroup) = _+₊_
+    SemigroupStr.isSemigroup (snd R₊AdditiveSemigroup) = isSG
+      where
+        isSG : IsSemigroup _
+        isSG .IsSemigroup.is-set = isSetR₊
+        isSG .IsSemigroup.·Assoc = λ _ _ _ → R₊≡ (+Assoc _ _ _)
+
+    open SemigroupStr (snd R₊AdditiveSemigroup) public hiding (_·_) renaming (
+      ·Assoc to +₊Assoc)
+
+    R₊MultiplicativeCommMonoid : CommMonoid _
+    fst R₊MultiplicativeCommMonoid = R₊
+    CommMonoidStr.ε   (snd R₊MultiplicativeCommMonoid) = 1r , 0<1
+    CommMonoidStr._·_ (snd R₊MultiplicativeCommMonoid) = _·₊_
+    CommMonoidStr.isCommMonoid (snd R₊MultiplicativeCommMonoid) =
+      makeIsCommMonoid
+        isSetR₊
+        (λ _ _ _ → R₊≡ (·Assoc _ _ _))
+        (λ _     → R₊≡ (·IdR _))
+        (λ _ _   → R₊≡ (·Comm _ _))
+
+    open CommMonoidStr (snd R₊MultiplicativeCommMonoid) public hiding (_·_) renaming (
+      ε to 1₊ ; ·Assoc to ·₊Assoc ; ·IdR to ·₊IdR ; ·Comm to ·₊Comm)
+
+    selfSeparated : ∀ (x y : R) → (∀ (z : R₊) → abs(x - y) < ⟨ z ⟩₊) → x ≡ y
+    selfSeparated x y ∀[•]∣x-y∣<• =
+      let
+        ∣x-y∣≤0 : abs(x - y) ≤ 0r
+        ∣x-y∣≤0 = ¬<→≥ 0r (abs(x - y)) λ 0<∣x-y∣ → is-irrefl (abs(x - y)) $ begin<
+          abs(x - y) <⟨ ∀[•]∣x-y∣<• (abs(x - y) , 0<∣x-y∣) ⟩
+          abs(x - y) ◾
+
+        x-y≡0 : x - y ≡ 0r
+        x-y≡0 = abs≤0→≡0 (x - y) ∣x-y∣≤0
+      in
+        equalByDifference x y x-y≡0
+
+    _⊔₊_ : R₊ → R₊ → R₊
+    (x ⊔₊ y) .fst = ⟨ x ⟩₊ ⊔ ⟨ y ⟩₊
+    (x ⊔₊ y) .snd = begin< 0r <⟨ snd x ⟩ ⟨ x ⟩₊ ≤⟨ L≤⊔ ⟩ ⟨ x ⟩₊ ⊔ ⟨ y ⟩₊ ◾
+
+    plusMinus₊ : ∀ x y → (x +₊ y) -₊ y ≡ ⟨ x ⟩₊
+    plusMinus₊ (x , _) (y , _) = solve! RCR
+
+    minusPlus₊ : ∀ x y → x -₊ y + ⟨ y ⟩₊ ≡ ⟨ x ⟩₊
+    minusPlus₊ (x , _) (y , _) = solve! RCR
+
+    ≡₊→0< : ∀ {x} y → x ≡ ⟨ y ⟩₊ → 0r < x
+    ≡₊→0< y p = subst (0r <_) (sym p) (snd y)
+
+    ≡₊→R₊ : ∀ {x} y → x ≡ ⟨ y ⟩₊ → R₊
+    ≡₊→R₊ y p .fst = _
+    ≡₊→R₊ y p .snd = ≡₊→0< y p
+
+    infixl 6 -₊<
+    -₊< : ∀ x y → y <₊ x → R₊
+    -₊< x y y<x .fst = x -₊ y
+    -₊< x y y<x .snd = <→0<Δ ⟨ y ⟩₊ ⟨ x ⟩₊ y<x
+
+    syntax -₊< x y y<x = x -₊[ y<x ] y
+
+    [_-₊_]⟨_⟩ : ∀ x y → y <₊ x → R₊
+    [_-₊_]⟨_⟩ = -₊<
+
+    <₊SumLeft : ∀ x y → x <₊ x +₊ y
+    <₊SumLeft (x , _) (y , 0<y) = begin<
+      x ≡→≤⟨ solve! RCR ⟩ x + 0r <⟨ +MonoL< _ _ _ 0<y ⟩ x + y ◾
+
+    <₊SumRight : ∀ x y → x <₊ y +₊ x
+    <₊SumRight (x , _) (y , 0<y) = begin<
+      x ≡→≤⟨ solve! RCR ⟩ 0r + x <⟨ +MonoR< _ _ _ 0<y ⟩ y + x ◾
+
+    Δ<₊ : ∀ x y → x -₊ y < ⟨ x ⟩₊
+    Δ<₊ (x , _) (y , 0<y) = begin<
+      x - y <⟨ +MonoL< _ _ _ (-Flip< 0r y 0<y) ⟩ x - 0r ≡→≤⟨ solve! RCR ⟩ x ◾
+
+  -- Of course 0≤+Closed and 0≤·Closed are derivable, but for concrete instances
+  -- (like the rationals) it's more efficient to use alternative proofs
+  module NonNegative
+    (0≤+Closed : (x y : R) → 0r ≤ x → 0r ≤ y → 0r ≤ x + y)
+    (0≤·Closed : (x y : R) → 0r ≤ x → 0r ≤ y → 0r ≤ x · y)
+    where
+    open AdditiveAndMultiplicativeSubType
+      (0r ≤_) (is-prop-valued≤ 0r) 0≤+Closed 0≤·Closed public renaming (
+        subtype to R₀₊ ; isSetSubtype to isSetR₀₊ ; ι to ⟨_⟩₀₊ ; subtype≡ to R₀₊≡
+      ; _+subtype_ to _+₀₊_ ; _·subtype_ to _·₀₊_ ; _-subtype_ to _-₀₊_
+      ; _≤subtype_ to _≤₀₊_ ; _<subtype_ to _<₀₊_)
+
+    R₀₊CommSemiring : CommSemiring _
+    fst R₀₊CommSemiring = R₀₊
+    CommSemiringStr.0r  (snd R₀₊CommSemiring) = 0r , is-refl _
+    CommSemiringStr.1r  (snd R₀₊CommSemiring) = 1r , <-≤-weaken _ _ 0<1
+    CommSemiringStr._+_ (snd R₀₊CommSemiring) = _+₀₊_
+    CommSemiringStr._·_ (snd R₀₊CommSemiring) = _·₀₊_
+    CommSemiringStr.isCommSemiring (snd R₀₊CommSemiring) =
+      makeIsCommSemiring
+        isSetR₀₊
+        (λ _ _ _ → R₀₊≡ (+Assoc _ _ _))
+        (λ _     → R₀₊≡ (+IdR _))
+        (λ _ _   → R₀₊≡ (+Comm _ _))
+        (λ _ _ _ → R₀₊≡ (·Assoc _ _ _))
+        (λ _     → R₀₊≡ (·IdR _))
+        (λ _ _ _ → R₀₊≡ (·DistR+ _ _ _))
+        (λ _     → R₀₊≡ (0LeftAnnihilates _))
+        (λ _ _   → R₀₊≡ (·Comm _ _))
+
+    open CommSemiringStr (snd R₀₊CommSemiring) public hiding (_+_ ; _·_)
+      renaming (
+        0r to 0₀₊ ; 1r to 1₀₊
+      ; +Assoc to +₀₊Assoc ; +IdL to +₀₊IdL ; +IdR to +₀₊IdR ; +Comm to +₀₊Comm
+      ; ·Assoc to ·₀₊Assoc ; ·IdL to ·₀₊IdL ; ·IdR to ·₀₊IdR ; ·Comm to ·₀₊Comm
+      ; ·DistL+ to ·₀₊DistL+₀₊ ; ·DistR+ to ·₀₊DistR+₀₊
+      ; AnnihilL to AnnihilL₀₊ ; AnnihilR to AnnihilR₀₊)
+
+    _⊔₀₊_ : R₀₊ → R₀₊ → R₀₊
+    (x ⊔₀₊ y) .fst = ⟨ x ⟩₀₊ ⊔ ⟨ y ⟩₀₊
+    (x ⊔₀₊ y) .snd = begin≤ 0r ≤⟨ snd x ⟩ ⟨ x ⟩₀₊ ≤⟨ L≤⊔ ⟩ ⟨ x ⟩₀₊ ⊔ ⟨ y ⟩₀₊ ◾
+
+    _⊓₀₊_ : R₀₊ → R₀₊ → R₀₊
+    (x ⊓₀₊ y) .fst = ⟨ x ⟩₀₊ ⊓ ⟨ y ⟩₀₊
+    (x ⊓₀₊ y) .snd = ⊓GLB (snd x) (snd y)
+
+    plusMinus₀₊ : ∀ x y → (x +₀₊ y) -₀₊ y ≡ ⟨ x ⟩₀₊
+    plusMinus₀₊ (x , _) (y , _) = solve! RCR
+
+    minusPlus₀₊ : ∀ x y → x -₀₊ y + ⟨ y ⟩₀₊ ≡ ⟨ x ⟩₀₊
+    minusPlus₀₊ (x , _) (y , _) = solve! RCR
+
+    ≡₀₊→0≤ : ∀ {x} y → x ≡ ⟨ y ⟩₀₊ → 0r ≤ x
+    ≡₀₊→0≤ y p = subst (0r ≤_) (sym p) (snd y)
+
+    ≡₀₊→R₀₊ : ∀ {x} y → x ≡ ⟨ y ⟩₀₊ → R₀₊
+    ≡₀₊→R₀₊ y p .fst = _
+    ≡₀₊→R₀₊ y p .snd = ≡₀₊→0≤ y p
+
+    infixl 6 -₀₊≤
+    -₀₊≤ : ∀ x y → y ≤₀₊ x → R₀₊
+    -₀₊≤ x y y≤x .fst = x -₀₊ y
+    -₀₊≤ x y y≤x .snd = ≤→0≤Δ ⟨ y ⟩₀₊ ⟨ x ⟩₀₊ y≤x
+
+    syntax -₀₊≤ x y y≤x = x -₀₊[ y≤x ] y
+
+    [_-₀₊_]⟨_⟩ : ∀ x y → y ≤₀₊ x → R₀₊
+    [_-₀₊_]⟨_⟩ = -₀₊≤
+
+    ≤₀₊SumLeft : ∀ x y → x ≤₀₊ x +₀₊ y
+    ≤₀₊SumLeft (x , _) (y , 0≤y) = begin≤
+      x ≡→≤⟨ solve! RCR ⟩ x + 0r ≤⟨ +MonoL≤ _ _ _ 0≤y ⟩ x + y ◾
+
+    ≤₀₊SumRight : ∀ x y → x ≤₀₊ y +₀₊ x
+    ≤₀₊SumRight (x , _) (y , 0≤y) = begin≤
+      x ≡→≤⟨ solve! RCR ⟩ 0r + x ≤⟨ +MonoR≤ _ _ _ 0≤y ⟩ y + x ◾
+
+    Δ≤₀₊ : ∀ x y → x -₀₊ y ≤ ⟨ x ⟩₀₊
+    Δ≤₀₊ (x , _) (y , 0≤y) = begin≤
+      x - y ≤⟨ +MonoL≤ _ _ _ (-Flip≤ 0r y 0≤y) ⟩ x - 0r ≡→≤⟨ solve! RCR ⟩ x ◾
+
+  private
+    2r = 1r + 1r
+
+  module 1/2∈R (1/2 : R) (1/2≡2⁻¹ : 1/2 · 2r ≡ 1r) where
+
+    1/2+1/2≡1 : 1/2 + 1/2 ≡ 1r
+    1/2+1/2≡1 =
+      1/2 + 1/2 ≡⟨ solve! RCR ⟩
+      1/2 · 2r  ≡⟨ 1/2≡2⁻¹ ⟩
+      1r        ∎
+
+    0<1/2 : 0r < 1/2
+    0<1/2 = flip (PT.rec (is-prop-valued< 0r 1/2))
+      (posSum→pos∨pos 1/2 1/2 (subst (0r <_) (sym 1/2+1/2≡1) 0<1)) λ
+      { (inl 0<1/2) → 0<1/2
+      ; (inr 0<1/2) → 0<1/2
+      }
+
+    0≤1/2 : 0r ≤ 1/2
+    0≤1/2 = <-≤-weaken _ _ 0<1/2
+
+    _/2 : R → R
+    _/2 = _· 1/2
+
+    _/4 : R → R
+    _/4 = _/2 ∘ _/2
+
+    mean : R → R → R
+    mean x y = (x + y) · 1/2
+
+    meanIdem : ∀ x → mean x x ≡ x
+    meanIdem x =
+      (x + x) · 1/2     ≡⟨ solve! RCR ⟩
+      x · (1/2 + 1/2)   ≡⟨ cong (x ·_) 1/2+1/2≡1 ⟩
+      x · 1r            ≡⟨ solve! RCR ⟩
+      x                 ∎
+
+    <→<mean : ∀ x y → x < y → x < mean x y
+    <→<mean x y x<y = begin<
+      x             ≡→≤⟨ sym (meanIdem x) ⟩
+      (x + x) · 1/2   <⟨ ·MonoR< (x + x) (x + y) 1/2 0<1/2 (+MonoL< x y x x<y) ⟩
+      (x + y) · 1/2   ◾
+
+    <→mean< : ∀ x y → x < y → mean x y < y
+    <→mean< x y x<y = begin<
+      (x + y) · 1/2   <⟨ ·MonoR< (x + y) (y + y) 1/2 0<1/2 (+MonoR< x y y x<y) ⟩
+      (y + y) · 1/2 ≡→≤⟨ meanIdem y ⟩
+      y               ◾
+
+    /2+/2≡id : ∀ x → x /2 + x /2 ≡ x
+    /2+/2≡id x = solve! RCR ∙ meanIdem x
+
+    id-/2≡/2 : ∀ x → x - x /2 ≡ x /2
+    id-/2≡/2 x = cong (_- x /2) (sym (/2+/2≡id x)) ∙ solve! RCR
+
+    /4+/4≡/2 : ∀ x → x /4 + x /4 ≡ x /2
+    /4+/4≡/2 = /2+/2≡id ∘ (_/2)
+
+    /4+/4+/4+/4≡id : ∀ x → (x /4 + x /4) + (x /4 + x /4) ≡ x
+    /4+/4+/4+/4≡id x = cong (∘diag _+_) (/4+/4≡/2 x) ∙ /2+/2≡id x
+
+    /2-/4≡/4 : ∀ x → x /2 - x /4 ≡ x /4
+    /2-/4≡/4 = id-/2≡/2 ∘ (_/2)
+
+    id-[/4+/4]≡/2 : ∀ x → x - (x /4 + x /4) ≡ x /2
+    id-[/4+/4]≡/2 x = cong (_-_ x) (/4+/4≡/2 x) ∙ id-/2≡/2 x
+
+  module PositiveHalves
+    (1/2 : R)
+    (1/2≡2⁻¹ : 1/2 · 2r ≡ 1r)
+    (0<+Closed : (x y : R) → 0r < x → 0r < y → 0r < x + y)
+    (0<·Closed : (x y : R) → 0r < x → 0r < y → 0r < x · y)
+    where
+
+    open 1/2∈R 1/2 1/2≡2⁻¹
+    open Positive 0<+Closed 0<·Closed
+
+    _/2₊ : R₊ → R₊
+    _/2₊ = _·₊ (1/2 , 0<1/2)
+
+    _/4₊ : R₊ → R₊
+    _/4₊ = _/2₊ ∘ _/2₊
+
+    /2₊<id : ∀ x → (x /2₊) <₊ x
+    /2₊<id x = begin<
+      ⟨ x /2₊ ⟩₊            <⟨ <₊SumLeft (x /2₊) (x /2₊) ⟩
+      ⟨ x /2₊ +₊ x /2₊ ⟩₊ ≡→≤⟨ /2+/2≡id ⟨ x ⟩₊ ⟩
+      ⟨ x ⟩₊                ◾
+
+    /4₊</2₊ : ∀ x → (x /4₊) <₊ (x /2₊)
+    /4₊</2₊ = /2₊<id ∘ _/2₊
+
+    /4₊<id : ∀ x → (x /4₊) <₊ x
+    /4₊<id x = begin<
+      ⟨ x /4₊ ⟩₊ <⟨ /4₊</2₊ x ⟩
+      ⟨ x /2₊ ⟩₊ <⟨ /2₊<id x ⟩
+      ⟨ x ⟩₊     ◾
+
+    id-/2₊ : ∀ x → 0r < x -₊ (x /2₊)
+    id-/2₊ x = subst (0r <_) (sym (id-/2≡/2 ⟨ x ⟩₊)) (snd (x /2₊))
+
+    id-[/4+/4]₊ : ∀ x → 0r < x -₊ (x /4₊ +₊ x /4₊)
+    id-[/4+/4]₊ x = subst (0r <_) (cong (_-_ ⟨ x ⟩₊) (sym (/4+/4≡/2 ⟨ x ⟩₊))) (id-/2₊ x)
diff --git a/Cubical/Algebra/OrderedCommRing/Univalence.agda b/Cubical/Algebra/OrderedCommRing/Univalence.agda
new file mode 100644
index 0000000000..94ced02b7b
--- /dev/null
+++ b/Cubical/Algebra/OrderedCommRing/Univalence.agda
@@ -0,0 +1,78 @@
+module Cubical.Algebra.OrderedCommRing.Univalence where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Isomorphism
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.HLevels
+
+open import Cubical.Algebra.OrderedCommRing.Base
+open import Cubical.Algebra.OrderedCommRing.Morphisms
+
+open import Cubical.Data.Sigma
+
+open import Cubical.Displayed.Base
+open import Cubical.Displayed.Auto
+open import Cubical.Displayed.Record
+open import Cubical.Displayed.Universe
+
+private
+  variable
+    ℓ ℓ' ℓ<≤ ℓ<≤' : Level
+
+open Iso
+
+𝒮ᴰ-OrderedCommRing : DUARel (𝒮-Univ ℓ) (OrderedCommRingStr ℓ') (ℓ-max ℓ ℓ')
+𝒮ᴰ-OrderedCommRing =
+  𝒮ᴰ-Record (𝒮-Univ _) IsOrderedCommRingEquiv
+    (fields:
+      data[ 0r ∣ null ∣ pres0 ]
+      data[ 1r ∣ null ∣ pres1 ]
+      data[ _+_ ∣ bin ∣ pres+ ]
+      data[ _·_ ∣ bin ∣ pres· ]
+      data[ -_ ∣ un ∣ pres- ]
+      data[ _<_ ∣ binRel ∣ pres< ]
+      data[ _≤_ ∣ binRel ∣ pres≤ ]
+      prop[ isOrderedCommRing ∣ (λ _ _ → isPropIsOrderedCommRing _ _ _ _ _ _ _) ])
+  where
+    open OrderedCommRingStr
+    open IsOrderedCommRingEquiv
+
+    -- faster with some sharing
+    null = autoDUARel (𝒮-Univ _) (λ A → A)
+    un = autoDUARel (𝒮-Univ _) (λ A → A → A)
+    bin = autoDUARel (𝒮-Univ _) (λ A → A → A → A)
+    binRel = autoDUARel (𝒮-Univ _) (λ A → A → A → Type _)
+
+OrderedCommRingPath : (R S : OrderedCommRing ℓ ℓ') → OrderedCommRingEquiv R S ≃ (R ≡ S)
+OrderedCommRingPath = ∫ 𝒮ᴰ-OrderedCommRing .UARel.ua
+
+uaOrderedCommRing : {A B : OrderedCommRing ℓ ℓ'} → OrderedCommRingEquiv A B → A ≡ B
+uaOrderedCommRing {A = A} {B = B} = equivFun (OrderedCommRingPath A B)
+
+OrderedCommRingIso : OrderedCommRing ℓ ℓ<≤ → OrderedCommRing ℓ' ℓ<≤' → Type _
+OrderedCommRingIso R S =
+  Σ[ e ∈ Iso (R .fst) (S .fst) ] IsOrderedCommRingMono (R .snd) (e .fun) (S .snd)
+
+OrderedCommRingEquivIsoOrderedCommRingIso : (R : OrderedCommRing ℓ  ℓ<≤)
+                                          → (S : OrderedCommRing ℓ' ℓ<≤')
+                                          → Iso (OrderedCommRingEquiv R S)
+                                                (OrderedCommRingIso R S)
+OrderedCommRingEquivIsoOrderedCommRingIso R S = OCREquivIsoOCRIso
+  where
+    open Iso
+    OCREquivIsoOCRIso : Iso (OrderedCommRingEquiv R S) (OrderedCommRingIso R S)
+    fst (fun OCREquivIsoOCRIso e) = equivToIso (fst e)
+    snd (fun OCREquivIsoOCRIso e) = snd (OrderedCommRingEquiv→OrderedCommRingMono e)
+    fst (inv OCREquivIsoOCRIso e) = isoToEquiv (fst e)
+    snd (inv OCREquivIsoOCRIso e) = makeIsOrderedCommRingEquiv (isoToEquiv (fst e)) (snd e)
+    sec OCREquivIsoOCRIso e =
+      Σ≡Prop (λ f → isPropIsOrderedCommRingMono _ (fun f) _) (
+      Iso≡Set (OrderedCommRingStr.is-set (snd R)) (OrderedCommRingStr.is-set (snd S))
+        _ _ (λ x → refl) (λ x → refl))
+    ret OCREquivIsoOCRIso e =
+      Σ≡Prop (λ f → isPropIsOrderedCommRingEquiv _ f _)
+      (equivEq refl)
+
+isGroupoidOrderedCommRing : isGroupoid (OrderedCommRing ℓ ℓ')
+isGroupoidOrderedCommRing _ _ =
+  isOfHLevelRespectEquiv 2 (OrderedCommRingPath _ _) (isSetOrderedCommRingEquiv _ _)
diff --git a/Cubical/Algebra/Ring/Properties.agda b/Cubical/Algebra/Ring/Properties.agda
index 1f9b90f29e..6c8b1a81ef 100644
--- a/Cubical/Algebra/Ring/Properties.agda
+++ b/Cubical/Algebra/Ring/Properties.agda
@@ -14,6 +14,8 @@ open import Cubical.Foundations.Path
 
 open import Cubical.Functions.Embedding
 
+import Cubical.Data.Nat.Base as ℕ
+import Cubical.Data.Int.Base as ℤ
 open import Cubical.Data.Sigma
 
 open import Cubical.Algebra.Monoid
@@ -154,6 +156,15 @@ module RingTheory (R' : Ring ℓ) where
   ·-assoc2 : (x y z w : R) → (x · y) · (z · w) ≡ x · (y · z) · w
   ·-assoc2 x y z w = ·Assoc (x · y) z w ∙ congL _·_ (sym (·Assoc x y z))
 
+  fromℕ : ℕ.ℕ → R
+  fromℕ ℕ.zero = 0r
+  fromℕ (ℕ.suc ℕ.zero) = 1r
+  fromℕ (ℕ.suc (ℕ.suc n)) = 1r + fromℕ (ℕ.suc n)
+
+  fromℤ : ℤ.ℤ → R
+  fromℤ (ℤ.pos n) = fromℕ n
+  fromℤ (ℤ.negsuc n) = - (fromℕ (ℕ.suc n))
+
 Ring→Semiring : Ring ℓ → Semiring ℓ
 Ring→Semiring R =
   let open RingStr (snd R)

From ebe4cd8386dc995f4bb9a3921377d420eebdea04 Mon Sep 17 00:00:00 2001
From: Lorenzo Molena <lorenzo.molena8@gmail.com>
Date: Sat, 4 Apr 2026 18:50:34 +0200
Subject: [PATCH 02/19] =?UTF-8?q?add=20`isUniqueFrom=E2=84=A4OCR`=20and=20?=
 =?UTF-8?q?`isUniqueFrom=E2=84=A4OCRMono`=20in=20`CanonicalMonoFrom?=
 =?UTF-8?q?=E2=84=A4`?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../OrderedCommRing/Instances/Fast/Int.agda      | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/Cubical/Algebra/OrderedCommRing/Instances/Fast/Int.agda b/Cubical/Algebra/OrderedCommRing/Instances/Fast/Int.agda
index cb25a0bd4b..48ccb6ddff 100644
--- a/Cubical/Algebra/OrderedCommRing/Instances/Fast/Int.agda
+++ b/Cubical/Algebra/OrderedCommRing/Instances/Fast/Int.agda
@@ -152,12 +152,20 @@ module CanonicalMonoFromℤ (R : OrderedCommRing ℓ ℓ') where
   fst fromℤOCRMono = R.fromℤ
   snd fromℤOCRMono = isOCRMonoFromℤ
 
+  isUniqueFromℤOCR : (φ : OrderedCommRingHom ℤOrderedCommRing R)
+                   → ∀ n → R.fromℤ n ≡ fst φ n
+  isUniqueFromℤOCR φ = isUniqueFromℤ (OrderedCommRingHom→CommRingHom φ)
+    where open IsOrderedCommRingHom (snd φ)
+
+  isUniqueFromℤOCRMono : (φ : OrderedCommRingMono ℤOrderedCommRing R)
+                       → ∀ n → R.fromℤ n ≡ fst φ n
+  isUniqueFromℤOCRMono φ = isUniqueFromℤ (OrderedCommRingMono→CommRingHom φ)
+    where open IsOrderedCommRingMono (snd φ)
+
   isContrHom[ℤOCR,-] : isContr (OrderedCommRingHom ℤOrderedCommRing R)
   fst isContrHom[ℤOCR,-] = fromℤOCR
-  snd isContrHom[ℤOCR,-] =
-    OrderedCommRingHom≡ ∘ funExt ∘ isUniqueFromℤ ∘ OrderedCommRingHom→CommRingHom
+  snd isContrHom[ℤOCR,-] = OrderedCommRingHom≡ ∘ funExt ∘ isUniqueFromℤOCR
 
   isContrMono[ℤOCR,-] : isContr (OrderedCommRingMono ℤOrderedCommRing R)
   fst isContrMono[ℤOCR,-] = fromℤOCRMono
-  snd isContrMono[ℤOCR,-] =
-    OrderedCommRingMono≡ ∘ funExt ∘ isUniqueFromℤ ∘ OrderedCommRingMono→CommRingHom
+  snd isContrMono[ℤOCR,-] = OrderedCommRingMono≡ ∘ funExt ∘ isUniqueFromℤOCRMono

From 9a827882189e8ed66bd0e8d746a93b5a71c45f6c Mon Sep 17 00:00:00 2001
From: Lorenzo Molena <lorenzo.molena8@gmail.com>
Date: Sat, 4 Apr 2026 19:48:36 +0200
Subject: [PATCH 03/19] =?UTF-8?q?call=20the=20ring=20solver=20only=20when?=
 =?UTF-8?q?=20there=20is=20not=20already=20a=20specific=20lemma=20solving?=
 =?UTF-8?q?=20the=20equality=20;=20use=20`=5F<+[=5F]`,=20`=5F=E2=89=A4?=
 =?UTF-8?q?=C2=B7[=5F,=5F]`,=20etc.=20in=20equational=20reasoning=20;=20sh?=
 =?UTF-8?q?orten=20comment=20about=20`=C2=B7CancelL<`,=20`=C2=B7CancelR<`?=
 =?UTF-8?q?=20;=20add=20`/2+/2=E2=89=A1mean`=20and=20`mean=E2=82=8A`?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../Algebra/OrderedCommRing/Properties.agda   | 70 ++++++++++---------
 1 file changed, 36 insertions(+), 34 deletions(-)

diff --git a/Cubical/Algebra/OrderedCommRing/Properties.agda b/Cubical/Algebra/OrderedCommRing/Properties.agda
index 1a9a11c117..415151ce09 100644
--- a/Cubical/Algebra/OrderedCommRing/Properties.agda
+++ b/Cubical/Algebra/OrderedCommRing/Properties.agda
@@ -148,11 +148,7 @@ module _ (R' : OrderedCommRing ℓ ℓ') where
     ·CancelR≤ : ∀ x y z → 0r < z → x · z ≤ y · z → x ≤ y
     ·CancelR≤ x y z 0<z zx≤zy = ¬<→≥ y x $ ≤→¬> _ _ zx≤zy ∘ ·MonoR< _ _ z 0<z
 
-    -- NOTE:
-    -- It's to not clear if the properties commented below are derivable.
-    -- Note that we can prove their double negations, so they are classically valid;
-    -- moreover, in a Ordered Heyting Field (where elements are invertible iff they
-    -- are apart form zero) we can prove them by multiplying both sides by z⁻¹
+    -- It's to not clear if the properties commented below are constructively derivable.
     --
     -- ·CancelL< : ∀ x y z → 0r < z → z · x < z · y → x < y
     -- ·CancelL< = ?
@@ -160,6 +156,7 @@ module _ (R' : OrderedCommRing ℓ ℓ') where
     -- ·CancelR< : ∀ x y z → 0r < z → x · z < y · z → x < y
     -- ·CancelR< = ?
 
+    -- Howeverer, we can prove their double negations, so they are classically valid
     ¬¬·CancelL< : ∀ x y z → 0r < z → z · x < z · y → ¬ ¬ (x < y)
     ¬¬·CancelL< x y z 0<z zx<zy ¬x<y =
       ≤→¬> _ _ (·MonoL≤ _ _ z (<-≤-weaken 0r z 0<z) (¬<→≥ _ _ ¬x<y)) zx<zy
@@ -202,16 +199,16 @@ module _ (R' : OrderedCommRing ℓ ℓ') where
       - x             ◾
 
     0<→-<0 : ∀ x → 0r < x → - x < 0r
-    0<→-<0 x = subst (- x <_) (solve! RCR) ∘ -Flip< 0r x
+    0<→-<0 x = subst (- x <_) 0Selfinverse ∘ -Flip< 0r x
 
     <0→0<- : ∀ x → x < 0r → 0r < - x
-    <0→0<- x = subst (_< - x) (solve! RCR) ∘ -Flip< x 0r
+    <0→0<- x = subst (_< - x) 0Selfinverse ∘ -Flip< x 0r
 
     0≤→-≤0 : ∀ x → 0r ≤ x → - x ≤ 0r
-    0≤→-≤0 x = subst (- x ≤_) (solve! RCR) ∘ -Flip≤ 0r x
+    0≤→-≤0 x = subst (- x ≤_) 0Selfinverse ∘ -Flip≤ 0r x
 
     ≤0→0≤- : ∀ x → x ≤ 0r → 0r ≤ - x
-    ≤0→0≤- x = subst (_≤ - x) (solve! RCR) ∘ -Flip≤ x 0r
+    ≤0→0≤- x = subst (_≤ - x) 0Selfinverse ∘ -Flip≤ x 0r
 
     <→0<Δ : ∀ x y → x < y → 0r < y - x
     <→0<Δ x y = subst (_< (y - x)) (+InvR x) ∘ +MonoR< x y (- x)
@@ -220,10 +217,10 @@ module _ (R' : OrderedCommRing ℓ ℓ') where
     ≤→0≤Δ x y = subst (_≤ (y - x)) (+InvR x) ∘ +MonoR≤ x y (- x)
 
     0<Δ→< : ∀ x y → 0r < y - x → x < y
-    0<Δ→< x y = subst2 _<_ (solve! RCR) (solve! RCR) ∘ +MonoR< 0r (y - x) x
+    0<Δ→< x y = subst2 _<_ (+IdL x) (solve! RCR) ∘ +MonoR< 0r (y - x) x
 
     0≤Δ→≤ : ∀ x y → 0r ≤ y - x → x ≤ y
-    0≤Δ→≤ x y = subst2 _≤_ (solve! RCR) (solve! RCR) ∘ +MonoR≤ 0r (y - x) x
+    0≤Δ→≤ x y = subst2 _≤_ (+IdL x) (solve! RCR) ∘ +MonoR≤ 0r (y - x) x
 
     0≤² : ∀ x → 0r ≤ x · x
     0≤² x = ≥Using< (x · x) 0r λ x²<0 →
@@ -236,13 +233,13 @@ module _ (R' : OrderedCommRing ℓ ℓ') where
           x · x            <⟨ x²<0 ⟩
           0r               ◾
       in
-        subst (_≤ x · x) (solve! RCR) (∘diag (·MonoR≤ _ _ _) 0≤x)
+        subst (_≤ x · x) (0LeftAnnihilates x) (∘diag (·MonoR≤ _ _ _) 0≤x)
 
     #→0<² : ∀ x → x # 0r → 0r < x · x
     #→0<² x (inl x<0) =
-      subst2 _<_ (solve! RCR) (solve! RCR) (∘diag (·MonoR< _ _ _) (<0→0<- x x<0))
+      subst2 _<_ (0LeftAnnihilates _) (solve! RCR) (∘diag (·MonoR< _ _ _) (<0→0<- x x<0))
     #→0<² x (inr 0<x) =
-      subst (_< x · x) (solve! RCR) (∘diag (·MonoR< _ _ _) 0<x)
+      subst (_< x · x) (0LeftAnnihilates _) (∘diag (·MonoR< _ _ _) 0<x)
 
     ≤abs : ∀ z → z ≤ abs z
     ≤abs z = L≤⊔
@@ -252,7 +249,7 @@ module _ (R' : OrderedCommRing ℓ ℓ') where
 
     0≤abs : ∀ z → 0r ≤ abs z
     0≤abs z = ¬<→≥ (abs z) 0r λ ∣z∣<0 → is-irrefl 0r $ begin<
-      0r      ≡→≤⟨ solve! RCR ⟩
+      0r      ≡→≤⟨ sym 0Selfinverse ⟩
       - 0r      <⟨ -Flip< _ _ ∣z∣<0 ⟩
       - abs z   ≤⟨ -Flip≤ _ _ (≤abs z) ⟩
       - z       ≤⟨ -≤abs z ⟩
@@ -266,15 +263,15 @@ module _ (R' : OrderedCommRing ℓ ℓ') where
         abs z ≤⟨ ∣z∣≤0 ⟩
         0r         ◾)
       (begin≤
-        0r        ≡→≤⟨ solve! RCR ⟩
+        0r        ≡→≤⟨ sym 0Selfinverse ⟩
         - 0r        ≤⟨ -Flip≤ _ _ ∣z∣≤0 ⟩
         - (abs z)   ≤⟨ -Flip≤ _ _ $ -≤abs z ⟩
-        - - z     ≡→≤⟨ solve! RCR ⟩
+        - - z     ≡→≤⟨ -Idempotent z ⟩
         z           ◾)
 
     #→0<abs : ∀ z → z # 0r → 0r < abs z
     #→0<abs z (inl z<0) = begin<
-      0r    ≡→≤⟨ solve! RCR ⟩
+      0r    ≡→≤⟨ sym 0Selfinverse ⟩
       - 0r    <⟨ -Flip< z 0r z<0 ⟩
       - z     ≤⟨ -≤abs _ ⟩
       abs z   ◾
@@ -284,7 +281,7 @@ module _ (R' : OrderedCommRing ℓ ℓ') where
       abs z ◾
 
     abs- : ∀ x → abs (- x) ≡ abs x
-    abs- x = cong ((- x) ⊔_) (solve! RCR) ∙ ⊔Comm
+    abs- x = cong ((- x) ⊔_) (-Idempotent x) ∙ ⊔Comm
 
     0≤→abs≡id : ∀ x → 0r ≤ x → abs x ≡ x
     0≤→abs≡id x 0≤x = is-antisym (abs x) x
@@ -315,9 +312,8 @@ module _ (R' : OrderedCommRing ℓ ℓ') where
             abs x · abs x ≡→≤⟨ cong (∘diag _·_) (0≤→abs≡id x 0≤x) ⟩
             x · x           ◾))
       (0≤Δ→≤ (x · x) (abs x · abs x) (begin≤
-        0r                          ≡→≤⟨ solve! RCR ⟩
-        0r · (abs x - - x)            ≤⟨ ·MonoR≤ 0r _ _ (≤→0≤Δ _ _ (-≤abs x))
-                                                        (≤→0≤Δ _ _ (≤abs x)) ⟩
+        0r                          ≡→≤⟨ sym $ 0LeftAnnihilates (abs x - - x) ⟩
+        0r · (abs x - - x)            ≤⟨ ≤→0≤Δ _ _ (≤abs x) ≤·[ _ , ≤→0≤Δ _ _ (-≤abs x) ] ⟩
         (abs x - x) · (abs x - - x) ≡→≤⟨ solve! RCR ⟩
         abs x · abs x - x · x         ◾))
 
@@ -407,7 +403,7 @@ module _ (R' : OrderedCommRing ℓ ℓ') where
 
     infixl 7 _·subtype_
 
-  -- Of course 0<+Closed and 0<·Closed are derivable, but for concrete instances
+  -- 0<+Closed and 0<·Closed are derivable, but for concrete instances
   -- (like the rationals) it's more efficient to use alternative proofs
   module Positive
     (0<+Closed : (x y : R) → 0r < x → 0r < y → 0r < x + y)
@@ -487,17 +483,17 @@ module _ (R' : OrderedCommRing ℓ ℓ') where
 
     <₊SumLeft : ∀ x y → x <₊ x +₊ y
     <₊SumLeft (x , _) (y , 0<y) = begin<
-      x ≡→≤⟨ solve! RCR ⟩ x + 0r <⟨ +MonoL< _ _ _ 0<y ⟩ x + y ◾
+      x ≡→≤⟨ sym $ +IdR x ⟩ x + 0r <⟨ [ x ]+< 0<y ⟩ x + y ◾
 
     <₊SumRight : ∀ x y → x <₊ y +₊ x
     <₊SumRight (x , _) (y , 0<y) = begin<
-      x ≡→≤⟨ solve! RCR ⟩ 0r + x <⟨ +MonoR< _ _ _ 0<y ⟩ y + x ◾
+      x ≡→≤⟨ sym $ +IdL x ⟩ 0r + x <⟨ 0<y <+[ x ] ⟩ y + x ◾
 
     Δ<₊ : ∀ x y → x -₊ y < ⟨ x ⟩₊
     Δ<₊ (x , _) (y , 0<y) = begin<
-      x - y <⟨ +MonoL< _ _ _ (-Flip< 0r y 0<y) ⟩ x - 0r ≡→≤⟨ solve! RCR ⟩ x ◾
+      x - y <⟨ [ x ]+< -Flip< 0r y 0<y ⟩ x - 0r ≡→≤⟨ solve! RCR ⟩ x ◾
 
-  -- Of course 0≤+Closed and 0≤·Closed are derivable, but for concrete instances
+  -- 0≤+Closed and 0≤·Closed are derivable, but for concrete instances
   -- (like the rationals) it's more efficient to use alternative proofs
   module NonNegative
     (0≤+Closed : (x y : R) → 0r ≤ x → 0r ≤ y → 0r ≤ x + y)
@@ -568,15 +564,15 @@ module _ (R' : OrderedCommRing ℓ ℓ') where
 
     ≤₀₊SumLeft : ∀ x y → x ≤₀₊ x +₀₊ y
     ≤₀₊SumLeft (x , _) (y , 0≤y) = begin≤
-      x ≡→≤⟨ solve! RCR ⟩ x + 0r ≤⟨ +MonoL≤ _ _ _ 0≤y ⟩ x + y ◾
+      x ≡→≤⟨ sym $ +IdR x ⟩ x + 0r ≤⟨ [ x ]+≤ 0≤y ⟩ x + y ◾
 
     ≤₀₊SumRight : ∀ x y → x ≤₀₊ y +₀₊ x
     ≤₀₊SumRight (x , _) (y , 0≤y) = begin≤
-      x ≡→≤⟨ solve! RCR ⟩ 0r + x ≤⟨ +MonoR≤ _ _ _ 0≤y ⟩ y + x ◾
+      x ≡→≤⟨ sym $ +IdL x ⟩ 0r + x ≤⟨ 0≤y ≤+[ x ] ⟩ y + x ◾
 
     Δ≤₀₊ : ∀ x y → x -₀₊ y ≤ ⟨ x ⟩₀₊
     Δ≤₀₊ (x , _) (y , 0≤y) = begin≤
-      x - y ≤⟨ +MonoL≤ _ _ _ (-Flip≤ 0r y 0≤y) ⟩ x - 0r ≡→≤⟨ solve! RCR ⟩ x ◾
+      x - y ≤⟨ [ x ]+≤ -Flip≤ 0r y 0≤y ⟩ x - 0r ≡→≤⟨ solve! RCR ⟩ x ◾
 
   private
     2r = 1r + 1r
@@ -608,27 +604,30 @@ module _ (R' : OrderedCommRing ℓ ℓ') where
     mean : R → R → R
     mean x y = (x + y) · 1/2
 
+    /2+/2≡mean : ∀ x y → x /2 + y /2 ≡ mean x y
+    /2+/2≡mean x y = sym (·DistL+ x y 1/2)
+
     meanIdem : ∀ x → mean x x ≡ x
     meanIdem x =
       (x + x) · 1/2     ≡⟨ solve! RCR ⟩
       x · (1/2 + 1/2)   ≡⟨ cong (x ·_) 1/2+1/2≡1 ⟩
-      x · 1r            ≡⟨ solve! RCR ⟩
+      x · 1r            ≡⟨ ·IdR x ⟩
       x                 ∎
 
     <→<mean : ∀ x y → x < y → x < mean x y
     <→<mean x y x<y = begin<
       x             ≡→≤⟨ sym (meanIdem x) ⟩
-      (x + x) · 1/2   <⟨ ·MonoR< (x + x) (x + y) 1/2 0<1/2 (+MonoL< x y x x<y) ⟩
+      (x + x) · 1/2   <⟨ ([ x ]+< x<y) <·[ 1/2 , 0<1/2 ] ⟩
       (x + y) · 1/2   ◾
 
     <→mean< : ∀ x y → x < y → mean x y < y
     <→mean< x y x<y = begin<
-      (x + y) · 1/2   <⟨ ·MonoR< (x + y) (y + y) 1/2 0<1/2 (+MonoR< x y y x<y) ⟩
+      (x + y) · 1/2   <⟨ (x<y <+[ y ]) <·[ 1/2 , 0<1/2 ] ⟩
       (y + y) · 1/2 ≡→≤⟨ meanIdem y ⟩
       y               ◾
 
     /2+/2≡id : ∀ x → x /2 + x /2 ≡ x
-    /2+/2≡id x = solve! RCR ∙ meanIdem x
+    /2+/2≡id x = /2+/2≡mean x x ∙ meanIdem x
 
     id-/2≡/2 : ∀ x → x - x /2 ≡ x /2
     id-/2≡/2 x = cong (_- x /2) (sym (/2+/2≡id x)) ∙ solve! RCR
@@ -661,6 +660,9 @@ module _ (R' : OrderedCommRing ℓ ℓ') where
     _/4₊ : R₊ → R₊
     _/4₊ = _/2₊ ∘ _/2₊
 
+    mean₊ : R₊ → R₊ → R₊
+    mean₊ x y = (x +₊ y) /2₊
+
     /2₊<id : ∀ x → (x /2₊) <₊ x
     /2₊<id x = begin<
       ⟨ x /2₊ ⟩₊            <⟨ <₊SumLeft (x /2₊) (x /2₊) ⟩

From 382d8266b412b852303aa214c8eb4e3dea250226 Mon Sep 17 00:00:00 2001
From: Lorenzo Molena <lorenzo.molena8@gmail.com>
Date: Sat, 4 Apr 2026 19:52:35 +0200
Subject: [PATCH 04/19] =?UTF-8?q?replace=20`<-=E2=89=A4-weaken=20=5F=20=5F?=
 =?UTF-8?q?=200<1`=20with=20`0=E2=89=A41`=20in=20`R=E2=82=80=E2=82=8ACommS?=
 =?UTF-8?q?emiring`?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 Cubical/Algebra/OrderedCommRing/Properties.agda | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Cubical/Algebra/OrderedCommRing/Properties.agda b/Cubical/Algebra/OrderedCommRing/Properties.agda
index 415151ce09..622f7957d0 100644
--- a/Cubical/Algebra/OrderedCommRing/Properties.agda
+++ b/Cubical/Algebra/OrderedCommRing/Properties.agda
@@ -508,7 +508,7 @@ module _ (R' : OrderedCommRing ℓ ℓ') where
     R₀₊CommSemiring : CommSemiring _
     fst R₀₊CommSemiring = R₀₊
     CommSemiringStr.0r  (snd R₀₊CommSemiring) = 0r , is-refl _
-    CommSemiringStr.1r  (snd R₀₊CommSemiring) = 1r , <-≤-weaken _ _ 0<1
+    CommSemiringStr.1r  (snd R₀₊CommSemiring) = 1r , 0≤1
     CommSemiringStr._+_ (snd R₀₊CommSemiring) = _+₀₊_
     CommSemiringStr._·_ (snd R₀₊CommSemiring) = _·₀₊_
     CommSemiringStr.isCommSemiring (snd R₀₊CommSemiring) =

From 4531d699b4a9c34707f2a1a1f15a6f12b6a1c15a Mon Sep 17 00:00:00 2001
From: Lorenzo Molena <lorenzo.molena8@gmail.com>
Date: Sat, 4 Apr 2026 23:29:16 +0200
Subject: [PATCH 05/19] move export of `PseudolatticeTheory`, add type
 annotation to `subtype`

---
 Cubical/Algebra/OrderedCommRing/Properties.agda | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/Cubical/Algebra/OrderedCommRing/Properties.agda b/Cubical/Algebra/OrderedCommRing/Properties.agda
index 622f7957d0..1dc65943df 100644
--- a/Cubical/Algebra/OrderedCommRing/Properties.agda
+++ b/Cubical/Algebra/OrderedCommRing/Properties.agda
@@ -57,9 +57,6 @@ module _ (R' : OrderedCommRing ℓ ℓ') where
     RCR = OrderedCommRing→CommRing R'
   open RingTheory (OrderedCommRing→Ring R')
   open OrderedCommRingStr (snd R')
-  open PseudolatticeTheory (OrderedCommRing→PseudoLattice R') public renaming (
-      L≤∨ to L≤⊔ ; R≤∨ to R≤⊔ ; ∨Comm to ⊔Comm ; ∨Idem to ⊔Idem ; ∨LUB to ⊔LUB
-    ; ∧≤L to ⊓≤L ; ∧≤R to ⊓≤R ; ∧Comm to ⊓Comm ; ∧Idem to ⊓Idem ; ∧GLB to ⊓GLB)
 
   module OrderedCommRingReasoning where
     open <-≤-Reasoning
@@ -114,6 +111,9 @@ module _ (R' : OrderedCommRing ℓ ℓ') where
 
   module OrderedCommRingTheory where
     open ApartnessStr (str (OrderedCommRing→Apartness R')) using (_#_) public
+    open PseudolatticeTheory (OrderedCommRing→PseudoLattice R') public renaming (
+        L≤∨ to L≤⊔ ; R≤∨ to R≤⊔ ; ∨Comm to ⊔Comm ; ∨Idem to ⊔Idem ; ∨LUB to ⊔LUB
+      ; ∧≤L to ⊓≤L ; ∧≤R to ⊓≤R ; ∧Comm to ⊓Comm ; ∧Idem to ⊓Idem ; ∧GLB to ⊓GLB)
 
     0≤1 : 0r ≤ 1r
     0≤1 = <-≤-weaken 0r 1r 0<1
@@ -362,6 +362,7 @@ module _ (R' : OrderedCommRing ℓ ℓ') where
     (+Closed : (x y : R) → P x → P y → P (x + y))
     where
 
+    subtype : Type (ℓ-max ℓ ℓ'')
     subtype = Σ[ x ∈ R ] P x
 
     isSetSubtype : isSet subtype

From f788f6db663497109ae9b7b1047a8525d3fea8b0 Mon Sep 17 00:00:00 2001
From: Lorenzo Molena <lorenzo.molena8@gmail.com>
Date: Sat, 4 Apr 2026 23:33:02 +0200
Subject: [PATCH 06/19] add `using ()` to avoid exporting more than what is
 needed

---
 Cubical/Algebra/OrderedCommRing/Properties.agda | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Cubical/Algebra/OrderedCommRing/Properties.agda b/Cubical/Algebra/OrderedCommRing/Properties.agda
index 1dc65943df..88b3904a33 100644
--- a/Cubical/Algebra/OrderedCommRing/Properties.agda
+++ b/Cubical/Algebra/OrderedCommRing/Properties.agda
@@ -111,7 +111,7 @@ module _ (R' : OrderedCommRing ℓ ℓ') where
 
   module OrderedCommRingTheory where
     open ApartnessStr (str (OrderedCommRing→Apartness R')) using (_#_) public
-    open PseudolatticeTheory (OrderedCommRing→PseudoLattice R') public renaming (
+    open PseudolatticeTheory (OrderedCommRing→PseudoLattice R') public using () renaming (
         L≤∨ to L≤⊔ ; R≤∨ to R≤⊔ ; ∨Comm to ⊔Comm ; ∨Idem to ⊔Idem ; ∨LUB to ⊔LUB
       ; ∧≤L to ⊓≤L ; ∧≤R to ⊓≤R ; ∧Comm to ⊓Comm ; ∧Idem to ⊓Idem ; ∧GLB to ⊓GLB)
 

From 369a119d1dad22416f26793dc11c2cfd01ce7932 Mon Sep 17 00:00:00 2001
From: Lorenzo Molena <lorenzo.molena8@gmail.com>
Date: Sun, 5 Apr 2026 00:32:35 +0200
Subject: [PATCH 07/19] update `Rationals` to use fast integers operations ;
 fix broken proofs in `Field.Instances.Rationals`

---
 .../Algebra/CommRing/Instances/Rationals.agda |   1 -
 .../Algebra/Field/Instances/Rationals.agda    |  33 +-
 Cubical/Data/Rationals/Base.agda              |   2 +-
 Cubical/Data/Rationals/Order.agda             | 311 ++++++++++--------
 Cubical/Data/Rationals/Properties.agda        | 121 ++++++-
 5 files changed, 285 insertions(+), 183 deletions(-)

diff --git a/Cubical/Algebra/CommRing/Instances/Rationals.agda b/Cubical/Algebra/CommRing/Instances/Rationals.agda
index 92416ac328..eeb40346c9 100644
--- a/Cubical/Algebra/CommRing/Instances/Rationals.agda
+++ b/Cubical/Algebra/CommRing/Instances/Rationals.agda
@@ -20,4 +20,3 @@ open import Cubical.Data.Rationals as ℚ
   where
   p : IsCommRing 0 1 _+_ _·_ (-_)
   p = makeIsCommRing isSetℚ +Assoc +IdR +InvR +Comm ·Assoc ·IdR ·DistL+ ·Comm
-
diff --git a/Cubical/Algebra/Field/Instances/Rationals.agda b/Cubical/Algebra/Field/Instances/Rationals.agda
index 2209eb5f03..fa3bfadbd4 100644
--- a/Cubical/Algebra/Field/Instances/Rationals.agda
+++ b/Cubical/Algebra/Field/Instances/Rationals.agda
@@ -14,7 +14,7 @@ open import Cubical.Algebra.CommRing.Instances.Rationals
 open import Cubical.Algebra.Field
 
 open import Cubical.Data.Empty as Empty
-open import Cubical.Data.Int as ℤ
+open import Cubical.Data.Fast.Int as ℤ
 open import Cubical.Data.Nat as ℕ using (ℕ ; zero ; suc)
 open import Cubical.Data.NatPlusOne
 open import Cubical.Data.Rationals as ℚ
@@ -42,36 +42,9 @@ hasInverseℚ = SetQuotients.elimProp
   q (ℤ.pos zero , b) p =
     Empty.rec (p (numerator0→0 ((ℤ.pos zero , b)) refl))
   q (ℤ.pos (suc n) , (1+ m)) _ =
-    eq/ ((ℤ.pos (suc n) ℤ.· (ℕ₊₁→ℤ (1+ m)) , (1+ m) ·₊₁ (1+ n))) ((1 , 1)) q'
-    where
-    q' = (ℤ.pos (suc n) ℤ.· (ℕ₊₁→ℤ (1+ m))) ℤ.· 1
-           ≡⟨ ℤ.·IdR _ ⟩
-         ℤ.pos (suc n) ℤ.· ℤ.pos (suc m)
-           ≡⟨ sym $ ℤ.pos·pos (suc n) (suc m) ⟩
-         ℤ.pos ((suc n) ℕ.· (suc m))
-           ≡⟨ cong ℤ.pos (ℕ.·-comm (suc n) (suc m)) ⟩
-         ℤ.pos ((suc m) ℕ.· (suc n))
-           ≡⟨ refl ⟩
-         ℕ₊₁→ℤ ((1+ m) ·₊₁ (1+ n))
-           ≡⟨ sym (ℤ.·IdL _) ⟩
-         1 ℤ.· (ℕ₊₁→ℤ ((1+ m) ·₊₁ (1+ n))) ∎
+    eq/ _ _ (ℤ.·IdR _ ∙∙ ℤ.·Comm (pos (suc n)) (pos (suc m)) ∙∙ sym (ℤ.·IdL _))
   q (ℤ.negsuc n , (1+ m)) _ =
-    eq/ ((ℤ.negsuc n ℤ.· ℤ.negsuc m) , ((1+ m) ·₊₁ (1+ n))) ((1 , 1)) q'
-    where
-    q' : (ℤ.negsuc n ℤ.· ℤ.negsuc m , (1+ m) ·₊₁ (1+ n)) ∼ (1 , 1)
-    q' = (ℤ.negsuc n ℤ.· ℤ.negsuc m) ℤ.· 1
-           ≡⟨ ℤ.·IdR _ ⟩
-         (ℤ.negsuc n ℤ.· ℤ.negsuc m)
-           ≡⟨ negsuc·negsuc n m ⟩
-         (ℤ.pos (suc n) ℤ.· ℤ.pos (suc m))
-           ≡⟨ sym $ ℤ.pos·pos (suc n) (suc m) ⟩
-         ℤ.pos ((suc n) ℕ.· (suc m))
-           ≡⟨ cong ℤ.pos (ℕ.·-comm (suc n) (suc m)) ⟩
-         ℤ.pos ((suc m) ℕ.· (suc n))
-           ≡⟨ refl ⟩
-         ℕ₊₁→ℤ ((1+ m) ·₊₁ (1+ n))
-           ≡⟨ sym (ℤ.·IdL _) ⟩
-         1 ℤ.· (ℕ₊₁→ℤ ((1+ m) ·₊₁ (1+ n))) ∎
+    eq/ _ _ (ℤ.·IdR _ ∙∙ ℤ.·Comm (pos (suc n)) (pos (suc m)) ∙∙ sym (ℤ.·IdL _))
 
 0≢1-ℚ : ¬ Path ℚ 0 1
 0≢1-ℚ p = 0≢1-ℤ (effective (λ _ _ → isSetℤ _ _) isEquivRel∼ _ _ p)
diff --git a/Cubical/Data/Rationals/Base.agda b/Cubical/Data/Rationals/Base.agda
index ce0f87081b..e2468e3004 100644
--- a/Cubical/Data/Rationals/Base.agda
+++ b/Cubical/Data/Rationals/Base.agda
@@ -7,7 +7,7 @@ open import Cubical.Foundations.Function
 open import Cubical.Data.Nat as ℕ using (discreteℕ)
 open import Cubical.Data.NatPlusOne
 open import Cubical.Data.Sigma
-open import Cubical.Data.Int
+open import Cubical.Data.Fast.Int
 
 open import Cubical.HITs.SetQuotients as SetQuotient
   using ([_]; eq/; discreteSetQuotients) renaming (_/_ to _//_) public
diff --git a/Cubical/Data/Rationals/Order.agda b/Cubical/Data/Rationals/Order.agda
index 106d6334ec..2755b7bcba 100644
--- a/Cubical/Data/Rationals/Order.agda
+++ b/Cubical/Data/Rationals/Order.agda
@@ -9,9 +9,9 @@ open import Cubical.Foundations.Univalence
 open import Cubical.Functions.Logic using (_⊔′_)
 
 open import Cubical.Data.Empty as ⊥
-open import Cubical.Data.Int.Base as ℤ using (ℤ)
-open import Cubical.Data.Int.Properties as ℤ using ()
-open import Cubical.Data.Int.Order as ℤ using ()
+open import Cubical.Data.Fast.Int.Base as ℤ using (ℤ)
+import Cubical.Data.Fast.Int.Properties as ℤ
+import Cubical.Data.Fast.Int.Order as ℤ
 open import Cubical.Data.Rationals.Base as ℚ
 open import Cubical.Data.Rationals.Properties as ℚ
 open import Cubical.Data.Nat as ℕ
@@ -20,7 +20,7 @@ open import Cubical.Data.Sigma
 open import Cubical.Data.Sum as ⊎ using (_⊎_; inl; inr; isProp⊎)
 
 open import Cubical.HITs.PropositionalTruncation as ∥₁ using (isPropPropTrunc; ∣_∣₁)
-open import Cubical.HITs.SetQuotients
+open import Cubical.HITs.SetQuotients renaming (_/_ to _//_)
 
 open import Cubical.Relation.Nullary
 open import Cubical.Relation.Binary.Base
@@ -39,18 +39,18 @@ private
                 → ((a ℤ.· ℕ₊₁→ℤ d) ℤ.≤ (c ℤ.· ℕ₊₁→ℤ b))
                 ≡ ((a ℤ.· ℕ₊₁→ℤ f) ℤ.≤ (e ℤ.· ℕ₊₁→ℤ b))
         lemma≤ (a , b) (c , d) (e , f) cf≡ed = (ua (propBiimpl→Equiv ℤ.isProp≤ ℤ.isProp≤
-                (ℤ.≤-·o-cancel {k = -1+ d} ∘
+                (ℤ.≤-·o-cancel ∘
                   subst2 ℤ._≤_ (·CommR a (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ f))
                                (·CommR c (ℕ₊₁→ℤ b) (ℕ₊₁→ℤ f) ∙
                                 cong (ℤ._· ℕ₊₁→ℤ b) cf≡ed ∙
                                 ·CommR e (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ b)) ∘
-                 ℤ.≤-·o {k = ℕ₊₁→ℕ f})
-                (ℤ.≤-·o-cancel {k = -1+ f} ∘
+                 ℤ.≤-·o)
+                (ℤ.≤-·o-cancel ∘
                   subst2 ℤ._≤_ (·CommR a (ℕ₊₁→ℤ f) (ℕ₊₁→ℤ d))
                                 (·CommR e (ℕ₊₁→ℤ b) (ℕ₊₁→ℤ d) ∙
                                  cong (ℤ._· ℕ₊₁→ℤ b) (sym cf≡ed) ∙
                                  ·CommR c (ℕ₊₁→ℤ f) (ℕ₊₁→ℤ b)) ∘
-                 ℤ.≤-·o {k = ℕ₊₁→ℕ d})))
+                 ℤ.≤-·o)))
 
         fun₀ : ℤ × ℕ₊₁ → ℚ → hProp ℓ-zero
         fst (fun₀ (a , b) [ c , d ]) = a ℤ.· ℕ₊₁→ℤ d ℤ.≤ c ℤ.· ℕ₊₁→ℤ b
@@ -68,18 +68,18 @@ private
         toPath : ∀ a/b c/d (x : a/b ∼ c/d) (y : ℚ) → fun₀ a/b y ≡ fun₀ c/d y
         toPath (a , b) (c , d) ad≡cb = elimProp (λ _ → isSetHProp _ _) λ (e , f) →
           Σ≡Prop (λ _ → isPropIsProp) (ua (propBiimpl→Equiv ℤ.isProp≤ ℤ.isProp≤
-                (ℤ.≤-·o-cancel {k = -1+ b} ∘
+                (ℤ.≤-·o-cancel ∘
                   subst2 ℤ._≤_ (·CommR a (ℕ₊₁→ℤ f) (ℕ₊₁→ℤ d) ∙
                                  cong (ℤ._· ℕ₊₁→ℤ f) ad≡cb ∙
                                  ·CommR c (ℕ₊₁→ℤ b) (ℕ₊₁→ℤ f))
                                (·CommR e (ℕ₊₁→ℤ b) (ℕ₊₁→ℤ d)) ∘
-                 ℤ.≤-·o {k = ℕ₊₁→ℕ d})
-                (ℤ.≤-·o-cancel {k = -1+ d} ∘
+                 ℤ.≤-·o)
+                (ℤ.≤-·o-cancel ∘
                   subst2 ℤ._≤_ (·CommR c (ℕ₊₁→ℤ f) (ℕ₊₁→ℤ b) ∙
                                  cong (ℤ._· ℕ₊₁→ℤ f) (sym ad≡cb) ∙
                                  ·CommR a (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ f))
                                (·CommR e (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ b)) ∘
-                 ℤ.≤-·o {k = ℕ₊₁→ℕ b})))
+                 ℤ.≤-·o)))
 
         fun : ℚ → ℚ → hProp ℓ-zero
         fun [ a/b ] y = fun₀ a/b y
@@ -95,18 +95,18 @@ private
                 → ((a ℤ.· ℕ₊₁→ℤ d) ℤ.< (c ℤ.· ℕ₊₁→ℤ b))
                 ≡ ((a ℤ.· ℕ₊₁→ℤ f) ℤ.< (e ℤ.· ℕ₊₁→ℤ b))
         lemma< (a , b) (c , d) (e , f) cf≡ed = (ua (propBiimpl→Equiv ℤ.isProp< ℤ.isProp<
-                (ℤ.<-·o-cancel {k = -1+ d} ∘
+                (ℤ.<-·o-cancel ∘
                   subst2 ℤ._<_ (·CommR a (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ f))
                                (·CommR c (ℕ₊₁→ℤ b) (ℕ₊₁→ℤ f) ∙
                                 cong (ℤ._· ℕ₊₁→ℤ b) cf≡ed ∙
                                 ·CommR e (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ b)) ∘
-                 ℤ.<-·o {k = -1+ f})
-                (ℤ.<-·o-cancel {k = -1+ f} ∘
+                 ℤ.<-·o)
+                (ℤ.<-·o-cancel ∘
                   subst2 ℤ._<_ (·CommR a (ℕ₊₁→ℤ f) (ℕ₊₁→ℤ d))
                                (·CommR e (ℕ₊₁→ℤ b) (ℕ₊₁→ℤ d) ∙
                                 cong (ℤ._· ℕ₊₁→ℤ b) (sym cf≡ed) ∙
                                 ·CommR c (ℕ₊₁→ℤ f) (ℕ₊₁→ℤ b)) ∘
-                 ℤ.<-·o {k = -1+ d})))
+                 ℤ.<-·o)))
 
         fun₀ : ℤ × ℕ₊₁ → ℚ → hProp ℓ-zero
         fst (fun₀ (a , b) [ c , d ]) = a ℤ.· ℕ₊₁→ℤ d ℤ.< c ℤ.· ℕ₊₁→ℤ b
@@ -124,18 +124,18 @@ private
         toPath : ∀ a/b c/d (x : a/b ∼ c/d) (y : ℚ) → fun₀ a/b y ≡ fun₀ c/d y
         toPath (a , b) (c , d) ad≡cb = elimProp (λ _ → isSetHProp _ _) λ (e , f) →
           Σ≡Prop (λ _ → isPropIsProp) (ua (propBiimpl→Equiv ℤ.isProp< ℤ.isProp<
-                (ℤ.<-·o-cancel {k = -1+ b} ∘
+                (ℤ.<-·o-cancel ∘
                   subst2 ℤ._<_ (·CommR a (ℕ₊₁→ℤ f) (ℕ₊₁→ℤ d) ∙
                                 cong (ℤ._· ℕ₊₁→ℤ f) ad≡cb ∙
                                 ·CommR c (ℕ₊₁→ℤ b) (ℕ₊₁→ℤ f))
                                (·CommR e (ℕ₊₁→ℤ b) (ℕ₊₁→ℤ d)) ∘
-                 ℤ.<-·o {k = -1+ d})
-                (ℤ.<-·o-cancel {k = -1+ d} ∘
+                 ℤ.<-·o)
+                (ℤ.<-·o-cancel ∘
                   subst2 ℤ._<_ (·CommR c (ℕ₊₁→ℤ f) (ℕ₊₁→ℤ b) ∙
                                 cong (ℤ._· ℕ₊₁→ℤ f) (sym ad≡cb) ∙
                                 ·CommR a (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ f))
                                (·CommR e (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ b)) ∘
-                 ℤ.<-·o {k = -1+ b})))
+                 ℤ.<-·o)))
 
         fun : ℚ → ℚ → hProp ℓ-zero
         fun [ a/b ] y = fun₀ a/b y
@@ -143,11 +143,23 @@ private
         fun (squash/ x y p q i j) z = isSet→SquareP (λ _ _ → isSetHProp)
           (λ _ → fun x z) (λ _ → fun y z) (λ i → fun (p i) z) (λ i → fun (q i) z) j i
 
-_≤_ : ℚ → ℚ → Type₀
-m ≤ n = fst (m ≤' n)
+record _≤_ (m n : ℚ ) : Type₀ where
+  constructor inj
+  field
+    prf : fst (m ≤' n)
 
-_<_ : ℚ → ℚ → Type₀
-m < n = fst (m <' n)
+record _<_ (m n : ℚ ) : Type₀ where
+  constructor inj
+  field
+    prf : fst (m <' n)
+
+pattern pos≤pos p       = inj (ℤ.pos≤pos p)
+pattern negsuc≤pos      = inj ℤ.negsuc≤pos
+pattern negsuc≤negsuc p = inj (ℤ.negsuc≤negsuc p)
+
+pattern pos<pos p       = inj (ℤ.pos<pos p)
+pattern negsuc<pos      = inj ℤ.negsuc<pos
+pattern negsuc<negsuc p = inj (ℤ.negsuc<negsuc p)
 
 _≥_ : ℚ → ℚ → Type₀
 m ≥ n = n ≤ m
@@ -167,53 +179,79 @@ module _ where
   open BinaryRelation
 
   isProp≤ : isPropValued _≤_
-  isProp≤ m n = snd (m ≤' n)
+  isProp≤ m n (inj p) (inj q) = cong inj (snd (m ≤' n) p q)
 
   isProp< : isPropValued _<_
-  isProp< m n = snd (m <' n)
+  isProp< m n (inj p) (inj q) = cong inj (snd (m <' n) p q)
+
+  recompute≤ : ∀ {a b} → a ≤ b → a ≤ b
+  recompute≤ = elimProp2 {P = λ a b → a ≤ b → a ≤ b}
+                         (λ _ _ → isProp→ (isProp≤ _ _))
+                         (λ _ _ → inj ∘ ℤ.recompute≤ ∘ _≤_.prf) _ _
+
+  recompute< : ∀ {a b} → a < b → a < b
+  recompute< = elimProp2 {P = λ a b → a < b → a < b}
+                         (λ _ _ → isProp→ (isProp< _ _))
+                         (λ _ _ → inj ∘ ℤ.recompute< ∘ _<_.prf) _ _
+
+  recompute¬≤ : ∀ {a b} → ¬ (a ≤ b) → ¬ (a ≤ b)
+  recompute¬≤ = elimProp2 {P = λ a b → ¬ (a ≤ b) → ¬ (a ≤ b)}
+                          (λ _ _ → isProp→ (isProp¬ _))
+                          (λ _ _ ¬a≤b → ℤ.recompute¬≤ (¬a≤b ∘ inj) ∘ _≤_.prf) _ _
+
+  recompute¬< : ∀ {a b} → ¬ (a < b) → ¬ (a < b)
+  recompute¬< = elimProp2 {P = λ a b → ¬ (a < b) → ¬ (a < b)}
+                          (λ _ _ → isProp→ (isProp¬ _))
+                          (λ _ _ ¬a<b → ℤ.recompute¬< (¬a<b ∘ inj) ∘ _<_.prf) _ _
+
+  recompute# : ∀ {a b} → a # b → a # b
+  recompute# = ⊎.map recompute< recompute<
+
+  recompute¬# : ∀ {a b} → ¬ (a # b) → ¬ (a # b)
+  recompute¬# r = ⊎.rec (recompute¬< (r ∘ inl)) (recompute¬< (r ∘ inr))
 
   isRefl≤ : isRefl _≤_
-  isRefl≤ = elimProp {P = λ x → x ≤ x} (λ x → isProp≤ x x) λ _ → ℤ.isRefl≤
+  isRefl≤ = elimProp {P = λ x → x ≤ x} (λ x → isProp≤ x x) λ _ → inj ℤ.isRefl≤
 
   isIrrefl< : isIrrefl _<_
-  isIrrefl< = elimProp {P = λ x → ¬ x < x} (λ _ → isProp¬ _) λ _ → ℤ.isIrrefl<
+  isIrrefl< = elimProp {P = λ x → ¬ x < x} (λ _ → isProp¬ _) λ _ → ℤ.isIrrefl< ∘ _<_.prf
 
   isAntisym≤ : isAntisym _≤_
   isAntisym≤ =
     elimProp2 {P = λ a b → a ≤ b → b ≤ a → a ≡ b}
               (λ x y → isPropΠ2 λ _ _ → isSetℚ x y)
-              λ a b a≤b b≤a → eq/ a b (ℤ.isAntisym≤ a≤b b≤a)
+              λ a b (inj a≤b) (inj b≤a) → eq/ a b (ℤ.isAntisym≤ a≤b b≤a)
 
   isTrans≤ : isTrans _≤_
   isTrans≤ =
     elimProp3 {P = λ a b c → a ≤ b → b ≤ c → a ≤ c}
               (λ x _ z → isPropΠ2 λ _ _ → isProp≤ x z)
-              λ { (a , b) (c , d) (e , f) ad≤cb cf≤ed →
-                ℤ.≤-·o-cancel {k = -1+ d}
+              λ { (a , b) (c , d) (e , f) (inj ad≤cb) (inj cf≤ed) →
+                inj (ℤ.≤-·o-cancel
                   (subst (ℤ._≤ e ℤ.· ℕ₊₁→ℤ b ℤ.· ℕ₊₁→ℤ d)
                     (·CommR a (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ f))
-                  (ℤ.isTrans≤ (ℤ.≤-·o {k = ℕ₊₁→ℕ f} ad≤cb)
+                  (ℤ.isTrans≤ (ℤ.≤-·o ad≤cb)
                     (subst2 ℤ._≤_
                       (·CommR c (ℕ₊₁→ℤ f) (ℕ₊₁→ℤ b))
                       (·CommR e (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ b))
-                      (ℤ.≤-·o {k = ℕ₊₁→ℕ b} cf≤ed)))) }
+                      (ℤ.≤-·o cf≤ed))))) }
 
   isTrans< : isTrans _<_
   isTrans< =
     elimProp3 {P = λ a b c → a < b → b < c → a < c}
               (λ x _ z → isPropΠ2 λ _ _ → isProp< x z)
-              λ { (a , b) (c , d) (e , f) ad<cb cf<ed →
-                ℤ.<-·o-cancel {k = -1+ d}
+              λ { (a , b) (c , d) (e , f) (inj ad<cb) (inj cf<ed) →
+                inj (ℤ.<-·o-cancel
                   (subst (ℤ._< e ℤ.· ℕ₊₁→ℤ b ℤ.· ℕ₊₁→ℤ d)
                     (·CommR a (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ f))
-                  (ℤ.isTrans< (ℤ.<-·o {k = -1+ f} ad<cb)
+                  (ℤ.isTrans< (ℤ.<-·o ad<cb)
                     (subst2 ℤ._<_
                       (·CommR c (ℕ₊₁→ℤ f) (ℕ₊₁→ℤ b))
                       (·CommR e (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ b))
-                      (ℤ.<-·o {k = -1+ b} cf<ed)))) }
+                      (ℤ.<-·o cf<ed))))) }
 
   isAsym< : isAsym _<_
-  isAsym< = isIrrefl×isTrans→isAsym _<_ (isIrrefl< , isTrans<)
+  isAsym< = ((recompute¬< ∘_) ∘_) ∘ isIrrefl×isTrans→isAsym _<_ (isIrrefl< , isTrans<)
 
   isTotal≤ : isTotal _≤_
   isTotal≤ =
@@ -223,9 +261,9 @@ module _ where
     where
       lem : (a b : ℤ.ℤ × ℕ₊₁) → ([ a ] ≤ [ b ]) ⊎ ([ b ] ≤ [ a ])
       lem (a , b) (c , d) with (a ℤ.· ℕ₊₁→ℤ d) ℤ.≟ (c ℤ.· ℕ₊₁→ℤ b)
-      ... | ℤ.lt ad<cb = inl (ℤ.<-weaken ad<cb)
-      ... | ℤ.eq ad≡cb = inl (0 , ad≡cb)
-      ... | ℤ.gt cb<ad = inr (ℤ.<-weaken cb<ad)
+      ... | ℤ.lt ad<cb = inl (inj (ℤ.<-weaken ad<cb))
+      ... | ℤ.eq ad≡cb = inl (inj (ℤ.recompute≤ $ subst (_ ℤ.≤_) ad≡cb ℤ.isRefl≤))
+      ... | ℤ.gt cb<ad = inr (inj (ℤ.<-weaken cb<ad))
 
   isConnected< : isConnected _<_
   isConnected< =
@@ -235,9 +273,9 @@ module _ where
     where
       lem : (a b : ℤ.ℤ × ℕ₊₁) → (¬ [ a ] < [ b ]) × (¬ [ b ] < [ a ]) → [ a ] ≡ [ b ]
       lem (a , b) (c , d) (¬ad<cb , ¬cb<ad) with (a ℤ.· ℕ₊₁→ℤ d) ℤ.≟ (c ℤ.· ℕ₊₁→ℤ b)
-      ... | ℤ.lt ad<cb = ⊥.rec (¬ad<cb ad<cb)
+      ... | ℤ.lt ad<cb = ⊥.rec (¬ad<cb (inj ad<cb))
       ... | ℤ.eq ad≡cb = eq/ (a , b) (c , d) ad≡cb
-      ... | ℤ.gt cb<ad = ⊥.rec (¬cb<ad cb<ad)
+      ... | ℤ.gt cb<ad = ⊥.rec (¬cb<ad (inj cb<ad))
 
   isProp# : isPropValued _#_
   isProp# x y = isProp⊎ (isProp< x y) (isProp< y x) (isAsym< x y)
@@ -258,9 +296,9 @@ module _ where
     where
       lem : (a b : ℤ.ℤ × ℕ₊₁) → ¬ [_] {R = _∼_} a ≡ [ b ] → [ a ] # [ b ]
       lem (a , b) (c , d) ¬a≡b with (a ℤ.· ℕ₊₁→ℤ d) ℤ.≟ (c ℤ.· ℕ₊₁→ℤ b)
-      ... | ℤ.lt ad<cb = inl ad<cb
+      ... | ℤ.lt ad<cb = inl (inj ad<cb)
       ... | ℤ.eq ad≡cb = ⊥.rec (¬a≡b (eq/ (a , b) (c , d) ad≡cb))
-      ... | ℤ.gt cb<ad = inr cb<ad
+      ... | ℤ.gt cb<ad = inr (inj cb<ad)
 
   isWeaklyLinear< : isWeaklyLinear _<_
   isWeaklyLinear< =
@@ -270,7 +308,7 @@ module _ where
     where
       lem : (a b c : ℤ.ℤ × ℕ₊₁) → [ a ] < [ b ] → ([ a ] < [ c ]) ⊔′ ([ c ] < [ b ])
       lem a b c a<b with discreteℚ [ a ] [ c ]
-      ... | yes a≡c = ∣ inr (subst (_< [ b ]) a≡c a<b) ∣₁
+      ... | yes a≡c = ∣ inr (recompute< (subst (_< [ b ]) a≡c a<b)) ∣₁
       ... | no a≢c = ∣ ⊎.map (λ a<c → a<c)
                              (λ c<a → isTrans< [ c ] [ a ] [ b ] c<a a<b)
                              (inequalityImplies# [ a ] [ c ] a≢c) ∣₁
@@ -283,15 +321,15 @@ module _ where
       where
         lem : (a b c : ℤ.ℤ × ℕ₊₁) → [ a ] # [ b ] → ([ a ] # [ c ]) ⊔′ ([ b ] # [ c ])
         lem a b c a#b with discreteℚ [ b ] [ c ]
-        ... | yes b≡c = ∣ inl (subst ([ a ] #_) b≡c a#b) ∣₁
+        ... | yes b≡c = ∣ inl (recompute# (subst ([ a ] #_) b≡c a#b)) ∣₁
         ... | no  b≢c = ∣ inr (inequalityImplies# [ b ] [ c ] b≢c) ∣₁
 
 ≤-+o : ∀ m n o → m ≤ n → m ℚ.+ o ≤ n ℚ.+ o
 ≤-+o =
   elimProp3 {P = λ a b c → a ≤ b → a ℚ.+ c ≤ b ℚ.+ c}
             (λ x y z → isProp→ (isProp≤ (x ℚ.+ z) (y ℚ.+ z)))
-             λ { (a , b) (c , d) (e , f) ad≤cb →
-               subst2 ℤ._≤_
+             λ { (a , b) (c , d) (e , f) (inj ad≤cb) →
+                inj $ ℤ.recompute≤ $ subst2 ℤ._≤_
                        (cong₂ ℤ._+_
                               (cong (λ x → a ℤ.· ℕ₊₁→ℤ d ℤ.· x)
                                     (ℤ.pos·pos (ℕ₊₁→ℕ f) (ℕ₊₁→ℕ f)) ∙
@@ -324,13 +362,10 @@ module _ where
                                     cong (λ x → e ℤ.· ℕ₊₁→ℤ d ℤ.· x)
                                          (sym (ℤ.pos·pos (ℕ₊₁→ℕ b) (ℕ₊₁→ℕ f)))) ∙
                        sym (ℤ.·DistL+ (c ℤ.· ℕ₊₁→ℤ f) (e ℤ.· ℕ₊₁→ℤ d) (ℕ₊₁→ℤ (b ·₊₁ f))))
-                       (ℤ.≤-+o {o = e ℤ.· ℕ₊₁→ℤ b ℤ.· ℕ₊₁→ℤ d ℤ.· ℕ₊₁→ℤ f}
-                               (ℤ.≤-·o {k = ℕ₊₁→ℕ (f ·₊₁ f)} ad≤cb)) }
+                       (ℤ.≤-+o (ℤ.≤-·o ad≤cb)) }
 
 ≤-o+ : ∀ m n o →  m ≤ n → o ℚ.+ m ≤ o ℚ.+ n
-≤-o+ m n o = subst2 _≤_ (+Comm m o)
-                         (+Comm n o) ∘
-             ≤-+o m n o
+≤-o+ m n o = recompute≤ ∘ subst2 _≤_ (+Comm m o) (+Comm n o) ∘ ≤-+o m n o
 
 ≤Monotone+ : ∀ m n o s → m ≤ n → o ≤ s → m ℚ.+ o ≤ n ℚ.+ s
 ≤Monotone+ m n o s m≤n o≤s
@@ -341,23 +376,23 @@ module _ where
               (≤-o+ o s n o≤s)
 
 ≤-o+-cancel : ∀ m n o →  o ℚ.+ m ≤ o ℚ.+ n → m ≤ n
-≤-o+-cancel m n o
-  = subst2 _≤_ (+Assoc (- o) o m ∙ cong (ℚ._+ m) (+InvL o) ∙ +IdL m)
-                (+Assoc (- o) o n ∙ cong (ℚ._+ n) (+InvL o) ∙ +IdL n) ∘
-           ≤-o+ (o ℚ.+ m) (o ℚ.+ n) (- o)
+≤-o+-cancel m n o = recompute≤ ∘
+  subst2 _≤_ (+Assoc (- o) o m ∙ cong (ℚ._+ m) (+InvL o) ∙ +IdL m)
+             (+Assoc (- o) o n ∙ cong (ℚ._+ n) (+InvL o) ∙ +IdL n) ∘
+        ≤-o+ (o ℚ.+ m) (o ℚ.+ n) (- o)
 
 ≤-+o-cancel : ∀ m n o → m ℚ.+ o ≤ n ℚ.+ o → m ≤ n
-≤-+o-cancel m n o
-  = subst2 _≤_ (sym (+Assoc m o (- o)) ∙ cong (λ x → m ℚ.+ x) (+InvR o) ∙ +IdR m)
-                (sym (+Assoc n o (- o)) ∙ cong (λ x → n ℚ.+ x) (+InvR o) ∙ +IdR n) ∘
-           ≤-+o (m ℚ.+ o) (n ℚ.+ o) (- o)
+≤-+o-cancel m n o = recompute≤ ∘
+    subst2 _≤_ (sym (+Assoc m o (- o)) ∙ cong (λ x → m ℚ.+ x) (+InvR o) ∙ +IdR m)
+               (sym (+Assoc n o (- o)) ∙ cong (λ x → n ℚ.+ x) (+InvR o) ∙ +IdR n) ∘
+          ≤-+o (m ℚ.+ o) (n ℚ.+ o) (- o)
 
 <-+o : ∀ m n o → m < n → m ℚ.+ o < n ℚ.+ o
 <-+o =
   elimProp3 {P = λ a b c → a < b → a ℚ.+ c < b ℚ.+ c}
             (λ x y z → isProp→ (isProp< (x ℚ.+ z) (y ℚ.+ z)))
-             λ { (a , b) (c , d) (e , f) ad<cb →
-               subst2 ℤ._<_
+             λ { (a , b) (c , d) (e , f) (inj ad<cb) →
+               inj $ ℤ.recompute< $ subst2 ℤ._<_
                        (cong₂ ℤ._+_
                               (cong (λ x → a ℤ.· ℕ₊₁→ℤ d ℤ.· x)
                                     (ℤ.pos·pos (ℕ₊₁→ℕ f) (ℕ₊₁→ℕ f)) ∙
@@ -390,81 +425,78 @@ module _ where
                                     cong (λ x → e ℤ.· ℕ₊₁→ℤ d ℤ.· x)
                                          (sym (ℤ.pos·pos (ℕ₊₁→ℕ b) (ℕ₊₁→ℕ f)))) ∙
                        sym (ℤ.·DistL+ (c ℤ.· ℕ₊₁→ℤ f) (e ℤ.· ℕ₊₁→ℤ d) (ℕ₊₁→ℤ (b ·₊₁ f))))
-                       (ℤ.<-+o {o = e ℤ.· ℕ₊₁→ℤ b ℤ.· ℕ₊₁→ℤ d ℤ.· ℕ₊₁→ℤ f}
-                               (ℤ.<-·o {k = -1+ (f ·₊₁ f)} ad<cb)) }
+                       (ℤ.<-+o (ℤ.<-·o ad<cb)) }
 
 <-o+ : ∀ m n o → m < n → o ℚ.+ m < o ℚ.+ n
-<-o+ m n o = subst2 _<_ (+Comm m o) (+Comm n o) ∘ <-+o m n o
+<-o+ m n o = recompute< ∘ subst2 _<_ (+Comm m o) (+Comm n o) ∘ <-+o m n o
 
 <Monotone+ : ∀ m n o s → m < n → o < s → m ℚ.+ o < n ℚ.+ s
 <Monotone+ m n o s m<n o<s
   = isTrans< (m ℚ.+ o) (n ℚ.+ o) (n ℚ.+ s) (<-+o m n o m<n) (<-o+ o s n o<s)
 
 <-o+-cancel : ∀ m n o → o ℚ.+ m < o ℚ.+ n → m < n
-<-o+-cancel m n o
-  = subst2 _<_ (+Assoc (- o) o m ∙ cong (ℚ._+ m) (+InvL o) ∙ +IdL m)
-               (+Assoc (- o) o n ∙ cong (ℚ._+ n) (+InvL o) ∙ +IdL n) ∘
-           <-o+ (o ℚ.+ m) (o ℚ.+ n) (- o)
+<-o+-cancel m n o = recompute< ∘
+  subst2 _<_ (+Assoc (- o) o m ∙ cong (ℚ._+ m) (+InvL o) ∙ +IdL m)
+             (+Assoc (- o) o n ∙ cong (ℚ._+ n) (+InvL o) ∙ +IdL n) ∘
+        <-o+ (o ℚ.+ m) (o ℚ.+ n) (- o)
 
 <-+o-cancel : ∀ m n o → m ℚ.+ o < n ℚ.+ o → m < n
-<-+o-cancel m n o
-  = subst2 _<_ (sym (+Assoc m o (- o)) ∙ cong (λ x → m ℚ.+ x) (+InvR o) ∙ +IdR m)
-               (sym (+Assoc n o (- o)) ∙ cong (λ x → n ℚ.+ x) (+InvR o) ∙ +IdR n) ∘
-           <-+o (m ℚ.+ o) (n ℚ.+ o) (- o)
+<-+o-cancel m n o = recompute< ∘
+  subst2 _<_ (sym (+Assoc m o (- o)) ∙ cong (λ x → m ℚ.+ x) (+InvR o) ∙ +IdR m)
+             (sym (+Assoc n o (- o)) ∙ cong (λ x → n ℚ.+ x) (+InvR o) ∙ +IdR n) ∘
+        <-+o (m ℚ.+ o) (n ℚ.+ o) (- o)
 
 <Weaken≤ : ∀ m n → m < n → m ≤ n
 <Weaken≤ m n = elimProp2 {P = λ x y → x < y → x ≤ y}
                              (λ x y → isProp→ (isProp≤ x y))
-                             (λ { (a , b) (c , d) → ℤ.<-weaken }) m n
+                             (λ { (a , b) (c , d) → inj ∘ ℤ.<-weaken ∘ _<_.prf }) m n
 
 isTrans<≤ : ∀ m n o → m < n → n ≤ o → m < o
 isTrans<≤ =
     elimProp3 {P = λ a b c → a < b → b ≤ c → a < c}
               (λ x _ z → isPropΠ2 λ _ _ → isProp< x z)
-               λ { (a , b) (c , d) (e , f) ad<cb cf≤ed
-                → ℤ.<-·o-cancel {k = -1+ d}
-                 (ℤ.<≤-trans {m = c ℤ.· ℕ₊₁→ℤ f ℤ.· ℕ₊₁→ℤ b}
-                              (subst2 ℤ._<_ (·CommR a (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ f))
+               λ { (a , b) (c , d) (e , f) (inj ad<cb) (inj cf≤ed)
+                → inj $ ℤ.<-·o-cancel
+                 (ℤ.<≤-trans (subst2 ℤ._<_ (·CommR a (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ f))
                                             (·CommR c (ℕ₊₁→ℤ b) (ℕ₊₁→ℤ f))
-                                            (ℤ.<-·o {k = -1+ f} ad<cb))
-                              (subst (_ ℤ.≤_) (·CommR e (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ b))
-                                     (ℤ.≤-·o {k = ℕ₊₁→ℕ b} cf≤ed)) )}
+                                            (ℤ.<-·o ad<cb))
+                             (subst (_ ℤ.≤_) (·CommR e (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ b))
+                                    (ℤ.≤-·o cf≤ed)) )}
 
 isTrans≤< : ∀ m n o → m ≤ n → n < o → m < o
 isTrans≤< =
     elimProp3 {P = λ a b c → a ≤ b → b < c → a < c}
               (λ x _ z → isPropΠ2 λ _ _ → isProp< x z)
-               λ { (a , b) (c , d) (e , f) ad≤cb cf<ed
-                → ℤ.<-·o-cancel {k = -1+ d}
-                 (ℤ.≤<-trans {m = c ℤ.· ℕ₊₁→ℤ f ℤ.· ℕ₊₁→ℤ b}
-                              (subst2 ℤ._≤_ (·CommR a (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ f))
-                                             (·CommR c (ℕ₊₁→ℤ b) (ℕ₊₁→ℤ f))
-                                             (ℤ.≤-·o {k = ℕ₊₁→ℕ f} ad≤cb))
-                              (subst (_ ℤ.<_) (·CommR e (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ b))
-                                     (ℤ.<-·o {k = -1+ b} cf<ed)) )}
+               λ { (a , b) (c , d) (e , f) (inj ad≤cb) (inj cf<ed)
+                → inj $ ℤ.<-·o-cancel
+                 (ℤ.≤<-trans (subst2 ℤ._≤_ (·CommR a (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ f))
+                                            (·CommR c (ℕ₊₁→ℤ b) (ℕ₊₁→ℤ f))
+                                            (ℤ.≤-·o ad≤cb))
+                             (subst (_ ℤ.<_) (·CommR e (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ b))
+                                    (ℤ.<-·o cf<ed)) )}
 
 ≤-·o : ∀ m n o → 0 ≤ o → m ≤ n → m ℚ.· o ≤ n ℚ.· o
 ≤-·o =
   elimProp3 {P = λ a b c → 0 ≤ c → a ≤ b → a ℚ.· c ≤ b ℚ.· c}
             (λ x y z → isPropΠ2 λ _ _ → isProp≤ (x ℚ.· z) (y ℚ.· z))
-             λ { (a , b) (c , d) (e , f) 0≤e ad≤cb
-             → subst2 ℤ._≤_ (cong (ℤ._· ℕ₊₁→ℤ f) (·CommR a (ℕ₊₁→ℤ d) e) ∙
+             λ { (a , b) (c , d) (e , f) (inj 0≤e) (inj ad≤cb)
+             → inj $ ℤ.recompute≤ $
+               subst2 ℤ._≤_ (cong (ℤ._· ℕ₊₁→ℤ f) (·CommR a (ℕ₊₁→ℤ d) e) ∙
                               sym (ℤ.·Assoc (a ℤ.· e) (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ f)) ∙
                               cong (a ℤ.· e ℤ.·_) (sym (ℤ.pos·pos (ℕ₊₁→ℕ d) (ℕ₊₁→ℕ f))))
                              (cong (ℤ._· ℕ₊₁→ℤ f) (·CommR c (ℕ₊₁→ℤ b) e) ∙
                               sym (ℤ.·Assoc (c ℤ.· e) (ℕ₊₁→ℤ b) (ℕ₊₁→ℤ f)) ∙
                               cong (c ℤ.· e ℤ.·_) (sym (ℤ.pos·pos (ℕ₊₁→ℕ b) (ℕ₊₁→ℕ f))))
-                             (ℤ.≤-·o {k = ℕ₊₁→ℕ f}
-                                      (ℤ.0≤o→≤-·o (subst (0 ℤ.≤_) (ℤ.·IdR e) 0≤e) ad≤cb)) }
+                             (ℤ.≤-·o (ℤ.0≤o→≤-·o (subst (0 ℤ.≤_) (ℤ.·IdR e) 0≤e) ad≤cb)) }
 
 ≤-·o-cancel : ∀ m n o → 0 < o → m ℚ.· o ≤ n ℚ.· o → m ≤ n
 ≤-·o-cancel =
   elimProp3 {P = λ a b c → 0 < c → a ℚ.· c ≤ b ℚ.· c → a ≤ b}
             (λ x y _ → isPropΠ2 λ _ _ → isProp≤ x y)
-             λ { (a , b) (c , d) (e , f) 0<e aedf≤cebf
-             → ℤ.0<o→≤-·o-cancel (subst (0 ℤ.<_) (ℤ.·IdR e) 0<e)
+             λ { (a , b) (c , d) (e , f) (inj 0<e) (inj aedf≤cebf)
+             → inj $ ℤ.0<o→≤-·o-cancel (subst (0 ℤ.<_) (ℤ.·IdR e) 0<e)
                (subst2 ℤ._≤_ (·CommR a e (ℕ₊₁→ℤ d)) (·CommR c e (ℕ₊₁→ℤ b))
-                      (ℤ.≤-·o-cancel {k = -1+ f}
+                      (ℤ.≤-·o-cancel
                         (subst2 ℤ._≤_ (sym (ℤ.·Assoc a e (ℕ₊₁→ℤ (d ·₊₁ f))) ∙
                                        cong (λ x → a ℤ.· (e ℤ.· x))
                                             (ℤ.pos·pos (ℕ₊₁→ℕ d) (ℕ₊₁→ℕ f)) ∙
@@ -484,24 +516,24 @@ isTrans≤< =
 <-·o =
   elimProp3 {P = λ a b c → 0 < c → a < b → a ℚ.· c < b ℚ.· c}
             (λ x y z → isPropΠ2 λ _ _ → isProp< (x ℚ.· z) (y ℚ.· z))
-             λ { (a , b) (c , d) (e , f) 0<e ad<cb
-             → subst2 ℤ._<_ (cong (ℤ._· ℕ₊₁→ℤ f) (·CommR a (ℕ₊₁→ℤ d) e) ∙
+             λ { (a , b) (c , d) (e , f) (inj 0<e) (inj ad<cb)
+             → inj $ ℤ.recompute< $
+               subst2 ℤ._<_ (cong (ℤ._· ℕ₊₁→ℤ f) (·CommR a (ℕ₊₁→ℤ d) e) ∙
                              sym (ℤ.·Assoc (a ℤ.· e) (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ f)) ∙
                              cong (a ℤ.· e ℤ.·_) (sym (ℤ.pos·pos (ℕ₊₁→ℕ d) (ℕ₊₁→ℕ f))))
                             (cong (ℤ._· ℕ₊₁→ℤ f) (·CommR c (ℕ₊₁→ℤ b) e) ∙
                              sym (ℤ.·Assoc (c ℤ.· e) (ℕ₊₁→ℤ b) (ℕ₊₁→ℤ f)) ∙
                              cong (c ℤ.· e ℤ.·_) (sym (ℤ.pos·pos (ℕ₊₁→ℕ b) (ℕ₊₁→ℕ f))))
-                            (ℤ.<-·o {k = -1+ f}
-                                    (ℤ.0<o→<-·o (subst (0 ℤ.<_) (ℤ.·IdR e) 0<e) ad<cb)) }
+                            (ℤ.<-·o (ℤ.0<o→<-·o (subst (0 ℤ.<_) (ℤ.·IdR e) 0<e) ad<cb)) }
 
 <-·o-cancel : ∀ m n o → 0 < o → m ℚ.· o < n ℚ.· o → m < n
 <-·o-cancel =
   elimProp3 {P = λ a b c → 0 < c → a ℚ.· c < b ℚ.· c → a < b}
             (λ x y _ → isPropΠ2 λ _ _ → isProp< x y)
-             λ { (a , b) (c , d) (e , f) 0<e aedf<cebf
-             → ℤ.0<o→<-·o-cancel (subst (0 ℤ.<_) (ℤ.·IdR e) 0<e)
+             λ { (a , b) (c , d) (e , f) (inj 0<e) (inj aedf<cebf)
+             → inj $ ℤ.0<o→<-·o-cancel (subst (0 ℤ.<_) (ℤ.·IdR e) 0<e)
                (subst2 ℤ._<_ (·CommR a e (ℕ₊₁→ℤ d)) (·CommR c e (ℕ₊₁→ℤ b))
-                      (ℤ.<-·o-cancel {k = -1+ f}
+                      (ℤ.<-·o-cancel
                         (subst2 ℤ._<_ (sym (ℤ.·Assoc a e (ℕ₊₁→ℤ (d ·₊₁ f))) ∙
                                        cong (λ x → a ℤ.· (e ℤ.· x))
                                             (ℤ.pos·pos (ℕ₊₁→ℕ d) (ℕ₊₁→ℕ f)) ∙
@@ -522,20 +554,20 @@ min≤
     = elimProp2 {P = λ a b → ℚ.min a b ≤ a}
                 (λ x y → isProp≤ (ℚ.min x y) x)
                  λ { (a , b) (c , d)
-                  → subst2 ℤ._≤_ (sym (ℤ.·DistPosLMin (a ℤ.· ℕ₊₁→ℤ d)
+                  → inj (ℤ.recompute≤ (
+                    subst2 ℤ._≤_ (sym (ℤ.·DistPosLMin (a ℤ.· ℕ₊₁→ℤ d)
                                                        (c ℤ.· ℕ₊₁→ℤ b)
                                                        (ℕ₊₁→ℕ b)))
                                   (sym (ℤ.·Assoc a (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ b)) ∙
                                    cong (a ℤ.·_) (sym (ℤ.pos·pos (ℕ₊₁→ℕ d) (ℕ₊₁→ℕ b)) ∙
                                                   cong ℕ₊₁→ℤ (·₊₁-comm d b)))
-                                  (ℤ.min≤ {a ℤ.· ℕ₊₁→ℤ d ℤ.· ℕ₊₁→ℤ b}
-                                           {c ℤ.· ℕ₊₁→ℤ b ℤ.· ℕ₊₁→ℤ b}) }
+                                  ℤ.min≤)) }
 
 ≤→min : ∀ m n → m ≤ n → ℚ.min m n ≡ m
 ≤→min
     = elimProp2 {P = λ a b → a ≤ b → ℚ.min a b ≡ a}
                 (λ x y → isProp→ (isSetℚ (ℚ.min x y) x))
-                 λ { (a , b) (c , d) ad≤cb
+                 λ { (a , b) (c , d) (inj ad≤cb)
                   → eq/ (ℤ.min (a ℤ.· ℕ₊₁→ℤ d)
                                (c ℤ.· ℕ₊₁→ℤ b)
                          , b ·₊₁ d)
@@ -550,20 +582,20 @@ min≤
     = elimProp2 {P = λ a b → a ≤ ℚ.max a b}
                 (λ x y → isProp≤ x (ℚ.max x y))
                  λ { (a , b) (c , d)
-                  → subst2 ℤ._≤_ (sym (ℤ.·Assoc a (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ b)) ∙
+                  → inj (ℤ.recompute≤ (
+                    subst2 ℤ._≤_ (sym (ℤ.·Assoc a (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ b)) ∙
                                    cong (a ℤ.·_) (sym (ℤ.pos·pos (ℕ₊₁→ℕ d) (ℕ₊₁→ℕ b)) ∙
                                                   cong ℕ₊₁→ℤ (·₊₁-comm d b)))
                                   (sym (ℤ.·DistPosLMax (a ℤ.· ℕ₊₁→ℤ d)
                                                        (c ℤ.· ℕ₊₁→ℤ b)
                                                        (ℕ₊₁→ℕ b)))
-                                  (ℤ.≤max {a ℤ.· ℕ₊₁→ℤ d ℤ.· ℕ₊₁→ℤ b}
-                                           {c ℤ.· ℕ₊₁→ℤ b ℤ.· ℕ₊₁→ℤ b}) }
+                                  ℤ.≤max)) }
 
 ≤→max : ∀ m n →  m ≤ n → ℚ.max m n ≡ n
 ≤→max m n
     = elimProp2 {P = λ a b → a ≤ b → ℚ.max a b ≡ b}
                 (λ x y → isProp→ (isSetℚ (ℚ.max x y) y))
-                (λ { (a , b) (c , d) ad≤cb
+                (λ { (a , b) (c , d) (inj ad≤cb)
                   → eq/ (ℤ.max (a ℤ.· ℕ₊₁→ℤ d)
                                (c ℤ.· ℕ₊₁→ℤ b)
                          , b ·₊₁ d)
@@ -574,11 +606,14 @@ min≤
 
 ≤Dec : ∀ m n → Dec (m ≤ n)
 ≤Dec = elimProp2 (λ x y → isPropDec (isProp≤ x y))
-       λ { (a , b) (c , d) → ℤ.≤Dec (a ℤ.· ℕ₊₁→ℤ d) (c ℤ.· ℕ₊₁→ℤ b) }
+       (λ (a , b) (c , d) → decRec (yes ∘ inj) (no ∘ _∘ _≤_.prf)
+        (ℤ.≤Dec (a ℤ.· ℕ₊₁→ℤ d) (c ℤ.· ℕ₊₁→ℤ b))  )
 
 <Dec : ∀ m n → Dec (m < n)
 <Dec = elimProp2 (λ x y → isPropDec (isProp< x y))
-       λ { (a , b) (c , d) → ℤ.<Dec (a ℤ.· ℕ₊₁→ℤ d) (c ℤ.· ℕ₊₁→ℤ b) }
+       λ { (a , b) (c , d) → decRec (yes ∘ inj) (no ∘ _∘ _<_.prf)
+        (ℤ.<Dec (a ℤ.· ℕ₊₁→ℤ d) (c ℤ.· ℕ₊₁→ℤ b)) }
+
 
 _≟_ : (m n : ℚ) → Trichotomy m n
 m ≟ n with discreteℚ m n
@@ -588,33 +623,34 @@ m ≟ n with discreteℚ m n
 ...             | inr n<m = gt n<m
 
 ≤MonotoneMin : ∀ m n o s → m ≤ n → o ≤ s → ℚ.min m o ≤ ℚ.min n s
-≤MonotoneMin m n o s m≤n o≤s
-  = subst (_≤ ℚ.min n s)
-          (sym (ℚ.minAssoc n s (ℚ.min m o)) ∙
-           cong (ℚ.min n) (ℚ.minAssoc s m o ∙
-                           cong (λ a → ℚ.min a o) (ℚ.minComm s m) ∙
-                                 sym (ℚ.minAssoc m s o)) ∙
-                           ℚ.minAssoc n m (ℚ.min s o) ∙
-           cong₂ ℚ.min (ℚ.minComm n m ∙ ≤→min m n m≤n)
-                       (ℚ.minComm s o ∙ ≤→min o s o≤s))
-           (min≤ (ℚ.min n s) (ℚ.min m o))
+≤MonotoneMin m n o s m≤n o≤s = recompute≤ $
+  subst (_≤ ℚ.min n s)
+        (sym (ℚ.minAssoc n s (ℚ.min m o)) ∙
+         cong (ℚ.min n) (ℚ.minAssoc s m o ∙
+                         cong (λ a → ℚ.min a o) (ℚ.minComm s m) ∙
+                               sym (ℚ.minAssoc m s o)) ∙
+                         ℚ.minAssoc n m (ℚ.min s o) ∙
+         cong₂ ℚ.min (ℚ.minComm n m ∙ ≤→min m n m≤n)
+                     (ℚ.minComm s o ∙ ≤→min o s o≤s))
+         (min≤ (ℚ.min n s) (ℚ.min m o))
 
 ≤MonotoneMax : ∀ m n o s → m ≤ n → o ≤ s → ℚ.max m o ≤ ℚ.max n s
-≤MonotoneMax m n o s m≤n o≤s
-  = subst (ℚ.max m o ≤_)
-          (sym (ℚ.maxAssoc m o (ℚ.max n s)) ∙
-           cong (ℚ.max m) (ℚ.maxAssoc o n s ∙
-                           cong (λ a → ℚ.max a s) (ℚ.maxComm o n) ∙
-                                 sym (ℚ.maxAssoc n o s)) ∙
-                           ℚ.maxAssoc m n (ℚ.max o s) ∙
-           cong₂ ℚ.max (≤→max m n m≤n) (≤→max o s o≤s))
-          (≤max (ℚ.max m o) (ℚ.max n s))
+≤MonotoneMax m n o s m≤n o≤s = recompute≤ $
+  subst (ℚ.max m o ≤_)
+        (sym (ℚ.maxAssoc m o (ℚ.max n s)) ∙
+         cong (ℚ.max m) (ℚ.maxAssoc o n s ∙
+                         cong (λ a → ℚ.max a s) (ℚ.maxComm o n) ∙
+                               sym (ℚ.maxAssoc n o s)) ∙
+                         ℚ.maxAssoc m n (ℚ.max o s) ∙
+         cong₂ ℚ.max (≤→max m n m≤n) (≤→max o s o≤s))
+        (≤max (ℚ.max m o) (ℚ.max n s))
 
 ≡Weaken≤ : ∀ m n → m ≡ n → m ≤ n
-≡Weaken≤ m n m≡n = subst (m ≤_) m≡n (isRefl≤ m)
+≡Weaken≤ m n m≡n = recompute≤ $ subst (m ≤_) m≡n (isRefl≤ m)
 
 ≤→≯ : ∀ m n →  m ≤ n → ¬ (m > n)
-≤→≯ m n m≤n n<m = isIrrefl< n (subst (n <_) (isAntisym≤ m n m≤n (<Weaken≤ n m n<m)) n<m)
+≤→≯ m n m≤n = recompute¬< $
+  λ n<m → isIrrefl< n (subst (n <_) (isAntisym≤ m n m≤n (<Weaken≤ n m n<m)) n<m)
 
 ≮→≥ : ∀ m n → ¬ (m < n) → m ≥ n
 ≮→≥ m n m≮n with discreteℚ m n
@@ -628,3 +664,6 @@ m ≟ n with discreteℚ m n
 ... | no 0≮m | no 0≮n = ⊥.rec (≤→≯ (m ℚ.+ n) 0 (≤Monotone+ m 0 n 0 (≮→≥ 0 m 0≮m) (≮→≥ 0 n 0≮n)) 0<m+n)
 ... | no _    | yes 0<n = inr 0<n
 ... | yes 0<m | _ = inl 0<m
+
+<ℤ→<ℚ : ∀ m n k → m ℤ.< n → [ m / k ] < [ n / k ]
+<ℤ→<ℚ m n (1+ k) m<n = inj (ℤ.<-·o {m} m<n)
diff --git a/Cubical/Data/Rationals/Properties.agda b/Cubical/Data/Rationals/Properties.agda
index d12f6bcaf1..4f32d7e383 100644
--- a/Cubical/Data/Rationals/Properties.agda
+++ b/Cubical/Data/Rationals/Properties.agda
@@ -1,23 +1,42 @@
 module Cubical.Data.Rationals.Properties where
 
 open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Function
 open import Cubical.Foundations.Isomorphism
 open import Cubical.Foundations.Equiv
 open import Cubical.Foundations.GroupoidLaws hiding (_⁻¹)
 open import Cubical.Foundations.Univalence
+open import Cubical.Foundations.HLevels
 
-open import Cubical.Data.Int as ℤ using (ℤ; pos·pos; pos0+)
-open import Cubical.HITs.SetQuotients as SetQuotient using () renaming (_/_ to _//_)
+open import Cubical.Data.Empty as ⊥
+
+open import Cubical.Data.Fast.Int as ℤ using (ℤ; pos·pos; pos0+; pos; negsuc) renaming
+  (_+_ to _+ℤ_ ; _·_ to _·ℤ_ ; -_ to -ℤ_ ; abs to ∣_∣ℤ ; sign to sgn)
 
-open import Cubical.Data.Nat as ℕ using (ℕ; zero; suc)
+open import Cubical.Data.Nat as ℕ using (ℕ; zero; suc) renaming
+  (_+_ to _+ℕ_ ; _·_ to _·ℕ_)
+open import Cubical.Data.Nat.GCD
+open import Cubical.Data.Nat.Coprime
 open import Cubical.Data.NatPlusOne
 open import Cubical.Data.Sigma
-
 open import Cubical.Data.Sum
+
+open import Cubical.HITs.SetQuotients as SetQuotient using () renaming (_/_ to _//_)
+
 open import Cubical.Relation.Nullary
 
 open import Cubical.Data.Rationals.Base
 
+∼→sign≡sign : ∀ a a' b b' → (a , b) ∼ (a' , b') → ℤ.sign a ≡ ℤ.sign a'
+∼→sign≡sign (ℤ.pos zero)    (ℤ.pos zero)    (1+ _) (1+ _) = λ _ → refl
+∼→sign≡sign (ℤ.pos zero)    (ℤ.pos (suc n)) (1+ _) (1+ _) = ⊥.rec ∘ ℕ.znots ∘ ℤ.injPos
+∼→sign≡sign (ℤ.pos (suc m)) (ℤ.pos zero)    (1+ _) (1+ _) = ⊥.rec ∘ ℕ.snotz ∘ ℤ.injPos
+∼→sign≡sign (ℤ.pos (suc m)) (ℤ.pos (suc n)) (1+ _) (1+ _) = λ _ → refl
+∼→sign≡sign (ℤ.pos m)       (ℤ.negsuc n)    (1+ _) (1+ _) = ⊥.rec ∘ ℤ.posNotnegsuc _ _
+∼→sign≡sign (ℤ.negsuc m)    (ℤ.pos n)       (1+ _) (1+ _) = ⊥.rec ∘ ℤ.negsucNotpos _ _
+∼→sign≡sign (ℤ.negsuc m)    (ℤ.negsuc n)    (1+ _) (1+ _) = λ _ → refl
+
+
 ·CancelL : ∀ {a b} (c : ℕ₊₁) → [ ℕ₊₁→ℤ c ℤ.· a / c ·₊₁ b ] ≡ [ a / b ]
 ·CancelL {a} {b} c = eq/ _ _
   ((ℕ₊₁→ℤ c ℤ.· a)   ℤ.· ℕ₊₁→ℤ b  ≡⟨ cong (ℤ._· ℕ₊₁→ℤ b) (ℤ.·Comm (ℕ₊₁→ℤ c) a) ⟩
@@ -32,6 +51,88 @@ open import Cubical.Data.Rationals.Base
    a ℤ.· (ℕ₊₁→ℤ b ℤ.· ℕ₊₁→ℤ c)  ≡⟨ cong (a ℤ.·_) (sym (pos·pos (ℕ₊₁→ℕ b) (ℕ₊₁→ℕ c))) ⟩
    a ℤ.· ℕ₊₁→ℤ (b ·₊₁ c) ∎)
 
+module Reduce where
+  private
+    ℕ[_] = ℕ₊₁→ℕ
+    ℤ[_] = ℕ₊₁→ℤ
+    +[_] = ℤ.pos
+
+    Cod : ∀ x → Type
+    Cod x = Σ[ (p , q) ∈ (ℤ × ℕ₊₁) ] areCoprime (ℤ.abs p , ℕ₊₁→ℕ q) × ([ p / q ] ≡ x)
+    isSetValuedCod : ∀ x → isSet (Cod x)
+    isSetValuedCod x = isSetΣSndProp
+      (isSet× ℤ.isSetℤ (subst isSet 1+Path ℕ.isSetℕ))
+      λ _ → isProp× isPropIsGCD (isSetℚ _ _)
+
+    lemma-cop : ∀ {d-1} a c₁ → (c₁ ·ℕ suc d-1 ≡ ∣ a ∣ℤ) → c₁ ≡ ∣ sgn a ·ℤ +[ c₁ ] ∣ℤ
+    lemma-cop (pos zero)    zero     _ = refl
+    lemma-cop (pos zero)    (suc _)  x = ⊥.rec (ℕ.snotz x)
+    lemma-cop (pos (suc n)) c₁       _ = sym $ ℕ.+-zero c₁
+    lemma-cop (negsuc n)    zero     _ = refl
+    lemma-cop (negsuc n)    (suc c₁) _ = cong suc $ sym $ ℕ.+-zero c₁
+
+  module cop ((a , b) : ℤ × ℕ₊₁) where
+    open ToCoprime (∣ a ∣ℤ , b) renaming (toCoprimeAreCoprime to tcac) public
+
+    reduced[] : Cod [ a / b ]
+    reduced[] .fst      = sgn a ·ℤ pos c₁ , c₂
+    reduced[] .snd .fst = subst (areCoprime ∘ (_, ℕ[ c₂ ]))
+                                (lemma-cop a _ (cong (c₁ ·ℕ_) (sym q) ∙ p₁))
+                                tcac
+    reduced[] .snd .snd = eq/ _ _ $
+      sgn a ·ℤ   +[ c₁ ] ·ℤ ℤ[ b ]         ≡⟨ sym $ ℤ.·Assoc (sgn a) _ _ ⟩
+      sgn a ·ℤ ( +[ c₁ ] ·ℤ ℤ[ b ])        ≡⟨⟩
+      sgn a ·ℤ ( +[ c₁ ·ℕ ℕ[ b ] ])        ≡⟨ cong ((sgn a ·ℤ_) ∘ +[_]) $
+                    c₁ ·ℕ ℕ[ b ]           ≡⟨ sym $ cong (c₁ ·ℕ_) p₂ ⟩
+                    c₁ ·ℕ (ℕ[ c₂ ] ·ℕ d)   ≡⟨ cong (c₁ ·ℕ_) (ℕ.·-comm ℕ[ c₂ ] d) ⟩
+                    c₁ ·ℕ (d ·ℕ ℕ[ c₂ ])   ≡⟨ ℕ.·-assoc c₁ d ℕ[ c₂ ] ⟩
+                    c₁ ·ℕ  d ·ℕ ℕ[ c₂ ]    ≡⟨ cong (_·ℕ ℕ[ c₂ ]) p₁ ⟩ refl ⟩
+      sgn a ·ℤ ( +[    ∣ a ∣ℤ ·ℕ ℕ[ c₂ ] ]) ≡⟨⟩
+      sgn a ·ℤ ( +[  ∣ a ∣ℤ ] ·ℤ ℤ[ c₂ ] )  ≡⟨ ℤ.·Assoc (sgn a) _ _ ⟩
+      sgn a ·ℤ   +[  ∣ a ∣ℤ ] ·ℤ ℤ[ c₂ ]    ≡⟨ cong (_·ℤ ℤ[ c₂ ]) (ℤ.sign·abs a) ⟩
+                           a ·ℤ ℤ[ c₂ ]    ∎
+
+  reduced[]∼ : ∀ x y r → PathP (λ i → Cod (eq/ x y r i)) (cop.reduced[] x) (cop.reduced[] y)
+  reduced[]∼ x@(a , b) y@(a' , b') r = let
+    ∣x∣ = (∣ a  ∣ℤ , b)
+    ∣y∣ = (∣ a' ∣ℤ , b')
+
+    tc∣x∣≡tc∣y∣ =
+      tc ∣x∣                             ≡⟨⟩
+      tc (∣ a ∣ℤ , b)                    ≡⟨ sym $ tc-cancelʳ ∣x∣ b' ⟩
+      tc (∣ a ∣ℤ ·ℕ ℕ[ b' ] , b ·₊₁ b') ≡⟨ cong (tc ∘ (_, b ·₊₁ b')) $
+          ∣ a ∣ℤ ·ℕ ℕ[ b' ]             ≡⟨ sym $ ℤ.abs· a ℤ[ b' ] ⟩
+          ∣ a  ·ℤ ℤ[ b' ] ∣ℤ             ≡⟨ cong ∣_∣ℤ r ⟩
+          ∣ a' ·ℤ ℤ[ b  ] ∣ℤ             ≡⟨ ℤ.abs· a' ℤ[ b ] ⟩ refl ⟩
+      tc (∣ a' ∣ℤ ·ℕ ℕ[ b ] , b ·₊₁ b') ≡⟨ cong (tc ∘ (∣ a' ∣ℤ ·ℕ ℕ[ b ] ,_)) $ ·₊₁-comm b b' ⟩
+      tc (∣ a' ∣ℤ ·ℕ ℕ[ b ] , b' ·₊₁ b) ≡⟨ tc-cancelʳ ∣y∣ b ⟩
+      tc (∣ a' ∣ℤ , b')                  ≡⟨⟩
+      tc ∣y∣                             ∎
+
+    step0 = cong (uncurry (_,_ ∘ (sgn a ·ℤ_) ∘ pos)) tc∣x∣≡tc∣y∣
+    step1 = cong ((_, c₂ ∣y∣) ∘ (_·ℤ pos (c₁ ∣y∣))) (∼→sign≡sign a a' b b' r)
+    in
+      ΣPathPProp (λ _ → isProp× isPropIsGCD (isSetℚ _ _)) $
+        sgn a  ·ℤ pos (c₁ ∣x∣) , c₂ ∣x∣ ≡⟨ step0 ⟩
+        sgn a  ·ℤ pos (c₁ ∣y∣) , c₂ ∣y∣ ≡⟨ step1 ⟩
+        sgn a' ·ℤ pos (c₁ ∣y∣) , c₂ ∣y∣ ∎
+    where
+      open ToCoprime renaming (toCoprime to tc) ; tc-cancelʳ = toCoprime-cancelʳ
+
+  reduced : ∀ x → Cod x
+  reduced = SetQuotient.elim isSetValuedCod cop.reduced[] reduced[]∼
+
+open Reduce public
+
+reduceFrac : ℚ → ℤ × ℕ₊₁
+reduceFrac = fst ∘ reduced
+
+reduce : ℚ → ℚ
+reduce = [_] ∘ fst ∘ reduced
+
+reduce≡id : ∀ x → reduce x ≡ x
+reduce≡id = snd ∘ snd ∘ reduced
+
 -- useful functions for defining operations on ℚ
 
 onCommonDenom :
@@ -485,14 +586,4 @@ x - y = x + (- y)
 +CancelR x y z p = +CancelL y x z (+Comm y x ∙ p ∙ +Comm z y)
 
 numerator0→0 : (u : ℤ × ℕ₊₁) → u .fst ≡ 0 → [ u ] ≡ 0
-numerator0→0 (a , b) p = eq/ ((a , b)) ((0 , 1)) q
-  where
-  q : a ℤ.· (ℕ₊₁→ℤ 1) ≡ 0 ℤ.· (ℕ₊₁→ℤ b)
-  q =
-    a ℤ.· (ℕ₊₁→ℤ 1)
-      ≡⟨ ℤ.·IdR a ⟩
-    a
-      ≡⟨ p ⟩
-    0
-      ≡⟨ sym (ℤ.·AnnihilL (ℕ₊₁→ℤ b)) ⟩
-    0 ℤ.· (ℕ₊₁→ℤ b) ∎
+numerator0→0 (a , b) p = eq/ (a , b) (0 , 1) (ℤ.·IdR _ ∙ p)

From 44a319d35583b0d0c811990a2b1a13429ddaa5d2 Mon Sep 17 00:00:00 2001
From: Lorenzo Molena <lorenzo.molena8@gmail.com>
Date: Sun, 5 Apr 2026 01:20:40 +0200
Subject: [PATCH 08/19] add instances of `Rationals` as order structures and as
 an `OrderedCommRing` ; add positive rationals and their properties

---
 .../OrderedCommRing/Instances/Rationals.agda  | 187 ++++++++++++++++++
 .../Order/Loset/Instances/Rationals.agda      |  31 +++
 .../Order/Poset/Instances/Rationals.agda      |  11 ++
 .../Order/Proset/Instances/Rationals.agda     |  11 ++
 .../Pseudolattice/Instances/Rationals.agda    |  19 ++
 .../Order/Quoset/Instances/Rationals.agda     |  11 ++
 .../StrictOrder/Instances/Rationals.agda      |  11 ++
 .../Order/Toset/Instances/Rationals.agda      |  31 +++
 8 files changed, 312 insertions(+)
 create mode 100644 Cubical/Algebra/OrderedCommRing/Instances/Rationals.agda
 create mode 100644 Cubical/Relation/Binary/Order/Loset/Instances/Rationals.agda
 create mode 100644 Cubical/Relation/Binary/Order/Poset/Instances/Rationals.agda
 create mode 100644 Cubical/Relation/Binary/Order/Proset/Instances/Rationals.agda
 create mode 100644 Cubical/Relation/Binary/Order/Pseudolattice/Instances/Rationals.agda
 create mode 100644 Cubical/Relation/Binary/Order/Quoset/Instances/Rationals.agda
 create mode 100644 Cubical/Relation/Binary/Order/StrictOrder/Instances/Rationals.agda
 create mode 100644 Cubical/Relation/Binary/Order/Toset/Instances/Rationals.agda

diff --git a/Cubical/Algebra/OrderedCommRing/Instances/Rationals.agda b/Cubical/Algebra/OrderedCommRing/Instances/Rationals.agda
new file mode 100644
index 0000000000..600f38c22a
--- /dev/null
+++ b/Cubical/Algebra/OrderedCommRing/Instances/Rationals.agda
@@ -0,0 +1,187 @@
+module Cubical.Algebra.OrderedCommRing.Instances.Rationals where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Equiv
+
+open import Cubical.Data.Empty as ⊥
+
+open import Cubical.HITs.PropositionalTruncation as PT
+open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_)
+
+open import Cubical.Data.Nat as ℕ hiding (_+_ ; _·_)
+open import Cubical.Data.NatPlusOne as ℕ₊₁
+open import Cubical.Data.Fast.Int as ℤ hiding (_+_ ; _-_ ; -_ ; _·_)
+import Cubical.Data.Fast.Int.Order as ℤ
+
+open import Cubical.Data.Rationals as ℚ
+  renaming (_+_ to _+ℚ_ ; _-_ to _-ℚ_; -_ to -ℚ_ ; _·_ to _·ℚ_)
+open import Cubical.Data.Rationals.Order as ℚ
+  renaming (_<_ to _<ℚ_ ; _≤_ to _≤ℚ_)
+
+open import Cubical.Algebra.CommRing
+open import Cubical.Algebra.CommRing.Instances.Rationals
+
+open import Cubical.Algebra.OrderedCommRing.Base
+open import Cubical.Algebra.OrderedCommRing.Properties
+
+open import Cubical.Relation.Nullary
+
+open import Cubical.Relation.Binary.Order.StrictOrder
+open import Cubical.Relation.Binary.Order.StrictOrder.Instances.Rationals
+
+open import Cubical.Relation.Binary.Order.Pseudolattice
+open import Cubical.Relation.Binary.Order.Pseudolattice.Instances.Rationals
+
+open CommRingStr
+open OrderedCommRingStr
+open PseudolatticeStr
+open StrictOrderStr
+
+ℚOrderedCommRing : OrderedCommRing ℓ-zero ℓ-zero
+fst ℚOrderedCommRing = ℚ
+0r  (snd ℚOrderedCommRing) = 0
+1r  (snd ℚOrderedCommRing) = 1
+_+_ (snd ℚOrderedCommRing) = _+ℚ_
+_·_ (snd ℚOrderedCommRing) = _·ℚ_
+-_  (snd ℚOrderedCommRing) = -ℚ_
+_<_ (snd ℚOrderedCommRing) = _<ℚ_
+_≤_ (snd ℚOrderedCommRing) = _≤ℚ_
+isOrderedCommRing (snd ℚOrderedCommRing) = isOrderedCommRingℚ
+  where
+  open IsOrderedCommRing
+
+  isOrderedCommRingℚ : IsOrderedCommRing 0 1 _+ℚ_ _·ℚ_ -ℚ_ _<ℚ_ _≤ℚ_
+  isOrderedCommRingℚ .isCommRing      = ℚCommRing .snd .isCommRing
+  isOrderedCommRingℚ .isPseudolattice = ℚ≤Pseudolattice .snd .is-pseudolattice
+  isOrderedCommRingℚ .isStrictOrder   = ℚ<StrictOrder .snd .isStrictOrder
+  isOrderedCommRingℚ .<-≤-weaken      = <Weaken≤
+  isOrderedCommRingℚ .≤≃¬>            = λ x y →
+    propBiimpl→Equiv (isProp≤ x y) (isProp¬ (y <ℚ x)) (≤→≯  x y) (≮→≥ y x)
+  isOrderedCommRingℚ .+MonoR≤         = ≤-+o
+  isOrderedCommRingℚ .+MonoR<         = <-+o
+  isOrderedCommRingℚ .posSum→pos∨pos  = λ x y → ∣_∣₁ ∘ 0<+ x y
+  isOrderedCommRingℚ .<-≤-trans       = isTrans<≤
+  isOrderedCommRingℚ .≤-<-trans       = isTrans≤<
+  isOrderedCommRingℚ .·MonoR≤         = ≤-·o
+  isOrderedCommRingℚ .·MonoR<         = <-·o
+  isOrderedCommRingℚ .0<1             = pos<pos tt
+
+module 1/2∈ℚ = 1/2∈R ℚOrderedCommRing [ 1 / 2 ] (eq/ _ _ refl)
+
+module PositiveRationals where
+  private
+    0<+Closed : ∀ x y → 0 <ℚ x → 0 <ℚ y → 0 <ℚ x +ℚ y
+    0<+Closed = SQ.elimProp2 (λ _ _ → isProp→ (isProp→ (isProp< 0 _))) λ
+      { (pos (suc n) , _) (pos (suc m) , _) (pos<pos p) (pos<pos q) → pos<pos tt }
+
+    0<·Closed : ∀ x y → 0 <ℚ x → 0 <ℚ y → 0 <ℚ x ·ℚ y
+    0<·Closed = SQ.elimProp2 (λ _ _ → isProp→ (isProp→ (isProp< 0 _))) λ
+      { (pos (suc n) , _) (pos (suc m) , _) (pos<pos p) (pos<pos q) → pos<pos tt }
+
+  open Units ℚCommRing
+  open CommRingTheory ℚCommRing
+  open OrderedCommRingReasoning ℚOrderedCommRing
+
+  open Positive ℚOrderedCommRing 0<+Closed 0<·Closed public renaming (
+      R₊ to ℚ₊ ; isSetR₊ to isSetℚ₊ ; R₊≡ to ℚ₊≡ ; ≡₊→R₊ to ≡₊→ℚ₊
+    ; R₊AdditiveSemigroup to +ℚ₊Semigroup ; R₊MultiplicativeCommMonoid to ·ℚ₊CommMonoid)
+  open module PositiveHalvesℚ =
+    PositiveHalves ℚOrderedCommRing [ 1 / 2 ] (eq/ _ _ refl) 0<+Closed 0<·Closed
+
+  -- Natural number literals for ℚ
+
+  open import Cubical.Data.Nat.Literals public
+
+  instance
+    fromNatℚ₊ : HasFromNat ℚ₊
+    fromNatℚ₊ = record { Constraint = λ { zero → ⊥ ; _ → Unit }
+                       ; fromNat = λ { (suc n) .fst → [ pos (suc n) / 1 ]
+                                     ; (suc n) .snd → pos<pos tt } }
+
+  [_/_]₊ : ℕ₊₁ → ℕ₊₁ → ℚ₊
+  [ 1+ n / 1+ m ]₊ = [ pos (suc n) / 1+ m ] , pos<pos tt
+
+  max₊ : ℚ₊ → ℚ₊ → ℚ₊
+  fst (max₊ x y) = ℚ.max (fst x) (fst y)
+  snd (max₊ x y) = elimProp2
+    {P = λ a b → 0 <ℚ a → 0 <ℚ b → 0 <ℚ ℚ.max a b}
+    (λ a b → isPropΠ2 λ _ _ → isProp< 0 (ℚ.max a b))
+    (λ { (pos (suc n) , 1+ a) (pos (suc m) , 1+ b) (pos<pos p) (pos<pos q) →
+    let
+      1+n = suc n ; 1+m = suc m ; 1+a = suc a ; 1+b = suc b
+    in
+      -- NOTE :
+      -- if we are only concerned about efficiency, then there is no need to recompute,
+      -- as `maxSuc` already reduces efficiently to refl for concrete (large) numbers
+      -- however, since `_<_` is an indexed data type, we recompute anyway to avoid
+      -- `transpX-_<_` in the normal form
+      inj (ℤ.recompute< (subst (0 ℤ.<_)
+      (sym $ cong (pos ∘ (ℕ._· 1)) $ maxSuc {predℕ (1+n ℕ.· 1+b)} {predℕ (1+m ℕ.· 1+a)})
+      (ℤ.pos<pos tt))) })
+    (fst x) (fst y) (snd x) (snd y)
+
+  min₊ : ℚ₊ → ℚ₊ → ℚ₊
+  fst (min₊ x y) = ℚ.min (fst x) (fst y)
+  snd (min₊ x y) = elimProp2
+    {P = λ a b → 0 <ℚ a → 0 <ℚ b → 0 <ℚ ℚ.min a b}
+    (λ a b → isPropΠ2 λ _ _ → isProp< 0 (ℚ.min a b))
+    (λ { (pos (suc n) , 1+ a) (pos (suc m) , 1+ b) (pos<pos p) (pos<pos q) →
+    let
+      1+n = suc n ; 1+m = suc m ; 1+a = suc a ; 1+b = suc b
+    in
+      inj (ℤ.recompute< (subst (0 ℤ.<_)
+      (sym $ cong (pos ∘ (ℕ._· 1)) $ minSuc {predℕ (1+n ℕ.· 1+b)} {predℕ (1+m ℕ.· 1+a)})
+      (ℤ.pos<pos tt))) })
+    (fst x) (fst y) (snd x) (snd y)
+
+  min₊≤L : ∀ ε δ → min₊ ε δ ≤₊ ε
+  min₊≤L ε δ = min≤ ⟨ ε ⟩₊ ⟨ δ ⟩₊
+
+  min₊≤R : ∀ ε δ → min₊ ε δ ≤₊ δ
+  min₊≤R ε δ = ℚ.recompute≤ $
+    subst (_≤ℚ ⟨ δ ⟩₊) (ℚ.minComm ⟨ δ ⟩₊ ⟨ ε ⟩₊) (min≤ ⟨ δ ⟩₊ ⟨ ε ⟩₊)
+
+  min/2₊<L : ∀ ε δ → (min₊ ε δ /2₊) <₊ ε
+  min/2₊<L ε δ = begin<
+    ⟨ min₊ ε δ /2₊ ⟩₊ <⟨ /2₊<id (min₊ ε δ) ⟩
+    ⟨ min₊ ε δ ⟩₊     ≤⟨ min₊≤L ε δ ⟩
+    ⟨ ε ⟩₊            ◾
+
+  min/2₊<R : ∀ ε δ → (min₊ ε δ /2₊) <₊ δ
+  min/2₊<R ε δ = begin<
+    ⟨ min₊ ε δ /2₊ ⟩₊ <⟨ /2₊<id (min₊ ε δ) ⟩
+    ⟨ min₊ ε δ ⟩₊     ≤⟨ min₊≤R ε δ ⟩
+    ⟨ δ ⟩₊            ◾
+
+  module ℚ₊Inverse where
+
+    Σinverseℚ₊ : ((ε , 0<ε) : ℚ₊) → Σ[ δ ∈ ℚ ] (ε ℚ.· δ ≡ 1)
+    Σinverseℚ₊ = uncurry $ SQ.elimProp (λ ε → isPropΠ λ _ → inverseUniqueness ε) λ
+      { (pos (suc n) , 1+ d) (pos<pos p) .fst → [ pos (suc d) , 1+ n ]
+      ; (pos (suc n) , 1+ d) (pos<pos p) .snd →
+        eq/ _ _ (ℤ.·IdR _ ∙∙ ℤ.·Comm (pos (suc n)) (pos (suc d)) ∙∙ sym (ℤ.·IdL _)) }
+
+    infixl 7 _⁻¹₊
+
+    0<inverseℚ⁺ : ∀ ε → 0 <ℚ fst (Σinverseℚ₊ ε)
+    0<inverseℚ⁺ = uncurry $ SQ.elimProp (λ ε → isPropΠ λ p → isProp< 0 _) λ
+      { (pos (suc n) , 1+ d) (pos<pos x) → pos<pos tt }
+
+    _⁻¹₊ : ℚ₊ → ℚ₊
+    fst (ε ⁻¹₊) = fst (Σinverseℚ₊ ε)
+    snd (ε ⁻¹₊) = 0<inverseℚ⁺ ε
+
+    _/_ : ℚ₊ → ℚ₊ → ℚ₊
+    ε / L = ε ·₊ (L ⁻¹₊)
+
+    ⁻¹inverse : ∀ ε → ⟨ ε / ε ⟩₊ ≡ 1
+    ⁻¹inverse = snd ∘ Σinverseℚ₊
+
+    ·/ : ∀ L ε → ⟨ L ·₊ (ε / L) ⟩₊ ≡ ⟨ ε ⟩₊
+    ·/ L ε =
+      ⟨ L ·₊ (ε ·₊ (L ⁻¹₊)) ⟩₊ ≡⟨ ·CommAssocl ⟨ L ⟩₊ ⟨ ε ⟩₊ ⟨ L ⁻¹₊ ⟩₊ ⟩
+      ⟨ ε ·₊ (L ·₊ (L ⁻¹₊)) ⟩₊ ≡⟨ cong (⟨ ε ⟩₊ ℚ.·_) (⁻¹inverse L) ⟩
+      ⟨ ε ⟩₊ ℚ.· 1             ≡⟨ ℚ.·IdR ⟨ ε ⟩₊ ⟩
+      ⟨ ε ⟩₊                   ∎
diff --git a/Cubical/Relation/Binary/Order/Loset/Instances/Rationals.agda b/Cubical/Relation/Binary/Order/Loset/Instances/Rationals.agda
new file mode 100644
index 0000000000..86a2cbc8ac
--- /dev/null
+++ b/Cubical/Relation/Binary/Order/Loset/Instances/Rationals.agda
@@ -0,0 +1,31 @@
+module Cubical.Relation.Binary.Order.Loset.Instances.Rationals where
+
+open import Cubical.Foundations.Prelude
+
+open import Cubical.Data.Sum
+open import Cubical.HITs.PropositionalTruncation
+
+open import Cubical.Data.Empty as ⊥
+
+open import Cubical.Data.Rationals
+open import Cubical.Data.Rationals.Order renaming (_<_ to _<ℚ_)
+
+open import Cubical.Relation.Binary.Order.Loset
+
+open LosetStr
+
+ℚ<Loset : Loset ℓ-zero ℓ-zero
+fst ℚ<Loset = ℚ
+_<_ (snd ℚ<Loset) = _<ℚ_
+isLoset (snd ℚ<Loset) = isLosetℚ<
+  where
+    open IsLoset
+    abstract
+      isLosetℚ< : IsLoset _<ℚ_
+      isLosetℚ< .is-set           = isSetℚ
+      isLosetℚ< .is-prop-valued   = isProp<
+      isLosetℚ< .is-irrefl        = isIrrefl<
+      isLosetℚ< .is-trans         = isTrans<
+      isLosetℚ< .is-asym          = isAsym<
+      isLosetℚ< .is-weakly-linear = isWeaklyLinear<
+      isLosetℚ< .is-connected     = isConnected<
diff --git a/Cubical/Relation/Binary/Order/Poset/Instances/Rationals.agda b/Cubical/Relation/Binary/Order/Poset/Instances/Rationals.agda
new file mode 100644
index 0000000000..26db946ef3
--- /dev/null
+++ b/Cubical/Relation/Binary/Order/Poset/Instances/Rationals.agda
@@ -0,0 +1,11 @@
+module Cubical.Relation.Binary.Order.Poset.Instances.Rationals where
+
+open import Cubical.Foundations.Prelude
+
+open import Cubical.Relation.Binary.Order.Poset
+open import Cubical.Relation.Binary.Order.Toset
+
+open import Cubical.Relation.Binary.Order.Toset.Instances.Rationals
+
+ℚ≤Poset : Poset ℓ-zero ℓ-zero
+ℚ≤Poset = Toset→Poset ℚ≤Toset
diff --git a/Cubical/Relation/Binary/Order/Proset/Instances/Rationals.agda b/Cubical/Relation/Binary/Order/Proset/Instances/Rationals.agda
new file mode 100644
index 0000000000..aa89d5a7ff
--- /dev/null
+++ b/Cubical/Relation/Binary/Order/Proset/Instances/Rationals.agda
@@ -0,0 +1,11 @@
+module Cubical.Relation.Binary.Order.Proset.Instances.Rationals where
+
+open import Cubical.Foundations.Prelude
+
+open import Cubical.Relation.Binary.Order.Poset
+open import Cubical.Relation.Binary.Order.Proset
+
+open import Cubical.Relation.Binary.Order.Poset.Instances.Rationals
+
+ℚ≤Proset : Proset ℓ-zero ℓ-zero
+ℚ≤Proset = Poset→Proset ℚ≤Poset
diff --git a/Cubical/Relation/Binary/Order/Pseudolattice/Instances/Rationals.agda b/Cubical/Relation/Binary/Order/Pseudolattice/Instances/Rationals.agda
new file mode 100644
index 0000000000..25b3765ef7
--- /dev/null
+++ b/Cubical/Relation/Binary/Order/Pseudolattice/Instances/Rationals.agda
@@ -0,0 +1,19 @@
+module Cubical.Relation.Binary.Order.Pseudolattice.Instances.Rationals where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Function
+
+open import Cubical.Data.Rationals
+open import Cubical.Data.Rationals.Order renaming (_≤_ to _≤ℚ_)
+
+open import Cubical.Relation.Binary.Order.Poset.Instances.Rationals
+open import Cubical.Relation.Binary.Order.Pseudolattice
+
+ℚ≤Pseudolattice : Pseudolattice ℓ-zero ℓ-zero
+ℚ≤Pseudolattice = makePseudolatticeFromPoset ℚ≤Poset min max
+  (λ {a b}   → min≤ a b)
+  (λ {a b}   → recompute≤ (subst (_≤ℚ b) (minComm b a) (min≤ b a)))
+  (λ {a b x} → ((recompute≤ ∘ subst (_≤ℚ min a b) (minIdem x)) ∘_) ∘ ≤MonotoneMin x a x b)
+  (λ {x} {y} → ≤max x y)
+  (λ {a b}   → recompute≤ (subst (b ≤ℚ_) (maxComm b a) (≤max b a)))
+  (λ {a b x} → ((recompute≤ ∘ subst (max a b ≤ℚ_) (maxIdem x)) ∘_) ∘ ≤MonotoneMax a x b x)
diff --git a/Cubical/Relation/Binary/Order/Quoset/Instances/Rationals.agda b/Cubical/Relation/Binary/Order/Quoset/Instances/Rationals.agda
new file mode 100644
index 0000000000..fbc311e060
--- /dev/null
+++ b/Cubical/Relation/Binary/Order/Quoset/Instances/Rationals.agda
@@ -0,0 +1,11 @@
+module Cubical.Relation.Binary.Order.Quoset.Instances.Rationals where
+
+open import Cubical.Foundations.Prelude
+
+open import Cubical.Relation.Binary.Order.Quoset
+open import Cubical.Relation.Binary.Order.StrictOrder
+
+open import Cubical.Relation.Binary.Order.StrictOrder.Instances.Rationals
+
+ℚ<Quoset : Quoset ℓ-zero ℓ-zero
+ℚ<Quoset = StrictOrder→Quoset ℚ<StrictOrder
diff --git a/Cubical/Relation/Binary/Order/StrictOrder/Instances/Rationals.agda b/Cubical/Relation/Binary/Order/StrictOrder/Instances/Rationals.agda
new file mode 100644
index 0000000000..a0af1e2169
--- /dev/null
+++ b/Cubical/Relation/Binary/Order/StrictOrder/Instances/Rationals.agda
@@ -0,0 +1,11 @@
+module Cubical.Relation.Binary.Order.StrictOrder.Instances.Rationals where
+
+open import Cubical.Foundations.Prelude
+
+open import Cubical.Relation.Binary.Order.StrictOrder
+open import Cubical.Relation.Binary.Order.Loset
+
+open import Cubical.Relation.Binary.Order.Loset.Instances.Rationals
+
+ℚ<StrictOrder : StrictOrder ℓ-zero ℓ-zero
+ℚ<StrictOrder = Loset→StrictOrder ℚ<Loset
diff --git a/Cubical/Relation/Binary/Order/Toset/Instances/Rationals.agda b/Cubical/Relation/Binary/Order/Toset/Instances/Rationals.agda
new file mode 100644
index 0000000000..d209a0c0ec
--- /dev/null
+++ b/Cubical/Relation/Binary/Order/Toset/Instances/Rationals.agda
@@ -0,0 +1,31 @@
+module Cubical.Relation.Binary.Order.Toset.Instances.Rationals where
+
+open import Cubical.Foundations.Prelude
+
+open import Cubical.Data.Sum
+open import Cubical.HITs.PropositionalTruncation
+
+open import Cubical.Data.Rationals
+open import Cubical.Data.Rationals.Order renaming (_≤_ to _≤ℚ_)
+
+open import Cubical.Relation.Binary.Order.Toset
+
+open import Cubical.Relation.Binary
+open BinaryRelation
+
+open TosetStr
+
+ℚ≤Toset : Toset ℓ-zero ℓ-zero
+fst ℚ≤Toset = ℚ
+_≤_ (snd ℚ≤Toset) = _≤ℚ_
+isToset (snd ℚ≤Toset) = isTosetℚ≤
+  where
+    open IsToset
+    abstract
+      isTosetℚ≤ : IsToset _≤ℚ_
+      isTosetℚ≤ .is-set         = isSetℚ
+      isTosetℚ≤ .is-prop-valued = isProp≤
+      isTosetℚ≤ .is-refl        = isRefl≤
+      isTosetℚ≤ .is-trans       = isTrans≤
+      isTosetℚ≤ .is-antisym     = isAntisym≤
+      isTosetℚ≤ .is-total       = isTotal≤

From b956d6b38a26f5e35225223b8007400850b49969 Mon Sep 17 00:00:00 2001
From: Lorenzo Molena <lorenzo.molena8@gmail.com>
Date: Sun, 5 Apr 2026 09:09:18 +0200
Subject: [PATCH 09/19] add definition of `PremetricSpace`

---
 Cubical/Relation/Premetric.agda      |  3 ++
 Cubical/Relation/Premetric/Base.agda | 73 ++++++++++++++++++++++++++++
 2 files changed, 76 insertions(+)
 create mode 100644 Cubical/Relation/Premetric.agda
 create mode 100644 Cubical/Relation/Premetric/Base.agda

diff --git a/Cubical/Relation/Premetric.agda b/Cubical/Relation/Premetric.agda
new file mode 100644
index 0000000000..845c6bc839
--- /dev/null
+++ b/Cubical/Relation/Premetric.agda
@@ -0,0 +1,3 @@
+module Cubical.Relation.Premetric where
+
+open import Cubical.Relation.Premetric.Base public
diff --git a/Cubical/Relation/Premetric/Base.agda b/Cubical/Relation/Premetric/Base.agda
new file mode 100644
index 0000000000..bd31c2b346
--- /dev/null
+++ b/Cubical/Relation/Premetric/Base.agda
@@ -0,0 +1,73 @@
+module Cubical.Relation.Premetric.Base where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.SIP
+
+open import Cubical.Algebra.OrderedCommRing
+open import Cubical.Algebra.OrderedCommRing.Instances.Rationals
+
+open import Cubical.Data.Empty as ⊥
+open import Cubical.Data.Rationals.Order as ℚ
+open import Cubical.Data.Sigma
+
+open import Cubical.HITs.PropositionalTruncation as PT
+
+open import Cubical.Reflection.RecordEquiv
+
+open OrderedCommRingTheory ℚOrderedCommRing
+open PositiveRationals
+
+private
+  variable
+    ℓ ℓ' ℓ'' : Level
+
+record IsPremetric {M : Type ℓ} (_≈[_]_ : M → ℚ₊ → M → Type ℓ') : Type (ℓ-max ℓ ℓ') where
+
+  constructor ispremetric
+
+  field
+    isSetM        : isSet M
+    isProp≈       : ∀ x y ε → isProp (x ≈[ ε ] y)
+    isRefl≈       : ∀ x     ε   → x ≈[ ε ] x
+    isSym≈        : ∀ x y   ε   → x ≈[ ε ] y → y ≈[ ε ] x
+    isSeparated≈  : ∀ x y       → (∀ ε → x ≈[ ε ] y) → x ≡ y
+    isTriangular≈ : ∀ x y z ε δ → x ≈[ ε ] y → y ≈[ δ ] z → x ≈[ ε +₊ δ ] z
+    isRounded≈    : ∀ x y   ε   → x ≈[ ε ] y → ∃[ δ ∈ ℚ₊ ] (δ <₊ ε) × (x ≈[ δ ] y)
+
+unquoteDecl IsPremetricIsoΣ = declareRecordIsoΣ IsPremetricIsoΣ (quote IsPremetric)
+
+
+record PremetricStr (ℓ' : Level) (M : Type ℓ) : Type (ℓ-suc (ℓ-max ℓ ℓ')) where
+
+  constructor premetricstr
+
+  field
+    _≈[_]_      : M → ℚ₊ → M → Type ℓ'
+    isPremetric : IsPremetric _≈[_]_
+
+  open IsPremetric isPremetric public
+
+PremetricSpace : (ℓ ℓ' : Level) → Type (ℓ-suc (ℓ-max ℓ ℓ'))
+PremetricSpace ℓ ℓ' = TypeWithStr ℓ (PremetricStr ℓ')
+
+premetricspace : (M : Type ℓ)
+                  → (_≈[_]_ : M → ℚ₊ → M → Type ℓ')
+                  → IsPremetric _≈[_]_
+                  → PremetricSpace ℓ ℓ'
+premetricspace M (_≈[_]_) pm = M , (premetricstr _≈[_]_ pm)
+
+isPropIsPremetric : {M : Type ℓ} → (_≈[_]_ : M → ℚ₊ → M → Type ℓ')
+                  → isProp (IsPremetric _≈[_]_)
+isPropIsPremetric _≈[_]_ = isOfHLevelRetractFromIso 1
+  IsPremetricIsoΣ $
+  isPropΣ isPropIsSet λ isSetM →
+  isPropΣ (isPropΠ3 λ _ _ _ → isPropIsProp) λ isProp≈ →
+  isProp×4
+    (isPropΠ2 λ _ _ → isProp≈ _ _ _)
+    (isPropΠ4 λ _ _ _ _ → isProp≈ _ _ _)
+    (isPropΠ3 λ _ _ _ → isSetM _ _)
+    (isPropΠ6 λ _ _ _ _ _ _ → isPropΠ λ _ → isProp≈ _ _ _)
+    (isPropΠ4 λ _ _ _ _ → squash₁)

From 5dcf17443204939d7554e4098e64a93cb6dc1397 Mon Sep 17 00:00:00 2001
From: Lorenzo Molena <lorenzo.molena8@gmail.com>
Date: Tue, 14 Apr 2026 01:30:41 +0200
Subject: [PATCH 10/19] typo

---
 Cubical/Algebra/OrderedCommRing/Properties.agda | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Cubical/Algebra/OrderedCommRing/Properties.agda b/Cubical/Algebra/OrderedCommRing/Properties.agda
index 88b3904a33..c8625a7fe8 100644
--- a/Cubical/Algebra/OrderedCommRing/Properties.agda
+++ b/Cubical/Algebra/OrderedCommRing/Properties.agda
@@ -148,7 +148,7 @@ module _ (R' : OrderedCommRing ℓ ℓ') where
     ·CancelR≤ : ∀ x y z → 0r < z → x · z ≤ y · z → x ≤ y
     ·CancelR≤ x y z 0<z zx≤zy = ¬<→≥ y x $ ≤→¬> _ _ zx≤zy ∘ ·MonoR< _ _ z 0<z
 
-    -- It's to not clear if the properties commented below are constructively derivable.
+    -- It is not clear if the properties commented below are constructively derivable.
     --
     -- ·CancelL< : ∀ x y z → 0r < z → z · x < z · y → x < y
     -- ·CancelL< = ?

From 40e130d44405819403843a9105ce060ea4505725 Mon Sep 17 00:00:00 2001
From: LorenzoMolena <164308953+LorenzoMolena@users.noreply.github.com>
Date: Tue, 14 Apr 2026 01:32:55 +0200
Subject: [PATCH 11/19] typo (#41)

---
 Cubical/Algebra/OrderedCommRing/Properties.agda | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Cubical/Algebra/OrderedCommRing/Properties.agda b/Cubical/Algebra/OrderedCommRing/Properties.agda
index 88b3904a33..c8625a7fe8 100644
--- a/Cubical/Algebra/OrderedCommRing/Properties.agda
+++ b/Cubical/Algebra/OrderedCommRing/Properties.agda
@@ -148,7 +148,7 @@ module _ (R' : OrderedCommRing ℓ ℓ') where
     ·CancelR≤ : ∀ x y z → 0r < z → x · z ≤ y · z → x ≤ y
     ·CancelR≤ x y z 0<z zx≤zy = ¬<→≥ y x $ ≤→¬> _ _ zx≤zy ∘ ·MonoR< _ _ z 0<z
 
-    -- It's to not clear if the properties commented below are constructively derivable.
+    -- It is not clear if the properties commented below are constructively derivable.
     --
     -- ·CancelL< : ∀ x y z → 0r < z → z · x < z · y → x < y
     -- ·CancelL< = ?

From 8529a0a354bdf76eaab58a301075f7ab88bb79dc Mon Sep 17 00:00:00 2001
From: Lorenzo Molena <lorenzo.molena8@gmail.com>
Date: Tue, 14 Apr 2026 07:32:30 +0200
Subject: [PATCH 12/19] remove unnecessary imports, make some proofs
 ~~pointless~~ pointfree

---
 Cubical/Algebra/OrderedCommRing/Instances/Fast/Int.agda | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/Cubical/Algebra/OrderedCommRing/Instances/Fast/Int.agda b/Cubical/Algebra/OrderedCommRing/Instances/Fast/Int.agda
index 48ccb6ddff..93163da4ef 100644
--- a/Cubical/Algebra/OrderedCommRing/Instances/Fast/Int.agda
+++ b/Cubical/Algebra/OrderedCommRing/Instances/Fast/Int.agda
@@ -78,7 +78,6 @@ module CanonicalMonoFromℤ (R : OrderedCommRing ℓ ℓ') where
 
   open CanonicalHomFromℤ (OrderedCommRing→CommRing R)
   open OrderedCommRingTheory R
-  open OrderedCommRingReasoning R
 
   private
     module R where
@@ -154,13 +153,11 @@ module CanonicalMonoFromℤ (R : OrderedCommRing ℓ ℓ') where
 
   isUniqueFromℤOCR : (φ : OrderedCommRingHom ℤOrderedCommRing R)
                    → ∀ n → R.fromℤ n ≡ fst φ n
-  isUniqueFromℤOCR φ = isUniqueFromℤ (OrderedCommRingHom→CommRingHom φ)
-    where open IsOrderedCommRingHom (snd φ)
+  isUniqueFromℤOCR = isUniqueFromℤ ∘ OrderedCommRingHom→CommRingHom
 
   isUniqueFromℤOCRMono : (φ : OrderedCommRingMono ℤOrderedCommRing R)
                        → ∀ n → R.fromℤ n ≡ fst φ n
-  isUniqueFromℤOCRMono φ = isUniqueFromℤ (OrderedCommRingMono→CommRingHom φ)
-    where open IsOrderedCommRingMono (snd φ)
+  isUniqueFromℤOCRMono = isUniqueFromℤ ∘ OrderedCommRingMono→CommRingHom
 
   isContrHom[ℤOCR,-] : isContr (OrderedCommRingHom ℤOrderedCommRing R)
   fst isContrHom[ℤOCR,-] = fromℤOCR

From 7f32dbacb0917fb65a1cc89629539e7784df8be7 Mon Sep 17 00:00:00 2001
From: LorenzoMolena <164308953+LorenzoMolena@users.noreply.github.com>
Date: Tue, 14 Apr 2026 07:36:16 +0200
Subject: [PATCH 13/19] Sync with `ocr-update` (#42)

* typo

* remove unnecessary imports, make some proofs ~pointless~ pointfree
---
 Cubical/Algebra/OrderedCommRing/Instances/Fast/Int.agda | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/Cubical/Algebra/OrderedCommRing/Instances/Fast/Int.agda b/Cubical/Algebra/OrderedCommRing/Instances/Fast/Int.agda
index 48ccb6ddff..93163da4ef 100644
--- a/Cubical/Algebra/OrderedCommRing/Instances/Fast/Int.agda
+++ b/Cubical/Algebra/OrderedCommRing/Instances/Fast/Int.agda
@@ -78,7 +78,6 @@ module CanonicalMonoFromℤ (R : OrderedCommRing ℓ ℓ') where
 
   open CanonicalHomFromℤ (OrderedCommRing→CommRing R)
   open OrderedCommRingTheory R
-  open OrderedCommRingReasoning R
 
   private
     module R where
@@ -154,13 +153,11 @@ module CanonicalMonoFromℤ (R : OrderedCommRing ℓ ℓ') where
 
   isUniqueFromℤOCR : (φ : OrderedCommRingHom ℤOrderedCommRing R)
                    → ∀ n → R.fromℤ n ≡ fst φ n
-  isUniqueFromℤOCR φ = isUniqueFromℤ (OrderedCommRingHom→CommRingHom φ)
-    where open IsOrderedCommRingHom (snd φ)
+  isUniqueFromℤOCR = isUniqueFromℤ ∘ OrderedCommRingHom→CommRingHom
 
   isUniqueFromℤOCRMono : (φ : OrderedCommRingMono ℤOrderedCommRing R)
                        → ∀ n → R.fromℤ n ≡ fst φ n
-  isUniqueFromℤOCRMono φ = isUniqueFromℤ (OrderedCommRingMono→CommRingHom φ)
-    where open IsOrderedCommRingMono (snd φ)
+  isUniqueFromℤOCRMono = isUniqueFromℤ ∘ OrderedCommRingMono→CommRingHom
 
   isContrHom[ℤOCR,-] : isContr (OrderedCommRingHom ℤOrderedCommRing R)
   fst isContrHom[ℤOCR,-] = fromℤOCR

From 3bc2336b70394ffc90d8861e9af3ac6c08ee28f4 Mon Sep 17 00:00:00 2001
From: Lorenzo Molena <lorenzo.molena8@gmail.com>
Date: Tue, 14 Apr 2026 15:46:37 +0200
Subject: [PATCH 14/19] =?UTF-8?q?make=20more=20proofs=20pointfree,=20renam?=
 =?UTF-8?q?e=20`makeIsOrderedCommRingEquiv`=20=E2=86=92=20`makeIsOrderedCo?=
 =?UTF-8?q?mmRingEquivFromMono`,=20add=20a=20new=20`makeIsOrderedCommRingE?=
 =?UTF-8?q?quiv`=20that=20is=20actually=20a=20specialized=20`make`=20(i.e.?=
 =?UTF-8?q?=20taking=20as=20inputs=20the=20individual=20proofs=20needed=20?=
 =?UTF-8?q?to=20build=20the=20OCR=20equivalence)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../Algebra/OrderedCommRing/Morphisms.agda    | 34 +++++++++++++------
 .../Algebra/OrderedCommRing/Univalence.agda   |  5 ++-
 2 files changed, 25 insertions(+), 14 deletions(-)

diff --git a/Cubical/Algebra/OrderedCommRing/Morphisms.agda b/Cubical/Algebra/OrderedCommRing/Morphisms.agda
index 4e74bb721e..ecc2fcfd3e 100644
--- a/Cubical/Algebra/OrderedCommRing/Morphisms.agda
+++ b/Cubical/Algebra/OrderedCommRing/Morphisms.agda
@@ -286,9 +286,9 @@ snd (OrderedCommRingEquiv→OrderedCommRingMono e) = isOCRMono
     isOCRMono .isOCRHom .isCRHom .pres+ = E.pres+
     isOCRMono .isOCRHom .isCRHom .pres· = E.pres·
     isOCRMono .isOCRHom .isCRHom .pres- = E.pres-
-    isOCRMono .isOCRHom .pres≤          = λ x y → equivFun (E.pres≤ x y)
-    isOCRMono .isOCRHom .reflect<       = λ x y → invEq (E.pres< x y)
-    isOCRMono .pres<                    = λ x y → equivFun (E.pres< x y)
+    isOCRMono .isOCRHom .pres≤          = (equivFun ∘_) ∘ E.pres≤
+    isOCRMono .isOCRHom .reflect<       = (invEq ∘_) ∘ E.pres<
+    isOCRMono .pres<                    = (equivFun ∘_) ∘ E.pres<
 
 OrderedCommRingEquiv→OrderedCommRingHom : {A : OrderedCommRing ℓ  ℓ<≤}
                                         → {B : OrderedCommRing ℓ' ℓ<≤'}
@@ -346,15 +346,27 @@ module _ {R : OrderedCommRing ℓ ℓ<≤} {S : OrderedCommRing ℓ' ℓ<≤'} (
 
     open IsOrderedCommRingEquiv
 
-    makeIsOrderedCommRingEquiv : IsOrderedCommRingEquiv (str R) e (str S)
-    makeIsOrderedCommRingEquiv .pres0 = M.pres0
-    makeIsOrderedCommRingEquiv .pres1 = M.pres1
-    makeIsOrderedCommRingEquiv .pres+ = M.pres+
-    makeIsOrderedCommRingEquiv .pres· = M.pres·
-    makeIsOrderedCommRingEquiv .pres- = M.pres-
-    makeIsOrderedCommRingEquiv .pres≤ = λ x y → propBiimpl→Equiv
+    makeIsOrderedCommRingEquivFromMono : IsOrderedCommRingEquiv (str R) e (str S)
+    makeIsOrderedCommRingEquivFromMono .pres0 = M.pres0
+    makeIsOrderedCommRingEquivFromMono .pres1 = M.pres1
+    makeIsOrderedCommRingEquivFromMono .pres+ = M.pres+
+    makeIsOrderedCommRingEquivFromMono .pres· = M.pres·
+    makeIsOrderedCommRingEquivFromMono .pres- = M.pres-
+    makeIsOrderedCommRingEquivFromMono .pres≤ = λ x y → propBiimpl→Equiv
       (R.is-prop-valued≤ _ _) (S.is-prop-valued≤ _ _)
       (M.pres≤ x y) (isOrderedCommRingMono→reflect≤ isMono x y)
-    makeIsOrderedCommRingEquiv .pres< = λ x y → propBiimpl→Equiv
+    makeIsOrderedCommRingEquivFromMono .pres< = λ x y → propBiimpl→Equiv
       (R.is-prop-valued< _ _) (S.is-prop-valued< _ _)
       (M.pres< x y) (M.reflect< x y)
+
+  module _
+    (p1  : equivFun e R.1r ≡ S.1r)
+    (p+  : ∀ x y → equivFun e (x R.+ y) ≡ equivFun e x S.+ equivFun e y)
+    (p·  : ∀ x y → equivFun e (x R.· y) ≡ equivFun e x S.· equivFun e y)
+    (p<  : ∀ x y → x R.< y → equivFun e x S.< equivFun e y)
+    (p<⁻ : ∀ x y → equivFun e x S.< equivFun e y → x R.< y)
+    where
+
+    makeIsOrderedCommRingEquiv : IsOrderedCommRingEquiv (str R) e (str S)
+    makeIsOrderedCommRingEquiv = makeIsOrderedCommRingEquivFromMono
+      (makeIsOrderedCommRingMono p1 p+ p· p< p<⁻)
diff --git a/Cubical/Algebra/OrderedCommRing/Univalence.agda b/Cubical/Algebra/OrderedCommRing/Univalence.agda
index 94ced02b7b..ee613ccd6c 100644
--- a/Cubical/Algebra/OrderedCommRing/Univalence.agda
+++ b/Cubical/Algebra/OrderedCommRing/Univalence.agda
@@ -64,14 +64,13 @@ OrderedCommRingEquivIsoOrderedCommRingIso R S = OCREquivIsoOCRIso
     fst (fun OCREquivIsoOCRIso e) = equivToIso (fst e)
     snd (fun OCREquivIsoOCRIso e) = snd (OrderedCommRingEquiv→OrderedCommRingMono e)
     fst (inv OCREquivIsoOCRIso e) = isoToEquiv (fst e)
-    snd (inv OCREquivIsoOCRIso e) = makeIsOrderedCommRingEquiv (isoToEquiv (fst e)) (snd e)
+    snd (inv OCREquivIsoOCRIso e) = makeIsOrderedCommRingEquivFromMono (isoToEquiv (fst e)) (snd e)
     sec OCREquivIsoOCRIso e =
       Σ≡Prop (λ f → isPropIsOrderedCommRingMono _ (fun f) _) (
       Iso≡Set (OrderedCommRingStr.is-set (snd R)) (OrderedCommRingStr.is-set (snd S))
         _ _ (λ x → refl) (λ x → refl))
     ret OCREquivIsoOCRIso e =
-      Σ≡Prop (λ f → isPropIsOrderedCommRingEquiv _ f _)
-      (equivEq refl)
+      Σ≡Prop (λ f → isPropIsOrderedCommRingEquiv _ f _) (equivEq refl)
 
 isGroupoidOrderedCommRing : isGroupoid (OrderedCommRing ℓ ℓ')
 isGroupoidOrderedCommRing _ _ =

From 1a164965916f79ac4f602d259d6b874be767cd0f Mon Sep 17 00:00:00 2001
From: LorenzoMolena <164308953+LorenzoMolena@users.noreply.github.com>
Date: Tue, 14 Apr 2026 15:52:58 +0200
Subject: [PATCH 15/19] Sync with `ocr-update` (#45)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* typo

* remove unnecessary imports, make some proofs ~~pointless~~ pointfree

* make more proofs pointfree, rename `makeIsOrderedCommRingEquiv` → `makeIsOrderedCommRingEquivFromMono`, add a new `makeIsOrderedCommRingEquiv` that is actually a specialized `make` (i.e. taking as inputs the individual proofs needed to build the OCR equivalence)
---
 .../Algebra/OrderedCommRing/Morphisms.agda    | 34 +++++++++++++------
 .../Algebra/OrderedCommRing/Univalence.agda   |  5 ++-
 2 files changed, 25 insertions(+), 14 deletions(-)

diff --git a/Cubical/Algebra/OrderedCommRing/Morphisms.agda b/Cubical/Algebra/OrderedCommRing/Morphisms.agda
index 4e74bb721e..ecc2fcfd3e 100644
--- a/Cubical/Algebra/OrderedCommRing/Morphisms.agda
+++ b/Cubical/Algebra/OrderedCommRing/Morphisms.agda
@@ -286,9 +286,9 @@ snd (OrderedCommRingEquiv→OrderedCommRingMono e) = isOCRMono
     isOCRMono .isOCRHom .isCRHom .pres+ = E.pres+
     isOCRMono .isOCRHom .isCRHom .pres· = E.pres·
     isOCRMono .isOCRHom .isCRHom .pres- = E.pres-
-    isOCRMono .isOCRHom .pres≤          = λ x y → equivFun (E.pres≤ x y)
-    isOCRMono .isOCRHom .reflect<       = λ x y → invEq (E.pres< x y)
-    isOCRMono .pres<                    = λ x y → equivFun (E.pres< x y)
+    isOCRMono .isOCRHom .pres≤          = (equivFun ∘_) ∘ E.pres≤
+    isOCRMono .isOCRHom .reflect<       = (invEq ∘_) ∘ E.pres<
+    isOCRMono .pres<                    = (equivFun ∘_) ∘ E.pres<
 
 OrderedCommRingEquiv→OrderedCommRingHom : {A : OrderedCommRing ℓ  ℓ<≤}
                                         → {B : OrderedCommRing ℓ' ℓ<≤'}
@@ -346,15 +346,27 @@ module _ {R : OrderedCommRing ℓ ℓ<≤} {S : OrderedCommRing ℓ' ℓ<≤'} (
 
     open IsOrderedCommRingEquiv
 
-    makeIsOrderedCommRingEquiv : IsOrderedCommRingEquiv (str R) e (str S)
-    makeIsOrderedCommRingEquiv .pres0 = M.pres0
-    makeIsOrderedCommRingEquiv .pres1 = M.pres1
-    makeIsOrderedCommRingEquiv .pres+ = M.pres+
-    makeIsOrderedCommRingEquiv .pres· = M.pres·
-    makeIsOrderedCommRingEquiv .pres- = M.pres-
-    makeIsOrderedCommRingEquiv .pres≤ = λ x y → propBiimpl→Equiv
+    makeIsOrderedCommRingEquivFromMono : IsOrderedCommRingEquiv (str R) e (str S)
+    makeIsOrderedCommRingEquivFromMono .pres0 = M.pres0
+    makeIsOrderedCommRingEquivFromMono .pres1 = M.pres1
+    makeIsOrderedCommRingEquivFromMono .pres+ = M.pres+
+    makeIsOrderedCommRingEquivFromMono .pres· = M.pres·
+    makeIsOrderedCommRingEquivFromMono .pres- = M.pres-
+    makeIsOrderedCommRingEquivFromMono .pres≤ = λ x y → propBiimpl→Equiv
       (R.is-prop-valued≤ _ _) (S.is-prop-valued≤ _ _)
       (M.pres≤ x y) (isOrderedCommRingMono→reflect≤ isMono x y)
-    makeIsOrderedCommRingEquiv .pres< = λ x y → propBiimpl→Equiv
+    makeIsOrderedCommRingEquivFromMono .pres< = λ x y → propBiimpl→Equiv
       (R.is-prop-valued< _ _) (S.is-prop-valued< _ _)
       (M.pres< x y) (M.reflect< x y)
+
+  module _
+    (p1  : equivFun e R.1r ≡ S.1r)
+    (p+  : ∀ x y → equivFun e (x R.+ y) ≡ equivFun e x S.+ equivFun e y)
+    (p·  : ∀ x y → equivFun e (x R.· y) ≡ equivFun e x S.· equivFun e y)
+    (p<  : ∀ x y → x R.< y → equivFun e x S.< equivFun e y)
+    (p<⁻ : ∀ x y → equivFun e x S.< equivFun e y → x R.< y)
+    where
+
+    makeIsOrderedCommRingEquiv : IsOrderedCommRingEquiv (str R) e (str S)
+    makeIsOrderedCommRingEquiv = makeIsOrderedCommRingEquivFromMono
+      (makeIsOrderedCommRingMono p1 p+ p· p< p<⁻)
diff --git a/Cubical/Algebra/OrderedCommRing/Univalence.agda b/Cubical/Algebra/OrderedCommRing/Univalence.agda
index 94ced02b7b..ee613ccd6c 100644
--- a/Cubical/Algebra/OrderedCommRing/Univalence.agda
+++ b/Cubical/Algebra/OrderedCommRing/Univalence.agda
@@ -64,14 +64,13 @@ OrderedCommRingEquivIsoOrderedCommRingIso R S = OCREquivIsoOCRIso
     fst (fun OCREquivIsoOCRIso e) = equivToIso (fst e)
     snd (fun OCREquivIsoOCRIso e) = snd (OrderedCommRingEquiv→OrderedCommRingMono e)
     fst (inv OCREquivIsoOCRIso e) = isoToEquiv (fst e)
-    snd (inv OCREquivIsoOCRIso e) = makeIsOrderedCommRingEquiv (isoToEquiv (fst e)) (snd e)
+    snd (inv OCREquivIsoOCRIso e) = makeIsOrderedCommRingEquivFromMono (isoToEquiv (fst e)) (snd e)
     sec OCREquivIsoOCRIso e =
       Σ≡Prop (λ f → isPropIsOrderedCommRingMono _ (fun f) _) (
       Iso≡Set (OrderedCommRingStr.is-set (snd R)) (OrderedCommRingStr.is-set (snd S))
         _ _ (λ x → refl) (λ x → refl))
     ret OCREquivIsoOCRIso e =
-      Σ≡Prop (λ f → isPropIsOrderedCommRingEquiv _ f _)
-      (equivEq refl)
+      Σ≡Prop (λ f → isPropIsOrderedCommRingEquiv _ f _) (equivEq refl)
 
 isGroupoidOrderedCommRing : isGroupoid (OrderedCommRing ℓ ℓ')
 isGroupoidOrderedCommRing _ _ =

From 5f7a8d674cabaca9b8252b3a6fcd6e9ba5e7e916 Mon Sep 17 00:00:00 2001
From: Lorenzo Molena <lorenzo.molena8@gmail.com>
Date: Fri, 17 Apr 2026 20:40:23 +0200
Subject: [PATCH 16/19] avoid reexporting publicly too many properties

---
 Cubical/Algebra/OrderedCommRing/Properties.agda | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/Cubical/Algebra/OrderedCommRing/Properties.agda b/Cubical/Algebra/OrderedCommRing/Properties.agda
index c8625a7fe8..eb1ea38212 100644
--- a/Cubical/Algebra/OrderedCommRing/Properties.agda
+++ b/Cubical/Algebra/OrderedCommRing/Properties.agda
@@ -425,7 +425,7 @@ module _ (R' : OrderedCommRing ℓ ℓ') where
         isSG .IsSemigroup.is-set = isSetR₊
         isSG .IsSemigroup.·Assoc = λ _ _ _ → R₊≡ (+Assoc _ _ _)
 
-    open SemigroupStr (snd R₊AdditiveSemigroup) public hiding (_·_) renaming (
+    open SemigroupStr (snd R₊AdditiveSemigroup) using () public renaming (
       ·Assoc to +₊Assoc)
 
     R₊MultiplicativeCommMonoid : CommMonoid _
@@ -439,7 +439,7 @@ module _ (R' : OrderedCommRing ℓ ℓ') where
         (λ _     → R₊≡ (·IdR _))
         (λ _ _   → R₊≡ (·Comm _ _))
 
-    open CommMonoidStr (snd R₊MultiplicativeCommMonoid) public hiding (_·_) renaming (
+    open CommMonoidStr (snd R₊MultiplicativeCommMonoid) using () public renaming (
       ε to 1₊ ; ·Assoc to ·₊Assoc ; ·IdR to ·₊IdR ; ·Comm to ·₊Comm)
 
     selfSeparated : ∀ (x y : R) → (∀ (z : R₊) → abs(x - y) < ⟨ z ⟩₊) → x ≡ y
@@ -524,8 +524,7 @@ module _ (R' : OrderedCommRing ℓ ℓ') where
         (λ _     → R₀₊≡ (0LeftAnnihilates _))
         (λ _ _   → R₀₊≡ (·Comm _ _))
 
-    open CommSemiringStr (snd R₀₊CommSemiring) public hiding (_+_ ; _·_)
-      renaming (
+    open CommSemiringStr (snd R₀₊CommSemiring) using () public renaming (
         0r to 0₀₊ ; 1r to 1₀₊
       ; +Assoc to +₀₊Assoc ; +IdL to +₀₊IdL ; +IdR to +₀₊IdR ; +Comm to +₀₊Comm
       ; ·Assoc to ·₀₊Assoc ; ·IdL to ·₀₊IdL ; ·IdR to ·₀₊IdR ; ·Comm to ·₀₊Comm

From cf249e4d0ed9af9d13ed8da5af25bad2d99b8d4e Mon Sep 17 00:00:00 2001
From: Lorenzo Molena <lorenzo.molena8@gmail.com>
Date: Fri, 17 Apr 2026 20:40:23 +0200
Subject: [PATCH 17/19] avoid reexporting publicly too many properties

---
 Cubical/Algebra/OrderedCommRing/Properties.agda | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/Cubical/Algebra/OrderedCommRing/Properties.agda b/Cubical/Algebra/OrderedCommRing/Properties.agda
index c8625a7fe8..eb1ea38212 100644
--- a/Cubical/Algebra/OrderedCommRing/Properties.agda
+++ b/Cubical/Algebra/OrderedCommRing/Properties.agda
@@ -425,7 +425,7 @@ module _ (R' : OrderedCommRing ℓ ℓ') where
         isSG .IsSemigroup.is-set = isSetR₊
         isSG .IsSemigroup.·Assoc = λ _ _ _ → R₊≡ (+Assoc _ _ _)
 
-    open SemigroupStr (snd R₊AdditiveSemigroup) public hiding (_·_) renaming (
+    open SemigroupStr (snd R₊AdditiveSemigroup) using () public renaming (
       ·Assoc to +₊Assoc)
 
     R₊MultiplicativeCommMonoid : CommMonoid _
@@ -439,7 +439,7 @@ module _ (R' : OrderedCommRing ℓ ℓ') where
         (λ _     → R₊≡ (·IdR _))
         (λ _ _   → R₊≡ (·Comm _ _))
 
-    open CommMonoidStr (snd R₊MultiplicativeCommMonoid) public hiding (_·_) renaming (
+    open CommMonoidStr (snd R₊MultiplicativeCommMonoid) using () public renaming (
       ε to 1₊ ; ·Assoc to ·₊Assoc ; ·IdR to ·₊IdR ; ·Comm to ·₊Comm)
 
     selfSeparated : ∀ (x y : R) → (∀ (z : R₊) → abs(x - y) < ⟨ z ⟩₊) → x ≡ y
@@ -524,8 +524,7 @@ module _ (R' : OrderedCommRing ℓ ℓ') where
         (λ _     → R₀₊≡ (0LeftAnnihilates _))
         (λ _ _   → R₀₊≡ (·Comm _ _))
 
-    open CommSemiringStr (snd R₀₊CommSemiring) public hiding (_+_ ; _·_)
-      renaming (
+    open CommSemiringStr (snd R₀₊CommSemiring) using () public renaming (
         0r to 0₀₊ ; 1r to 1₀₊
       ; +Assoc to +₀₊Assoc ; +IdL to +₀₊IdL ; +IdR to +₀₊IdR ; +Comm to +₀₊Comm
       ; ·Assoc to ·₀₊Assoc ; ·IdL to ·₀₊IdL ; ·IdR to ·₀₊IdR ; ·Comm to ·₀₊Comm

From e05d63c7507e8436f788a93793bde654d091fa89 Mon Sep 17 00:00:00 2001
From: Lorenzo Molena <lorenzo.molena8@gmail.com>
Date: Tue, 21 Apr 2026 21:49:38 +0200
Subject: [PATCH 18/19] Revert "Merge branch 'premetric+fast-rationals' into
 ocr-update"

This reverts commit 312f5053de8f472ceffae4642ead5290b8e9b79a, reversing
changes made to 207e123164fefb0633306f957eaf989465caf84f.
---
 .../Algebra/CommRing/Instances/Rationals.agda |   1 +
 .../Algebra/Field/Instances/Rationals.agda    |  33 +-
 .../OrderedCommRing/Instances/Rationals.agda  | 187 -----------
 Cubical/Data/Rationals/Base.agda              |   2 +-
 Cubical/Data/Rationals/Order.agda             | 311 ++++++++----------
 Cubical/Data/Rationals/Properties.agda        | 121 +------
 .../Order/Loset/Instances/Rationals.agda      |  31 --
 .../Order/Poset/Instances/Rationals.agda      |  11 -
 .../Order/Proset/Instances/Rationals.agda     |  11 -
 .../Pseudolattice/Instances/Rationals.agda    |  19 --
 .../Order/Quoset/Instances/Rationals.agda     |  11 -
 .../StrictOrder/Instances/Rationals.agda      |  11 -
 .../Order/Toset/Instances/Rationals.agda      |  31 --
 Cubical/Relation/Premetric.agda               |   3 -
 Cubical/Relation/Premetric/Base.agda          |  73 ----
 15 files changed, 183 insertions(+), 673 deletions(-)
 delete mode 100644 Cubical/Algebra/OrderedCommRing/Instances/Rationals.agda
 delete mode 100644 Cubical/Relation/Binary/Order/Loset/Instances/Rationals.agda
 delete mode 100644 Cubical/Relation/Binary/Order/Poset/Instances/Rationals.agda
 delete mode 100644 Cubical/Relation/Binary/Order/Proset/Instances/Rationals.agda
 delete mode 100644 Cubical/Relation/Binary/Order/Pseudolattice/Instances/Rationals.agda
 delete mode 100644 Cubical/Relation/Binary/Order/Quoset/Instances/Rationals.agda
 delete mode 100644 Cubical/Relation/Binary/Order/StrictOrder/Instances/Rationals.agda
 delete mode 100644 Cubical/Relation/Binary/Order/Toset/Instances/Rationals.agda
 delete mode 100644 Cubical/Relation/Premetric.agda
 delete mode 100644 Cubical/Relation/Premetric/Base.agda

diff --git a/Cubical/Algebra/CommRing/Instances/Rationals.agda b/Cubical/Algebra/CommRing/Instances/Rationals.agda
index eeb40346c9..92416ac328 100644
--- a/Cubical/Algebra/CommRing/Instances/Rationals.agda
+++ b/Cubical/Algebra/CommRing/Instances/Rationals.agda
@@ -20,3 +20,4 @@ open import Cubical.Data.Rationals as ℚ
   where
   p : IsCommRing 0 1 _+_ _·_ (-_)
   p = makeIsCommRing isSetℚ +Assoc +IdR +InvR +Comm ·Assoc ·IdR ·DistL+ ·Comm
+
diff --git a/Cubical/Algebra/Field/Instances/Rationals.agda b/Cubical/Algebra/Field/Instances/Rationals.agda
index fa3bfadbd4..2209eb5f03 100644
--- a/Cubical/Algebra/Field/Instances/Rationals.agda
+++ b/Cubical/Algebra/Field/Instances/Rationals.agda
@@ -14,7 +14,7 @@ open import Cubical.Algebra.CommRing.Instances.Rationals
 open import Cubical.Algebra.Field
 
 open import Cubical.Data.Empty as Empty
-open import Cubical.Data.Fast.Int as ℤ
+open import Cubical.Data.Int as ℤ
 open import Cubical.Data.Nat as ℕ using (ℕ ; zero ; suc)
 open import Cubical.Data.NatPlusOne
 open import Cubical.Data.Rationals as ℚ
@@ -42,9 +42,36 @@ hasInverseℚ = SetQuotients.elimProp
   q (ℤ.pos zero , b) p =
     Empty.rec (p (numerator0→0 ((ℤ.pos zero , b)) refl))
   q (ℤ.pos (suc n) , (1+ m)) _ =
-    eq/ _ _ (ℤ.·IdR _ ∙∙ ℤ.·Comm (pos (suc n)) (pos (suc m)) ∙∙ sym (ℤ.·IdL _))
+    eq/ ((ℤ.pos (suc n) ℤ.· (ℕ₊₁→ℤ (1+ m)) , (1+ m) ·₊₁ (1+ n))) ((1 , 1)) q'
+    where
+    q' = (ℤ.pos (suc n) ℤ.· (ℕ₊₁→ℤ (1+ m))) ℤ.· 1
+           ≡⟨ ℤ.·IdR _ ⟩
+         ℤ.pos (suc n) ℤ.· ℤ.pos (suc m)
+           ≡⟨ sym $ ℤ.pos·pos (suc n) (suc m) ⟩
+         ℤ.pos ((suc n) ℕ.· (suc m))
+           ≡⟨ cong ℤ.pos (ℕ.·-comm (suc n) (suc m)) ⟩
+         ℤ.pos ((suc m) ℕ.· (suc n))
+           ≡⟨ refl ⟩
+         ℕ₊₁→ℤ ((1+ m) ·₊₁ (1+ n))
+           ≡⟨ sym (ℤ.·IdL _) ⟩
+         1 ℤ.· (ℕ₊₁→ℤ ((1+ m) ·₊₁ (1+ n))) ∎
   q (ℤ.negsuc n , (1+ m)) _ =
-    eq/ _ _ (ℤ.·IdR _ ∙∙ ℤ.·Comm (pos (suc n)) (pos (suc m)) ∙∙ sym (ℤ.·IdL _))
+    eq/ ((ℤ.negsuc n ℤ.· ℤ.negsuc m) , ((1+ m) ·₊₁ (1+ n))) ((1 , 1)) q'
+    where
+    q' : (ℤ.negsuc n ℤ.· ℤ.negsuc m , (1+ m) ·₊₁ (1+ n)) ∼ (1 , 1)
+    q' = (ℤ.negsuc n ℤ.· ℤ.negsuc m) ℤ.· 1
+           ≡⟨ ℤ.·IdR _ ⟩
+         (ℤ.negsuc n ℤ.· ℤ.negsuc m)
+           ≡⟨ negsuc·negsuc n m ⟩
+         (ℤ.pos (suc n) ℤ.· ℤ.pos (suc m))
+           ≡⟨ sym $ ℤ.pos·pos (suc n) (suc m) ⟩
+         ℤ.pos ((suc n) ℕ.· (suc m))
+           ≡⟨ cong ℤ.pos (ℕ.·-comm (suc n) (suc m)) ⟩
+         ℤ.pos ((suc m) ℕ.· (suc n))
+           ≡⟨ refl ⟩
+         ℕ₊₁→ℤ ((1+ m) ·₊₁ (1+ n))
+           ≡⟨ sym (ℤ.·IdL _) ⟩
+         1 ℤ.· (ℕ₊₁→ℤ ((1+ m) ·₊₁ (1+ n))) ∎
 
 0≢1-ℚ : ¬ Path ℚ 0 1
 0≢1-ℚ p = 0≢1-ℤ (effective (λ _ _ → isSetℤ _ _) isEquivRel∼ _ _ p)
diff --git a/Cubical/Algebra/OrderedCommRing/Instances/Rationals.agda b/Cubical/Algebra/OrderedCommRing/Instances/Rationals.agda
deleted file mode 100644
index 600f38c22a..0000000000
--- a/Cubical/Algebra/OrderedCommRing/Instances/Rationals.agda
+++ /dev/null
@@ -1,187 +0,0 @@
-module Cubical.Algebra.OrderedCommRing.Instances.Rationals where
-
-open import Cubical.Foundations.Prelude
-open import Cubical.Foundations.Function
-open import Cubical.Foundations.HLevels
-open import Cubical.Foundations.Equiv
-
-open import Cubical.Data.Empty as ⊥
-
-open import Cubical.HITs.PropositionalTruncation as PT
-open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_)
-
-open import Cubical.Data.Nat as ℕ hiding (_+_ ; _·_)
-open import Cubical.Data.NatPlusOne as ℕ₊₁
-open import Cubical.Data.Fast.Int as ℤ hiding (_+_ ; _-_ ; -_ ; _·_)
-import Cubical.Data.Fast.Int.Order as ℤ
-
-open import Cubical.Data.Rationals as ℚ
-  renaming (_+_ to _+ℚ_ ; _-_ to _-ℚ_; -_ to -ℚ_ ; _·_ to _·ℚ_)
-open import Cubical.Data.Rationals.Order as ℚ
-  renaming (_<_ to _<ℚ_ ; _≤_ to _≤ℚ_)
-
-open import Cubical.Algebra.CommRing
-open import Cubical.Algebra.CommRing.Instances.Rationals
-
-open import Cubical.Algebra.OrderedCommRing.Base
-open import Cubical.Algebra.OrderedCommRing.Properties
-
-open import Cubical.Relation.Nullary
-
-open import Cubical.Relation.Binary.Order.StrictOrder
-open import Cubical.Relation.Binary.Order.StrictOrder.Instances.Rationals
-
-open import Cubical.Relation.Binary.Order.Pseudolattice
-open import Cubical.Relation.Binary.Order.Pseudolattice.Instances.Rationals
-
-open CommRingStr
-open OrderedCommRingStr
-open PseudolatticeStr
-open StrictOrderStr
-
-ℚOrderedCommRing : OrderedCommRing ℓ-zero ℓ-zero
-fst ℚOrderedCommRing = ℚ
-0r  (snd ℚOrderedCommRing) = 0
-1r  (snd ℚOrderedCommRing) = 1
-_+_ (snd ℚOrderedCommRing) = _+ℚ_
-_·_ (snd ℚOrderedCommRing) = _·ℚ_
--_  (snd ℚOrderedCommRing) = -ℚ_
-_<_ (snd ℚOrderedCommRing) = _<ℚ_
-_≤_ (snd ℚOrderedCommRing) = _≤ℚ_
-isOrderedCommRing (snd ℚOrderedCommRing) = isOrderedCommRingℚ
-  where
-  open IsOrderedCommRing
-
-  isOrderedCommRingℚ : IsOrderedCommRing 0 1 _+ℚ_ _·ℚ_ -ℚ_ _<ℚ_ _≤ℚ_
-  isOrderedCommRingℚ .isCommRing      = ℚCommRing .snd .isCommRing
-  isOrderedCommRingℚ .isPseudolattice = ℚ≤Pseudolattice .snd .is-pseudolattice
-  isOrderedCommRingℚ .isStrictOrder   = ℚ<StrictOrder .snd .isStrictOrder
-  isOrderedCommRingℚ .<-≤-weaken      = <Weaken≤
-  isOrderedCommRingℚ .≤≃¬>            = λ x y →
-    propBiimpl→Equiv (isProp≤ x y) (isProp¬ (y <ℚ x)) (≤→≯  x y) (≮→≥ y x)
-  isOrderedCommRingℚ .+MonoR≤         = ≤-+o
-  isOrderedCommRingℚ .+MonoR<         = <-+o
-  isOrderedCommRingℚ .posSum→pos∨pos  = λ x y → ∣_∣₁ ∘ 0<+ x y
-  isOrderedCommRingℚ .<-≤-trans       = isTrans<≤
-  isOrderedCommRingℚ .≤-<-trans       = isTrans≤<
-  isOrderedCommRingℚ .·MonoR≤         = ≤-·o
-  isOrderedCommRingℚ .·MonoR<         = <-·o
-  isOrderedCommRingℚ .0<1             = pos<pos tt
-
-module 1/2∈ℚ = 1/2∈R ℚOrderedCommRing [ 1 / 2 ] (eq/ _ _ refl)
-
-module PositiveRationals where
-  private
-    0<+Closed : ∀ x y → 0 <ℚ x → 0 <ℚ y → 0 <ℚ x +ℚ y
-    0<+Closed = SQ.elimProp2 (λ _ _ → isProp→ (isProp→ (isProp< 0 _))) λ
-      { (pos (suc n) , _) (pos (suc m) , _) (pos<pos p) (pos<pos q) → pos<pos tt }
-
-    0<·Closed : ∀ x y → 0 <ℚ x → 0 <ℚ y → 0 <ℚ x ·ℚ y
-    0<·Closed = SQ.elimProp2 (λ _ _ → isProp→ (isProp→ (isProp< 0 _))) λ
-      { (pos (suc n) , _) (pos (suc m) , _) (pos<pos p) (pos<pos q) → pos<pos tt }
-
-  open Units ℚCommRing
-  open CommRingTheory ℚCommRing
-  open OrderedCommRingReasoning ℚOrderedCommRing
-
-  open Positive ℚOrderedCommRing 0<+Closed 0<·Closed public renaming (
-      R₊ to ℚ₊ ; isSetR₊ to isSetℚ₊ ; R₊≡ to ℚ₊≡ ; ≡₊→R₊ to ≡₊→ℚ₊
-    ; R₊AdditiveSemigroup to +ℚ₊Semigroup ; R₊MultiplicativeCommMonoid to ·ℚ₊CommMonoid)
-  open module PositiveHalvesℚ =
-    PositiveHalves ℚOrderedCommRing [ 1 / 2 ] (eq/ _ _ refl) 0<+Closed 0<·Closed
-
-  -- Natural number literals for ℚ
-
-  open import Cubical.Data.Nat.Literals public
-
-  instance
-    fromNatℚ₊ : HasFromNat ℚ₊
-    fromNatℚ₊ = record { Constraint = λ { zero → ⊥ ; _ → Unit }
-                       ; fromNat = λ { (suc n) .fst → [ pos (suc n) / 1 ]
-                                     ; (suc n) .snd → pos<pos tt } }
-
-  [_/_]₊ : ℕ₊₁ → ℕ₊₁ → ℚ₊
-  [ 1+ n / 1+ m ]₊ = [ pos (suc n) / 1+ m ] , pos<pos tt
-
-  max₊ : ℚ₊ → ℚ₊ → ℚ₊
-  fst (max₊ x y) = ℚ.max (fst x) (fst y)
-  snd (max₊ x y) = elimProp2
-    {P = λ a b → 0 <ℚ a → 0 <ℚ b → 0 <ℚ ℚ.max a b}
-    (λ a b → isPropΠ2 λ _ _ → isProp< 0 (ℚ.max a b))
-    (λ { (pos (suc n) , 1+ a) (pos (suc m) , 1+ b) (pos<pos p) (pos<pos q) →
-    let
-      1+n = suc n ; 1+m = suc m ; 1+a = suc a ; 1+b = suc b
-    in
-      -- NOTE :
-      -- if we are only concerned about efficiency, then there is no need to recompute,
-      -- as `maxSuc` already reduces efficiently to refl for concrete (large) numbers
-      -- however, since `_<_` is an indexed data type, we recompute anyway to avoid
-      -- `transpX-_<_` in the normal form
-      inj (ℤ.recompute< (subst (0 ℤ.<_)
-      (sym $ cong (pos ∘ (ℕ._· 1)) $ maxSuc {predℕ (1+n ℕ.· 1+b)} {predℕ (1+m ℕ.· 1+a)})
-      (ℤ.pos<pos tt))) })
-    (fst x) (fst y) (snd x) (snd y)
-
-  min₊ : ℚ₊ → ℚ₊ → ℚ₊
-  fst (min₊ x y) = ℚ.min (fst x) (fst y)
-  snd (min₊ x y) = elimProp2
-    {P = λ a b → 0 <ℚ a → 0 <ℚ b → 0 <ℚ ℚ.min a b}
-    (λ a b → isPropΠ2 λ _ _ → isProp< 0 (ℚ.min a b))
-    (λ { (pos (suc n) , 1+ a) (pos (suc m) , 1+ b) (pos<pos p) (pos<pos q) →
-    let
-      1+n = suc n ; 1+m = suc m ; 1+a = suc a ; 1+b = suc b
-    in
-      inj (ℤ.recompute< (subst (0 ℤ.<_)
-      (sym $ cong (pos ∘ (ℕ._· 1)) $ minSuc {predℕ (1+n ℕ.· 1+b)} {predℕ (1+m ℕ.· 1+a)})
-      (ℤ.pos<pos tt))) })
-    (fst x) (fst y) (snd x) (snd y)
-
-  min₊≤L : ∀ ε δ → min₊ ε δ ≤₊ ε
-  min₊≤L ε δ = min≤ ⟨ ε ⟩₊ ⟨ δ ⟩₊
-
-  min₊≤R : ∀ ε δ → min₊ ε δ ≤₊ δ
-  min₊≤R ε δ = ℚ.recompute≤ $
-    subst (_≤ℚ ⟨ δ ⟩₊) (ℚ.minComm ⟨ δ ⟩₊ ⟨ ε ⟩₊) (min≤ ⟨ δ ⟩₊ ⟨ ε ⟩₊)
-
-  min/2₊<L : ∀ ε δ → (min₊ ε δ /2₊) <₊ ε
-  min/2₊<L ε δ = begin<
-    ⟨ min₊ ε δ /2₊ ⟩₊ <⟨ /2₊<id (min₊ ε δ) ⟩
-    ⟨ min₊ ε δ ⟩₊     ≤⟨ min₊≤L ε δ ⟩
-    ⟨ ε ⟩₊            ◾
-
-  min/2₊<R : ∀ ε δ → (min₊ ε δ /2₊) <₊ δ
-  min/2₊<R ε δ = begin<
-    ⟨ min₊ ε δ /2₊ ⟩₊ <⟨ /2₊<id (min₊ ε δ) ⟩
-    ⟨ min₊ ε δ ⟩₊     ≤⟨ min₊≤R ε δ ⟩
-    ⟨ δ ⟩₊            ◾
-
-  module ℚ₊Inverse where
-
-    Σinverseℚ₊ : ((ε , 0<ε) : ℚ₊) → Σ[ δ ∈ ℚ ] (ε ℚ.· δ ≡ 1)
-    Σinverseℚ₊ = uncurry $ SQ.elimProp (λ ε → isPropΠ λ _ → inverseUniqueness ε) λ
-      { (pos (suc n) , 1+ d) (pos<pos p) .fst → [ pos (suc d) , 1+ n ]
-      ; (pos (suc n) , 1+ d) (pos<pos p) .snd →
-        eq/ _ _ (ℤ.·IdR _ ∙∙ ℤ.·Comm (pos (suc n)) (pos (suc d)) ∙∙ sym (ℤ.·IdL _)) }
-
-    infixl 7 _⁻¹₊
-
-    0<inverseℚ⁺ : ∀ ε → 0 <ℚ fst (Σinverseℚ₊ ε)
-    0<inverseℚ⁺ = uncurry $ SQ.elimProp (λ ε → isPropΠ λ p → isProp< 0 _) λ
-      { (pos (suc n) , 1+ d) (pos<pos x) → pos<pos tt }
-
-    _⁻¹₊ : ℚ₊ → ℚ₊
-    fst (ε ⁻¹₊) = fst (Σinverseℚ₊ ε)
-    snd (ε ⁻¹₊) = 0<inverseℚ⁺ ε
-
-    _/_ : ℚ₊ → ℚ₊ → ℚ₊
-    ε / L = ε ·₊ (L ⁻¹₊)
-
-    ⁻¹inverse : ∀ ε → ⟨ ε / ε ⟩₊ ≡ 1
-    ⁻¹inverse = snd ∘ Σinverseℚ₊
-
-    ·/ : ∀ L ε → ⟨ L ·₊ (ε / L) ⟩₊ ≡ ⟨ ε ⟩₊
-    ·/ L ε =
-      ⟨ L ·₊ (ε ·₊ (L ⁻¹₊)) ⟩₊ ≡⟨ ·CommAssocl ⟨ L ⟩₊ ⟨ ε ⟩₊ ⟨ L ⁻¹₊ ⟩₊ ⟩
-      ⟨ ε ·₊ (L ·₊ (L ⁻¹₊)) ⟩₊ ≡⟨ cong (⟨ ε ⟩₊ ℚ.·_) (⁻¹inverse L) ⟩
-      ⟨ ε ⟩₊ ℚ.· 1             ≡⟨ ℚ.·IdR ⟨ ε ⟩₊ ⟩
-      ⟨ ε ⟩₊                   ∎
diff --git a/Cubical/Data/Rationals/Base.agda b/Cubical/Data/Rationals/Base.agda
index 449a952b19..2da896fb2f 100644
--- a/Cubical/Data/Rationals/Base.agda
+++ b/Cubical/Data/Rationals/Base.agda
@@ -8,7 +8,7 @@ open import Cubical.Foundations.Isomorphism
 open import Cubical.Data.Nat as ℕ using (discreteℕ)
 open import Cubical.Data.NatPlusOne
 open import Cubical.Data.Sigma
-open import Cubical.Data.Fast.Int as ℤ
+open import Cubical.Data.Int as ℤ
 
 open import Cubical.HITs.SetQuotients as SetQuotient
   using ([_]; eq/; discreteSetQuotients) renaming (_/_ to _//_) public
diff --git a/Cubical/Data/Rationals/Order.agda b/Cubical/Data/Rationals/Order.agda
index 2755b7bcba..106d6334ec 100644
--- a/Cubical/Data/Rationals/Order.agda
+++ b/Cubical/Data/Rationals/Order.agda
@@ -9,9 +9,9 @@ open import Cubical.Foundations.Univalence
 open import Cubical.Functions.Logic using (_⊔′_)
 
 open import Cubical.Data.Empty as ⊥
-open import Cubical.Data.Fast.Int.Base as ℤ using (ℤ)
-import Cubical.Data.Fast.Int.Properties as ℤ
-import Cubical.Data.Fast.Int.Order as ℤ
+open import Cubical.Data.Int.Base as ℤ using (ℤ)
+open import Cubical.Data.Int.Properties as ℤ using ()
+open import Cubical.Data.Int.Order as ℤ using ()
 open import Cubical.Data.Rationals.Base as ℚ
 open import Cubical.Data.Rationals.Properties as ℚ
 open import Cubical.Data.Nat as ℕ
@@ -20,7 +20,7 @@ open import Cubical.Data.Sigma
 open import Cubical.Data.Sum as ⊎ using (_⊎_; inl; inr; isProp⊎)
 
 open import Cubical.HITs.PropositionalTruncation as ∥₁ using (isPropPropTrunc; ∣_∣₁)
-open import Cubical.HITs.SetQuotients renaming (_/_ to _//_)
+open import Cubical.HITs.SetQuotients
 
 open import Cubical.Relation.Nullary
 open import Cubical.Relation.Binary.Base
@@ -39,18 +39,18 @@ private
                 → ((a ℤ.· ℕ₊₁→ℤ d) ℤ.≤ (c ℤ.· ℕ₊₁→ℤ b))
                 ≡ ((a ℤ.· ℕ₊₁→ℤ f) ℤ.≤ (e ℤ.· ℕ₊₁→ℤ b))
         lemma≤ (a , b) (c , d) (e , f) cf≡ed = (ua (propBiimpl→Equiv ℤ.isProp≤ ℤ.isProp≤
-                (ℤ.≤-·o-cancel ∘
+                (ℤ.≤-·o-cancel {k = -1+ d} ∘
                   subst2 ℤ._≤_ (·CommR a (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ f))
                                (·CommR c (ℕ₊₁→ℤ b) (ℕ₊₁→ℤ f) ∙
                                 cong (ℤ._· ℕ₊₁→ℤ b) cf≡ed ∙
                                 ·CommR e (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ b)) ∘
-                 ℤ.≤-·o)
-                (ℤ.≤-·o-cancel ∘
+                 ℤ.≤-·o {k = ℕ₊₁→ℕ f})
+                (ℤ.≤-·o-cancel {k = -1+ f} ∘
                   subst2 ℤ._≤_ (·CommR a (ℕ₊₁→ℤ f) (ℕ₊₁→ℤ d))
                                 (·CommR e (ℕ₊₁→ℤ b) (ℕ₊₁→ℤ d) ∙
                                  cong (ℤ._· ℕ₊₁→ℤ b) (sym cf≡ed) ∙
                                  ·CommR c (ℕ₊₁→ℤ f) (ℕ₊₁→ℤ b)) ∘
-                 ℤ.≤-·o)))
+                 ℤ.≤-·o {k = ℕ₊₁→ℕ d})))
 
         fun₀ : ℤ × ℕ₊₁ → ℚ → hProp ℓ-zero
         fst (fun₀ (a , b) [ c , d ]) = a ℤ.· ℕ₊₁→ℤ d ℤ.≤ c ℤ.· ℕ₊₁→ℤ b
@@ -68,18 +68,18 @@ private
         toPath : ∀ a/b c/d (x : a/b ∼ c/d) (y : ℚ) → fun₀ a/b y ≡ fun₀ c/d y
         toPath (a , b) (c , d) ad≡cb = elimProp (λ _ → isSetHProp _ _) λ (e , f) →
           Σ≡Prop (λ _ → isPropIsProp) (ua (propBiimpl→Equiv ℤ.isProp≤ ℤ.isProp≤
-                (ℤ.≤-·o-cancel ∘
+                (ℤ.≤-·o-cancel {k = -1+ b} ∘
                   subst2 ℤ._≤_ (·CommR a (ℕ₊₁→ℤ f) (ℕ₊₁→ℤ d) ∙
                                  cong (ℤ._· ℕ₊₁→ℤ f) ad≡cb ∙
                                  ·CommR c (ℕ₊₁→ℤ b) (ℕ₊₁→ℤ f))
                                (·CommR e (ℕ₊₁→ℤ b) (ℕ₊₁→ℤ d)) ∘
-                 ℤ.≤-·o)
-                (ℤ.≤-·o-cancel ∘
+                 ℤ.≤-·o {k = ℕ₊₁→ℕ d})
+                (ℤ.≤-·o-cancel {k = -1+ d} ∘
                   subst2 ℤ._≤_ (·CommR c (ℕ₊₁→ℤ f) (ℕ₊₁→ℤ b) ∙
                                  cong (ℤ._· ℕ₊₁→ℤ f) (sym ad≡cb) ∙
                                  ·CommR a (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ f))
                                (·CommR e (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ b)) ∘
-                 ℤ.≤-·o)))
+                 ℤ.≤-·o {k = ℕ₊₁→ℕ b})))
 
         fun : ℚ → ℚ → hProp ℓ-zero
         fun [ a/b ] y = fun₀ a/b y
@@ -95,18 +95,18 @@ private
                 → ((a ℤ.· ℕ₊₁→ℤ d) ℤ.< (c ℤ.· ℕ₊₁→ℤ b))
                 ≡ ((a ℤ.· ℕ₊₁→ℤ f) ℤ.< (e ℤ.· ℕ₊₁→ℤ b))
         lemma< (a , b) (c , d) (e , f) cf≡ed = (ua (propBiimpl→Equiv ℤ.isProp< ℤ.isProp<
-                (ℤ.<-·o-cancel ∘
+                (ℤ.<-·o-cancel {k = -1+ d} ∘
                   subst2 ℤ._<_ (·CommR a (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ f))
                                (·CommR c (ℕ₊₁→ℤ b) (ℕ₊₁→ℤ f) ∙
                                 cong (ℤ._· ℕ₊₁→ℤ b) cf≡ed ∙
                                 ·CommR e (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ b)) ∘
-                 ℤ.<-·o)
-                (ℤ.<-·o-cancel ∘
+                 ℤ.<-·o {k = -1+ f})
+                (ℤ.<-·o-cancel {k = -1+ f} ∘
                   subst2 ℤ._<_ (·CommR a (ℕ₊₁→ℤ f) (ℕ₊₁→ℤ d))
                                (·CommR e (ℕ₊₁→ℤ b) (ℕ₊₁→ℤ d) ∙
                                 cong (ℤ._· ℕ₊₁→ℤ b) (sym cf≡ed) ∙
                                 ·CommR c (ℕ₊₁→ℤ f) (ℕ₊₁→ℤ b)) ∘
-                 ℤ.<-·o)))
+                 ℤ.<-·o {k = -1+ d})))
 
         fun₀ : ℤ × ℕ₊₁ → ℚ → hProp ℓ-zero
         fst (fun₀ (a , b) [ c , d ]) = a ℤ.· ℕ₊₁→ℤ d ℤ.< c ℤ.· ℕ₊₁→ℤ b
@@ -124,18 +124,18 @@ private
         toPath : ∀ a/b c/d (x : a/b ∼ c/d) (y : ℚ) → fun₀ a/b y ≡ fun₀ c/d y
         toPath (a , b) (c , d) ad≡cb = elimProp (λ _ → isSetHProp _ _) λ (e , f) →
           Σ≡Prop (λ _ → isPropIsProp) (ua (propBiimpl→Equiv ℤ.isProp< ℤ.isProp<
-                (ℤ.<-·o-cancel ∘
+                (ℤ.<-·o-cancel {k = -1+ b} ∘
                   subst2 ℤ._<_ (·CommR a (ℕ₊₁→ℤ f) (ℕ₊₁→ℤ d) ∙
                                 cong (ℤ._· ℕ₊₁→ℤ f) ad≡cb ∙
                                 ·CommR c (ℕ₊₁→ℤ b) (ℕ₊₁→ℤ f))
                                (·CommR e (ℕ₊₁→ℤ b) (ℕ₊₁→ℤ d)) ∘
-                 ℤ.<-·o)
-                (ℤ.<-·o-cancel ∘
+                 ℤ.<-·o {k = -1+ d})
+                (ℤ.<-·o-cancel {k = -1+ d} ∘
                   subst2 ℤ._<_ (·CommR c (ℕ₊₁→ℤ f) (ℕ₊₁→ℤ b) ∙
                                 cong (ℤ._· ℕ₊₁→ℤ f) (sym ad≡cb) ∙
                                 ·CommR a (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ f))
                                (·CommR e (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ b)) ∘
-                 ℤ.<-·o)))
+                 ℤ.<-·o {k = -1+ b})))
 
         fun : ℚ → ℚ → hProp ℓ-zero
         fun [ a/b ] y = fun₀ a/b y
@@ -143,23 +143,11 @@ private
         fun (squash/ x y p q i j) z = isSet→SquareP (λ _ _ → isSetHProp)
           (λ _ → fun x z) (λ _ → fun y z) (λ i → fun (p i) z) (λ i → fun (q i) z) j i
 
-record _≤_ (m n : ℚ ) : Type₀ where
-  constructor inj
-  field
-    prf : fst (m ≤' n)
+_≤_ : ℚ → ℚ → Type₀
+m ≤ n = fst (m ≤' n)
 
-record _<_ (m n : ℚ ) : Type₀ where
-  constructor inj
-  field
-    prf : fst (m <' n)
-
-pattern pos≤pos p       = inj (ℤ.pos≤pos p)
-pattern negsuc≤pos      = inj ℤ.negsuc≤pos
-pattern negsuc≤negsuc p = inj (ℤ.negsuc≤negsuc p)
-
-pattern pos<pos p       = inj (ℤ.pos<pos p)
-pattern negsuc<pos      = inj ℤ.negsuc<pos
-pattern negsuc<negsuc p = inj (ℤ.negsuc<negsuc p)
+_<_ : ℚ → ℚ → Type₀
+m < n = fst (m <' n)
 
 _≥_ : ℚ → ℚ → Type₀
 m ≥ n = n ≤ m
@@ -179,79 +167,53 @@ module _ where
   open BinaryRelation
 
   isProp≤ : isPropValued _≤_
-  isProp≤ m n (inj p) (inj q) = cong inj (snd (m ≤' n) p q)
+  isProp≤ m n = snd (m ≤' n)
 
   isProp< : isPropValued _<_
-  isProp< m n (inj p) (inj q) = cong inj (snd (m <' n) p q)
-
-  recompute≤ : ∀ {a b} → a ≤ b → a ≤ b
-  recompute≤ = elimProp2 {P = λ a b → a ≤ b → a ≤ b}
-                         (λ _ _ → isProp→ (isProp≤ _ _))
-                         (λ _ _ → inj ∘ ℤ.recompute≤ ∘ _≤_.prf) _ _
-
-  recompute< : ∀ {a b} → a < b → a < b
-  recompute< = elimProp2 {P = λ a b → a < b → a < b}
-                         (λ _ _ → isProp→ (isProp< _ _))
-                         (λ _ _ → inj ∘ ℤ.recompute< ∘ _<_.prf) _ _
-
-  recompute¬≤ : ∀ {a b} → ¬ (a ≤ b) → ¬ (a ≤ b)
-  recompute¬≤ = elimProp2 {P = λ a b → ¬ (a ≤ b) → ¬ (a ≤ b)}
-                          (λ _ _ → isProp→ (isProp¬ _))
-                          (λ _ _ ¬a≤b → ℤ.recompute¬≤ (¬a≤b ∘ inj) ∘ _≤_.prf) _ _
-
-  recompute¬< : ∀ {a b} → ¬ (a < b) → ¬ (a < b)
-  recompute¬< = elimProp2 {P = λ a b → ¬ (a < b) → ¬ (a < b)}
-                          (λ _ _ → isProp→ (isProp¬ _))
-                          (λ _ _ ¬a<b → ℤ.recompute¬< (¬a<b ∘ inj) ∘ _<_.prf) _ _
-
-  recompute# : ∀ {a b} → a # b → a # b
-  recompute# = ⊎.map recompute< recompute<
-
-  recompute¬# : ∀ {a b} → ¬ (a # b) → ¬ (a # b)
-  recompute¬# r = ⊎.rec (recompute¬< (r ∘ inl)) (recompute¬< (r ∘ inr))
+  isProp< m n = snd (m <' n)
 
   isRefl≤ : isRefl _≤_
-  isRefl≤ = elimProp {P = λ x → x ≤ x} (λ x → isProp≤ x x) λ _ → inj ℤ.isRefl≤
+  isRefl≤ = elimProp {P = λ x → x ≤ x} (λ x → isProp≤ x x) λ _ → ℤ.isRefl≤
 
   isIrrefl< : isIrrefl _<_
-  isIrrefl< = elimProp {P = λ x → ¬ x < x} (λ _ → isProp¬ _) λ _ → ℤ.isIrrefl< ∘ _<_.prf
+  isIrrefl< = elimProp {P = λ x → ¬ x < x} (λ _ → isProp¬ _) λ _ → ℤ.isIrrefl<
 
   isAntisym≤ : isAntisym _≤_
   isAntisym≤ =
     elimProp2 {P = λ a b → a ≤ b → b ≤ a → a ≡ b}
               (λ x y → isPropΠ2 λ _ _ → isSetℚ x y)
-              λ a b (inj a≤b) (inj b≤a) → eq/ a b (ℤ.isAntisym≤ a≤b b≤a)
+              λ a b a≤b b≤a → eq/ a b (ℤ.isAntisym≤ a≤b b≤a)
 
   isTrans≤ : isTrans _≤_
   isTrans≤ =
     elimProp3 {P = λ a b c → a ≤ b → b ≤ c → a ≤ c}
               (λ x _ z → isPropΠ2 λ _ _ → isProp≤ x z)
-              λ { (a , b) (c , d) (e , f) (inj ad≤cb) (inj cf≤ed) →
-                inj (ℤ.≤-·o-cancel
+              λ { (a , b) (c , d) (e , f) ad≤cb cf≤ed →
+                ℤ.≤-·o-cancel {k = -1+ d}
                   (subst (ℤ._≤ e ℤ.· ℕ₊₁→ℤ b ℤ.· ℕ₊₁→ℤ d)
                     (·CommR a (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ f))
-                  (ℤ.isTrans≤ (ℤ.≤-·o ad≤cb)
+                  (ℤ.isTrans≤ (ℤ.≤-·o {k = ℕ₊₁→ℕ f} ad≤cb)
                     (subst2 ℤ._≤_
                       (·CommR c (ℕ₊₁→ℤ f) (ℕ₊₁→ℤ b))
                       (·CommR e (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ b))
-                      (ℤ.≤-·o cf≤ed))))) }
+                      (ℤ.≤-·o {k = ℕ₊₁→ℕ b} cf≤ed)))) }
 
   isTrans< : isTrans _<_
   isTrans< =
     elimProp3 {P = λ a b c → a < b → b < c → a < c}
               (λ x _ z → isPropΠ2 λ _ _ → isProp< x z)
-              λ { (a , b) (c , d) (e , f) (inj ad<cb) (inj cf<ed) →
-                inj (ℤ.<-·o-cancel
+              λ { (a , b) (c , d) (e , f) ad<cb cf<ed →
+                ℤ.<-·o-cancel {k = -1+ d}
                   (subst (ℤ._< e ℤ.· ℕ₊₁→ℤ b ℤ.· ℕ₊₁→ℤ d)
                     (·CommR a (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ f))
-                  (ℤ.isTrans< (ℤ.<-·o ad<cb)
+                  (ℤ.isTrans< (ℤ.<-·o {k = -1+ f} ad<cb)
                     (subst2 ℤ._<_
                       (·CommR c (ℕ₊₁→ℤ f) (ℕ₊₁→ℤ b))
                       (·CommR e (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ b))
-                      (ℤ.<-·o cf<ed))))) }
+                      (ℤ.<-·o {k = -1+ b} cf<ed)))) }
 
   isAsym< : isAsym _<_
-  isAsym< = ((recompute¬< ∘_) ∘_) ∘ isIrrefl×isTrans→isAsym _<_ (isIrrefl< , isTrans<)
+  isAsym< = isIrrefl×isTrans→isAsym _<_ (isIrrefl< , isTrans<)
 
   isTotal≤ : isTotal _≤_
   isTotal≤ =
@@ -261,9 +223,9 @@ module _ where
     where
       lem : (a b : ℤ.ℤ × ℕ₊₁) → ([ a ] ≤ [ b ]) ⊎ ([ b ] ≤ [ a ])
       lem (a , b) (c , d) with (a ℤ.· ℕ₊₁→ℤ d) ℤ.≟ (c ℤ.· ℕ₊₁→ℤ b)
-      ... | ℤ.lt ad<cb = inl (inj (ℤ.<-weaken ad<cb))
-      ... | ℤ.eq ad≡cb = inl (inj (ℤ.recompute≤ $ subst (_ ℤ.≤_) ad≡cb ℤ.isRefl≤))
-      ... | ℤ.gt cb<ad = inr (inj (ℤ.<-weaken cb<ad))
+      ... | ℤ.lt ad<cb = inl (ℤ.<-weaken ad<cb)
+      ... | ℤ.eq ad≡cb = inl (0 , ad≡cb)
+      ... | ℤ.gt cb<ad = inr (ℤ.<-weaken cb<ad)
 
   isConnected< : isConnected _<_
   isConnected< =
@@ -273,9 +235,9 @@ module _ where
     where
       lem : (a b : ℤ.ℤ × ℕ₊₁) → (¬ [ a ] < [ b ]) × (¬ [ b ] < [ a ]) → [ a ] ≡ [ b ]
       lem (a , b) (c , d) (¬ad<cb , ¬cb<ad) with (a ℤ.· ℕ₊₁→ℤ d) ℤ.≟ (c ℤ.· ℕ₊₁→ℤ b)
-      ... | ℤ.lt ad<cb = ⊥.rec (¬ad<cb (inj ad<cb))
+      ... | ℤ.lt ad<cb = ⊥.rec (¬ad<cb ad<cb)
       ... | ℤ.eq ad≡cb = eq/ (a , b) (c , d) ad≡cb
-      ... | ℤ.gt cb<ad = ⊥.rec (¬cb<ad (inj cb<ad))
+      ... | ℤ.gt cb<ad = ⊥.rec (¬cb<ad cb<ad)
 
   isProp# : isPropValued _#_
   isProp# x y = isProp⊎ (isProp< x y) (isProp< y x) (isAsym< x y)
@@ -296,9 +258,9 @@ module _ where
     where
       lem : (a b : ℤ.ℤ × ℕ₊₁) → ¬ [_] {R = _∼_} a ≡ [ b ] → [ a ] # [ b ]
       lem (a , b) (c , d) ¬a≡b with (a ℤ.· ℕ₊₁→ℤ d) ℤ.≟ (c ℤ.· ℕ₊₁→ℤ b)
-      ... | ℤ.lt ad<cb = inl (inj ad<cb)
+      ... | ℤ.lt ad<cb = inl ad<cb
       ... | ℤ.eq ad≡cb = ⊥.rec (¬a≡b (eq/ (a , b) (c , d) ad≡cb))
-      ... | ℤ.gt cb<ad = inr (inj cb<ad)
+      ... | ℤ.gt cb<ad = inr cb<ad
 
   isWeaklyLinear< : isWeaklyLinear _<_
   isWeaklyLinear< =
@@ -308,7 +270,7 @@ module _ where
     where
       lem : (a b c : ℤ.ℤ × ℕ₊₁) → [ a ] < [ b ] → ([ a ] < [ c ]) ⊔′ ([ c ] < [ b ])
       lem a b c a<b with discreteℚ [ a ] [ c ]
-      ... | yes a≡c = ∣ inr (recompute< (subst (_< [ b ]) a≡c a<b)) ∣₁
+      ... | yes a≡c = ∣ inr (subst (_< [ b ]) a≡c a<b) ∣₁
       ... | no a≢c = ∣ ⊎.map (λ a<c → a<c)
                              (λ c<a → isTrans< [ c ] [ a ] [ b ] c<a a<b)
                              (inequalityImplies# [ a ] [ c ] a≢c) ∣₁
@@ -321,15 +283,15 @@ module _ where
       where
         lem : (a b c : ℤ.ℤ × ℕ₊₁) → [ a ] # [ b ] → ([ a ] # [ c ]) ⊔′ ([ b ] # [ c ])
         lem a b c a#b with discreteℚ [ b ] [ c ]
-        ... | yes b≡c = ∣ inl (recompute# (subst ([ a ] #_) b≡c a#b)) ∣₁
+        ... | yes b≡c = ∣ inl (subst ([ a ] #_) b≡c a#b) ∣₁
         ... | no  b≢c = ∣ inr (inequalityImplies# [ b ] [ c ] b≢c) ∣₁
 
 ≤-+o : ∀ m n o → m ≤ n → m ℚ.+ o ≤ n ℚ.+ o
 ≤-+o =
   elimProp3 {P = λ a b c → a ≤ b → a ℚ.+ c ≤ b ℚ.+ c}
             (λ x y z → isProp→ (isProp≤ (x ℚ.+ z) (y ℚ.+ z)))
-             λ { (a , b) (c , d) (e , f) (inj ad≤cb) →
-                inj $ ℤ.recompute≤ $ subst2 ℤ._≤_
+             λ { (a , b) (c , d) (e , f) ad≤cb →
+               subst2 ℤ._≤_
                        (cong₂ ℤ._+_
                               (cong (λ x → a ℤ.· ℕ₊₁→ℤ d ℤ.· x)
                                     (ℤ.pos·pos (ℕ₊₁→ℕ f) (ℕ₊₁→ℕ f)) ∙
@@ -362,10 +324,13 @@ module _ where
                                     cong (λ x → e ℤ.· ℕ₊₁→ℤ d ℤ.· x)
                                          (sym (ℤ.pos·pos (ℕ₊₁→ℕ b) (ℕ₊₁→ℕ f)))) ∙
                        sym (ℤ.·DistL+ (c ℤ.· ℕ₊₁→ℤ f) (e ℤ.· ℕ₊₁→ℤ d) (ℕ₊₁→ℤ (b ·₊₁ f))))
-                       (ℤ.≤-+o (ℤ.≤-·o ad≤cb)) }
+                       (ℤ.≤-+o {o = e ℤ.· ℕ₊₁→ℤ b ℤ.· ℕ₊₁→ℤ d ℤ.· ℕ₊₁→ℤ f}
+                               (ℤ.≤-·o {k = ℕ₊₁→ℕ (f ·₊₁ f)} ad≤cb)) }
 
 ≤-o+ : ∀ m n o →  m ≤ n → o ℚ.+ m ≤ o ℚ.+ n
-≤-o+ m n o = recompute≤ ∘ subst2 _≤_ (+Comm m o) (+Comm n o) ∘ ≤-+o m n o
+≤-o+ m n o = subst2 _≤_ (+Comm m o)
+                         (+Comm n o) ∘
+             ≤-+o m n o
 
 ≤Monotone+ : ∀ m n o s → m ≤ n → o ≤ s → m ℚ.+ o ≤ n ℚ.+ s
 ≤Monotone+ m n o s m≤n o≤s
@@ -376,23 +341,23 @@ module _ where
               (≤-o+ o s n o≤s)
 
 ≤-o+-cancel : ∀ m n o →  o ℚ.+ m ≤ o ℚ.+ n → m ≤ n
-≤-o+-cancel m n o = recompute≤ ∘
-  subst2 _≤_ (+Assoc (- o) o m ∙ cong (ℚ._+ m) (+InvL o) ∙ +IdL m)
-             (+Assoc (- o) o n ∙ cong (ℚ._+ n) (+InvL o) ∙ +IdL n) ∘
-        ≤-o+ (o ℚ.+ m) (o ℚ.+ n) (- o)
+≤-o+-cancel m n o
+  = subst2 _≤_ (+Assoc (- o) o m ∙ cong (ℚ._+ m) (+InvL o) ∙ +IdL m)
+                (+Assoc (- o) o n ∙ cong (ℚ._+ n) (+InvL o) ∙ +IdL n) ∘
+           ≤-o+ (o ℚ.+ m) (o ℚ.+ n) (- o)
 
 ≤-+o-cancel : ∀ m n o → m ℚ.+ o ≤ n ℚ.+ o → m ≤ n
-≤-+o-cancel m n o = recompute≤ ∘
-    subst2 _≤_ (sym (+Assoc m o (- o)) ∙ cong (λ x → m ℚ.+ x) (+InvR o) ∙ +IdR m)
-               (sym (+Assoc n o (- o)) ∙ cong (λ x → n ℚ.+ x) (+InvR o) ∙ +IdR n) ∘
-          ≤-+o (m ℚ.+ o) (n ℚ.+ o) (- o)
+≤-+o-cancel m n o
+  = subst2 _≤_ (sym (+Assoc m o (- o)) ∙ cong (λ x → m ℚ.+ x) (+InvR o) ∙ +IdR m)
+                (sym (+Assoc n o (- o)) ∙ cong (λ x → n ℚ.+ x) (+InvR o) ∙ +IdR n) ∘
+           ≤-+o (m ℚ.+ o) (n ℚ.+ o) (- o)
 
 <-+o : ∀ m n o → m < n → m ℚ.+ o < n ℚ.+ o
 <-+o =
   elimProp3 {P = λ a b c → a < b → a ℚ.+ c < b ℚ.+ c}
             (λ x y z → isProp→ (isProp< (x ℚ.+ z) (y ℚ.+ z)))
-             λ { (a , b) (c , d) (e , f) (inj ad<cb) →
-               inj $ ℤ.recompute< $ subst2 ℤ._<_
+             λ { (a , b) (c , d) (e , f) ad<cb →
+               subst2 ℤ._<_
                        (cong₂ ℤ._+_
                               (cong (λ x → a ℤ.· ℕ₊₁→ℤ d ℤ.· x)
                                     (ℤ.pos·pos (ℕ₊₁→ℕ f) (ℕ₊₁→ℕ f)) ∙
@@ -425,78 +390,81 @@ module _ where
                                     cong (λ x → e ℤ.· ℕ₊₁→ℤ d ℤ.· x)
                                          (sym (ℤ.pos·pos (ℕ₊₁→ℕ b) (ℕ₊₁→ℕ f)))) ∙
                        sym (ℤ.·DistL+ (c ℤ.· ℕ₊₁→ℤ f) (e ℤ.· ℕ₊₁→ℤ d) (ℕ₊₁→ℤ (b ·₊₁ f))))
-                       (ℤ.<-+o (ℤ.<-·o ad<cb)) }
+                       (ℤ.<-+o {o = e ℤ.· ℕ₊₁→ℤ b ℤ.· ℕ₊₁→ℤ d ℤ.· ℕ₊₁→ℤ f}
+                               (ℤ.<-·o {k = -1+ (f ·₊₁ f)} ad<cb)) }
 
 <-o+ : ∀ m n o → m < n → o ℚ.+ m < o ℚ.+ n
-<-o+ m n o = recompute< ∘ subst2 _<_ (+Comm m o) (+Comm n o) ∘ <-+o m n o
+<-o+ m n o = subst2 _<_ (+Comm m o) (+Comm n o) ∘ <-+o m n o
 
 <Monotone+ : ∀ m n o s → m < n → o < s → m ℚ.+ o < n ℚ.+ s
 <Monotone+ m n o s m<n o<s
   = isTrans< (m ℚ.+ o) (n ℚ.+ o) (n ℚ.+ s) (<-+o m n o m<n) (<-o+ o s n o<s)
 
 <-o+-cancel : ∀ m n o → o ℚ.+ m < o ℚ.+ n → m < n
-<-o+-cancel m n o = recompute< ∘
-  subst2 _<_ (+Assoc (- o) o m ∙ cong (ℚ._+ m) (+InvL o) ∙ +IdL m)
-             (+Assoc (- o) o n ∙ cong (ℚ._+ n) (+InvL o) ∙ +IdL n) ∘
-        <-o+ (o ℚ.+ m) (o ℚ.+ n) (- o)
+<-o+-cancel m n o
+  = subst2 _<_ (+Assoc (- o) o m ∙ cong (ℚ._+ m) (+InvL o) ∙ +IdL m)
+               (+Assoc (- o) o n ∙ cong (ℚ._+ n) (+InvL o) ∙ +IdL n) ∘
+           <-o+ (o ℚ.+ m) (o ℚ.+ n) (- o)
 
 <-+o-cancel : ∀ m n o → m ℚ.+ o < n ℚ.+ o → m < n
-<-+o-cancel m n o = recompute< ∘
-  subst2 _<_ (sym (+Assoc m o (- o)) ∙ cong (λ x → m ℚ.+ x) (+InvR o) ∙ +IdR m)
-             (sym (+Assoc n o (- o)) ∙ cong (λ x → n ℚ.+ x) (+InvR o) ∙ +IdR n) ∘
-        <-+o (m ℚ.+ o) (n ℚ.+ o) (- o)
+<-+o-cancel m n o
+  = subst2 _<_ (sym (+Assoc m o (- o)) ∙ cong (λ x → m ℚ.+ x) (+InvR o) ∙ +IdR m)
+               (sym (+Assoc n o (- o)) ∙ cong (λ x → n ℚ.+ x) (+InvR o) ∙ +IdR n) ∘
+           <-+o (m ℚ.+ o) (n ℚ.+ o) (- o)
 
 <Weaken≤ : ∀ m n → m < n → m ≤ n
 <Weaken≤ m n = elimProp2 {P = λ x y → x < y → x ≤ y}
                              (λ x y → isProp→ (isProp≤ x y))
-                             (λ { (a , b) (c , d) → inj ∘ ℤ.<-weaken ∘ _<_.prf }) m n
+                             (λ { (a , b) (c , d) → ℤ.<-weaken }) m n
 
 isTrans<≤ : ∀ m n o → m < n → n ≤ o → m < o
 isTrans<≤ =
     elimProp3 {P = λ a b c → a < b → b ≤ c → a < c}
               (λ x _ z → isPropΠ2 λ _ _ → isProp< x z)
-               λ { (a , b) (c , d) (e , f) (inj ad<cb) (inj cf≤ed)
-                → inj $ ℤ.<-·o-cancel
-                 (ℤ.<≤-trans (subst2 ℤ._<_ (·CommR a (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ f))
+               λ { (a , b) (c , d) (e , f) ad<cb cf≤ed
+                → ℤ.<-·o-cancel {k = -1+ d}
+                 (ℤ.<≤-trans {m = c ℤ.· ℕ₊₁→ℤ f ℤ.· ℕ₊₁→ℤ b}
+                              (subst2 ℤ._<_ (·CommR a (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ f))
                                             (·CommR c (ℕ₊₁→ℤ b) (ℕ₊₁→ℤ f))
-                                            (ℤ.<-·o ad<cb))
-                             (subst (_ ℤ.≤_) (·CommR e (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ b))
-                                    (ℤ.≤-·o cf≤ed)) )}
+                                            (ℤ.<-·o {k = -1+ f} ad<cb))
+                              (subst (_ ℤ.≤_) (·CommR e (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ b))
+                                     (ℤ.≤-·o {k = ℕ₊₁→ℕ b} cf≤ed)) )}
 
 isTrans≤< : ∀ m n o → m ≤ n → n < o → m < o
 isTrans≤< =
     elimProp3 {P = λ a b c → a ≤ b → b < c → a < c}
               (λ x _ z → isPropΠ2 λ _ _ → isProp< x z)
-               λ { (a , b) (c , d) (e , f) (inj ad≤cb) (inj cf<ed)
-                → inj $ ℤ.<-·o-cancel
-                 (ℤ.≤<-trans (subst2 ℤ._≤_ (·CommR a (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ f))
-                                            (·CommR c (ℕ₊₁→ℤ b) (ℕ₊₁→ℤ f))
-                                            (ℤ.≤-·o ad≤cb))
-                             (subst (_ ℤ.<_) (·CommR e (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ b))
-                                    (ℤ.<-·o cf<ed)) )}
+               λ { (a , b) (c , d) (e , f) ad≤cb cf<ed
+                → ℤ.<-·o-cancel {k = -1+ d}
+                 (ℤ.≤<-trans {m = c ℤ.· ℕ₊₁→ℤ f ℤ.· ℕ₊₁→ℤ b}
+                              (subst2 ℤ._≤_ (·CommR a (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ f))
+                                             (·CommR c (ℕ₊₁→ℤ b) (ℕ₊₁→ℤ f))
+                                             (ℤ.≤-·o {k = ℕ₊₁→ℕ f} ad≤cb))
+                              (subst (_ ℤ.<_) (·CommR e (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ b))
+                                     (ℤ.<-·o {k = -1+ b} cf<ed)) )}
 
 ≤-·o : ∀ m n o → 0 ≤ o → m ≤ n → m ℚ.· o ≤ n ℚ.· o
 ≤-·o =
   elimProp3 {P = λ a b c → 0 ≤ c → a ≤ b → a ℚ.· c ≤ b ℚ.· c}
             (λ x y z → isPropΠ2 λ _ _ → isProp≤ (x ℚ.· z) (y ℚ.· z))
-             λ { (a , b) (c , d) (e , f) (inj 0≤e) (inj ad≤cb)
-             → inj $ ℤ.recompute≤ $
-               subst2 ℤ._≤_ (cong (ℤ._· ℕ₊₁→ℤ f) (·CommR a (ℕ₊₁→ℤ d) e) ∙
+             λ { (a , b) (c , d) (e , f) 0≤e ad≤cb
+             → subst2 ℤ._≤_ (cong (ℤ._· ℕ₊₁→ℤ f) (·CommR a (ℕ₊₁→ℤ d) e) ∙
                               sym (ℤ.·Assoc (a ℤ.· e) (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ f)) ∙
                               cong (a ℤ.· e ℤ.·_) (sym (ℤ.pos·pos (ℕ₊₁→ℕ d) (ℕ₊₁→ℕ f))))
                              (cong (ℤ._· ℕ₊₁→ℤ f) (·CommR c (ℕ₊₁→ℤ b) e) ∙
                               sym (ℤ.·Assoc (c ℤ.· e) (ℕ₊₁→ℤ b) (ℕ₊₁→ℤ f)) ∙
                               cong (c ℤ.· e ℤ.·_) (sym (ℤ.pos·pos (ℕ₊₁→ℕ b) (ℕ₊₁→ℕ f))))
-                             (ℤ.≤-·o (ℤ.0≤o→≤-·o (subst (0 ℤ.≤_) (ℤ.·IdR e) 0≤e) ad≤cb)) }
+                             (ℤ.≤-·o {k = ℕ₊₁→ℕ f}
+                                      (ℤ.0≤o→≤-·o (subst (0 ℤ.≤_) (ℤ.·IdR e) 0≤e) ad≤cb)) }
 
 ≤-·o-cancel : ∀ m n o → 0 < o → m ℚ.· o ≤ n ℚ.· o → m ≤ n
 ≤-·o-cancel =
   elimProp3 {P = λ a b c → 0 < c → a ℚ.· c ≤ b ℚ.· c → a ≤ b}
             (λ x y _ → isPropΠ2 λ _ _ → isProp≤ x y)
-             λ { (a , b) (c , d) (e , f) (inj 0<e) (inj aedf≤cebf)
-             → inj $ ℤ.0<o→≤-·o-cancel (subst (0 ℤ.<_) (ℤ.·IdR e) 0<e)
+             λ { (a , b) (c , d) (e , f) 0<e aedf≤cebf
+             → ℤ.0<o→≤-·o-cancel (subst (0 ℤ.<_) (ℤ.·IdR e) 0<e)
                (subst2 ℤ._≤_ (·CommR a e (ℕ₊₁→ℤ d)) (·CommR c e (ℕ₊₁→ℤ b))
-                      (ℤ.≤-·o-cancel
+                      (ℤ.≤-·o-cancel {k = -1+ f}
                         (subst2 ℤ._≤_ (sym (ℤ.·Assoc a e (ℕ₊₁→ℤ (d ·₊₁ f))) ∙
                                        cong (λ x → a ℤ.· (e ℤ.· x))
                                             (ℤ.pos·pos (ℕ₊₁→ℕ d) (ℕ₊₁→ℕ f)) ∙
@@ -516,24 +484,24 @@ isTrans≤< =
 <-·o =
   elimProp3 {P = λ a b c → 0 < c → a < b → a ℚ.· c < b ℚ.· c}
             (λ x y z → isPropΠ2 λ _ _ → isProp< (x ℚ.· z) (y ℚ.· z))
-             λ { (a , b) (c , d) (e , f) (inj 0<e) (inj ad<cb)
-             → inj $ ℤ.recompute< $
-               subst2 ℤ._<_ (cong (ℤ._· ℕ₊₁→ℤ f) (·CommR a (ℕ₊₁→ℤ d) e) ∙
+             λ { (a , b) (c , d) (e , f) 0<e ad<cb
+             → subst2 ℤ._<_ (cong (ℤ._· ℕ₊₁→ℤ f) (·CommR a (ℕ₊₁→ℤ d) e) ∙
                              sym (ℤ.·Assoc (a ℤ.· e) (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ f)) ∙
                              cong (a ℤ.· e ℤ.·_) (sym (ℤ.pos·pos (ℕ₊₁→ℕ d) (ℕ₊₁→ℕ f))))
                             (cong (ℤ._· ℕ₊₁→ℤ f) (·CommR c (ℕ₊₁→ℤ b) e) ∙
                              sym (ℤ.·Assoc (c ℤ.· e) (ℕ₊₁→ℤ b) (ℕ₊₁→ℤ f)) ∙
                              cong (c ℤ.· e ℤ.·_) (sym (ℤ.pos·pos (ℕ₊₁→ℕ b) (ℕ₊₁→ℕ f))))
-                            (ℤ.<-·o (ℤ.0<o→<-·o (subst (0 ℤ.<_) (ℤ.·IdR e) 0<e) ad<cb)) }
+                            (ℤ.<-·o {k = -1+ f}
+                                    (ℤ.0<o→<-·o (subst (0 ℤ.<_) (ℤ.·IdR e) 0<e) ad<cb)) }
 
 <-·o-cancel : ∀ m n o → 0 < o → m ℚ.· o < n ℚ.· o → m < n
 <-·o-cancel =
   elimProp3 {P = λ a b c → 0 < c → a ℚ.· c < b ℚ.· c → a < b}
             (λ x y _ → isPropΠ2 λ _ _ → isProp< x y)
-             λ { (a , b) (c , d) (e , f) (inj 0<e) (inj aedf<cebf)
-             → inj $ ℤ.0<o→<-·o-cancel (subst (0 ℤ.<_) (ℤ.·IdR e) 0<e)
+             λ { (a , b) (c , d) (e , f) 0<e aedf<cebf
+             → ℤ.0<o→<-·o-cancel (subst (0 ℤ.<_) (ℤ.·IdR e) 0<e)
                (subst2 ℤ._<_ (·CommR a e (ℕ₊₁→ℤ d)) (·CommR c e (ℕ₊₁→ℤ b))
-                      (ℤ.<-·o-cancel
+                      (ℤ.<-·o-cancel {k = -1+ f}
                         (subst2 ℤ._<_ (sym (ℤ.·Assoc a e (ℕ₊₁→ℤ (d ·₊₁ f))) ∙
                                        cong (λ x → a ℤ.· (e ℤ.· x))
                                             (ℤ.pos·pos (ℕ₊₁→ℕ d) (ℕ₊₁→ℕ f)) ∙
@@ -554,20 +522,20 @@ min≤
     = elimProp2 {P = λ a b → ℚ.min a b ≤ a}
                 (λ x y → isProp≤ (ℚ.min x y) x)
                  λ { (a , b) (c , d)
-                  → inj (ℤ.recompute≤ (
-                    subst2 ℤ._≤_ (sym (ℤ.·DistPosLMin (a ℤ.· ℕ₊₁→ℤ d)
+                  → subst2 ℤ._≤_ (sym (ℤ.·DistPosLMin (a ℤ.· ℕ₊₁→ℤ d)
                                                        (c ℤ.· ℕ₊₁→ℤ b)
                                                        (ℕ₊₁→ℕ b)))
                                   (sym (ℤ.·Assoc a (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ b)) ∙
                                    cong (a ℤ.·_) (sym (ℤ.pos·pos (ℕ₊₁→ℕ d) (ℕ₊₁→ℕ b)) ∙
                                                   cong ℕ₊₁→ℤ (·₊₁-comm d b)))
-                                  ℤ.min≤)) }
+                                  (ℤ.min≤ {a ℤ.· ℕ₊₁→ℤ d ℤ.· ℕ₊₁→ℤ b}
+                                           {c ℤ.· ℕ₊₁→ℤ b ℤ.· ℕ₊₁→ℤ b}) }
 
 ≤→min : ∀ m n → m ≤ n → ℚ.min m n ≡ m
 ≤→min
     = elimProp2 {P = λ a b → a ≤ b → ℚ.min a b ≡ a}
                 (λ x y → isProp→ (isSetℚ (ℚ.min x y) x))
-                 λ { (a , b) (c , d) (inj ad≤cb)
+                 λ { (a , b) (c , d) ad≤cb
                   → eq/ (ℤ.min (a ℤ.· ℕ₊₁→ℤ d)
                                (c ℤ.· ℕ₊₁→ℤ b)
                          , b ·₊₁ d)
@@ -582,20 +550,20 @@ min≤
     = elimProp2 {P = λ a b → a ≤ ℚ.max a b}
                 (λ x y → isProp≤ x (ℚ.max x y))
                  λ { (a , b) (c , d)
-                  → inj (ℤ.recompute≤ (
-                    subst2 ℤ._≤_ (sym (ℤ.·Assoc a (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ b)) ∙
+                  → subst2 ℤ._≤_ (sym (ℤ.·Assoc a (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ b)) ∙
                                    cong (a ℤ.·_) (sym (ℤ.pos·pos (ℕ₊₁→ℕ d) (ℕ₊₁→ℕ b)) ∙
                                                   cong ℕ₊₁→ℤ (·₊₁-comm d b)))
                                   (sym (ℤ.·DistPosLMax (a ℤ.· ℕ₊₁→ℤ d)
                                                        (c ℤ.· ℕ₊₁→ℤ b)
                                                        (ℕ₊₁→ℕ b)))
-                                  ℤ.≤max)) }
+                                  (ℤ.≤max {a ℤ.· ℕ₊₁→ℤ d ℤ.· ℕ₊₁→ℤ b}
+                                           {c ℤ.· ℕ₊₁→ℤ b ℤ.· ℕ₊₁→ℤ b}) }
 
 ≤→max : ∀ m n →  m ≤ n → ℚ.max m n ≡ n
 ≤→max m n
     = elimProp2 {P = λ a b → a ≤ b → ℚ.max a b ≡ b}
                 (λ x y → isProp→ (isSetℚ (ℚ.max x y) y))
-                (λ { (a , b) (c , d) (inj ad≤cb)
+                (λ { (a , b) (c , d) ad≤cb
                   → eq/ (ℤ.max (a ℤ.· ℕ₊₁→ℤ d)
                                (c ℤ.· ℕ₊₁→ℤ b)
                          , b ·₊₁ d)
@@ -606,14 +574,11 @@ min≤
 
 ≤Dec : ∀ m n → Dec (m ≤ n)
 ≤Dec = elimProp2 (λ x y → isPropDec (isProp≤ x y))
-       (λ (a , b) (c , d) → decRec (yes ∘ inj) (no ∘ _∘ _≤_.prf)
-        (ℤ.≤Dec (a ℤ.· ℕ₊₁→ℤ d) (c ℤ.· ℕ₊₁→ℤ b))  )
+       λ { (a , b) (c , d) → ℤ.≤Dec (a ℤ.· ℕ₊₁→ℤ d) (c ℤ.· ℕ₊₁→ℤ b) }
 
 <Dec : ∀ m n → Dec (m < n)
 <Dec = elimProp2 (λ x y → isPropDec (isProp< x y))
-       λ { (a , b) (c , d) → decRec (yes ∘ inj) (no ∘ _∘ _<_.prf)
-        (ℤ.<Dec (a ℤ.· ℕ₊₁→ℤ d) (c ℤ.· ℕ₊₁→ℤ b)) }
-
+       λ { (a , b) (c , d) → ℤ.<Dec (a ℤ.· ℕ₊₁→ℤ d) (c ℤ.· ℕ₊₁→ℤ b) }
 
 _≟_ : (m n : ℚ) → Trichotomy m n
 m ≟ n with discreteℚ m n
@@ -623,34 +588,33 @@ m ≟ n with discreteℚ m n
 ...             | inr n<m = gt n<m
 
 ≤MonotoneMin : ∀ m n o s → m ≤ n → o ≤ s → ℚ.min m o ≤ ℚ.min n s
-≤MonotoneMin m n o s m≤n o≤s = recompute≤ $
-  subst (_≤ ℚ.min n s)
-        (sym (ℚ.minAssoc n s (ℚ.min m o)) ∙
-         cong (ℚ.min n) (ℚ.minAssoc s m o ∙
-                         cong (λ a → ℚ.min a o) (ℚ.minComm s m) ∙
-                               sym (ℚ.minAssoc m s o)) ∙
-                         ℚ.minAssoc n m (ℚ.min s o) ∙
-         cong₂ ℚ.min (ℚ.minComm n m ∙ ≤→min m n m≤n)
-                     (ℚ.minComm s o ∙ ≤→min o s o≤s))
-         (min≤ (ℚ.min n s) (ℚ.min m o))
+≤MonotoneMin m n o s m≤n o≤s
+  = subst (_≤ ℚ.min n s)
+          (sym (ℚ.minAssoc n s (ℚ.min m o)) ∙
+           cong (ℚ.min n) (ℚ.minAssoc s m o ∙
+                           cong (λ a → ℚ.min a o) (ℚ.minComm s m) ∙
+                                 sym (ℚ.minAssoc m s o)) ∙
+                           ℚ.minAssoc n m (ℚ.min s o) ∙
+           cong₂ ℚ.min (ℚ.minComm n m ∙ ≤→min m n m≤n)
+                       (ℚ.minComm s o ∙ ≤→min o s o≤s))
+           (min≤ (ℚ.min n s) (ℚ.min m o))
 
 ≤MonotoneMax : ∀ m n o s → m ≤ n → o ≤ s → ℚ.max m o ≤ ℚ.max n s
-≤MonotoneMax m n o s m≤n o≤s = recompute≤ $
-  subst (ℚ.max m o ≤_)
-        (sym (ℚ.maxAssoc m o (ℚ.max n s)) ∙
-         cong (ℚ.max m) (ℚ.maxAssoc o n s ∙
-                         cong (λ a → ℚ.max a s) (ℚ.maxComm o n) ∙
-                               sym (ℚ.maxAssoc n o s)) ∙
-                         ℚ.maxAssoc m n (ℚ.max o s) ∙
-         cong₂ ℚ.max (≤→max m n m≤n) (≤→max o s o≤s))
-        (≤max (ℚ.max m o) (ℚ.max n s))
+≤MonotoneMax m n o s m≤n o≤s
+  = subst (ℚ.max m o ≤_)
+          (sym (ℚ.maxAssoc m o (ℚ.max n s)) ∙
+           cong (ℚ.max m) (ℚ.maxAssoc o n s ∙
+                           cong (λ a → ℚ.max a s) (ℚ.maxComm o n) ∙
+                                 sym (ℚ.maxAssoc n o s)) ∙
+                           ℚ.maxAssoc m n (ℚ.max o s) ∙
+           cong₂ ℚ.max (≤→max m n m≤n) (≤→max o s o≤s))
+          (≤max (ℚ.max m o) (ℚ.max n s))
 
 ≡Weaken≤ : ∀ m n → m ≡ n → m ≤ n
-≡Weaken≤ m n m≡n = recompute≤ $ subst (m ≤_) m≡n (isRefl≤ m)
+≡Weaken≤ m n m≡n = subst (m ≤_) m≡n (isRefl≤ m)
 
 ≤→≯ : ∀ m n →  m ≤ n → ¬ (m > n)
-≤→≯ m n m≤n = recompute¬< $
-  λ n<m → isIrrefl< n (subst (n <_) (isAntisym≤ m n m≤n (<Weaken≤ n m n<m)) n<m)
+≤→≯ m n m≤n n<m = isIrrefl< n (subst (n <_) (isAntisym≤ m n m≤n (<Weaken≤ n m n<m)) n<m)
 
 ≮→≥ : ∀ m n → ¬ (m < n) → m ≥ n
 ≮→≥ m n m≮n with discreteℚ m n
@@ -664,6 +628,3 @@ m ≟ n with discreteℚ m n
 ... | no 0≮m | no 0≮n = ⊥.rec (≤→≯ (m ℚ.+ n) 0 (≤Monotone+ m 0 n 0 (≮→≥ 0 m 0≮m) (≮→≥ 0 n 0≮n)) 0<m+n)
 ... | no _    | yes 0<n = inr 0<n
 ... | yes 0<m | _ = inl 0<m
-
-<ℤ→<ℚ : ∀ m n k → m ℤ.< n → [ m / k ] < [ n / k ]
-<ℤ→<ℚ m n (1+ k) m<n = inj (ℤ.<-·o {m} m<n)
diff --git a/Cubical/Data/Rationals/Properties.agda b/Cubical/Data/Rationals/Properties.agda
index 4f32d7e383..d12f6bcaf1 100644
--- a/Cubical/Data/Rationals/Properties.agda
+++ b/Cubical/Data/Rationals/Properties.agda
@@ -1,42 +1,23 @@
 module Cubical.Data.Rationals.Properties where
 
 open import Cubical.Foundations.Prelude
-open import Cubical.Foundations.Function
 open import Cubical.Foundations.Isomorphism
 open import Cubical.Foundations.Equiv
 open import Cubical.Foundations.GroupoidLaws hiding (_⁻¹)
 open import Cubical.Foundations.Univalence
-open import Cubical.Foundations.HLevels
 
-open import Cubical.Data.Empty as ⊥
-
-open import Cubical.Data.Fast.Int as ℤ using (ℤ; pos·pos; pos0+; pos; negsuc) renaming
-  (_+_ to _+ℤ_ ; _·_ to _·ℤ_ ; -_ to -ℤ_ ; abs to ∣_∣ℤ ; sign to sgn)
+open import Cubical.Data.Int as ℤ using (ℤ; pos·pos; pos0+)
+open import Cubical.HITs.SetQuotients as SetQuotient using () renaming (_/_ to _//_)
 
-open import Cubical.Data.Nat as ℕ using (ℕ; zero; suc) renaming
-  (_+_ to _+ℕ_ ; _·_ to _·ℕ_)
-open import Cubical.Data.Nat.GCD
-open import Cubical.Data.Nat.Coprime
+open import Cubical.Data.Nat as ℕ using (ℕ; zero; suc)
 open import Cubical.Data.NatPlusOne
 open import Cubical.Data.Sigma
-open import Cubical.Data.Sum
-
-open import Cubical.HITs.SetQuotients as SetQuotient using () renaming (_/_ to _//_)
 
+open import Cubical.Data.Sum
 open import Cubical.Relation.Nullary
 
 open import Cubical.Data.Rationals.Base
 
-∼→sign≡sign : ∀ a a' b b' → (a , b) ∼ (a' , b') → ℤ.sign a ≡ ℤ.sign a'
-∼→sign≡sign (ℤ.pos zero)    (ℤ.pos zero)    (1+ _) (1+ _) = λ _ → refl
-∼→sign≡sign (ℤ.pos zero)    (ℤ.pos (suc n)) (1+ _) (1+ _) = ⊥.rec ∘ ℕ.znots ∘ ℤ.injPos
-∼→sign≡sign (ℤ.pos (suc m)) (ℤ.pos zero)    (1+ _) (1+ _) = ⊥.rec ∘ ℕ.snotz ∘ ℤ.injPos
-∼→sign≡sign (ℤ.pos (suc m)) (ℤ.pos (suc n)) (1+ _) (1+ _) = λ _ → refl
-∼→sign≡sign (ℤ.pos m)       (ℤ.negsuc n)    (1+ _) (1+ _) = ⊥.rec ∘ ℤ.posNotnegsuc _ _
-∼→sign≡sign (ℤ.negsuc m)    (ℤ.pos n)       (1+ _) (1+ _) = ⊥.rec ∘ ℤ.negsucNotpos _ _
-∼→sign≡sign (ℤ.negsuc m)    (ℤ.negsuc n)    (1+ _) (1+ _) = λ _ → refl
-
-
 ·CancelL : ∀ {a b} (c : ℕ₊₁) → [ ℕ₊₁→ℤ c ℤ.· a / c ·₊₁ b ] ≡ [ a / b ]
 ·CancelL {a} {b} c = eq/ _ _
   ((ℕ₊₁→ℤ c ℤ.· a)   ℤ.· ℕ₊₁→ℤ b  ≡⟨ cong (ℤ._· ℕ₊₁→ℤ b) (ℤ.·Comm (ℕ₊₁→ℤ c) a) ⟩
@@ -51,88 +32,6 @@ open import Cubical.Data.Rationals.Base
    a ℤ.· (ℕ₊₁→ℤ b ℤ.· ℕ₊₁→ℤ c)  ≡⟨ cong (a ℤ.·_) (sym (pos·pos (ℕ₊₁→ℕ b) (ℕ₊₁→ℕ c))) ⟩
    a ℤ.· ℕ₊₁→ℤ (b ·₊₁ c) ∎)
 
-module Reduce where
-  private
-    ℕ[_] = ℕ₊₁→ℕ
-    ℤ[_] = ℕ₊₁→ℤ
-    +[_] = ℤ.pos
-
-    Cod : ∀ x → Type
-    Cod x = Σ[ (p , q) ∈ (ℤ × ℕ₊₁) ] areCoprime (ℤ.abs p , ℕ₊₁→ℕ q) × ([ p / q ] ≡ x)
-    isSetValuedCod : ∀ x → isSet (Cod x)
-    isSetValuedCod x = isSetΣSndProp
-      (isSet× ℤ.isSetℤ (subst isSet 1+Path ℕ.isSetℕ))
-      λ _ → isProp× isPropIsGCD (isSetℚ _ _)
-
-    lemma-cop : ∀ {d-1} a c₁ → (c₁ ·ℕ suc d-1 ≡ ∣ a ∣ℤ) → c₁ ≡ ∣ sgn a ·ℤ +[ c₁ ] ∣ℤ
-    lemma-cop (pos zero)    zero     _ = refl
-    lemma-cop (pos zero)    (suc _)  x = ⊥.rec (ℕ.snotz x)
-    lemma-cop (pos (suc n)) c₁       _ = sym $ ℕ.+-zero c₁
-    lemma-cop (negsuc n)    zero     _ = refl
-    lemma-cop (negsuc n)    (suc c₁) _ = cong suc $ sym $ ℕ.+-zero c₁
-
-  module cop ((a , b) : ℤ × ℕ₊₁) where
-    open ToCoprime (∣ a ∣ℤ , b) renaming (toCoprimeAreCoprime to tcac) public
-
-    reduced[] : Cod [ a / b ]
-    reduced[] .fst      = sgn a ·ℤ pos c₁ , c₂
-    reduced[] .snd .fst = subst (areCoprime ∘ (_, ℕ[ c₂ ]))
-                                (lemma-cop a _ (cong (c₁ ·ℕ_) (sym q) ∙ p₁))
-                                tcac
-    reduced[] .snd .snd = eq/ _ _ $
-      sgn a ·ℤ   +[ c₁ ] ·ℤ ℤ[ b ]         ≡⟨ sym $ ℤ.·Assoc (sgn a) _ _ ⟩
-      sgn a ·ℤ ( +[ c₁ ] ·ℤ ℤ[ b ])        ≡⟨⟩
-      sgn a ·ℤ ( +[ c₁ ·ℕ ℕ[ b ] ])        ≡⟨ cong ((sgn a ·ℤ_) ∘ +[_]) $
-                    c₁ ·ℕ ℕ[ b ]           ≡⟨ sym $ cong (c₁ ·ℕ_) p₂ ⟩
-                    c₁ ·ℕ (ℕ[ c₂ ] ·ℕ d)   ≡⟨ cong (c₁ ·ℕ_) (ℕ.·-comm ℕ[ c₂ ] d) ⟩
-                    c₁ ·ℕ (d ·ℕ ℕ[ c₂ ])   ≡⟨ ℕ.·-assoc c₁ d ℕ[ c₂ ] ⟩
-                    c₁ ·ℕ  d ·ℕ ℕ[ c₂ ]    ≡⟨ cong (_·ℕ ℕ[ c₂ ]) p₁ ⟩ refl ⟩
-      sgn a ·ℤ ( +[    ∣ a ∣ℤ ·ℕ ℕ[ c₂ ] ]) ≡⟨⟩
-      sgn a ·ℤ ( +[  ∣ a ∣ℤ ] ·ℤ ℤ[ c₂ ] )  ≡⟨ ℤ.·Assoc (sgn a) _ _ ⟩
-      sgn a ·ℤ   +[  ∣ a ∣ℤ ] ·ℤ ℤ[ c₂ ]    ≡⟨ cong (_·ℤ ℤ[ c₂ ]) (ℤ.sign·abs a) ⟩
-                           a ·ℤ ℤ[ c₂ ]    ∎
-
-  reduced[]∼ : ∀ x y r → PathP (λ i → Cod (eq/ x y r i)) (cop.reduced[] x) (cop.reduced[] y)
-  reduced[]∼ x@(a , b) y@(a' , b') r = let
-    ∣x∣ = (∣ a  ∣ℤ , b)
-    ∣y∣ = (∣ a' ∣ℤ , b')
-
-    tc∣x∣≡tc∣y∣ =
-      tc ∣x∣                             ≡⟨⟩
-      tc (∣ a ∣ℤ , b)                    ≡⟨ sym $ tc-cancelʳ ∣x∣ b' ⟩
-      tc (∣ a ∣ℤ ·ℕ ℕ[ b' ] , b ·₊₁ b') ≡⟨ cong (tc ∘ (_, b ·₊₁ b')) $
-          ∣ a ∣ℤ ·ℕ ℕ[ b' ]             ≡⟨ sym $ ℤ.abs· a ℤ[ b' ] ⟩
-          ∣ a  ·ℤ ℤ[ b' ] ∣ℤ             ≡⟨ cong ∣_∣ℤ r ⟩
-          ∣ a' ·ℤ ℤ[ b  ] ∣ℤ             ≡⟨ ℤ.abs· a' ℤ[ b ] ⟩ refl ⟩
-      tc (∣ a' ∣ℤ ·ℕ ℕ[ b ] , b ·₊₁ b') ≡⟨ cong (tc ∘ (∣ a' ∣ℤ ·ℕ ℕ[ b ] ,_)) $ ·₊₁-comm b b' ⟩
-      tc (∣ a' ∣ℤ ·ℕ ℕ[ b ] , b' ·₊₁ b) ≡⟨ tc-cancelʳ ∣y∣ b ⟩
-      tc (∣ a' ∣ℤ , b')                  ≡⟨⟩
-      tc ∣y∣                             ∎
-
-    step0 = cong (uncurry (_,_ ∘ (sgn a ·ℤ_) ∘ pos)) tc∣x∣≡tc∣y∣
-    step1 = cong ((_, c₂ ∣y∣) ∘ (_·ℤ pos (c₁ ∣y∣))) (∼→sign≡sign a a' b b' r)
-    in
-      ΣPathPProp (λ _ → isProp× isPropIsGCD (isSetℚ _ _)) $
-        sgn a  ·ℤ pos (c₁ ∣x∣) , c₂ ∣x∣ ≡⟨ step0 ⟩
-        sgn a  ·ℤ pos (c₁ ∣y∣) , c₂ ∣y∣ ≡⟨ step1 ⟩
-        sgn a' ·ℤ pos (c₁ ∣y∣) , c₂ ∣y∣ ∎
-    where
-      open ToCoprime renaming (toCoprime to tc) ; tc-cancelʳ = toCoprime-cancelʳ
-
-  reduced : ∀ x → Cod x
-  reduced = SetQuotient.elim isSetValuedCod cop.reduced[] reduced[]∼
-
-open Reduce public
-
-reduceFrac : ℚ → ℤ × ℕ₊₁
-reduceFrac = fst ∘ reduced
-
-reduce : ℚ → ℚ
-reduce = [_] ∘ fst ∘ reduced
-
-reduce≡id : ∀ x → reduce x ≡ x
-reduce≡id = snd ∘ snd ∘ reduced
-
 -- useful functions for defining operations on ℚ
 
 onCommonDenom :
@@ -586,4 +485,14 @@ x - y = x + (- y)
 +CancelR x y z p = +CancelL y x z (+Comm y x ∙ p ∙ +Comm z y)
 
 numerator0→0 : (u : ℤ × ℕ₊₁) → u .fst ≡ 0 → [ u ] ≡ 0
-numerator0→0 (a , b) p = eq/ (a , b) (0 , 1) (ℤ.·IdR _ ∙ p)
+numerator0→0 (a , b) p = eq/ ((a , b)) ((0 , 1)) q
+  where
+  q : a ℤ.· (ℕ₊₁→ℤ 1) ≡ 0 ℤ.· (ℕ₊₁→ℤ b)
+  q =
+    a ℤ.· (ℕ₊₁→ℤ 1)
+      ≡⟨ ℤ.·IdR a ⟩
+    a
+      ≡⟨ p ⟩
+    0
+      ≡⟨ sym (ℤ.·AnnihilL (ℕ₊₁→ℤ b)) ⟩
+    0 ℤ.· (ℕ₊₁→ℤ b) ∎
diff --git a/Cubical/Relation/Binary/Order/Loset/Instances/Rationals.agda b/Cubical/Relation/Binary/Order/Loset/Instances/Rationals.agda
deleted file mode 100644
index 86a2cbc8ac..0000000000
--- a/Cubical/Relation/Binary/Order/Loset/Instances/Rationals.agda
+++ /dev/null
@@ -1,31 +0,0 @@
-module Cubical.Relation.Binary.Order.Loset.Instances.Rationals where
-
-open import Cubical.Foundations.Prelude
-
-open import Cubical.Data.Sum
-open import Cubical.HITs.PropositionalTruncation
-
-open import Cubical.Data.Empty as ⊥
-
-open import Cubical.Data.Rationals
-open import Cubical.Data.Rationals.Order renaming (_<_ to _<ℚ_)
-
-open import Cubical.Relation.Binary.Order.Loset
-
-open LosetStr
-
-ℚ<Loset : Loset ℓ-zero ℓ-zero
-fst ℚ<Loset = ℚ
-_<_ (snd ℚ<Loset) = _<ℚ_
-isLoset (snd ℚ<Loset) = isLosetℚ<
-  where
-    open IsLoset
-    abstract
-      isLosetℚ< : IsLoset _<ℚ_
-      isLosetℚ< .is-set           = isSetℚ
-      isLosetℚ< .is-prop-valued   = isProp<
-      isLosetℚ< .is-irrefl        = isIrrefl<
-      isLosetℚ< .is-trans         = isTrans<
-      isLosetℚ< .is-asym          = isAsym<
-      isLosetℚ< .is-weakly-linear = isWeaklyLinear<
-      isLosetℚ< .is-connected     = isConnected<
diff --git a/Cubical/Relation/Binary/Order/Poset/Instances/Rationals.agda b/Cubical/Relation/Binary/Order/Poset/Instances/Rationals.agda
deleted file mode 100644
index 26db946ef3..0000000000
--- a/Cubical/Relation/Binary/Order/Poset/Instances/Rationals.agda
+++ /dev/null
@@ -1,11 +0,0 @@
-module Cubical.Relation.Binary.Order.Poset.Instances.Rationals where
-
-open import Cubical.Foundations.Prelude
-
-open import Cubical.Relation.Binary.Order.Poset
-open import Cubical.Relation.Binary.Order.Toset
-
-open import Cubical.Relation.Binary.Order.Toset.Instances.Rationals
-
-ℚ≤Poset : Poset ℓ-zero ℓ-zero
-ℚ≤Poset = Toset→Poset ℚ≤Toset
diff --git a/Cubical/Relation/Binary/Order/Proset/Instances/Rationals.agda b/Cubical/Relation/Binary/Order/Proset/Instances/Rationals.agda
deleted file mode 100644
index aa89d5a7ff..0000000000
--- a/Cubical/Relation/Binary/Order/Proset/Instances/Rationals.agda
+++ /dev/null
@@ -1,11 +0,0 @@
-module Cubical.Relation.Binary.Order.Proset.Instances.Rationals where
-
-open import Cubical.Foundations.Prelude
-
-open import Cubical.Relation.Binary.Order.Poset
-open import Cubical.Relation.Binary.Order.Proset
-
-open import Cubical.Relation.Binary.Order.Poset.Instances.Rationals
-
-ℚ≤Proset : Proset ℓ-zero ℓ-zero
-ℚ≤Proset = Poset→Proset ℚ≤Poset
diff --git a/Cubical/Relation/Binary/Order/Pseudolattice/Instances/Rationals.agda b/Cubical/Relation/Binary/Order/Pseudolattice/Instances/Rationals.agda
deleted file mode 100644
index 25b3765ef7..0000000000
--- a/Cubical/Relation/Binary/Order/Pseudolattice/Instances/Rationals.agda
+++ /dev/null
@@ -1,19 +0,0 @@
-module Cubical.Relation.Binary.Order.Pseudolattice.Instances.Rationals where
-
-open import Cubical.Foundations.Prelude
-open import Cubical.Foundations.Function
-
-open import Cubical.Data.Rationals
-open import Cubical.Data.Rationals.Order renaming (_≤_ to _≤ℚ_)
-
-open import Cubical.Relation.Binary.Order.Poset.Instances.Rationals
-open import Cubical.Relation.Binary.Order.Pseudolattice
-
-ℚ≤Pseudolattice : Pseudolattice ℓ-zero ℓ-zero
-ℚ≤Pseudolattice = makePseudolatticeFromPoset ℚ≤Poset min max
-  (λ {a b}   → min≤ a b)
-  (λ {a b}   → recompute≤ (subst (_≤ℚ b) (minComm b a) (min≤ b a)))
-  (λ {a b x} → ((recompute≤ ∘ subst (_≤ℚ min a b) (minIdem x)) ∘_) ∘ ≤MonotoneMin x a x b)
-  (λ {x} {y} → ≤max x y)
-  (λ {a b}   → recompute≤ (subst (b ≤ℚ_) (maxComm b a) (≤max b a)))
-  (λ {a b x} → ((recompute≤ ∘ subst (max a b ≤ℚ_) (maxIdem x)) ∘_) ∘ ≤MonotoneMax a x b x)
diff --git a/Cubical/Relation/Binary/Order/Quoset/Instances/Rationals.agda b/Cubical/Relation/Binary/Order/Quoset/Instances/Rationals.agda
deleted file mode 100644
index fbc311e060..0000000000
--- a/Cubical/Relation/Binary/Order/Quoset/Instances/Rationals.agda
+++ /dev/null
@@ -1,11 +0,0 @@
-module Cubical.Relation.Binary.Order.Quoset.Instances.Rationals where
-
-open import Cubical.Foundations.Prelude
-
-open import Cubical.Relation.Binary.Order.Quoset
-open import Cubical.Relation.Binary.Order.StrictOrder
-
-open import Cubical.Relation.Binary.Order.StrictOrder.Instances.Rationals
-
-ℚ<Quoset : Quoset ℓ-zero ℓ-zero
-ℚ<Quoset = StrictOrder→Quoset ℚ<StrictOrder
diff --git a/Cubical/Relation/Binary/Order/StrictOrder/Instances/Rationals.agda b/Cubical/Relation/Binary/Order/StrictOrder/Instances/Rationals.agda
deleted file mode 100644
index a0af1e2169..0000000000
--- a/Cubical/Relation/Binary/Order/StrictOrder/Instances/Rationals.agda
+++ /dev/null
@@ -1,11 +0,0 @@
-module Cubical.Relation.Binary.Order.StrictOrder.Instances.Rationals where
-
-open import Cubical.Foundations.Prelude
-
-open import Cubical.Relation.Binary.Order.StrictOrder
-open import Cubical.Relation.Binary.Order.Loset
-
-open import Cubical.Relation.Binary.Order.Loset.Instances.Rationals
-
-ℚ<StrictOrder : StrictOrder ℓ-zero ℓ-zero
-ℚ<StrictOrder = Loset→StrictOrder ℚ<Loset
diff --git a/Cubical/Relation/Binary/Order/Toset/Instances/Rationals.agda b/Cubical/Relation/Binary/Order/Toset/Instances/Rationals.agda
deleted file mode 100644
index d209a0c0ec..0000000000
--- a/Cubical/Relation/Binary/Order/Toset/Instances/Rationals.agda
+++ /dev/null
@@ -1,31 +0,0 @@
-module Cubical.Relation.Binary.Order.Toset.Instances.Rationals where
-
-open import Cubical.Foundations.Prelude
-
-open import Cubical.Data.Sum
-open import Cubical.HITs.PropositionalTruncation
-
-open import Cubical.Data.Rationals
-open import Cubical.Data.Rationals.Order renaming (_≤_ to _≤ℚ_)
-
-open import Cubical.Relation.Binary.Order.Toset
-
-open import Cubical.Relation.Binary
-open BinaryRelation
-
-open TosetStr
-
-ℚ≤Toset : Toset ℓ-zero ℓ-zero
-fst ℚ≤Toset = ℚ
-_≤_ (snd ℚ≤Toset) = _≤ℚ_
-isToset (snd ℚ≤Toset) = isTosetℚ≤
-  where
-    open IsToset
-    abstract
-      isTosetℚ≤ : IsToset _≤ℚ_
-      isTosetℚ≤ .is-set         = isSetℚ
-      isTosetℚ≤ .is-prop-valued = isProp≤
-      isTosetℚ≤ .is-refl        = isRefl≤
-      isTosetℚ≤ .is-trans       = isTrans≤
-      isTosetℚ≤ .is-antisym     = isAntisym≤
-      isTosetℚ≤ .is-total       = isTotal≤
diff --git a/Cubical/Relation/Premetric.agda b/Cubical/Relation/Premetric.agda
deleted file mode 100644
index 845c6bc839..0000000000
--- a/Cubical/Relation/Premetric.agda
+++ /dev/null
@@ -1,3 +0,0 @@
-module Cubical.Relation.Premetric where
-
-open import Cubical.Relation.Premetric.Base public
diff --git a/Cubical/Relation/Premetric/Base.agda b/Cubical/Relation/Premetric/Base.agda
deleted file mode 100644
index bd31c2b346..0000000000
--- a/Cubical/Relation/Premetric/Base.agda
+++ /dev/null
@@ -1,73 +0,0 @@
-module Cubical.Relation.Premetric.Base where
-
-open import Cubical.Foundations.Prelude
-open import Cubical.Foundations.Function
-open import Cubical.Foundations.HLevels
-open import Cubical.Foundations.Equiv
-open import Cubical.Foundations.SIP
-
-open import Cubical.Algebra.OrderedCommRing
-open import Cubical.Algebra.OrderedCommRing.Instances.Rationals
-
-open import Cubical.Data.Empty as ⊥
-open import Cubical.Data.Rationals.Order as ℚ
-open import Cubical.Data.Sigma
-
-open import Cubical.HITs.PropositionalTruncation as PT
-
-open import Cubical.Reflection.RecordEquiv
-
-open OrderedCommRingTheory ℚOrderedCommRing
-open PositiveRationals
-
-private
-  variable
-    ℓ ℓ' ℓ'' : Level
-
-record IsPremetric {M : Type ℓ} (_≈[_]_ : M → ℚ₊ → M → Type ℓ') : Type (ℓ-max ℓ ℓ') where
-
-  constructor ispremetric
-
-  field
-    isSetM        : isSet M
-    isProp≈       : ∀ x y ε → isProp (x ≈[ ε ] y)
-    isRefl≈       : ∀ x     ε   → x ≈[ ε ] x
-    isSym≈        : ∀ x y   ε   → x ≈[ ε ] y → y ≈[ ε ] x
-    isSeparated≈  : ∀ x y       → (∀ ε → x ≈[ ε ] y) → x ≡ y
-    isTriangular≈ : ∀ x y z ε δ → x ≈[ ε ] y → y ≈[ δ ] z → x ≈[ ε +₊ δ ] z
-    isRounded≈    : ∀ x y   ε   → x ≈[ ε ] y → ∃[ δ ∈ ℚ₊ ] (δ <₊ ε) × (x ≈[ δ ] y)
-
-unquoteDecl IsPremetricIsoΣ = declareRecordIsoΣ IsPremetricIsoΣ (quote IsPremetric)
-
-
-record PremetricStr (ℓ' : Level) (M : Type ℓ) : Type (ℓ-suc (ℓ-max ℓ ℓ')) where
-
-  constructor premetricstr
-
-  field
-    _≈[_]_      : M → ℚ₊ → M → Type ℓ'
-    isPremetric : IsPremetric _≈[_]_
-
-  open IsPremetric isPremetric public
-
-PremetricSpace : (ℓ ℓ' : Level) → Type (ℓ-suc (ℓ-max ℓ ℓ'))
-PremetricSpace ℓ ℓ' = TypeWithStr ℓ (PremetricStr ℓ')
-
-premetricspace : (M : Type ℓ)
-                  → (_≈[_]_ : M → ℚ₊ → M → Type ℓ')
-                  → IsPremetric _≈[_]_
-                  → PremetricSpace ℓ ℓ'
-premetricspace M (_≈[_]_) pm = M , (premetricstr _≈[_]_ pm)
-
-isPropIsPremetric : {M : Type ℓ} → (_≈[_]_ : M → ℚ₊ → M → Type ℓ')
-                  → isProp (IsPremetric _≈[_]_)
-isPropIsPremetric _≈[_]_ = isOfHLevelRetractFromIso 1
-  IsPremetricIsoΣ $
-  isPropΣ isPropIsSet λ isSetM →
-  isPropΣ (isPropΠ3 λ _ _ _ → isPropIsProp) λ isProp≈ →
-  isProp×4
-    (isPropΠ2 λ _ _ → isProp≈ _ _ _)
-    (isPropΠ4 λ _ _ _ _ → isProp≈ _ _ _)
-    (isPropΠ3 λ _ _ _ → isSetM _ _)
-    (isPropΠ6 λ _ _ _ _ _ _ → isPropΠ λ _ → isProp≈ _ _ _)
-    (isPropΠ4 λ _ _ _ _ → squash₁)

From 5b57ff48a6caa3dcd6d50b2003865bdf598938fc Mon Sep 17 00:00:00 2001
From: Lorenzo Molena <lorenzo.molena8@gmail.com>
Date: Tue, 21 Apr 2026 22:05:00 +0200
Subject: [PATCH 19/19] add missing `Is` into the name of an helper function

---
 Cubical/Algebra/OrderedCommRing/Morphisms.agda | 18 +++++++++---------
 .../Algebra/OrderedCommRing/Univalence.agda    |  2 +-
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/Cubical/Algebra/OrderedCommRing/Morphisms.agda b/Cubical/Algebra/OrderedCommRing/Morphisms.agda
index ecc2fcfd3e..09bb5c8684 100644
--- a/Cubical/Algebra/OrderedCommRing/Morphisms.agda
+++ b/Cubical/Algebra/OrderedCommRing/Morphisms.agda
@@ -346,16 +346,16 @@ module _ {R : OrderedCommRing ℓ ℓ<≤} {S : OrderedCommRing ℓ' ℓ<≤'} (
 
     open IsOrderedCommRingEquiv
 
-    makeIsOrderedCommRingEquivFromMono : IsOrderedCommRingEquiv (str R) e (str S)
-    makeIsOrderedCommRingEquivFromMono .pres0 = M.pres0
-    makeIsOrderedCommRingEquivFromMono .pres1 = M.pres1
-    makeIsOrderedCommRingEquivFromMono .pres+ = M.pres+
-    makeIsOrderedCommRingEquivFromMono .pres· = M.pres·
-    makeIsOrderedCommRingEquivFromMono .pres- = M.pres-
-    makeIsOrderedCommRingEquivFromMono .pres≤ = λ x y → propBiimpl→Equiv
+    makeIsOrderedCommRingEquivFromIsMono : IsOrderedCommRingEquiv (str R) e (str S)
+    makeIsOrderedCommRingEquivFromIsMono .pres0 = M.pres0
+    makeIsOrderedCommRingEquivFromIsMono .pres1 = M.pres1
+    makeIsOrderedCommRingEquivFromIsMono .pres+ = M.pres+
+    makeIsOrderedCommRingEquivFromIsMono .pres· = M.pres·
+    makeIsOrderedCommRingEquivFromIsMono .pres- = M.pres-
+    makeIsOrderedCommRingEquivFromIsMono .pres≤ = λ x y → propBiimpl→Equiv
       (R.is-prop-valued≤ _ _) (S.is-prop-valued≤ _ _)
       (M.pres≤ x y) (isOrderedCommRingMono→reflect≤ isMono x y)
-    makeIsOrderedCommRingEquivFromMono .pres< = λ x y → propBiimpl→Equiv
+    makeIsOrderedCommRingEquivFromIsMono .pres< = λ x y → propBiimpl→Equiv
       (R.is-prop-valued< _ _) (S.is-prop-valued< _ _)
       (M.pres< x y) (M.reflect< x y)
 
@@ -368,5 +368,5 @@ module _ {R : OrderedCommRing ℓ ℓ<≤} {S : OrderedCommRing ℓ' ℓ<≤'} (
     where
 
     makeIsOrderedCommRingEquiv : IsOrderedCommRingEquiv (str R) e (str S)
-    makeIsOrderedCommRingEquiv = makeIsOrderedCommRingEquivFromMono
+    makeIsOrderedCommRingEquiv = makeIsOrderedCommRingEquivFromIsMono
       (makeIsOrderedCommRingMono p1 p+ p· p< p<⁻)
diff --git a/Cubical/Algebra/OrderedCommRing/Univalence.agda b/Cubical/Algebra/OrderedCommRing/Univalence.agda
index ee613ccd6c..a34fe37db5 100644
--- a/Cubical/Algebra/OrderedCommRing/Univalence.agda
+++ b/Cubical/Algebra/OrderedCommRing/Univalence.agda
@@ -64,7 +64,7 @@ OrderedCommRingEquivIsoOrderedCommRingIso R S = OCREquivIsoOCRIso
     fst (fun OCREquivIsoOCRIso e) = equivToIso (fst e)
     snd (fun OCREquivIsoOCRIso e) = snd (OrderedCommRingEquiv→OrderedCommRingMono e)
     fst (inv OCREquivIsoOCRIso e) = isoToEquiv (fst e)
-    snd (inv OCREquivIsoOCRIso e) = makeIsOrderedCommRingEquivFromMono (isoToEquiv (fst e)) (snd e)
+    snd (inv OCREquivIsoOCRIso e) = makeIsOrderedCommRingEquivFromIsMono (isoToEquiv (fst e)) (snd e)
     sec OCREquivIsoOCRIso e =
       Σ≡Prop (λ f → isPropIsOrderedCommRingMono _ (fun f) _) (
       Iso≡Set (OrderedCommRingStr.is-set (snd R)) (OrderedCommRingStr.is-set (snd S))