diff --git a/Cubical/Data/Fin/Properties.agda b/Cubical/Data/Fin/Properties.agda
index dda477bf43..87ea9a5cd5 100644
--- a/Cubical/Data/Fin/Properties.agda
+++ b/Cubical/Data/Fin/Properties.agda
@@ -16,7 +16,7 @@ open import Cubical.HITs.PropositionalTruncation renaming (rec to ∥∥rec)
 
 open import Cubical.Data.Fin.Base as Fin
 open import Cubical.Data.Nat
-open import Cubical.Data.Nat.Order
+open import Cubical.Data.Nat.Order hiding (<-·sk-cancel)
 open import Cubical.Data.Empty as Empty
 open import Cubical.Data.Unit
 open import Cubical.Data.Sum
diff --git a/Cubical/Data/Int/Order.agda b/Cubical/Data/Int/Order.agda
index fac79698da..e728308348 100644
--- a/Cubical/Data/Int/Order.agda
+++ b/Cubical/Data/Int/Order.agda
@@ -9,6 +9,7 @@ open import Cubical.Data.Empty as ⊥ using (⊥)
 open import Cubical.Data.Int.Base as ℤ
 open import Cubical.Data.Int.Properties as ℤ
 open import Cubical.Data.Nat as ℕ
+import Cubical.Data.Nat.Order as ℕ
 open import Cubical.Data.NatPlusOne.Base as ℕ₊₁
 open import Cubical.Data.Sigma
 
@@ -498,3 +499,45 @@ negsuc zero ≟ negsuc zero = eq refl
 negsuc zero ≟ negsuc (suc n) = gt (negsuc-≤-negsuc zero-≤pos)
 negsuc (suc m) ≟ negsuc zero = lt (negsuc-≤-negsuc zero-≤pos)
 negsuc (suc m) ≟ negsuc (suc n) = Trichotomy-pred (negsuc m ≟ negsuc n)
+
+0<_ : ℤ → Type
+0< pos zero = ⊥
+0< pos (suc n) = Unit
+0< negsuc n = ⊥
+
+isProp0< : ∀ n → isProp (0< n)
+isProp0< (pos (suc _)) _ _ = refl
+
+·0< : ∀ m n → 0< m → 0< n → 0< (m ℤ.· n)
+·0< (pos (suc m)) (pos (suc n)) _ _ =
+ subst (0<_) (pos+ (suc n) (m ℕ.· (suc n)) ∙ cong (pos (suc n) ℤ.+_) (pos·pos m (suc n))) _
+
+0<·ℕ₊₁ : ∀ m n → 0< (m ℤ.· pos (ℕ₊₁→ℕ n)) → 0< m
+0<·ℕ₊₁ (pos (suc m)) n x = _
+0<·ℕ₊₁ (negsuc n₁) (1+ n) x =
+  ⊥.rec (subst 0<_ (negsuc·pos n₁ (suc n)
+   ∙ congS -_ (cong (pos (suc n) ℤ.+_)
+     (sym (pos·pos n₁ (suc n))) ∙
+        sym (pos+ (suc n) (n₁ ℕ.· suc n)))) x)
+
++0< : ∀ m n → 0< m → 0< n → 0< (m ℤ.+ n)
++0< (pos (suc m)) (pos (suc n)) _ _ =
+ subst (0<_) (cong sucℤ (pos+ (suc m) n)) _
+
+0<→ℕ₊₁ : ∀ n → 0< n → Σ ℕ₊₁ λ m → n ≡ pos (ℕ₊₁→ℕ m)
+0<→ℕ₊₁ (pos (suc n)) x = (1+ n) , refl
+
+min-0< : ∀ m n → 0< m → 0< n → 0< (ℤ.min m n)
+min-0< (pos (suc zero)) (pos (suc n)) x x₁ = tt
+min-0< (pos (suc (suc n₁))) (pos (suc zero)) x x₁ = tt
+min-0< (pos (suc (suc n₁))) (pos (suc (suc n))) x x₁ =
+  +0< (sucℤ (ℤ.min (pos n₁) (pos n))) 1 (min-0< (pos (suc n₁)) (pos (suc n)) _ _) _
+
+ℕ≤→pos-≤-pos : ∀ m n → m ℕ.≤ n → pos m ≤ pos n
+ℕ≤→pos-≤-pos m n (k , p) = k , sym (pos+ m k) ∙∙ cong pos (ℕ.+-comm m k) ∙∙ cong pos p
+
+
+0≤x² : ∀ n → 0 ≤ n ℤ.· n
+0≤x² (pos n) = subst (0 ≤_) (pos·pos n n) zero-≤pos
+0≤x² (negsuc n) = subst (0 ≤_) (pos·pos (suc n) (suc n)
+  ∙ sym (negsuc·negsuc n n)) zero-≤pos
diff --git a/Cubical/Data/Int/Properties.agda b/Cubical/Data/Int/Properties.agda
index 1fc854cafa..088182ed42 100644
--- a/Cubical/Data/Int/Properties.agda
+++ b/Cubical/Data/Int/Properties.agda
@@ -11,7 +11,7 @@ open import Cubical.Relation.Nullary
 
 open import Cubical.Data.Empty as ⊥
 open import Cubical.Data.Bool
-open import Cubical.Data.Nat
+open import Cubical.Data.Nat as ℕ
   hiding   (+-assoc ; +-comm ; min ; max ; minComm ; maxComm)
   renaming (_·_ to _·ℕ_; _+_ to _+ℕ_ ; ·-assoc to ·ℕ-assoc ;
             ·-comm to ·ℕ-comm ; isEven to isEvenℕ ; isOdd to isOddℕ)
@@ -1505,3 +1505,24 @@ sumFinℤ0 n = sumFinGen0 _+_ 0 (λ _ → refl) n (λ _ → 0) λ _ → refl
 sumFinℤHom : {n : ℕ} (f g : Fin n → ℤ)
   → sumFinℤ {n = n} (λ x → f x + g x) ≡ sumFinℤ {n = n} f + sumFinℤ {n = n} g
 sumFinℤHom {n = n} = sumFinGenHom _+_ 0 (λ _ → refl) +Comm +Assoc n
+
+abs-max : ∀ n → pos (abs n) ≡ max n (- n)
+abs-max (pos zero) = refl
+abs-max (pos (suc n)) = refl
+abs-max (negsuc n) = refl
+
+min-pos-pos : ∀ m n → min (pos m) (pos n) ≡ pos (ℕ.min m n)
+min-pos-pos zero n = refl
+min-pos-pos (suc m) zero = refl
+min-pos-pos (suc m) (suc n) = cong sucℤ (min-pos-pos m n)
+
+max-pos-pos : ∀ m n → max (pos m) (pos n) ≡ pos (ℕ.max m n)
+max-pos-pos zero n = refl
+max-pos-pos (suc m) zero = refl
+max-pos-pos (suc m) (suc n) = cong sucℤ (max-pos-pos m n)
+
+
+sign : ℤ → ℤ
+sign (pos zero) = 0
+sign (pos (suc n)) = 1
+sign (negsuc n) = -1
diff --git a/Cubical/Data/Nat/Mod.agda b/Cubical/Data/Nat/Mod.agda
index 8911504e25..1d53e66990 100644
--- a/Cubical/Data/Nat/Mod.agda
+++ b/Cubical/Data/Nat/Mod.agda
@@ -4,7 +4,8 @@ module Cubical.Data.Nat.Mod where
 open import Cubical.Foundations.Prelude
 open import Cubical.Data.Nat
 open import Cubical.Data.Nat.Order
-open import Cubical.Data.Empty
+open import Cubical.Data.Empty as ⊥
+open import Cubical.Data.Sum as ⊎
 
 -- Defining x mod 0 to be 0. This way all the theorems below are true
 -- for n : ℕ instead of n : ℕ₊₁.
@@ -36,6 +37,9 @@ mod< n =
               , cong (λ x → fst ind + suc x)
                      (modIndStep n x) ∙ snd ind
 
+<→mod : (n x : ℕ) → x < (suc n) → x mod (suc n) ≡ x
+<→mod = modIndBase
+
 mod-rUnit : (n x : ℕ) → x mod n ≡ ((x + n) mod n)
 mod-rUnit zero x = refl
 mod-rUnit (suc n) x =
@@ -153,6 +157,7 @@ mod-lCancel n x y =
   ∙∙ mod-rCancel n y x
   ∙∙ cong (_mod n) (+-comm y (x mod n))
 
+
 -- remainder and quotient after division by n
 -- Again, allowing for 0-division to get nicer syntax
 remainder_/_ : (x n : ℕ) → ℕ
@@ -192,3 +197,117 @@ private
 
   test₁ : ((11 + (10 mod 3)) mod 3) ≡ 0
   test₁ = refl
+
+
+
+·mod : ∀ k n m → (k · n) mod (k · m)
+             ≡ k · (n mod m)
+·mod zero n m = refl
+·mod (suc k) n zero = cong ((n + k · n) mod_) (sym (0≡m·0 (suc k)))
+                  ∙ 0≡m·0 (suc k)
+·mod (suc k) n (suc m) = ·mod' n n ≤-refl (splitℕ-≤ (suc m) n)
+
+ where
+ ·mod' : ∀ N n → n ≤ N → ((suc m) ≤ n) ⊎ (n < suc m) →
+    ((suc k · n) mod (suc k · suc m)) ≡ suc k · (n mod suc m)
+ ·mod' _ zero x _ = cong (modInd (m + k · suc m)) (sym (0≡m·0 (suc k)))
+                  ∙ 0≡m·0 (suc k)
+ ·mod' zero (suc n) x _ = ⊥.rec (¬-<-zero x)
+ ·mod' (suc N) n@(suc n') x (inl (m' , p)) =
+  let z = ·mod' N m' (≤-trans (m
+               , +-comm m m' ∙ injSuc (sym (+-suc m' m) ∙ p))
+              (pred-≤-pred x)) (splitℕ-≤ _ _) ∙ cong ((suc k) ·_)
+            (sym (modIndStep m m') ∙
+             cong (_mod (suc m)) (+-comm (suc m) m' ∙ p))
+  in (cong (λ y → ((suc k · y) mod (suc k · suc m))) (sym p)
+       ∙ cong {x = (m' + suc m + k · (m' + suc m))}
+               {suc (m + k · suc m + (m' + k · m'))}
+            (modInd (m + k · suc m))
+              (cong (_+ k · (m' + suc m)) (+-suc m' m ∙ cong suc (+-comm m' m))
+                 ∙ cong suc
+                  (sym (+-assoc m m' _)
+                    ∙∙ cong (m +_)
+                       (((cong (m' +_) (sym (·-distribˡ k _ _)
+                         ∙ +-comm (k · m') _) ∙ +-assoc m' (k · suc m) (k · m'))
+                        ∙ cong (_+ k · m') (+-comm m' _))
+                        ∙ sym (+-assoc (k · suc m) m' (k · m')) )
+                    ∙∙ +-assoc m _ _))
+         ∙ modIndStep (m + k · suc m) (m' + k · m')) ∙ z
+ ·mod' (suc N) n x (inr x₁) =
+   modIndBase _ _ (
+     subst2 _<_ (·-comm n (suc k)) (·-comm _ (suc k))
+      (<-·sk {n} {suc m} {k = k} x₁) )
+    ∙ cong ((suc k) ·_) (sym (modIndBase _ _ x₁))
+
+2≤x→1<quotient[x/2] : ∀ n → 0 < quotient (2 + n) / 2
+2≤x→1<quotient[x/2] n =
+ let z : 0 < ((quotient (2 + n) / 2) · 2)
+     z = subst (0 <_) (·-comm 2 (quotient (2 + n) / 2))
+          (≤<-trans {m = n }
+             {n = 2 · (quotient (2 + n) / 2)} zero-≤
+            (<-k+-cancel (subst (_< 2 +
+             (2 · (quotient (2 + n) / 2)))
+           (≡remainder+quotient 2 (2 + n))
+             (<-+k {k = 2 · (quotient (2 + n) / 2)}
+              (mod< 1 (2 + n))))))
+ in <-·sk-cancel {0} {quotient (2 + n) / 2 } {k = 1} z
+
+
+
+2≤x→quotient[x/2]<x : ∀ n → quotient (2 + n) / 2 < (2 + n)
+2≤x→quotient[x/2]<x n =
+  subst ((quotient 2 + n / 2) <_)
+    (≡remainder+quotient 2 (2 + n))
+    (<≤-trans
+      ( subst ((quotient 2 + n / 2) <_)
+          ((cong ((quotient 2 + n / 2) +_)
+            (sym (+-zero (quotient 2 + n / 2)))))
+            (<-+k {k = (quotient 2 + n / 2)}
+             (2≤x→1<quotient[x/2] n)) )
+      (≤SumRight {_} {(remainder 2 + n / 2)}))
+
+
+-- -- TODO: shoulld be easy to generalise to other nuumbers than 2
+
+-- log2ℕ : ∀ n → Σ _ (Minimal.Least (λ k → n < 2 ^ k))
+-- log2ℕ n = w n n ≤-refl
+--  where
+
+--   w : ∀ N n → n ≤ N
+--           → Σ _ (Minimal.Least (λ k → n < 2 ^ k))
+--   w N zero x = 0 , (≤-refl , λ k' q → ⊥.rec (¬-<-zero q))
+--   w N (suc zero) x = 1 , (≤-refl ,
+--      λ { zero q → <-asym (suc-≤-suc ≤-refl)
+--       ; (suc k') q → ⊥.rec (¬-<-zero (pred-≤-pred q))})
+--   w zero (suc (suc n)) x = ⊥.rec (¬-<-zero x)
+--   w (suc N) (suc (suc n)) x =
+--    let (k , (X , Lst)) = w N
+--           (quotient 2 + n / 2)
+--           (≤-trans (pred-≤-pred (2≤x→quotient[x/2]<x n))
+--              (pred-≤-pred x))
+--        z = ≡remainder+quotient 2 (2 + n)
+--        zz = <-+-≤ X X
+--        zzz : suc (suc n) < (2 ^ suc k)
+--        zzz = subst2 (_<_)
+--            (+-comm ({!remainder 2 + n / 2!} +
+--                      (({!!})))
+--                       ({!!})
+--               ∙ sym (+-assoc _ _ _)
+--                ∙ cong ((remainder 2 + n / 2) +_)
+--              ((cong ((quotient 2 + n / 2) +_)
+--               (sym (+-zero (quotient 2 + n / 2)))))
+--              ∙ z)
+--            (cong ((2 ^ k) +_) (sym (+-zero (2 ^ k))))
+--            ((≤<-trans
+--              (≤-k+ {k = _}
+--                (≤-+k {k = {!!}} (pred-≤-pred (mod< 1 (2 + n))))) zz))
+--    in (suc k)
+--        , zzz
+--         , λ { zero 0'<sk 2+n<2^0' →
+--                 ⊥.rec (¬-<-zero (pred-≤-pred 2+n<2^0'))
+--             ; (suc k') k'<sk 2+n<2^k' →
+--                Lst k' (pred-≤-pred k'<sk)
+--                 (<-·sk-cancel {k = 1}
+--                     (subst2 _<_ (·-comm _ _) (·-comm _ _)
+--                       (≤<-trans (_ , z)
+--                          2+n<2^k' )))}
diff --git a/Cubical/Data/Nat/Order.agda b/Cubical/Data/Nat/Order.agda
index 87ffadf43f..0b6808ac7c 100644
--- a/Cubical/Data/Nat/Order.agda
+++ b/Cubical/Data/Nat/Order.agda
@@ -142,6 +142,11 @@ suc-< p = pred-≤-pred (≤-suc p)
            (d + m) · k   ≡⟨ cong (_· k) r ⟩
            n · k         ∎
 
+≤-k· : m ≤ n → k · m ≤ k · n
+≤-k· {m} {n} {k} p =
+  subst2 _≤_ (·-comm m k) (·-comm n k)
+    (≤-·k p)
+
 <-k+-cancel : k + m < k + n → m < n
 <-k+-cancel {k} {m} {n} = ≤-k+-cancel ∘ subst (_≤ k + n) (sym (+-suc k m))
 
@@ -224,6 +229,17 @@ predℕ-≤-predℕ {suc m} {suc n} ineq = pred-≤-pred ineq
            (d + suc m) · suc k               ≡⟨ cong (_· suc k) r ⟩
            n · suc k                         ∎
 
+
+<-·sk-cancel : ∀ {m n k} → m · suc k < n · suc k → m < n
+<-·sk-cancel {n = zero} x = ⊥.rec (¬-<-zero x)
+<-·sk-cancel {zero} {n = suc n} x = suc-≤-suc (zero-≤ {n})
+<-·sk-cancel {suc m} {n = suc n} {k} x =
+  suc-≤-suc {suc m} {n}
+    (<-·sk-cancel {m} {n} {k}
+     (≤-k+-cancel (subst (_≤ (k + n · suc k))
+       (sym (+-suc _ _)) (pred-≤-pred x))))
+
+
 ∸-≤ : ∀ m n → m ∸ n ≤ m
 ∸-≤ m zero = ≤-refl
 ∸-≤ zero (suc n) = ≤-refl
@@ -480,6 +496,12 @@ n∸l>0  zero   (suc l) r = ⊥.rec (¬-<-zero r)
 n∸l>0 (suc n)  zero   r = suc-≤-suc zero-≤
 n∸l>0 (suc n) (suc l) r = n∸l>0 n l (pred-≤-pred r)
 
+[n-m]+m : ∀ m n → m ≤ n → (n ∸ m) + m ≡ n
+[n-m]+m zero n _ = +-zero n
+[n-m]+m (suc m) zero p = ⊥.rec (¬-<-zero p)
+[n-m]+m (suc m) (suc n) p =
+  +-suc _ _ ∙ cong suc ([n-m]+m m n (pred-≤-pred p))
+
 -- automation
 
 ≤-solver-type : (m n : ℕ) → Trichotomy m n → Type
@@ -545,3 +567,25 @@ pattern s<s {m} {n} m<n = s≤s {m} {n} m<n
 ≤-∸-≥ n (suc l)  zero   r = ⊥.rec (¬-<-zero r)
 ≤-∸-≥  zero   (suc l) (suc k) r = ≤-refl
 ≤-∸-≥ (suc n) (suc l) (suc k) r = ≤-∸-≥ n l k (pred-≤-pred r)
+
+elimBy≤ : ∀ {ℓ} {A : ℕ → ℕ → Type ℓ}
+  → (∀ x y → A x y → A y x)
+  → (∀ x y → x ≤ y → A x y)
+  → ∀ x y → A x y
+elimBy≤ {A = A} s f n m = ≤CaseInduction {P = A}
+  (f _ _) (s _ _ ∘ f _ _ )
+
+elimBy≤+ : ∀ {ℓ} {A : ℕ → ℕ → Type ℓ}
+  → (∀ x y → A x y → A y x)
+  → (∀ x y → A x (y + x))
+  → ∀ x y → A x y
+elimBy≤+ {A = A} s f =
+ elimBy≤ s λ x y (y' , p) → subst (A x) p (f x y')
+
+module Minimal where
+  Least : ∀{ℓ} → (ℕ → Type ℓ) → (ℕ → Type ℓ)
+  Least P m = P m × (∀ n → n < m → ¬ P n)
+
+  isPropLeast : {P : ℕ → Type ℓ} → (∀ m → isProp (P m)) → ∀ m → isProp (Least P m)
+  isPropLeast pP m
+    = isPropΣ (pP m) (λ _ → isPropΠ3 λ _ _ _ → isProp⊥)
diff --git a/Cubical/Data/Nat/Order/Recursive.agda b/Cubical/Data/Nat/Order/Recursive.agda
index f35d5674b8..9c785a8cf1 100644
--- a/Cubical/Data/Nat/Order/Recursive.agda
+++ b/Cubical/Data/Nat/Order/Recursive.agda
@@ -54,6 +54,26 @@ isProp≤ {suc m} {suc n} = isProp≤ {m} {n}
 ≤-k+ {k = zero}  m≤n = m≤n
 ≤-k+ {k = suc k} m≤n = ≤-k+ {k = k} m≤n
 
+<-weaken : m < n → m ≤ n
+<-weaken {zero} _ = _
+<-weaken {suc m} {suc n} = <-weaken {m}
+
+<-+-weaken : m < n → m < k + n
+<-+-weaken {k = zero} x = x
+<-+-weaken {m = zero} {n = suc n} {k = suc k} x = _
+<-+-weaken {m = suc m} {n = n} {k = suc k} x = <-+-weaken {m = m} {n = n} {k = k} (<-weaken {suc m} {n} x)
+
++-<-+ : k < l → m < n →  k + m < l + n
++-<-+ {zero} {l = suc l} {m} {n = suc n} x x₁ = <-+-weaken {m = m} {n = suc n} {k = 1 + l} x₁
++-<-+ {suc k} {l = suc l} {m} {n = n} x x₁ = +-<-+ {k} {l} {m} {n} x x₁
+
++-≤-+ : k ≤ l → m ≤ n →  k + m ≤ l + n
++-≤-+ {zero} {zero} {n = n} _ x = x
++-≤-+ {zero} {suc l} {zero} {n = n} x y = _
++-≤-+ {zero} {suc l} {suc m} {n = n} x y = +-≤-+ {0} {l} {m} {n} x (<-weaken {m} {n} y)
++-≤-+ {suc k} {zero} {n = n} ()
++-≤-+ {suc k} {suc l} {m} {n = n} = +-≤-+ {k} {l} {m} {n}
+
 ≤-+k : m ≤ n → m + k ≤ n + k
 ≤-+k {m} {n} {k} m≤n
   = transport (λ i → +-comm k m i ≤ +-comm k n i) (≤-k+ {m} {n} {k} m≤n)
@@ -87,10 +107,6 @@ isProp≤ {suc m} {suc n} = isProp≤ {m} {n}
 ¬m+n<m : ¬ m + n < m
 ¬m+n<m {suc m} = ¬m+n<m {m}
 
-<-weaken : m < n → m ≤ n
-<-weaken {zero} _ = _
-<-weaken {suc m} {suc n} = <-weaken {m}
-
 <-trans : k < m → m < n → k < n
 <-trans {k} {m} {n} k<m m<n
   = ≤-trans {suc k} {m} {n} k<m (<-weaken {m} m<n)
@@ -125,6 +141,10 @@ n≤k+n {k} n = transport (λ i → n ≤ +-comm n k i) (k≤k+n n)
 ≤-split {suc m} {suc n} m≤n
   = Sum.map (idfun _) (cong suc) (≤-split {m} {n} m≤n)
 
+<→¬≥ : n < m → ¬ m ≤ n
+<→¬≥ {suc n} {suc m} p q = <→¬≥ {n} {m} p q
+
+
 module WellFounded where
   wf-< : WellFounded _<_
   wf-rec-< : ∀ n → WFRec _<_ (Acc _<_) n
diff --git a/Cubical/Data/Nat/Properties.agda b/Cubical/Data/Nat/Properties.agda
index a0097e49d9..b78f814b40 100644
--- a/Cubical/Data/Nat/Properties.agda
+++ b/Cubical/Data/Nat/Properties.agda
@@ -56,6 +56,10 @@ codeℕ zero (suc m) = ⊥
 codeℕ (suc n) zero = ⊥
 codeℕ (suc n) (suc m) = codeℕ n m
 
+codeℕ-trans : codeℕ n m → codeℕ m l → codeℕ n l
+codeℕ-trans {zero} {zero} {zero} _ _ = tt
+codeℕ-trans {suc n} {suc m} {suc l} = codeℕ-trans {n} {m} {l}
+
 encodeℕ : (n m : ℕ) → (n ≡ m) → codeℕ n m
 encodeℕ n m p = subst (λ m → codeℕ n m) p (reflCode n)
  where
diff --git a/Cubical/Data/Rationals/Order.agda b/Cubical/Data/Rationals/Order.agda
index a18910dbec..78828b1a2a 100644
--- a/Cubical/Data/Rationals/Order.agda
+++ b/Cubical/Data/Rationals/Order.agda
@@ -7,15 +7,17 @@ open import Cubical.Foundations.Function
 open import Cubical.Foundations.HLevels
 open import Cubical.Foundations.Univalence
 
-open import Cubical.Functions.Logic using (_⊔′_)
+open import Cubical.Functions.Logic using (_⊔′_; ⇔toPath)
 
 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.Int.Divisibility as ℤ
 open import Cubical.Data.Rationals.Base as ℚ
 open import Cubical.Data.Rationals.Properties as ℚ
 open import Cubical.Data.Nat as ℕ
+open import Cubical.Data.Nat.Mod as ℕ
 open import Cubical.Data.NatPlusOne
 open import Cubical.Data.Sigma
 open import Cubical.Data.Sum as ⊎ using (_⊎_; inl; inr; isProp⊎)
@@ -393,6 +395,7 @@ module _ where
 <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)
@@ -410,6 +413,7 @@ module _ where
                              (λ x y → isProp→ (isProp≤ x y))
                              (λ { (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}
@@ -436,6 +440,25 @@ isTrans≤< =
                               (subst (_ ℤ.<_) (·CommR e (ℕ₊₁→ℤ d) (ℕ₊₁→ℤ b))
                                      (ℤ.<-·o {k = -1+ b} cf<ed)) )}
 
+
+<≤Monotone+ : ∀ m n o s → m < n → o ≤ s → m ℚ.+ o < n ℚ.+ s
+<≤Monotone+ m n o s x x₁ =
+   isTrans<≤ (m ℚ.+ o) (n ℚ.+ o) (n ℚ.+ s) (<-+o m n o x) (≤-o+ o s n x₁)
+
+≤<Monotone+ : ∀ m n o s → m ≤ n → o < s → m ℚ.+ o < n ℚ.+ s
+≤<Monotone+ m n o s x x₁ =
+   isTrans≤< (m ℚ.+ o) (n ℚ.+ o) (n ℚ.+ s) (≤-+o m n o x) (<-o+ o s n x₁)
+
+
+<Weaken+nonNeg : ∀ m n o → m < n → 0 ≤ o → m < (n ℚ.+ o)
+<Weaken+nonNeg m n o u v =
+  subst (_< (n ℚ.+ o)) (ℚ.+IdR m) (<≤Monotone+ m n 0 o u v)
+
+<WeakenNonNeg+ : ∀ m n o → m < n → 0 ≤ o → m < (o ℚ.+ n)
+<WeakenNonNeg+ m n o u v =
+  subst (_< (o ℚ.+ n)) (ℚ.+IdL m) (≤<Monotone+ 0 o m n v u)
+
+
 ≤-·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}
@@ -450,6 +473,12 @@ isTrans≤< =
                              (ℤ.≤-·o {k = ℕ₊₁→ℕ f}
                                       (ℤ.0≤o→≤-·o (subst (0 ℤ.≤_) (ℤ.·IdR e) 0≤e) ad≤cb)) }
 
+≤-o· : ∀ m n o → 0 ≤ o → m ≤ n → o ℚ.· m ≤ o ℚ.· n
+≤-o· m n o x = subst2 _≤_ (·Comm m o)
+                         (·Comm n o) ∘
+             ≤-·o m n o x
+
+
 ≤-·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}
@@ -487,6 +516,18 @@ isTrans≤< =
                             (ℤ.<-·o {k = -1+ f}
                                     (ℤ.0<o→<-·o (subst (0 ℤ.<_) (ℤ.·IdR e) 0<e) ad<cb)) }
 
+
+<-o· : ∀ m n o → 0 < o → m < n → o ℚ.· m < o ℚ.· n
+<-o· m n o x = subst2 _<_ (·Comm m o)
+                         (·Comm n o) ∘
+             <-·o m n o x
+
+
+0<-m·n : ∀ m n → 0 < m → 0 < n → 0 < m ℚ.· n
+0<-m·n m n x y = subst (_< (m ℚ.· n)) (ℚ.·AnnihilL n)
+             (<-·o 0 m n y x)
+
+
 <-·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}
@@ -524,6 +565,9 @@ min≤
                                   (ℤ.min≤ {a ℤ.· ℕ₊₁→ℤ d ℤ.· ℕ₊₁→ℤ b}
                                            {c ℤ.· ℕ₊₁→ℤ b ℤ.· ℕ₊₁→ℤ b}) }
 
+min≤' : ∀ m n → ℚ.min m n ≤ n
+min≤' m n = subst (_≤ n) (ℚ.minComm n m) (min≤ n m)
+
 ≤→min : ∀ m n → m ≤ n → ℚ.min m n ≡ m
 ≤→min
     = elimProp2 {P = λ a b → a ≤ b → ℚ.min a b ≡ a}
@@ -551,6 +595,8 @@ min≤
                                                        (ℕ₊₁→ℕ b)))
                                   (ℤ.≤max {a ℤ.· ℕ₊₁→ℤ d ℤ.· ℕ₊₁→ℤ b}
                                            {c ℤ.· ℕ₊₁→ℤ b ℤ.· ℕ₊₁→ℤ b}) }
+≤max' : ∀ m n → n ≤ ℚ.max m n
+≤max' m n = subst (n ≤_) (ℚ.maxComm n m) (≤max n m)
 
 ≤→max : ∀ m n →  m ≤ n → ℚ.max m n ≡ n
 ≤→max m n
@@ -603,6 +649,8 @@ m ≟ n with discreteℚ m n
            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)
 
@@ -621,3 +669,268 @@ 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
+
+
+minus-< : ∀ m n → m < n → - n < - m
+minus-< m n p =
+  let z = (<-+o m n (- (n ℚ.+ m)) p)
+      p : m ℚ.+ ((- (n ℚ.+ m)))  ≡ - n
+      p = cong (m ℚ.+_) (-Distr n m ∙ +Comm (- n) (- m)) ∙∙
+             +Assoc m (- m) (- n) ∙∙
+               ((cong (ℚ._+ - n) (+InvR m) ∙ +IdL (- n) ))
+      q : n ℚ.+ ((- (n ℚ.+ m))) ≡ - m
+      q = cong (n ℚ.+_) (-Distr n m) ∙∙ +Assoc n (- n) (- m) ∙∙
+           (cong (ℚ._+ - m) (+InvR n) ∙ +IdL (- m) )
+  in subst2 _<_ p q z
+
+
+
+minus-≤ : ∀ m n → m ≤ n → - n ≤ - m
+minus-≤ m n p =
+  let z = (≤-+o m n (- (n ℚ.+ m)) p)
+      p : m ℚ.+ ((- (n ℚ.+ m)))  ≡ - n
+      p = cong (m ℚ.+_) (-Distr n m ∙ +Comm (- n) (- m)) ∙∙
+             +Assoc m (- m) (- n) ∙∙
+               ((cong (ℚ._+ - n) (+InvR m) ∙ +IdL (- n) ))
+      q : n ℚ.+ ((- (n ℚ.+ m))) ≡ - m
+      q = cong (n ℚ.+_) (-Distr n m) ∙∙ +Assoc n (- n) (- m) ∙∙
+           (cong (ℚ._+ - m) (+InvR n) ∙ +IdL (- m) )
+  in subst2 _≤_ p q z
+
+<→<minus : ∀ m n → m < n → 0 < n - m
+<→<minus m n x = subst (_< n - m) (+InvR m) (<-+o m n (- m) x)
+
+
+minus-<' : ∀ n m → - n < - m → m < n
+minus-<' n m p =
+  subst2 _<_ (-Invol m) (-Invol n)
+   (minus-< (ℚ.- n) (ℚ.- m) p)
+
+
+0<ₚ_ : ℚ → hProp ℓ-zero
+0<ₚ_ = Rec.go w
+ where
+ w : Rec (hProp ℓ-zero)
+ w .Rec.isSetB = isSetHProp
+ w .Rec.f (x , _) = ℤ.0< x , ℤ.isProp0< x
+ w .Rec.f∼ (x , y) (x' , y') p =
+  ⇔toPath --0<·ℕ₊₁
+     (λ u → ℤ.0<·ℕ₊₁ x' y
+       (subst ℤ.0<_ p (ℤ.·0< x (ℤ.pos (ℕ₊₁→ℕ y'))
+         u _)))
+     (λ u → ℤ.0<·ℕ₊₁ x y'
+       (subst ℤ.0<_ (sym p) (ℤ.·0< x' (ℤ.pos (ℕ₊₁→ℕ y))
+         u _)))
+
+0<_ = fst ∘ 0<ₚ_
+
+
+·0< : ∀ m n → 0< m → 0< n → 0< (m ℚ.· n)
+·0< = elimProp2
+  (λ x x' → isPropΠ2 λ _ _ → snd (0<ₚ (x ℚ.· x')) )
+  λ (x , _) (x' , _) → ℤ.·0< x x'
+
++0< : ∀ m n → 0< m → 0< n → 0< (m ℚ.+ n)
++0< = elimProp2
+  (λ x x' → isPropΠ2 λ _ _ → snd (0<ₚ (x ℚ.+ x')) )
+  λ (x , y) (x' , y')  p p' →
+    ℤ.+0< (x ℤ.· ℕ₊₁→ℤ y') (x' ℤ.· ℕ₊₁→ℤ y)
+      (ℤ.·0< x (ℕ₊₁→ℤ y') p tt) (ℤ.·0< x' (ℕ₊₁→ℤ y) p' tt)
+
++0<' : ∀ m n o → 0< m → 0< n → (m ℚ.+ n) ≡ o → 0< o
++0<' m n o x y p = subst (0<_) p (+0< m n x y)
+
++₃0< : ∀ m n o → 0< m → 0< n → 0< o → 0< ((m ℚ.+ n) ℚ.+ o)
++₃0< m n o x y z = +0< (m ℚ.+ n) o (+0< m n x y) z
+
++₃0<' : ∀ m n o o' → 0< m → 0< n → 0< o
+        → ((m ℚ.+ n) ℚ.+ o) ≡ o' → 0< o'
++₃0<' m n o o' x y z p = subst 0<_ p (+₃0< m n o x y z)
+
+
+ℚ₊ : Type
+ℚ₊ = Σ ℚ 0<_
+
+
+instance
+  fromNatℚ₊ : HasFromNat ℚ₊
+  fromNatℚ₊ =
+   record { Constraint = λ { zero → ⊥ ; _ → Unit }
+             ; fromNat = λ { (suc n) → ([ ℤ.pos (suc n) , 1 ] , _) } }
+
+ℚ₊≡ : {x y : ℚ₊} → fst x ≡ fst y → x ≡ y
+ℚ₊≡ = Σ≡Prop (snd ∘ 0<ₚ_)
+
+_ℚ₊·_ : ℚ₊ → ℚ₊ → ℚ₊
+_ℚ₊·_ x x₁ = ((fst x) ℚ.· (fst x₁)) ,
+  ·0< (fst x) (fst x₁) (snd x) (snd x₁)
+
+_ℚ₊+_ : ℚ₊ → ℚ₊ → ℚ₊
+_ℚ₊+_ x x₁ = ((fst x) ℚ.+ (fst x₁)) ,
+  +0< (fst x) (fst x₁) (snd x) (snd x₁)
+
+0<→< : ∀ q → 0< q → 0 < q
+0<→< = elimProp (λ x → isProp→ (isProp< 0 x)) zz
+ where
+
+ zz : ∀ a → 0< [ a ] → 0 < [ a ]
+ zz (ℤ.pos (suc n) , snd₁) x = n ,
+  (sym (ℤ.pos+ 1 n) ∙ sym (ℤ.·IdR (ℤ.pos (suc n))))
+
+0<ℚ₊ : (ε : ℚ₊) → 0 < fst ε
+0<ℚ₊ = uncurry 0<→<
+
+0≤ℚ₊ : (ε : ℚ₊) → 0 ≤ fst ε
+0≤ℚ₊ ε = <Weaken≤ 0 (fst ε) (uncurry 0<→< ε)
+
+
+<→0< : ∀ q → 0 < q → 0< q
+<→0< = elimProp (λ x → isProp→ (snd (0<ₚ x)))
+ zz
+ where
+ zz : ∀ a → 0 < [ a ] → 0< [ a ]
+ zz (ℤ.pos zero , snd₁) x =
+  ℕ.snotz (ℤ.injPos (ℤ.pos+ 1 (x .fst) ∙ snd x))
+ zz (ℤ.pos (suc n) , snd₁) x = tt
+ zz (ℤ.negsuc n , snd₁) x =
+   ℤ.posNotnegsuc _ _
+    (ℤ.pos+ 1 (x .fst) ∙  snd x ∙ ℤ.·IdR (ℤ.negsuc n))
+
+0<-min : ∀ x y → 0< x → 0< y → 0< (ℚ.min x y)
+0<-min = elimProp2
+ (λ x y → isPropΠ2 λ _ _ → snd (0<ₚ (ℚ.min x y)))
+ λ a b x x₁ →
+   let zzz = ℤ.min-0< (a .fst ℤ.· ℕ₊₁→ℤ (b .snd)) (b .fst ℤ.· ℕ₊₁→ℤ (a .snd))
+                (ℤ.·0< (a .fst) (ℕ₊₁→ℤ (b .snd)) x _ )
+                 ((ℤ.·0< (b .fst) (ℕ₊₁→ℤ (a .snd)) x₁ _ ))
+
+   in zzz
+
+min₊ : ℚ₊ → ℚ₊ → ℚ₊
+min₊ (x , y) (x' , y') =
+  ℚ.min x x' , 0<-min x x' y y'
+
+max₊ : ℚ₊ → ℚ₊ → ℚ₊
+max₊ (x , y) (x' , y') =
+  ℚ.max x x' , <→0< (ℚ.max x x') (isTrans<≤ 0 x _ (0<→< x y) (≤max x x'))
+
+-- min< : ∀ n m → n < m →  ℚ.min n m ≡ n
+-- min< = elimProp2 (λ _ _ → isPropΠ λ _ → isSetℚ _ _)
+--   λ (x , y) (x' , y') →
+--     {!!}
+-- -- with n ≟ m
+-- ... | lt x₁ = {!x!}
+-- ... | eq x₁ = cong (ℚ.min n) (sym x₁) ∙ minIdem n
+-- ... | gt x₁ = {!x!}
+
+-< : ∀ q r → q < r → 0 < r ℚ.- q
+-< q r x = subst (_< r ℚ.- q) (+InvR q) (<-+o q r (ℚ.- q) x)
+
+-≤ : ∀ q r → q ≤ r → 0 ≤ r ℚ.- q
+-≤ q r x = subst (_≤ r ℚ.- q) (+InvR q) (≤-+o q r (ℚ.- q) x)
+
+
+<→ℚ₊ : ∀ x y → x < y → ℚ₊
+<→ℚ₊ x y x<y = y - x , <→0< (y - x) (-< x y x<y)
+
+<+ℚ₊ : ∀ x y (ε : ℚ₊) → x < y → x < (y ℚ.+ fst ε)
+<+ℚ₊ x y ε x₁ =
+ subst (_< y ℚ.+ fst ε)
+   (ℚ.+IdR x) (<Monotone+ x y 0 (fst ε) x₁ (0<ℚ₊ ε))
+
+<+ℚ₊' : ∀ x y (ε : ℚ₊) → x ≤ y → x < (y ℚ.+ fst ε)
+<+ℚ₊' x y ε x₁ =
+ subst (_< y ℚ.+ fst ε)
+   (ℚ.+IdR x) (≤<Monotone+ x y 0 (fst ε) x₁ (0<ℚ₊ ε))
+
+
+≤+ℚ₊ : ∀ x y (ε : ℚ₊) → x ≤ y → x ≤ (y ℚ.+ fst ε)
+≤+ℚ₊ x y ε x₁ =
+ subst (_≤ y ℚ.+ fst ε)
+   (ℚ.+IdR x) (≤Monotone+ x y 0 (fst ε) x₁ (0≤ℚ₊ ε))
+
+
+-ℚ₊<0 : (ε : ℚ₊) → ℚ.- (fst ε) < 0
+-ℚ₊<0 ε = minus-< 0 (fst ε) (0<ℚ₊ ε)
+
+-ℚ₊≤0 : (ε : ℚ₊) → ℚ.- (fst ε) ≤ 0
+-ℚ₊≤0 ε = <Weaken≤ (ℚ.- (fst ε)) 0 (minus-< 0 (fst ε) (0<ℚ₊ ε))
+
+pos[-x<x] : (ε : ℚ₊) → ℚ.- (fst ε) < (fst ε)
+pos[-x<x] ε = isTrans< (ℚ.- (fst ε)) 0 (fst ε) (-ℚ₊<0 ε) (0<ℚ₊ ε)
+
+pos[-x≤x] : (ε : ℚ₊) → ℚ.- (fst ε) ≤ (fst ε)
+pos[-x≤x] ε = isTrans≤ (ℚ.- (fst ε)) 0 (fst ε) (-ℚ₊≤0 ε) (0≤ℚ₊ ε)
+
+<-ℚ₊ : ∀ x y (ε : ℚ₊) → x < y → (x ℚ.- fst ε) < y
+<-ℚ₊ x y ε x₁ =
+ subst ((x ℚ.- fst ε) <_)
+   (ℚ.+IdR y) (<Monotone+ x y (ℚ.- (fst ε)) 0 x₁ (-ℚ₊<0 ε))
+
+
+<-ℚ₊' : ∀ x y (ε : ℚ₊) → x ≤ y → (x ℚ.- fst ε) < y
+<-ℚ₊' x y ε x₁ =
+ subst ((x ℚ.- fst ε) <_)
+   (ℚ.+IdR y) (≤<Monotone+ x y (ℚ.- (fst ε)) 0 x₁ (-ℚ₊<0 ε))
+
+
+≤-ℚ₊ : ∀ x y (ε : ℚ₊) → x ≤ y → (x ℚ.- fst ε) ≤ y
+≤-ℚ₊ x y ε x₁ =
+ subst ((x ℚ.- fst ε) ≤_)
+   (ℚ.+IdR y) (≤Monotone+ x y (ℚ.- (fst ε)) 0 x₁ (-ℚ₊≤0 ε))
+
+-ℚ₊<ℚ₊ : (ε ε' : ℚ₊) → (ℚ.- (fst ε)) < fst ε'
+-ℚ₊<ℚ₊ ε ε' = isTrans< (ℚ.- (fst ε)) 0 (fst ε') (-ℚ₊<0 ε) (0<ℚ₊ ε')
+
+-ℚ₊≤ℚ₊ : (ε ε' : ℚ₊) → ℚ.- (fst ε) ≤ fst ε'
+-ℚ₊≤ℚ₊ ε ε' = isTrans≤ (ℚ.- fst ε) 0 (fst ε') (-ℚ₊≤0 ε) (0≤ℚ₊ ε')
+
+
+absCases : (q : ℚ) → (abs q ≡ - q) ⊎ (abs q ≡ q)
+absCases q with (- q) ≟ q
+... | lt x = inr (ℚ.maxComm q (- q) ∙ (≤→max (- q) q $ <Weaken≤ (- q) q x))
+... | eq x = inr (ℚ.maxComm q (- q) ∙ (≤→max (- q) q $ ≡Weaken≤ (- q) q x))
+... | gt x = inl (≤→max q (- q) (<Weaken≤ q (- q) x) )
+
+
+absFrom≤×≤ : ∀ ε q →
+                - ε ≤ q
+                → q ≤ ε
+                → abs q ≤ ε
+absFrom≤×≤ ε q x x₁ with absCases q
+... | inl x₂ = subst2 (_≤_) (sym x₂) (-Invol ε) (minus-≤ (- ε) q x  )
+... | inr x₂ = subst (_≤ ε) (sym x₂) x₁
+
+absFrom<×< : ∀ ε q →
+                - ε < q
+                → q < ε
+                → abs q < ε
+absFrom<×< ε q x x₁ with absCases q
+... | inl x₂ = subst2 (_<_) (sym x₂) (-Invol ε) (minus-< (- ε) q x  )
+... | inr x₂ = subst (_< ε) (sym x₂) x₁
+
+
+clamp : ℚ → ℚ → ℚ → ℚ
+clamp d u x = ℚ.min (ℚ.max d x) u
+
+≠→0<abs : ∀ q r → ¬ q ≡ r → 0< ℚ.abs (q ℚ.- r)
+≠→0<abs q r u with q ≟ r
+... | lt x = <→0< (ℚ.abs (q ℚ.- r)) $ isTrans<≤ 0 (r ℚ.- q) (ℚ.abs (q ℚ.- r))
+                 (-< q r x)
+                   (subst (_≤ abs (q - r))
+                     (-[x-y]≡y-x q r) $ ≤max' (q - r) (ℚ.- (q - r)))
+... | eq x = ⊥.rec (u x)
+... | gt x = <→0< (ℚ.abs (q ℚ.- r)) $ isTrans<≤ 0 (q ℚ.- r) (ℚ.abs (q ℚ.- r))
+                 (-< r q x) (≤max (q - r) (ℚ.- (q - r)))
+
+≤→≡⊎< : ∀ q r → q ≤ r → (q ≡ r) ⊎ (q < r)
+≤→≡⊎< q r y with q ≟ r
+... | lt x = inr x
+... | eq x = inl x
+... | gt x = ⊥.rec (≤→≯ q r y x)
+
+≤ℤ→≤ℚ : ∀ m n → m ℤ.≤ n → [ m , 1 ] ≤ [ n , 1 ]
+≤ℤ→≤ℚ m n = subst2 ℤ._≤_ (sym (ℤ.·IdR m)) (sym (ℤ.·IdR n))
+
+<ℤ→<ℚ : ∀ m n → m ℤ.< n → [ m , 1 ] < [ n , 1 ]
+<ℤ→<ℚ m n = subst2 ℤ._<_ (sym (ℤ.·IdR m)) (sym (ℤ.·IdR n))
diff --git a/Cubical/Data/Rationals/Order/Properties.agda b/Cubical/Data/Rationals/Order/Properties.agda
new file mode 100644
index 0000000000..a2a610e84d
--- /dev/null
+++ b/Cubical/Data/Rationals/Order/Properties.agda
@@ -0,0 +1,1538 @@
+{-# OPTIONS --safe --lossy-unification #-}
+module Cubical.Data.Rationals.Order.Properties where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Univalence
+open import Cubical.Foundations.Isomorphism
+
+open import Cubical.Functions.FunExtEquiv
+
+open import Cubical.Functions.Logic using (_⊔′_; ⇔toPath)
+
+open import Cubical.Data.Empty as ⊥
+open import Cubical.Data.Int.Base as ℤ using (ℤ;pos;negsuc)
+import Cubical.Data.Bool as 𝟚
+open import Cubical.Data.Int.Properties as ℤ using ()
+open import Cubical.Data.Int.Order as ℤ using ()
+open import Cubical.Data.Int.Divisibility as ℤ
+open import Cubical.Data.Rationals.Base as ℚ
+open import Cubical.Data.Rationals.Properties as ℚ
+open import Cubical.Data.Nat as ℕ using (ℕ; suc; zero;znots)
+open import Cubical.Data.Nat.Mod as ℕ
+import Cubical.Data.Nat.Order as ℕ
+open import Cubical.Data.NatPlusOne
+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 as SQ hiding (_/_)
+
+open import Cubical.Relation.Nullary
+open import Cubical.Relation.Binary.Base
+
+open import Cubical.Data.Rationals.Order
+
+open import Cubical.HITs.CauchyReals.Lems
+
+open import Cubical.Algebra.CommRing.Instances.Int
+
+decℚ? : ∀ {x y} → {𝟚.True (discreteℚ x y)} →  (x ≡ y)
+decℚ? {_} {_} {p} = 𝟚.toWitness p
+
+decℚ<? : ∀ {x y} → {𝟚.True (<Dec x y)} →  (x < y)
+decℚ<? {_} {_} {p} = 𝟚.toWitness p
+
+decℚ≤? : ∀ {x y} → {𝟚.True (≤Dec x y)} →  (x ≤ y)
+decℚ≤? {_} {_} {p} = 𝟚.toWitness p
+
+
+
+
+floor-lemma : ∀ p q → fromNat (ℕ.quotient p / (suc q))
+                   ℚ.+ [ ℤ.pos (ℕ.remainder p / (suc q)) / 1+ q ]
+                   ≡ [ ℤ.pos p / 1+ q ]
+floor-lemma p q = eq/ _ _
+     (cong (ℤ._· q') w ∙ cong (ℤ.pos p ℤ.·_)
+     (cong ℚ.ℕ₊₁→ℤ (sym (·₊₁-identityˡ (1+ q)))))
+
+ where
+  q' = ℚ.ℕ₊₁→ℤ (1+ q)
+  w : (ℤ.pos (ℕ.quotient p / (suc q)) ℤ.· q'
+        ℤ.+ ℤ.pos (ℕ.remainder p / (suc q)) ℤ.· ℤ.pos 1)
+           ≡ ℤ.pos p
+  w = cong₂ (ℤ._+_) (ℤ.·Comm _ _ ∙ sym (ℤ.pos·pos _ _)) (ℤ.·IdR _)
+       ∙ sym (ℤ.pos+ _ _) ∙ cong ℤ.pos
+          (ℕ.+-comm _ _  ∙ ℕ.≡remainder+quotient (suc q) p)
+
+
+floor-fracℚ₊ : ∀ (x : ℚ₊) → Σ (ℕ × ℚ) λ (k , q) →
+                       (fromNat k + q ≡ fst x ) × ((0 ≤ q)  × (q < 1))
+floor-fracℚ₊ = uncurry (SQ.Elim.go w)
+ where
+
+
+ ww : ∀ p p' q q' → p ℕ.· (suc q') ≡ p' ℕ.· (suc q) →
+         ℤ.pos (ℕ.remainder p / (suc q)) ℤ.·
+           (ℤ.pos (2 ℕ.· ((suc q) ℕ.· (suc q')) ))
+           ≡ ℤ.pos (ℕ.remainder (p ℕ.· (suc q') ℕ.+ p' ℕ.· (suc q))
+                / ℕ₊₁→ℕ (2 ·₊₁ ((1+ q) ·₊₁ (1+ q')))) ℤ.· ℤ.pos (suc q)
+ ww p p' q q' e =
+    sym (ℤ.pos·pos _ _)
+   ∙ (cong ℤ.pos ((cong ((p ℕ.mod suc q) ℕ.·_)
+         (cong (2 ℕ.·_) (ℕ.·-comm _ _) ∙  ℕ.·-assoc _ _ _)
+     ∙ ℕ.·-assoc _ _ _ ) ∙
+     cong (ℕ._· (suc q))
+       ((ℕ.·-comm _ _)
+         ∙ sym (ℕ.·mod (2 ℕ.· (suc q')) _ _) ∙ cong₂ ℕ.remainder_/_
+                 ((sym (ℕ.·-assoc 2 (suc q') p)
+                   ∙ cong (2 ℕ.·_) (ℕ.·-comm (suc q') p))
+                     ∙ (cong (p ℕ.· (suc q') ℕ.+_) (ℕ.+-zero _ ∙ e)))
+              (sym (ℕ.·-assoc 2 (suc q') (suc q)) ∙
+                cong (2 ℕ.·_) (ℕ.·-comm (suc q') (suc q))))))
+     ∙ ℤ.pos·pos _ _
+
+ w : Elim _
+ w .Elim.isSetB _ = isSetΠ λ _ →
+   isSetΣ (isSet× ℕ.isSetℕ isSetℚ)
+    (isProp→isSet ∘ λ _ → isProp× (isSetℚ _ _)
+      (isProp× (isProp≤ _ _) (isProp< _ _)))
+ w .Elim.f∼ (ℤ.negsuc n , (1+ n₁)) (ℤ.pos n₂ , (1+ n₃)) r =
+   funExtDep λ {x₀} → ⊥.rec x₀
+ w .Elim.f∼ (_ , (1+ n)) (ℤ.negsuc n₁ , (1+ n₂)) r =
+   funExtDep λ {_} {x₁} → ⊥.rec x₁
+ w .Elim.f (ℤ.pos p , 1+ q) _ =
+   ((ℕ.quotient p / (suc q)) ,
+     [ ℤ.pos (ℕ.remainder p / (suc q)) / 1+ q ]) ,
+      floor-lemma p q , (
+        subst (0 ℤ.≤_) (sym (ℤ.·IdR _)) ℤ.zero-≤pos , f<1)
+  where
+
+  f<1 : ℤ.pos (ℕ.remainder p / suc q) ℤ.· 1 ℤ.< ℤ.pos 1 ℤ.· ℕ₊₁→ℤ (1+ q)
+  f<1 = subst2 ℤ._<_
+     (sym (ℤ.·IdR _)) (sym (ℤ.·IdL _))
+     (ℤ.ℕ≤→pos-≤-pos _ _ (ℕ.mod< _ _))
+
+ w .Elim.f∼ (ℤ.pos p , 1+ q) (ℤ.pos p' , 1+ q') e₀ =
+  toPathP (funExt λ x → Σ≡Prop
+    (λ _ → isProp× (isSetℚ _ _)
+      (isProp× (isProp≤ _ _) (isProp< _ _)))
+    (cong₂ _,_ z z'))
+  where
+
+  e : p ℕ.· (suc q') ≡ p' ℕ.· (suc q)
+  e = ℤ.injPos (ℤ.pos·pos _ _ ∙∙ e₀ ∙∙ sym (ℤ.pos·pos _ _))
+
+
+  z' : [ ℤ.pos (ℕ.remainder p / (suc q)) / 1+ q ]
+        ≡ [ ℤ.pos (ℕ.remainder p' / (suc q')) / 1+ q' ]
+  z' = eq/ _ ((ℤ.pos (ℕ.remainder (p ℕ.· (suc q') ℕ.+ p' ℕ.· (suc q))
+                / (2 ℕ.· ((suc q) ℕ.· (suc q'))))) ,
+                 (2 ·₊₁ ((1+ q) ·₊₁ (1+ q'))))
+     (ww _ _ _ _ e) ∙∙
+      cong₂ [_/_] (cong ℤ.pos
+          (cong₂ ℕ.remainder_/_
+             (ℕ.+-comm _ _) (cong (2 ℕ.·_) (ℕ.·-comm _ _))))
+        (cong (2 ·₊₁_) (·₊₁-comm _ _))
+      ∙∙ sym (eq/ _
+        ((ℤ.pos (ℕ.remainder (p' ℕ.· (suc q) ℕ.+ p ℕ.· (suc q'))
+                / (2 ℕ.· ((suc q') ℕ.· (suc q))))) ,
+                 (2 ·₊₁ ((1+ q') ·₊₁ (1+ q))))
+                 (ww _ _ _ _ (sym e)))
+
+
+  z'' : (ℕ.remainder p / suc q) ℕ.· (suc q') ≡
+          (ℕ.remainder p' / suc q') ℕ.· (suc q)
+  z'' = ℤ.injPos (ℤ.pos·pos _ _ ∙∙ eq/⁻¹ _ _ z' ∙∙ sym (ℤ.pos·pos _ _))
+
+  z : (ℕ.quotient p / suc q)
+        ≡
+        (ℕ.quotient p' / suc q')
+  z = ℕ.inj-·sm (ℕ.inj-sm· (ℕ.·-assoc _ _ _
+     ∙∙ ℕ.inj-m+ ((cong (ℕ._+ (suc q ℕ.· (ℕ.quotient p / suc q) ℕ.· suc q'))
+      (sym z''))
+     ∙ (ℕ.·-distribʳ _ _ _) ∙∙ cong (ℕ._· (suc q'))
+         (ℕ.≡remainder+quotient (suc q) p) ∙∙ e ∙∙
+       sym (cong (ℕ._· (suc q)) (ℕ.≡remainder+quotient (suc q') p'))
+         ∙∙ sym (ℕ.·-distribʳ _ _ _))
+        ∙∙ (λ i → ℕ.·-comm (ℕ.·-comm (suc q') (ℕ.quotient p' / suc q') i) (suc q) i)))
+
+ceil-[1-frac]ℚ₊ : ∀ (x : ℚ₊) → Σ (ℕ × ℚ) λ (k , q) →
+                       (fst x + q ≡ fromNat k) × ((0 ≤ q)  × (q < 1))
+ceil-[1-frac]ℚ₊ x =
+ let ((fl , fr) , e , (e' , e'')) = floor-fracℚ₊ x
+
+ in decRec
+      (λ p → (fl , 0) ,
+        (+IdR _ ∙ sym e ∙ cong  ((fromNat fl) +_) (sym p) ∙ (+IdR _)) ,
+          (isRefl≤ 0 , decℚ<?))
+      (λ p → (suc fl , (1 ℚ.- fr)) ,
+          (cong₂ (_+_) (sym e) (ℚ.+Comm [ ℤ.pos 1 / 1+ 0 ] (- fr)) ∙
+            sym (ℚ.+Assoc _ _ _) ∙
+              cong  ((fromNat fl) +_)
+                (ℚ.+Assoc _ _ _
+                  ∙∙ cong (_+ 1) (+InvR _) ∙∙ +IdL 1)
+               ∙ ℚ.+Comm (fromNat fl) 1 ∙ ℕ+→ℚ+ _ _) ,
+               <Weaken≤ 0 _ (-< fr 1 e'') ,
+                 (<-o+ _ _ 1 (
+                   (⊎.rec (⊥.rec ∘ p) (minus-< 0 fr) (≤→≡⊎< 0 fr e')))))
+     (discreteℚ 0 fr)
+
+
+
+floor-frac : ∀ (x : ℚ) → Σ (ℤ × ℚ) λ (k , q) →
+                       ([ k , 1 ] + q ≡ x) × ((0 ≤ q)  × (q < 1))
+floor-frac x with 0 ≟ x
+... | lt x₁ =
+  let ((c , fr') , e ) = floor-fracℚ₊ (x , <→0< _ x₁)
+  in (ℤ.pos c , fr') , e
+
+... | eq x₁ = (0 , 0) , (x₁ , isRefl≤ 0 , decℚ<? )
+... | gt x₁ =
+  let ((c , fr') , e , e') = ceil-[1-frac]ℚ₊
+          (- x , <→0< (- x) (minus-< x 0 x₁))
+      fl = (ℤ.- ℤ.pos c)
+      p : [ fl , 1 ] + fr' ≡ x
+      p = (sym (-Invol _)
+             ∙ cong (-_) (-Distr _ _
+                 ∙ cong (_- fr')
+                    (cong [_/ 1 ] (ℤ.-Involutive _) )))
+              ∙ sym (cong -_ (+CancelL- _ _ _ e)) ∙ -Invol _
+  in (fl , fr') ,
+        p , e'
+
+
+ceilℚ₊ : (q : ℚ₊) → Σ[ k ∈ ℕ ] (fst q) < fromNat k
+ceilℚ₊ q = suc (fst (fst (floor-fracℚ₊ q))) ,
+   subst2 (_<_) --  (fromNat (suc (fst (fst (floor-fracℚ₊ q)))))
+      (ℚ.+Comm _ _ ∙ fst (snd (floor-fracℚ₊ q)))
+      (ℚ.ℕ+→ℚ+ _ _)
+       (<-+o _ _ (fromNat (fst (fst (floor-fracℚ₊ q))))
+         (snd (snd (snd (floor-fracℚ₊ q)))))
+
+
+
+sign : ℚ → ℚ
+sign = Rec.go w
+ where
+ w : Rec _
+ w .Rec.isSetB = isSetℚ
+ w .Rec.f (ℤ.pos zero , snd₁) = 0
+ w .Rec.f (ℤ.pos (suc n) , snd₁) = 1
+ w .Rec.f (ℤ.negsuc n , snd₁) = [ ℤ.ℤ.negsuc 0 , 1 ]
+ w .Rec.f∼ (ℤ.pos zero , (1+ nn)) (ℤ.pos zero , snd₂) x = refl
+ w .Rec.f∼ (ℤ.pos zero , (1+ nn)) (ℤ.pos (suc n₁) , snd₂) x =
+    ⊥.rec $ znots $
+     ℤ.injPos (x ∙ sym (ℤ.pos·pos (suc n₁) (suc nn)))
+ w .Rec.f∼ (ℤ.pos (suc n₁) , snd₁) (ℤ.pos zero , (1+ nn)) x =
+   ⊥.rec $ znots $
+     ℤ.injPos (sym x ∙ sym (ℤ.pos·pos (suc n₁) (suc nn)))
+ w .Rec.f∼ (ℤ.pos (suc n) , snd₁) (ℤ.pos (suc n₁) , snd₂) x = refl
+ w .Rec.f∼ (ℤ.pos n₁ , snd₂) (ℤ.negsuc n , snd₁) x =
+    ⊥.rec (
+     𝟚.toWitnessFalse
+      {Q = (ℤ.discreteℤ _ _)}
+       _ ((cong (ℤ.-_) (ℤ.pos·pos (suc n) _)
+        ∙ sym (ℤ.negsuc·pos n _)) ∙∙ (sym x) ∙∙ sym (ℤ.pos·pos n₁ _) ))
+ w .Rec.f∼ (ℤ.negsuc n , snd₁) (ℤ.pos n₁ , snd₂) x =
+   ⊥.rec (
+     𝟚.toWitnessFalse
+      {Q = (ℤ.discreteℤ _ _)}
+       _ ((cong (ℤ.-_) (ℤ.pos·pos (suc n) _)
+        ∙ sym (ℤ.negsuc·pos n _)) ∙∙ x ∙∙ sym (ℤ.pos·pos n₁ _) ))
+ w .Rec.f∼ (ℤ.negsuc n , snd₁) (ℤ.negsuc n₁ , snd₂) x = refl
+
+<≃sign : ∀ x → ((0 < x) ≃ (sign x ≡ 1))
+               × ((0 ≡ x) ≃ (sign x ≡ 0))
+                 × ((x < 0) ≃ (sign x ≡ -1))
+<≃sign = ElimProp.go w
+ where
+ w : ElimProp _
+ w .ElimProp.isPropB _ =
+  isProp× (isOfHLevel≃ 1 (isProp< _ _) (isSetℚ _ _))
+     (isProp× (isOfHLevel≃ 1 (isSetℚ _ _) (isSetℚ _ _))
+         (isOfHLevel≃ 1 (isProp< _ _) (isSetℚ _ _))
+       )
+ w .ElimProp.f (ℤ.pos zero , (1+ n)) =
+  propBiimpl→Equiv (isProp< _ _) (isSetℚ _ _)
+    ((λ x₁ → ⊥.rec $ ℤ.isIrrefl< x₁))
+      (λ x → ⊥.rec $ ℕ.znots (ℤ.injPos (eq/⁻¹ _ _ x))) ,
+   (propBiimpl→Equiv (isSetℚ _ _) (isSetℚ _ _)
+     (λ _ → refl) (λ _ → eq/ _ _ refl) ,
+      propBiimpl→Equiv (isProp< _ _) (isSetℚ _ _)
+        (λ x → ⊥.rec (ℤ.¬-pos<-zero x))
+          (λ x → ⊥.rec $ ℤ.posNotnegsuc _ _ ((eq/⁻¹ _ _ x))))
+
+ w .ElimProp.f (ℤ.pos (suc n) , snd₁) =
+   propBiimpl→Equiv (isProp< _ _) (isSetℚ _ _)
+    (λ _ → refl) (λ _ → 0<→< [ ℤ.pos (suc n) , snd₁ ] _) ,
+   (propBiimpl→Equiv (isSetℚ _ _) (isSetℚ _ _)
+     ((λ b → ⊥.rec
+      (znots $ ℤ.injPos (b ∙ ℤ.·IdR (ℤ.pos (suc n))))) ∘S eq/⁻¹ _ _)
+     (λ x → ⊥.rec (ℕ.snotz $ ℤ.injPos (eq/⁻¹ _ _ x)))  ,
+      propBiimpl→Equiv (isProp< _ _) (isSetℚ _ _)
+        (λ x → ⊥.rec (ℤ.¬-pos<-zero (subst (ℤ._< 0)
+         (sym (ℤ.pos·pos (suc n) 1)) x)))
+          λ x → ⊥.rec (ℤ.posNotnegsuc _ _ (eq/⁻¹ _ _ x)))
+
+ w .ElimProp.f (ℤ.negsuc n , snd₁) =
+   propBiimpl→Equiv (isProp< _ _) (isSetℚ _ _)
+    ((λ x₁ → ⊥.rec $
+   ℤ.¬pos≤negsuc (subst ((ℤ.pos _) ℤ.≤_) (ℤ.negsuc·pos n 1 ∙
+    cong ℤ.-_ (sym (ℤ.pos·pos (suc n) 1)) ) x₁)))
+     ((λ x → ⊥.rec (ℤ.posNotnegsuc 1 0 (sym x))) ∘S eq/⁻¹ _ _) ,
+   (propBiimpl→Equiv (isSetℚ _ _) (isSetℚ _ _)
+     ((λ x → ⊥.rec (ℤ.posNotnegsuc _ _
+     (eq/⁻¹ _ _ x ∙ ℤ.·IdR (ℤ.negsuc n)))))
+     ((⊥.rec ∘ ℤ.posNotnegsuc _ _ ∘ sym ) ∘S eq/⁻¹ _ _ )  ,
+      propBiimpl→Equiv (isProp< _ _) (isSetℚ _ _)
+        (λ _ → refl)
+         λ _ → minus-<' _ _ (0<→< (- [ ℤ.negsuc n , snd₁ ]) _))
+
+
+<→sign : ∀ x → (0 < x → sign x ≡ 1)
+               × (0 ≡ x → sign x ≡ 0)
+                 × (x < 0 → sign x ≡ -1)
+<→sign x =
+ let ((y , _) , (y' , _) , (y'' , _)) = <≃sign x
+ in (y , y' , y'')
+
+abs≡sign· : ∀ x → ℚ.abs x ≡ x ℚ.· (sign x)
+abs≡sign· x = abs'≡abs x ∙ ElimProp.go w x
+ where
+ w : ElimProp (λ z → abs' z ≡ z ℚ.· sign z)
+ w .ElimProp.isPropB _ = isSetℚ _ _
+ w .ElimProp.f x@(ℤ.pos zero , snd₁) = decℚ?
+ w .ElimProp.f x@(ℤ.pos (suc n) , snd₁) =
+  eq/ _ _ $
+    cong₂ ℤ._·_ (sym (ℤ.·IdR _)) (cong ℕ₊₁→ℤ (·₊₁-identityʳ (snd₁)))
+
+ w .ElimProp.f x@(ℤ.negsuc n , snd₁) = eq/ _ _
+   $ cong₂ ℤ._·_ (ℤ.·Comm (ℤ.negsuc 0) (ℤ.negsuc n) )
+      (cong ℕ₊₁→ℤ (·₊₁-identityʳ (snd₁)))
+
+absPos : ∀ x → 0 < x → abs x ≡ x
+absPos x 0<x = abs≡sign· x ∙∙ cong (x ℚ.·_) (fst (<→sign x) 0<x)  ∙∙ (ℚ.·IdR x)
+
+absNonNeg : ∀ x → 0 ≤ x → abs x ≡ x
+absNonNeg x 0<x with x ≟ 0
+... | lt x₁ = ⊥.rec $ ≤→≯ 0 x 0<x x₁
+... | eq x₁ = cong abs x₁ ∙ sym x₁
+... | gt x₁ = absPos x x₁
+
+
+
+absNeg : ∀ x → x < 0 → abs x ≡ - x
+absNeg x x<0 = abs≡sign· x ∙∙ cong (x ℚ.·_) (snd (snd (<→sign x)) x<0)
+                 ∙∙ ℚ.·Comm x -1
+
+
+
+0≤abs : ∀ x → 0 ≤ abs x
+0≤abs x with x ≟ 0
+... | lt x₁ = subst (0 ≤_) (sym (absNeg x x₁)) ((<Weaken≤ 0 (- x) (minus-< x 0 x₁) ))
+... | eq x₁ = subst ((0 ≤_) ∘ abs) (sym x₁) (isRefl≤ 0)
+... | gt x₁ = subst (0 ≤_) (sym (absPos x x₁)) (<Weaken≤ 0 x x₁)
+
+
+abs+pos : ∀ x y → 0 < x → abs (x ℚ.+ y) ≤ x ℚ.+ abs y
+abs+pos x y x₁ with y ≟ 0
+... | lt x₂ =
+ let xx = (≤-o+ y (- y) x
+            (<Weaken≤ y (- y) $ isTrans< y 0 (- y) x₂ ((minus-< y 0 x₂))))
+ in subst (λ yy → abs (x ℚ.+ y) ≤ x ℚ.+ yy)
+        (sym (absNeg y x₂)) (absFrom≤×≤ (x ℚ.- y) _
+          (subst (_≤ x ℚ.+ y)
+            (sym (-Distr' x y)) (≤-+o (- x) x y
+             (<Weaken≤ (- x) x $ isTrans< (- x) 0 x (minus-< 0 x x₁) x₁))) xx)
+... | eq x₂ = subst2 _≤_ (sym (absPos x x₁)
+        ∙ cong abs (sym (ℚ.+IdR x) ∙ cong (x ℚ.+_) ( (sym x₂))))
+   (sym (ℚ.+IdR x) ∙ cong (x ℚ.+_) (cong abs (sym x₂))  ) (isRefl≤ x)
+... | gt x₂ = subst2 _≤_ (sym (absPos _ (<Monotone+ 0 x 0 y x₁ x₂)))
+    (cong (x ℚ.+_) (sym (absPos y x₂)))
+   $ isRefl≤ (x ℚ.+ y)
+
+abs+≤abs+abs : ∀ x y → ℚ.abs (x ℚ.+ y) ≤ ℚ.abs x ℚ.+ ℚ.abs y
+abs+≤abs+abs x y with (x ≟ 0) | (y ≟ 0)
+... | _ | gt x₁ = subst2 (_≤_)
+                   (cong ℚ.abs (ℚ.+Comm y x))
+            ((ℚ.+Comm y (ℚ.abs x)) ∙ cong ((ℚ.abs x) ℚ.+_ ) (sym (absPos y x₁)))
+             (abs+pos y x x₁)
+... | eq x₁ | _ = subst2 _≤_ (cong ℚ.abs (sym (ℚ.+IdL y) ∙
+    cong (ℚ._+ y) (sym x₁) ))
+                    (sym (ℚ.+IdL (ℚ.abs y)) ∙
+                     cong (ℚ._+ (ℚ.abs y)) (cong ℚ.abs (sym x₁)))
+                      (isRefl≤ (ℚ.abs y))
+... | gt x₁ | _ = subst (ℚ.abs (x ℚ.+ y) ≤_)
+            (cong (ℚ._+ (ℚ.abs y)) (sym (absPos x x₁)))
+              (abs+pos x y x₁)
+... | lt x₁ | lt x₂ =
+  subst2 _≤_ (sym (-Distr x y) ∙ sym (absNeg (x ℚ.+ y)
+    (<Monotone+ x 0 y 0 x₁ x₂)))
+     (cong₂ ℚ._+_ (sym (absNeg x x₁)) (sym (absNeg y x₂))) (isRefl≤ ((- x) - y) )
+... | lt x₁ | eq x₂ =
+  subst2 _≤_ ((cong ℚ.abs (sym (ℚ.+IdR x) ∙
+    cong (x ℚ.+_) (sym x₂))))
+     (sym (ℚ.+IdR (ℚ.abs x)) ∙
+                     cong ((ℚ.abs x) ℚ.+_ ) (cong ℚ.abs (sym x₂)))
+    ((isRefl≤ (ℚ.abs x)))
+
+data Trichotomy0· (m n : ℚ) : Type₀ where
+  eqₘ₌₀ : m ≡ 0 → m ℚ.· n ≡ 0  → Trichotomy0· m n
+  eqₙ₌₀ : n ≡ 0 → m ℚ.· n ≡ 0 → Trichotomy0· m n
+  lt-lt : m < 0 → n < 0 → 0 < m ℚ.· n  → Trichotomy0· m n
+  lt-gt : m < 0 → 0 < n → m ℚ.· n < 0  → Trichotomy0· m n
+  gt-lt : 0 < m → n < 0 → m ℚ.· n < 0  → Trichotomy0· m n
+  gt-gt : 0 < m → 0 < n → 0 < m ℚ.· n  → Trichotomy0· m n
+
+trichotomy0· : ∀ m n → Trichotomy0· m n
+trichotomy0· m n with m ≟ 0 | n ≟ 0
+... | eq p | _    = eqₘ₌₀ p (cong (ℚ._· n) p ∙ ℚ.·AnnihilL n)
+... | _    | eq p = eqₙ₌₀ p (cong (m ℚ.·_) p ∙ ℚ.·AnnihilR m)
+... | lt x₁ | lt x₂ = lt-lt x₁ x₂
+  (subst (0 <_) (-·- m n)
+    (0<-m·n (- m) (- n) (minus-< m 0 x₁) (minus-< n 0 x₂)))
+... | lt x₁ | gt x₂ = lt-gt x₁ x₂
+ ((subst (m ℚ.· n <_) (ℚ.·AnnihilL n) $ <-·o m 0 n x₂ x₁ ))
+... | gt x₁ | lt x₂ = gt-lt x₁ x₂
+ (subst (m ℚ.· n <_) (ℚ.·AnnihilR m) $ <-o· n 0 m x₁ x₂ )
+... | gt x₁ | gt x₂ = gt-gt x₁ x₂ (0<-m·n m n x₁ x₂)
+
+sign·sign : ∀ x y → sign x ℚ.· sign y ≡ sign (x ℚ.· y)
+sign·sign x y = h $ trichotomy0· x y
+
+ where
+
+ x' = <→sign x
+ y' = <→sign y
+ x·y' = <→sign (x ℚ.· y)
+
+ h : Trichotomy0· x y → _ -- ℚ.·AnnihilL
+ h (eqₘ₌₀ p p₁) =
+  cong (ℚ._· sign y) (fst (snd x') (sym p))
+   ∙∙ ℚ.·AnnihilL _ ∙∙ sym (fst (snd x·y') (sym p₁))
+ h (eqₙ₌₀ p p₁) =   cong (sign x ℚ.·_) (fst (snd y') (sym p))
+   ∙∙ ℚ.·AnnihilR _ ∙∙ sym (fst (snd x·y') (sym p₁))
+ h (lt-lt p p₁ p₂) = cong₂ ℚ._·_ (snd (snd x') p) (snd (snd y') p₁)
+  ∙ (sym $ fst x·y' p₂)
+ h (lt-gt p p₁ p₂) = cong₂ ℚ._·_  (snd (snd x') p) (fst y' p₁)
+          ∙ sym (snd (snd x·y') p₂)
+ h (gt-lt p p₁ p₂) = cong₂ ℚ._·_ (fst x' p) (snd (snd y') p₁)
+          ∙ sym (snd (snd x·y') p₂)
+ h (gt-gt p p₁ p₂) = cong₂ ℚ._·_ (fst x' p) (fst y' p₁)
+  ∙ (sym $ fst x·y' p₂)
+
+0≤x² : ∀ x → 0 ≤ x ℚ.· x
+0≤x² = ElimProp.go w
+ where
+ w : ElimProp (λ z → 0 ≤ z ℚ.· z)
+ w .ElimProp.isPropB _ = isProp≤ _ _
+ w .ElimProp.f (p , q) = subst (0 ℤ.≤_) (sym (ℤ.·IdR _)) (ℤ.0≤x² p)
+
+signX·signX : ∀ x → 0 # x → sign x ℚ.· sign x ≡ 1
+signX·signX x y = sign·sign x x ∙
+   fst (fst (<≃sign (x ℚ.· x)))
+    (⊎.rec (λ z → 0<-m·n _ _ z z)
+      ((λ z → subst (0 <_) (-·- _ _) (0<-m·n _ _ z z)) ∘S minus-< x 0) y)
+
+abs·abs : ∀ x y → abs x ℚ.· abs y ≡ abs (x ℚ.· y)
+abs·abs x y = cong₂ ℚ._·_ (abs≡sign· x) (abs≡sign· y)
+ ∙∙ (sym (ℚ.·Assoc _ _ _)) ∙∙
+  cong (x ℚ.·_) (( (ℚ.·Assoc _ _ _)) ∙∙
+  cong (ℚ._· sign y) (ℚ.·Comm (sign x) y) ∙∙ (sym (ℚ.·Assoc _ _ _))) ∙∙ (ℚ.·Assoc _ _ _)
+ ∙∙ (λ i → x ℚ.· y ℚ.· sign·sign x y i) ∙ sym (abs≡sign· (x ℚ.· y))
+
+abs'·abs' : ∀ x y → abs' x ℚ.· abs' y ≡ abs' (x ℚ.· y)
+abs'·abs' x y = cong₂ ℚ._·_ (sym (abs'≡abs _)) (sym (abs'≡abs _))
+  ∙∙ abs·abs x y ∙∙ abs'≡abs _
+
+pos·abs : ∀ x y → 0 ≤ x →  abs (x ℚ.· y) ≡ x ℚ.· (abs y)
+pos·abs x y 0≤x = sym (abs·abs x y) ∙ cong (ℚ._· (abs y))
+  (absNonNeg x 0≤x)
+
+clamp≤ : ∀ L L' x → clamp L L' x ≤ L'
+clamp≤ L L' x = min≤' _ L'
+
+
+≤cases : ∀ x y → (x ≤ y) ⊎ (y ≤ x)
+≤cases x y with x ≟ y
+... | lt x₁ = inl (<Weaken≤ _ _ x₁)
+... | eq x₁ = inl (≡Weaken≤ _ _ x₁)
+... | gt x₁ = inr (<Weaken≤ _ _ x₁)
+
+elimBy≤ : ∀ {ℓ} {A : ℚ → ℚ → Type ℓ}
+  → (∀ x y → A x y → A y x)
+  → (∀ x y → x ≤ y → A x y)
+  → ∀ x y → A x y
+elimBy≤ s f x y = ⊎.rec
+  (f _ _ ) (s _ _ ∘ f _ _ ) (≤cases x y)
+
+elimBy≡⊎< : ∀ {ℓ} {A : ℚ → ℚ → Type ℓ}
+  → (∀ x y → A x y → A y x)
+  → (∀ x → A x x)
+  → (∀ x y → x < y → A x y)
+  → ∀ x y → A x y
+elimBy≡⊎< {A = A} s r f =
+ elimBy≤ s (λ x y → ⊎.rec (λ p → subst (A x) p (r x)) (f x y) ∘ ≤→≡⊎< x y)
+
+
+maxDistMin : ∀ x y z → ℚ.min (ℚ.max x y) z ≡ ℚ.max (ℚ.min x z) (ℚ.min y z)
+maxDistMin = elimBy≤
+ (λ x y p z → cong (flip ℚ.min z) (ℚ.maxComm y x)  ∙∙ p z ∙∙
+                ℚ.maxComm _ _ )
+ λ x y p z → cong (flip ℚ.min z) (≤→max x y p) ∙
+   sym (≤→max (ℚ.min x z) (ℚ.min y z) (≤MonotoneMin x y z z p (isRefl≤ z) ))
+
+
+
+minDistMax : ∀ x y y' → ℚ.max x (ℚ.min y y') ≡ ℚ.min (ℚ.max x y) (ℚ.max x y')
+minDistMax x = elimBy≤
+  (λ y y' X → cong (ℚ.max x) (ℚ.minComm _ _) ∙∙ X ∙∙ ℚ.minComm _ _)
+  λ y y' y≤y' → cong (ℚ.max x) (≤→min _ _ y≤y') ∙
+    sym (≤→min (ℚ.max x y) (ℚ.max x y')
+      (≤MonotoneMax x x y y' (isRefl≤ x) y≤y'))
+
+≤clamp : ∀ L L' x → L ≤ L' →  L ≤ clamp L L' x
+≤clamp L L' x y =
+ subst (L ≤_) (cong (λ y → ℚ.max y _) (sym $ ≤→min L L' y)
+      ∙ sym (maxDistMin L x L')) (≤max L (ℚ.min x L'))
+
+absComm- : ∀ x y → ℚ.abs (x ℚ.- y) ≡ ℚ.abs (y ℚ.- x)
+absComm- x y i = ℚ.maxComm (-[x-y]≡y-x y x (~ i)) (-[x-y]≡y-x x y i) i
+
+≤MonotoneClamp : ∀ L L' x y → x ≤ y → clamp L L' x ≤ clamp L L' y
+≤MonotoneClamp L L' x y p =
+ ≤MonotoneMin
+  (ℚ.max L x) (ℚ.max L y) L'
+   L' (≤MonotoneMax L L x y (isRefl≤ L) p) (isRefl≤ L')
+
+
+
+inClamps : ∀ L L' x → L ≤ x → x ≤ L' → clamp L L' x ≡ x
+inClamps L L' x u v =
+  cong (λ y → ℚ.min y L') (≤→max L x u)
+    ∙ ≤→min x L' v
+
+≤abs : ∀ x → x ≤ abs x
+≤abs x = ≤max x (ℚ.- x)
+
+≤abs' : ∀ x → x ≤ abs' x
+≤abs' x = subst (x ≤_) (abs'≡abs x) (≤abs x)
+
+
+-abs : ∀ x → ℚ.abs x ≡ ℚ.abs (ℚ.- x)
+-abs x = ℚ.maxComm _ _
+  ∙ cong (ℚ.max (ℚ.- x)) (sym (ℚ.-Invol x))
+
+-abs' : ∀ x → ℚ.abs' x ≡ ℚ.abs' (ℚ.- x)
+-abs' x = sym (ℚ.abs'≡abs x) ∙∙ -abs x ∙∙ ℚ.abs'≡abs (ℚ.- x)
+
+
+-≤abs' : ∀ x → ℚ.- x ≤ abs' x
+-≤abs' x = subst (- x ≤_) (sym (-abs' x)) (≤abs' (ℚ.- x))
+
+Dichotomyℚ : ∀ (n m : ℚ) → (n ≤ m) ⊎ (m < n)
+Dichotomyℚ n m = decRec inr (inl ∘ ≮→≥ _ _) (<Dec m n)
+
+sign·abs : ∀ x → abs x ℚ.· (sign x) ≡ x
+sign·abs x with 0 ≟ x
+... | lt x₁ =
+ cong₂ ℚ._·_ (absPos x x₁) (fst (<→sign x) x₁)
+    ∙ ℚ.·IdR x
+... | eq x₁ = cong (abs x ℚ.·_) ( (fst (snd (<→sign x)) x₁))
+ ∙ ·AnnihilR (abs x) ∙ x₁
+... | gt x₁ =
+  cong₂ ℚ._·_ (absNeg x x₁) (snd (snd (<→sign x)) x₁)
+    ∙ -·- _ _ ∙ ℚ.·IdR x
+
+
+0#→0<abs' : ∀ q → 0 # q → 0 < abs' q
+0#→0<abs' q (inl x) =
+  subst (0 <_) (sym (absPos q x) ∙ (abs'≡abs q)) x
+0#→0<abs' q (inr y) =
+  subst (0 <_) (sym (absNeg q y) ∙ (abs'≡abs q)) (minus-< q 0 y)
+
+0#→ℚ₊ : ∀ q → 0 # q → ℚ₊
+0#→ℚ₊ q x = abs' q , <→0< _ (0#→0<abs' q x)
+
+·Monotone0# : ∀ q q' → 0 # q → 0 # q' → 0 # (q ℚ.· q')
+·Monotone0# q q' (inl x) (inl x₁) =
+ inl (0<→< _ (·0< q q' (<→0< q x) (<→0< q' x₁)))
+·Monotone0# q q' (inl x) (inr x₁) =
+  inr (minus-<' 0 (q ℚ.· q')
+        (subst (0 <_) (((ℚ.·Comm  q (- q')) ∙ sym (ℚ.·Assoc -1 q' q))
+         ∙ cong (-_) (ℚ.·Comm _ _))
+         (0<→< _ (·0< q (- q') (<→0< q x) (<→0< _ (minus-< q' 0 x₁)))) ))
+·Monotone0# q q' (inr x) (inl x₁) =
+  inr (minus-<' 0 (q ℚ.· q')
+     (subst (0 <_) (sym (ℚ.·Assoc -1 q q'))
+       ((0<→< _ (·0< (- q) q' (<→0< _ (minus-< q 0 x)) (<→0< q' x₁))))))
+·Monotone0# q q' (inr x) (inr x₁) =
+ inl (subst (0 <_) (-·- _ _) (0<→< _
+     (·0< (- q) (- q') (<→0< _ (minus-< q 0 x)) (<→0< _ (minus-< q' 0 x₁)))) )
+
+
+
+0#sign : ∀ q → 0 # q ≃ 0 # (sign q)
+0#sign q =
+ propBiimpl→Equiv (isProp# _ _) (isProp# _ _)
+   (⊎.map (((flip (subst (0 <_))
+     (𝟚.toWitness {Q = <Dec 0 1} _)) ∘ sym) ∘S fst (<→sign q))
+     ((((flip (subst (_< 0))
+     (𝟚.toWitness {Q = <Dec -1 0} _)) ∘ sym) ∘S snd (snd (<→sign q)))))
+     (⊎.rec (⊎.rec ((λ y z → ⊥.rec (isIrrefl# (sign q) (subst (_# (sign q))
+        (sym y) z))) ∘S fst (snd (<→sign q))) (const ∘ inl) ∘ ≤→≡⊎< _ _ ) (λ x _ → inr x)
+      (Dichotomyℚ 0 q))
+
+
+
+-- floor-fracℚ₊ : ∀ (x : ℚ₊) → Σ (ℕ × ℚ) λ (k , q) →
+--                        (fromNat k + q ≡ fst x ) × (q < 1)
+-- floor-fracℚ₊ = uncurry (SQ.Elim.go w)
+
+-- ceil-fracℚ₊ : ∀ (x : ℚ₊) → Σ (ℕ × ℚ) λ (k , q) →
+--                        (fromNat k + q ≡ fst x ) × (q < 1)
+-- ceil-fracℚ₊ = uncurry (SQ.Elim.go w)
+
+boundℕ : ∀ q → Σ[ k ∈ ℕ₊₁ ] (abs q < ([ ℕ₊₁→ℤ k , 1 ]))
+boundℕ q with ≤→≡⊎< 0 (abs q) (0≤abs q)
+... | inl x = 1 , subst (_< 1) x (decℚ<? {0} {1})
+... | inr x =
+ let ((k , f) , e , e' , e'') = floor-fracℚ₊ (abs q , <→0< _ x)
+ in (1+ k , subst2 (_<_)
+          (+Comm f _ ∙ e)
+           (ℕ+→ℚ+ 1 k) ((<-+o f 1 [ pos k / 1+ 0 ] e'')))
+
+
+isSetℚ₊ : isSet ℚ₊
+isSetℚ₊ = isSetΣ isSetℚ λ q → isProp→isSet (snd (0<ₚ q))
+
+invℚ₊ : ℚ₊ → ℚ₊
+invℚ₊ = uncurry (Elim.go w)
+ where
+
+ w : Elim (λ z → (y : 0< z) → ℚ₊)
+ w .Elim.isSetB _ = isSetΠ λ _ → isSetℚ₊
+ w .Elim.f ( x , y ) z = [ (ℕ₊₁→ℤ y) , (fst (ℤ.0<→ℕ₊₁ x z)) ] , _
+ w .Elim.f∼ r@( x , y ) r'@( x' , y' ) p = ua→ (ℚ₊≡ ∘ eq/ _ _ ∘
+    h x y x' y' p )
+  where
+  h : ∀ x y x' y' → (p : (x , y) ∼ (x' , y')) → (a : ℤ.0< x) →
+           ( ℕ₊₁→ℤ y , fst (ℤ.0<→ℕ₊₁ x a) ) ∼
+           ( ℕ₊₁→ℤ y' , fst (ℤ.0<→ℕ₊₁ x'
+             (ℤ.0<·ℕ₊₁ x' y (subst ℤ.0<_ p (ℤ.·0< x (pos (ℕ₊₁→ℕ y')) a tt))) ) )
+
+  h x y x' y' p a with (ℤ.0<·ℕ₊₁ x' y (subst ℤ.0<_ p (ℤ.·0< x (pos (ℕ₊₁→ℕ y')) a tt)))
+  h (pos (suc n)) (1+ y) (pos (suc n₁)) (1+ y') p a | w =
+     ℤ.·Comm (pos (suc y)) (pos (suc n₁))
+       ∙∙ (sym p) ∙∙
+        sym (ℤ.·Comm (pos (suc y')) (pos (suc n)))
+
+invℚ₊-invol : ∀ x → fst (invℚ₊ (invℚ₊ x)) ≡ fst  x
+invℚ₊-invol = uncurry (ElimProp.go w)
+ where
+ w : ElimProp _
+ w .ElimProp.isPropB _ = isPropΠ λ _ → SQ.squash/ _ _
+ w .ElimProp.f x y = eq/ _ _ (ww x y)
+  where
+  ww : ∀ x x₁ → (ℕ₊₁→ℤ (fst (ℤ.0<→ℕ₊₁ (x .fst) x₁)) , (1+ x .snd .ℕ₊₁.n)) ∼ x
+  ww (pos (suc n) , snd₁) x₁ = refl
+
+x·invℚ₊[x] : ∀ x → fst x · fst (invℚ₊ x) ≡ 1
+x·invℚ₊[x] = uncurry (ElimProp.go w)
+ where
+ w : ElimProp _
+ w .ElimProp.isPropB _ = isPropΠ λ _ → isSetℚ _ _
+ w .ElimProp.f (pos (suc n) , 1+ y) u =
+   eq/ _ _ (ℤ.·IdR
+    (pos (suc (y)) ℤ.+ pos n ℤ.· pos (suc (y)))
+         ∙ cong (pos (suc y) ℤ.+_) (sym (ℤ.pos·pos n (suc y)))
+          ∙ (λ i → (ℤ.pos+ (suc y) (ℕ.·-comm n (suc y) i)) (~ i)) ∙
+           cong (pos ∘ suc) ((λ i → ℕ.+-assoc y n (ℕ.·-comm y n i) i)
+             ∙ (cong (ℕ._+ n ℕ.· y) (ℕ.+-comm y n) ∙
+               (sym (ℕ.+-assoc n y _)))
+               ∙ cong (n ℕ.+_) (sym (ℕ.·-comm y (suc n)))))
+
+invℚ₊[x]·x : ∀ x →  fst (invℚ₊ x) · fst x ≡ 1
+invℚ₊[x]·x x = cong (fst (invℚ₊ x) ·_) (sym $ invℚ₊-invol x)
+  ∙ x·invℚ₊[x] (invℚ₊ x)
+
+[y·x]/y : ∀ y x → fst (invℚ₊ y) · (fst y · x) ≡ x
+[y·x]/y y x = ·Assoc (fst (invℚ₊ y)) (fst y) x
+     ∙∙ cong (_· x) (·Comm (fst (invℚ₊ y)) (fst y) ∙ x·invℚ₊[x] y)
+     ∙∙ ·IdL x
+
+y·[x/y] : ∀ y x →  fst y · (fst (invℚ₊ y) · x) ≡ x
+y·[x/y] y x = cong (_· (fst (invℚ₊ y) · x)) (sym (invℚ₊-invol y))
+ ∙ [y·x]/y (invℚ₊ y) x
+
+invℚ₊Dist· : ∀ x y → (invℚ₊ x) ℚ₊· (invℚ₊ y) ≡ (invℚ₊ (x ℚ₊· y))
+invℚ₊Dist· = uncurry (flip ∘ uncurry ∘ ElimProp2.go w)
+ where
+ w : ElimProp2
+       (λ z z₁ →
+          (y : 0< z₁) (y₁ : 0< z) →
+          (invℚ₊ (z , y₁) ℚ₊· invℚ₊ (z₁ , y)) ≡
+          invℚ₊ ((z , y₁) ℚ₊· (z₁ , y)))
+ w .ElimProp2.isPropB _ _ = isPropΠ2 λ _ _ → isSetℚ₊ _ _
+ w .ElimProp2.f x y y₁ y₂ =
+  let qq : ((x .fst) ℤ.· (y .fst)) ≡
+            (ℕ₊₁→ℤ (fst (ℤ.0<→ℕ₊₁ (x .fst) y₂) ·₊₁ fst (ℤ.0<→ℕ₊₁ (y .fst) y₁)))
+      qq = cong₂ ℤ._·_ (snd (ℤ.0<→ℕ₊₁ (x .fst) y₂))
+                (snd (ℤ.0<→ℕ₊₁ (y .fst) y₁))
+          ∙ sym (ℤ.pos·pos (ℕ₊₁→ℕ (fst (ℤ.0<→ℕ₊₁ (x .fst) y₂)))
+                        (ℕ₊₁→ℕ (fst (ℤ.0<→ℕ₊₁ (y .fst) y₁))))
+      zz : ((ℕ₊₁→ℤ (y .snd) ℤ.+ pos (x .snd .ℕ₊₁.n) ℤ.· ℕ₊₁→ℤ (y .snd)))
+             ℤ.· (x .fst ℤ.· y .fst)
+             ≡
+           ( 1 ℤ.·  ((x .fst) ℤ.· (y .fst)))
+               ℤ.+
+                pos (y .snd .ℕ₊₁.n ℕ.+ x .snd .ℕ₊₁.n ℕ.· suc (y .snd .ℕ₊₁.n))
+             ℤ.· (((x .fst) ℤ.· (y .fst)))
+      zz = congS
+           {x = ((ℕ₊₁→ℤ (y .snd) ℤ.+ pos (x .snd .ℕ₊₁.n) ℤ.· ℕ₊₁→ℤ (y .snd)))}
+           {1 ℤ.+ pos (y .snd .ℕ₊₁.n ℕ.+ x .snd .ℕ₊₁.n ℕ.· suc (y .snd .ℕ₊₁.n))}
+           (ℤ._· (x .fst ℤ.· y .fst))
+             (cong₂ (ℤ._+_)
+                 (ℤ.pos+ 1 (y .snd .ℕ₊₁.n))
+                 (sym (ℤ.pos·pos (x .snd .ℕ₊₁.n) _))
+               ∙ sym (ℤ.+Assoc 1 (pos (y .snd .ℕ₊₁.n))
+                     (pos ((x .snd .ℕ₊₁.n) ℕ.· ℕ₊₁→ℕ (y .snd))))
+                      ∙ cong (1 ℤ.+_)
+                        (sym (ℤ.pos+ (y .snd .ℕ₊₁.n) _)))
+         ∙ ℤ.·DistL+ 1
+       (pos (y .snd .ℕ₊₁.n ℕ.+ x .snd .ℕ₊₁.n ℕ.· suc (y .snd .ℕ₊₁.n)))
+          ((x .fst) ℤ.· (y .fst))
+
+  in ℚ₊≡ (eq/ _ _
+             ((λ i →
+                ((ℕ₊₁→ℤ (y .snd) ℤ.+ pos (x .snd .ℕ₊₁.n) ℤ.· ℕ₊₁→ℤ (y .snd)))
+             ℤ.·
+              ((snd
+                (ℤ.0<→ℕ₊₁ (x .fst ℤ.· y .fst) (·0< _//_.[ x ] _//_.[ y ] y₂ y₁))
+                 (~ i))))
+              ∙ zz ∙
+
+                λ i → ((ℤ.·IdL (qq i) i))
+               ℤ.+
+                pos (y .snd .ℕ₊₁.n ℕ.+ x .snd .ℕ₊₁.n ℕ.· suc (y .snd .ℕ₊₁.n))
+             ℤ.· qq i))
+
+
+
+
+
+
+/2₊ : ℚ₊ → ℚ₊
+/2₊ = _ℚ₊· ([ 1 / 2 ] , tt)
+
+/3₊ : ℚ₊ → ℚ₊
+/3₊ = _ℚ₊· ([ 1 / 3 ] , tt)
+
+/4₊ : ℚ₊ → ℚ₊
+/4₊ = _ℚ₊· ([ 1 / 4 ] , tt)
+
+
+/4₊+/4₊≡/2₊ : ∀ ε → (/4₊ ε) ℚ₊+ (/4₊ ε) ≡ /2₊ ε
+/4₊+/4₊≡/2₊ ε = ℚ₊≡ (sym (·DistL+ (fst ε) [ 1 / 4 ] [ 1 / 4 ])
+   ∙ cong (fst ε ·_) decℚ?)
+
+weak0< : ∀ q (ε δ : ℚ₊)
+             →  q < (fst ε - fst δ)
+             → q < fst ε
+weak0< q ε δ x =
+  let z = <Monotone+ q (fst ε - fst δ) 0 (fst δ) x (0<→< (fst δ) (snd δ))
+   in subst2 _<_
+       (+IdR q) (lem--00 {fst ε} {fst δ}) z
+
+
+
+weak0<' : ∀ q (ε δ : ℚ₊)
+             → - (fst ε - fst δ) < q
+             → - (fst ε) < q
+weak0<' q ε δ x =
+  let z = <Monotone+ (- (fst ε - fst δ)) q (- fst δ) 0 x
+           (minus-< 0 (fst δ) ((0<→< (fst δ) (snd δ))))
+  in subst2 {x = (- (fst ε - fst δ)) + (- fst δ)}
+         {y = - (fst ε)} _<_  (lem--01 {fst ε} {fst δ}) (+IdR q) z
+
+n/k+m/k : ∀ n m k → [ n / k ] + [ m / k ] ≡ [ n ℤ.+ m / k ]
+n/k+m/k n m k = let k' = pos (suc (k .ℕ₊₁.n)) in
+  eq/ _ _
+  (cong (ℤ._· k') (sym (ℤ.·DistL+ n m k') ) ∙∙
+    sym (ℤ.·Assoc (n ℤ.+ m) k' k') ∙∙
+     cong ((n ℤ.+ m) ℤ.·_) (sym (ℤ.pos·pos (ℕ₊₁→ℕ k) (ℕ₊₁→ℕ k))))
+
+k/k : ∀ k → [ ℕ₊₁→ℤ k / k ] ≡ 1
+k/k (1+ k) = eq/ _ _ (ℤ.·IdR (ℕ₊₁→ℤ (1+ k)))
+
+1/[k+1]+k/[k+1] : (k : ℕ₊₁) →
+                    [ 1 / suc₊₁ k ] + [ pos (ℕ₊₁→ℕ k) / suc₊₁ k ] ≡ 1
+1/[k+1]+k/[k+1] k =
+  n/k+m/k 1 (pos (ℕ₊₁→ℕ k)) (suc₊₁ k)  ∙∙
+   cong [_/ (suc₊₁ k) ]
+    (ℤ.+Comm 1 (pos (ℕ₊₁→ℕ k))) ∙∙ k/k (suc₊₁ k)
+
+
+0</k : ∀ (q q' : ℚ₊) (k : ℕ₊₁) →
+          0< ((fst q - fst q') )
+           → 0< ((fst q - fst (q' ℚ₊· ([ 1 / (suc₊₁ k) ] , tt))) )
+0</k q q' (1+ k) x =
+   subst {x = (fst q - fst q') +
+     (fst (([ pos (suc k)  / (1+ (suc k)) ] , tt) ℚ₊· q'))}
+       {y = ((fst q - fst (q' ℚ₊· ([ 1 / 1+ (suc k) ] , tt))) )}  0<_
+     ( sym (+Assoc (fst q) (- fst q') (fst (([ pos (suc k) / 2+ k ] , tt) ℚ₊· q'))) ∙ cong (fst q +_)
+     (sym (·DistR+ (-1) [ pos (suc k) / 1+ (suc k) ] (fst q')) ∙
+        (cong (_· (fst q'))
+           (sym (-Distr' 1 ([ pos (ℕ₊₁→ℕ (1+ k)) / suc₊₁ (1+ k) ]))
+              ∙ sym (cong (-_) $ +CancelL- [ 1 / suc₊₁ (1+ k) ] [ pos (ℕ₊₁→ℕ (1+ k)) / suc₊₁ (1+ k) ] _ (1/[k+1]+k/[k+1] (1+ k))))
+          ∙∙ sym (·Assoc -1 [ pos 1 / 2+ k ] (fst q') )
+         ∙∙ (cong (-_) (·Comm  [ pos 1 / 2+ k ]  (fst q')) ) ))
+       ) (+0< (fst q - fst q')
+    (fst (([ pos (suc k)  / (1+ (suc k)) ] , tt) ℚ₊· q')) x
+     ((snd (([ pos (suc k)  / (1+ (suc k)) ] , tt) ℚ₊· q'))) )
+
+-- x/k<x : ∀ x k → fst (x ℚ₊· ([ 1 / (1+ (suc k)) ] , tt)) < fst x
+-- x/k<x x k =
+--   let z = {!0</k k !}
+--   in {!!}
+
+
+ε/2+ε/2≡ε : ∀ ε → (ε · [ 1 / 2 ]) + (ε · [ 1 / 2 ]) ≡ ε
+ε/2+ε/2≡ε ε =
+ sym (·DistL+ ε [ pos 1 / 1+ 1 ] [ pos 1 / 1+ 1 ]) ∙∙
+   cong (ε ·_) (1/[k+1]+k/[k+1] 1) ∙∙ ·IdR ε
+
+ε/3+ε/3+ε/3≡ε : ∀ ε → (ε · [ 1 / 3 ]) +
+                ((ε · [ 1 / 3 ]) + (ε · [ 1 / 3 ])) ≡ ε
+ε/3+ε/3+ε/3≡ε ε =
+ (cong (ε · [ pos 1 / 1+ 2 ] +_)
+    (sym (·DistL+ ε [ pos 1 / 1+ 2 ] [ pos 1 / 1+ 2 ])
+      ∙ cong (ε ·_) decℚ?)
+   ∙ sym (·DistL+ ε [ pos 1 / 1+ 2 ] [ pos 2 / 1+ 2 ]))
+   ∙∙ cong (ε ·_) (decℚ?) ∙∙ ·IdR ε
+
+ε/6+ε/6≡ε/3 : ∀ ε → (ε · [ 1 / 6 ]) + (ε · [ 1 / 6 ]) ≡
+               (ε · [ 1 / 3 ])
+ε/6+ε/6≡ε/3 ε = sym (·DistL+ ε _ _)
+  ∙ cong (ε ·_) decℚ?
+
+
+x/2<x : (ε : ℚ₊)
+           → (fst ε) · [ pos 1 / 1+ 1 ] < fst ε
+x/2<x ε =
+ let ε/2 = /2₊ ε
+     z = <-+o 0 (fst ε/2) ((fst ε/2)) $ 0<→< (fst ε/2) (snd ε/2)
+ in subst2 (_<_) (+IdL (fst ε/2))
+      (ε/2+ε/2≡ε (fst ε)) z
+
+
+getθ : ∀ (ε : ℚ₊) q → (((- fst ε) < q) × (q < fst ε)) →
+   Σ ℚ₊ λ θ → (0< (fst ε - fst θ))
+     × ((- (fst ε - fst θ) < q) × (q < (fst ε - fst θ)))
+getθ ε q (x , x') =
+ let m1< = <→0< (fst ε + q)
+            (subst (_< fst ε + q) (+InvR (fst ε))
+                   (<-o+  (- fst ε) q  (fst ε) x)
+                    )
+     m1 = (/2₊ (fst ε + q ,
+                   m1<))
+     m2< = <→0< (fst ε - q) $ subst (_< fst ε + (- q))
+              ((+InvR q)) (<-+o q (fst ε) (- q) x')
+     m2 = (/2₊ (fst ε - q , m2<))
+     mm = (min₊ m1 m2)
+     z'1 : fst mm < (fst ε + q)
+
+     z'1 = isTrans≤<
+            (fst mm)
+            ((fst ε + q) · [ 1 / 2 ])
+            (fst ε + q)
+             (min≤ ((fst ε + q) · [ 1 / 2 ])
+                  ((fst ε - q) · [ 1 / 2 ]))
+                  (x/2<x ((fst ε + q) , m1<))
+     z'2 : fst mm < (fst ε - q)
+
+     z'2 =
+        isTrans≤< (fst mm)
+            _
+            (fst ε - q)
+            (isTrans≤ (fst mm)
+                        _
+                        _
+               (≡Weaken≤ _ _
+                 (minComm (((fst ε + q) · [ 1 / 2 ]))
+                    (((fst ε - q) · [ 1 / 2 ]))))
+               (min≤ ((fst ε - q) · [ 1 / 2 ])
+                 ((fst ε + q) · [ 1 / 2 ])))
+            (x/2<x ((fst ε - q) , m2<))
+ in  mm ,
+             <→0< (fst ε - fst mm)
+               ( let zz = (<-·o ((fst mm) + (fst mm))
+                                 ((fst ε + q) + (fst ε - q))
+                               [ pos 1 / 1+ 1 ]
+                                 (0<→< [ pos 1 / 1+ 1 ] tt )
+                          (<Monotone+ (fst mm) (fst ε + q)
+                             (fst mm) (fst ε - q)
+                             z'1 z'2))
+                     zz' = subst2 _<_
+                             (·DistR+ (fst mm) (fst mm) [ pos 1 / 1+ 1 ]
+                                ∙ ε/2+ε/2≡ε (fst mm))
+                              (cong
+                                {x = ((fst ε + q) + (fst ε - q))}
+                                {y = (fst ε + fst ε)}
+                                (_· [ pos 1 / 1+ 1 ])
+                                (lem--02 {fst ε} {q})
+                                ∙∙ ·DistR+ (fst ε) (fst ε) [ pos 1 / 1+ 1 ]
+                                ∙∙ ε/2+ε/2≡ε (fst ε))
+                              zz
+                 in -< (fst mm) (fst ε)  zz')
+           , (subst2 _<_ (lem--03 {fst ε} {fst mm})
+                                 (lem--04 {fst ε} {q})
+                      (<-o+ (fst mm)
+                              (fst ε + q) (- fst ε) z'1)
+           , subst2 _<_ (lem--05 {fst mm} {q})
+                             (lem--06 {fst ε} {q} {fst mm})
+                       (<-+o (fst mm)
+                              (fst ε - q)
+                               (q - fst mm)
+                               z'2))
+
+
+strength-lem-01 : (ε q' a'' : ℚ₊) →
+                    0< (fst ε + (- fst q') + (- fst a''))
+                    → 0< (fst ε - fst a'')
+strength-lem-01 ε q' a'' x =
+   let z = +0< ((fst ε + (- fst q') + (- fst a'')))
+                (fst q') x (snd q')
+    in subst  {x = ((fst ε + (- fst q') + (- fst a''))) +
+                fst q' }
+        {y = (fst ε - fst a'')} 0<_ (lem--07 {fst ε} {fst q'} {fst a''}) z
+
+
+x/2+[y-x]=y-x/2 : ∀ (x y : ℚ₊) →
+   fst (/2₊ x) + (fst y - fst x) ≡
+     fst y - fst (/2₊ x)
+x/2+[y-x]=y-x/2 x y =
+  cong (λ xx → fst (/2₊ x) + (fst y - xx)) (sym (ε/2+ε/2≡ε (fst x)))
+    ∙ lem-05 (fst (/2₊ x)) (fst y)
+
+
+
+elimBy≡⊎<' : ∀ {ℓ} {A : ℚ → ℚ → Type ℓ}
+  → (∀ x y → A x y → A y x)
+  → (∀ x → A x x)
+  → (∀ x (ε : ℚ₊) → A x (x + fst ε))
+  → ∀ x y → A x y
+elimBy≡⊎<' {A = A} s r f' =
+ elimBy≤ s (λ x y → ⊎.rec (λ p → subst (A x) p (r x)) (f x y) ∘ ≤→≡⊎< x y)
+
+ where
+ f : ∀ x y → x < y → A x y
+ f x y v = subst (A x) lem--05 $ f' x (<→ℚ₊ x y v)
+
+
+
+module HLP where
+
+
+
+ data GExpr : Type where
+  ge[_] : ℚ → GExpr
+  neg-ge_ : GExpr → GExpr
+  _+ge_ : GExpr → GExpr → GExpr
+  _·ge_ : GExpr → GExpr → GExpr
+  ge1 : GExpr
+
+ infixl 6 _+ge_
+ infixl 7 _·ge_
+
+
+ ·GE : ℚ → GExpr → GExpr
+ ·GE ε ge[ x ] = ge[ ε · x ]
+ ·GE ε (neg-ge x) = (neg-ge (·GE ε x))
+ ·GE ε (x +ge x₁) = ·GE ε x +ge ·GE ε x₁
+ ·GE ε (x ·ge x₁) = (·GE ε x) ·ge x₁
+ ·GE ε ge1 = ge[ ε ]
+
+ evGE : GExpr → ℚ
+ evGE ge[ x ] = x
+ evGE (neg-ge x) = - evGE x
+ evGE (x +ge x₁) = evGE x + evGE x₁
+ evGE (x ·ge x₁) = evGE x · evGE x₁
+ evGE ge1 = 1
+
+ ·mapGE : ∀ ε e → ε · evGE e ≡ evGE (·GE ε e)
+ ·mapGE ε ge[ x ] = refl
+ ·mapGE ε (neg-ge e) = ·Assoc _ _ _ ∙∙
+   cong (_· evGE e) (·Comm ε -1) ∙
+    sym (·Assoc _ _ _) ∙∙ cong (-_) (·mapGE ε e)
+ ·mapGE ε (e +ge e₁) =
+   ·DistL+ ε _ _ ∙ λ i → (·mapGE ε e i) + (·mapGE ε e₁ i)
+ ·mapGE ε (e ·ge e₁) = ·Assoc _ _ _ ∙ cong (_· evGE e₁) (·mapGE ε e)
+ ·mapGE ε (ge1) = ·IdR ε
+
+
+ infixl 20 distℚ!_·[_≡_]
+
+
+ distℚ!_·[_≡_] : (ε : ℚ) → (lhs rhs : GExpr)
+    → {𝟚.True (discreteℚ (evGE lhs) (evGE rhs))}
+     → (evGE (·GE ε lhs)) ≡ (evGE (·GE ε rhs))
+ distℚ! ε ·[ lhs ≡ rhs ] {p} =
+   sym (·mapGE ε lhs) ∙∙ cong (ε ·_) (𝟚.toWitness p)  ∙∙
+    ·mapGE ε rhs
+
+ infixl 20 distℚ<!_[_<_]
+
+ distℚ<!_[_<_] : (ε : ℚ₊) → (lhs rhs : GExpr)
+    → {𝟚.True (<Dec (evGE lhs) (evGE rhs))}
+     → (evGE (·GE (fst ε) lhs)) < (evGE (·GE (fst ε) rhs))
+ distℚ<! ε [ lhs < rhs ] {p} =
+   subst2 _<_ (·mapGE (fst ε) lhs) (·mapGE (fst ε) rhs)
+     (<-o· _ _ (fst ε) (0<ℚ₊ ε) (𝟚.toWitness p))
+
+
+ distℚ≤!_[_≤_] : (ε : ℚ₊) → (lhs rhs : GExpr)
+    → {𝟚.True (≤Dec (evGE lhs) (evGE rhs))}
+     → (evGE (·GE (fst ε) lhs)) ≤ (evGE (·GE (fst ε) rhs))
+ distℚ≤! ε [ lhs ≤ rhs ] {p} =
+   subst2 _≤_ (·mapGE (fst ε) lhs) (·mapGE (fst ε) rhs)
+     (≤-o· _ _ (fst ε) (0≤ℚ₊ ε) (𝟚.toWitness p))
+
+ distℚ0<! : (ε : ℚ₊) → (rhs : GExpr)
+    → {𝟚.True (<Dec 0 (evGE rhs))}
+     →  0< (evGE (·GE (fst ε) rhs))
+ distℚ0<! ε rhs {p} =
+  <→0< _
+   (subst2 _<_ (·mapGE (fst ε) ge[ 0 ] ∙ ·AnnihilR (fst ε))
+    (·mapGE (fst ε) rhs)
+     (<-o· _ _ (fst ε) (0<ℚ₊ ε) (𝟚.toWitness p)))
+
+
+open HLP public
+
+
+-<⁻¹ : ∀ q r → 0 < r - q → q < r
+-<⁻¹ q r x = subst2 (_<_)
+ (+IdL q) ((sym (lem--035 {r} {q}))) (<-+o 0 (r - q) q x)
+
+
+riseQandD : ∀ p q r → Path ℚ ([ p / q ]) ([ p ℤ.· ℕ₊₁→ℤ r / (q ·₊₁ r) ])
+riseQandD p q r =
+ let z = _
+ in sym (·IdR z) ∙ cong (z ·_) (eq/ _ ( ℕ₊₁→ℤ r , r ) (ℤ.·Comm _ _))
+
+
++MaxDistrℚ : ∀ x y z → (max x y) + z ≡ max (x + z) (y + z)
++MaxDistrℚ = SQ.elimProp3 (λ _ _ _ → isSetℚ _ _)
+  λ (a , a') (b , b') (c , c') →
+   let zzz' : ∀ a' b' c' →
+            (ℤ.max (a ℤ.· b') (b ℤ.· a') ℤ.· (pos c') ℤ.+ c ℤ.· (a' ℤ.· b'))
+                 ≡
+            (ℤ.max ((a ℤ.· (pos c') ℤ.+ c ℤ.· a') ℤ.· b')
+                   ((b ℤ.· (pos c') ℤ.+ c ℤ.· b') ℤ.· a'))
+       zzz' a' b' c' =
+            cong (ℤ._+ _) (ℤ.·DistPosLMax _ _ _ ∙
+              cong₂ ℤ.max (sym (ℤ.·Assoc _ _ _) ∙∙
+                  cong (a ℤ.·_) (ℤ.·Comm _ _) ∙∙ (ℤ.·Assoc _ _ _))
+                  ((sym (ℤ.·Assoc _ _ _) ∙∙
+                  cong (b ℤ.·_) (ℤ.·Comm _ _) ∙∙ (ℤ.·Assoc _ _ _))))
+          ∙∙ ℤ.+DistLMax _ _ _
+          ∙∙ cong₂ ℤ.max
+               (cong (_ ℤ.+_) (ℤ.·Assoc _ _ _) ∙ sym (ℤ.·DistL+ _ _ _))
+               ((cong (((_ ℤ.· _) ℤ.· _)
+                      ℤ.+_) (cong (_ ℤ.·_) (ℤ.·Comm _ _)
+                        ∙ ℤ.·Assoc _ _ _) ∙ sym (ℤ.·DistL+ _ _ _)))
+       z* = _
+
+   in congS (SQ.[_] ∘S (_, a' ·₊₁ b' ·₊₁ c'))
+        (  congS ((λ ab → ℤ.max (a ℤ.· ℕ₊₁→ℤ b') (b ℤ.· ℕ₊₁→ℤ a')
+             ℤ.· pos (suc (ℕ₊₁.n c')) ℤ.+
+             ab) ∘ (c ℤ.·_)) (ℤ.pos·pos _ _)
+              ∙ zzz' (ℕ₊₁→ℤ a') (ℕ₊₁→ℤ b') (suc (ℕ₊₁.n c')))
+        ∙∙ (sym (·IdR z*) ∙ cong (z* ·_)
+            (eq/ _ ( ℕ₊₁→ℤ c' , c' )
+          (ℤ.·Comm _ _)) ) ∙∙
+         congS (SQ.[_])
+          (cong₂ _,_
+          ((ℤ.·DistPosLMax
+                 ((a ℤ.· pos (suc (ℕ₊₁.n c')) ℤ.+ c ℤ.· ℕ₊₁→ℤ a') ℤ.· ℕ₊₁→ℤ b')
+                 ((b ℤ.· pos (suc (ℕ₊₁.n c')) ℤ.+ c ℤ.· ℕ₊₁→ℤ b') ℤ.· ℕ₊₁→ℤ a')
+             (suc (ℕ₊₁.n c'))) ∙ cong₂
+            ℤ.max
+              (sym (ℤ.·Assoc _ _ _) ∙
+                  cong ((a ℤ.· ℕ₊₁→ℤ c' ℤ.+ c ℤ.· ℕ₊₁→ℤ a') ℤ.·_)
+                   ((sym (ℤ.pos·pos (ℕ₊₁→ℕ b') (ℕ₊₁→ℕ c')))) )
+               ((sym (ℤ.·Assoc _ _ _)) ∙
+                cong ((b ℤ.· ℕ₊₁→ℤ c' ℤ.+ c ℤ.· ℕ₊₁→ℤ b') ℤ.·_)
+                              (sym (ℤ.pos·pos (ℕ₊₁→ℕ a') (ℕ₊₁→ℕ c')))))
+
+          (cong (_·₊₁ c')
+            (sym (·₊₁-assoc _ _ _) ∙∙
+              ((λ i → a' ·₊₁ (·₊₁-comm b' c' i)))
+               ∙∙ ·₊₁-assoc _ _ _) ∙ sym (·₊₁-assoc _ _ _))
+             )
+
++MinDistrℚ : ∀ x y z → (min x y) + z ≡ min (x + z) (y + z)
++MinDistrℚ = SQ.elimProp3 (λ _ _ _ → isSetℚ _ _)
+  λ (a , a') (b , b') (c , c') →
+   let z : ∀ a' b' c' →
+              (ℤ.min (a ℤ.· pos b') (b ℤ.· pos a') ℤ.· pos c'
+                 ℤ.+ c ℤ.· (pos a' ℤ.· pos b')) ℤ.· pos c'
+               ≡
+               ℤ.min
+                ((a ℤ.· pos c' ℤ.+ c ℤ.· pos a') ℤ.· (pos b' ℤ.· pos c'))
+                ((b ℤ.· pos c' ℤ.+ c ℤ.· pos b') ℤ.· (pos a' ℤ.· pos c'))
+
+       z a' b' c' =  cong (ℤ._· pos c') (
+         cong (ℤ._+ c ℤ.· (pos a' ℤ.· pos b')) (
+          ℤ.·DistPosLMin _ _ _)
+            ∙ ℤ.+DistLMin _ _ _ ) ∙
+            ℤ.·DistPosLMin _ _ _ ∙ cong₂ ℤ.min
+              (Lems.lem--042 ℤCommRing )
+              (Lems.lem--043 ℤCommRing)
+   in riseQandD
+         (ℤ.min (a ℤ.· ℕ₊₁→ℤ b') (b ℤ.· ℕ₊₁→ℤ a') ℤ.· ℕ₊₁→ℤ c' ℤ.+
+               c ℤ.· ℕ₊₁→ℤ (a' ·₊₁ b')) ( a' ·₊₁ b' ·₊₁ c') c'
+            ∙ congS (SQ.[_])
+              (cong₂ _,_
+                 ((λ i →
+                      (ℤ.min (a ℤ.· ℕ₊₁→ℤ b') (b ℤ.· ℕ₊₁→ℤ a') ℤ.· ℕ₊₁→ℤ c' ℤ.+
+                         c ℤ.· ℤ.pos·pos (ℕ₊₁→ℕ a') (ℕ₊₁→ℕ b') (i))
+                        ℤ.· ℕ₊₁→ℤ c' )
+                   ∙∙ z (suc (ℕ₊₁.n a')) (suc (ℕ₊₁.n b')) (suc (ℕ₊₁.n c'))
+                   ∙∙ λ i → ℤ.min ((a ℤ.· ℕ₊₁→ℤ c' ℤ.+ c ℤ.· ℕ₊₁→ℤ a')
+                    ℤ.· ℤ.pos·pos (ℕ₊₁→ℕ b') (ℕ₊₁→ℕ c') (~ i))
+                     ((b ℤ.· ℕ₊₁→ℤ c' ℤ.+ c ℤ.· ℕ₊₁→ℤ b')
+                       ℤ.· ℤ.pos·pos (ℕ₊₁→ℕ a') (ℕ₊₁→ℕ c') (~ i)))
+                 (cong (_·₊₁ c') (sym (·₊₁-assoc _ _ _)
+                     ∙∙ cong (a' ·₊₁_) (·₊₁-comm _ _) ∙∙ (·₊₁-assoc _ _ _))
+                    ∙ sym (·₊₁-assoc _ _ _)))
+
+
+clampDiff : ∀ L L' x → clamp L L' x ≡
+               (x + clamp (L - x) (L' - x) 0)
+clampDiff L L' x =
+     cong₂ min
+       (cong₂ max (lem--035 {L} {x})
+         (sym $ +IdL x) ∙ sym (+MaxDistrℚ _ _ x))
+       (lem--035 {L'} {x})
+  ∙∙ sym (+MinDistrℚ (max (L - x) 0) (L' - x) x)
+  ∙∙ +Comm (min (max (L - x) 0) (L' - x)) x
+
+
+clampDist' : ∀ L L' x y → x ≤ y →
+    abs (clamp L L' y - clamp L L' x) ≤ abs (y - x)
+clampDist' L L' x y z =
+ subst2 _≤_
+  (sym (absNonNeg (clamp L L' y - clamp L L' x)
+          (-≤ (clamp L L' x) (clamp L L' y)  (≤MonotoneClamp L L' x y z))))
+  (sym (absNonNeg (y - x) (-≤ x y z)))
+  (subst2 _≤_
+     ((sym (lem--041 {y} {a'} {x} {a})) ∙
+       cong₂ _-_ (sym $ clampDiff L L' y)
+                   (sym $ clampDiff L L' x))
+     (+IdR (y - x))
+     (≤-o+ ((a' - a)) 0 (y - x)
+      (subst (_≤ 0) (-[x-y]≡y-x a a')
+       $ minus-≤ 0 (a - a') (-≤ a' a zz'))  ))
+
+ where
+
+ a = clamp (L - x) (L' - x) 0
+ a' = clamp (L - y) (L' - y) 0
+ zz' : a' ≤ a
+ zz' = ≤MonotoneMin _ _ _ _
+          (≤MonotoneMax _ _ _ _
+           (≤-o+ (- y) (- x) L (minus-≤ x y z)) (isRefl≤ 0)
+            ) (≤-o+ (- y) (- x) L' $ minus-≤ x y z)
+
+
+
+clampDist : ∀ L L' x y →
+    abs (clamp L L' y - clamp L L' x) ≤ abs (y - x)
+clampDist L L' =
+ elimBy≤ (λ x y → subst2 _≤_ (absComm- (clamp L L' y) (clamp L L' x))
+    (absComm- y x)) (clampDist' L L')
+
+maxDist : ∀ M x y →
+    abs (max M y - max M x) ≤ abs (y - x)
+maxDist M x y =
+  subst2 {x = min (max M y) (max M (max x y))}
+          {(max M y)}
+    {z = min (max M x) (max M (max x y))} {(max M x)}
+    (λ a b → abs (a - b) ≤ abs (y - x))
+    (≤→min _ _ (subst (max M y ≤_)
+      (sym (maxAssoc _ _ _) ∙ cong (max M) (maxComm _ _))
+      (≤max _ _)))
+    (≤→min _ _
+      ((subst (max M x ≤_)
+      (sym (maxAssoc _ _ _))
+      (≤max _ _))))
+    (clampDist M (max M (max x y)) x y)
+
+
+≤→<⊎≡ : ∀ p q → p ≤ q → (p ≡ q) ⊎ (p < q)
+≤→<⊎≡ p q x with p ≟ q
+... | lt x₁ = inr x₁
+... | eq x₁ = inl x₁
+... | gt x₁ = ⊥.rec $ ≤→≯ p q x x₁
+
+
+getPosRatio : (L₁ L₂ : ℚ₊) → (fst ((invℚ₊ L₁) ℚ₊·  L₂) ≤ 1)
+                           ⊎ (fst ((invℚ₊ L₂) ℚ₊·  L₁) ≤ 1)
+getPosRatio L₁ L₂ =
+  elimBy≤ {A = λ (L₁ L₂ : ℚ) → (<L₁ : 0< L₁) → (<L₂ : 0< L₂)
+                      →  (((fst (invℚ₊ (L₁ , <L₁) ℚ₊·  (L₂ , <L₂))) ≤ 1)
+                           ⊎ ((fst ((invℚ₊ (L₂ , <L₂)) ℚ₊·
+                            (L₁ , <L₁))) ≤ 1))}
+    (λ x y x₁ <L₁ <L₂ →
+      Iso.fun (⊎.⊎-swap-Iso) (x₁ <L₂ <L₁) )
+     (λ L₁ L₂ x₁ <L₁ <L₂ →
+             inr (
+               subst (fst (invℚ₊ (L₂ , <L₂)) · L₁ ≤_)
+                  (invℚ₊[x]·x (L₂ , <L₂))
+                  (≤-o· L₁ L₂ (fst (invℚ₊ (L₂ , <L₂)))
+                    (0≤ℚ₊ (invℚ₊ (L₂ , <L₂))) x₁)))
+     (fst L₁) (fst L₂) (snd L₁) (snd L₂)
+
+
+·MaxDistrℚ : ∀ x y z → 0< z → (max x y) · z ≡ max (x · z) (y · z)
+·MaxDistrℚ = SQ.elimProp3 (λ _ _ _ → isPropΠ λ _ → isSetℚ _ _)
+  www
+
+ where
+ www : (a b c : ℤ.ℤ × ℕ₊₁) →
+         0< _//_.[ c ] →
+         max _//_.[ a ] _//_.[ b ] · _//_.[ c ] ≡
+         max (_//_.[ a ] · _//_.[ c ]) (_//_.[ b ] · _//_.[ c ])
+ www (a , a') (b , b') (c@(pos (suc n)) , c') x = eq/ _ _
+    wwww
+  where
+
+   wwww' : ∀ a b' →  a ℤ.· ℕ₊₁→ℤ b' ℤ.· pos (suc n) ℤ.· pos (ℕ₊₁→ℕ c')
+              ≡ ((a ℤ.· c) ℤ.· ℕ₊₁→ℤ (b' ·₊₁ c'))
+   wwww' a b' =
+      cong (ℤ._· pos (ℕ₊₁→ℕ c')) (sym (ℤ.·Assoc _ _ _) ∙
+            (cong (a ℤ.·_) (ℤ.·Comm _ _)) ∙ ℤ.·Assoc _ _ _) ∙
+         sym (ℤ.·Assoc _ _ _) ∙
+         cong ((a ℤ.· pos (suc n)) ℤ.·_) (sym (ℤ.pos·pos _ _))
+
+
+   wwww : ℤ.max (a ℤ.· ℕ₊₁→ℤ b') (b ℤ.· ℕ₊₁→ℤ a') ℤ.· c
+            ℤ.· ℕ₊₁→ℤ (a' ·₊₁ c' ·₊₁ (b' ·₊₁ c'))
+          ≡ ℤ.max ((a ℤ.· c) ℤ.· ℕ₊₁→ℤ (b' ·₊₁ c'))
+                    ((b ℤ.· c) ℤ.· ℕ₊₁→ℤ (a' ·₊₁ c'))  ℤ.·
+              ℕ₊₁→ℤ (a' ·₊₁ b' ·₊₁ c')
+   wwww =
+    cong (ℤ.max (a ℤ.· ℕ₊₁→ℤ b') (b ℤ.· ℕ₊₁→ℤ a') ℤ.· pos (suc n) ℤ.·_)
+      (cong (λ ac → ℕ₊₁→ℤ (ac ·₊₁ (b' ·₊₁ c'))) (·₊₁-comm a'  c')
+       ∙∙ cong ℕ₊₁→ℤ (sym (·₊₁-assoc  _ _ _)) ∙∙
+         ℤ.pos·pos _ _)
+      ∙∙ ℤ.·Assoc _ _ _ ∙∙
+    cong₂ (ℤ._·_)
+       (cong (ℤ._· (pos (ℕ₊₁→ℕ c')))
+         (ℤ.·DistPosLMax (a ℤ.· ℕ₊₁→ℤ b') (b ℤ.· ℕ₊₁→ℤ a') (suc n))
+         ∙ ℤ.·DistPosLMax
+              ((a ℤ.· ℕ₊₁→ℤ b') ℤ.· pos (suc n))
+              ((b ℤ.· ℕ₊₁→ℤ a') ℤ.· pos (suc n)) (ℕ₊₁→ℕ c')
+          ∙ cong₂ ℤ.max
+          (wwww' a b') (wwww' b a'))
+           (cong ℕ₊₁→ℤ (·₊₁-assoc a' b' c'))
+
+
+·MaxDistrℚ' : ∀ x y z → 0 ≤ z → (max x y) · z ≡ max (x · z) (y · z)
+·MaxDistrℚ' x y z =
+  ⊎.rec (λ p → cong ((max x y) ·_) (sym p) ∙
+        ·AnnihilR (max x y)  ∙ cong₂ max (sym (·AnnihilR x) ∙ cong (x ·_) p)
+            (sym (·AnnihilR y) ∙ cong (y ·_) p))
+    (·MaxDistrℚ x y z ∘ <→0< z) ∘ (≤→≡⊎< 0 z)
+
+≤Monotone·-onNonNeg : ∀ x x' y y' →
+  x ≤ x' →
+  y ≤ y' →
+  0 ≤ x →
+  0 ≤ y →
+   x · y ≤ x' · y'
+≤Monotone·-onNonNeg x x' y y' x≤x' y≤y' 0≤x 0≤y =
+  isTrans≤ _ _ _ (≤-·o x x' y 0≤y x≤x')
+   (≤-o· y y' x' (isTrans≤ 0 _ _ 0≤x x≤x') y≤y')
+
+<Monotone·-onPos : ∀ x x' y y' →
+  x < x' →
+  y < y' →
+  0 ≤ x →
+  0 ≤ y →
+   x · y < x' · y'
+<Monotone·-onPos x x' y y' x₁ x₂ x₃ x₄ =
+   let zz = 0<-m·n (x' - x) (y' - y) (-< x x' x₁) (-< y y' x₂)
+   in subst2 _<_ (+IdL _ ∙ +IdR _)
+          (lem--039 {x'} {x} {y'} {y})
+        (<≤Monotone+ 0 ((x' - x) · (y' - y)) (x · y + 0)
+             (x' · y + ((x · (y' - y)))) zz
+               (≤Monotone+ (x · y) (x' · y) 0  (x · (y' - y))
+                (≤-·o x x' y x₄ (<Weaken≤ x x' x₁))
+                (subst (_≤ x · (y' - y))
+                  (·AnnihilL _) $ ≤-·o 0 x (y' - y)
+                  (<Weaken≤ 0 (y' - y) (-< y y' x₂) ) x₃)))
+
+
+
+
+invℚ : ∀ q → 0 # q → ℚ
+invℚ q p = sign q · fst (invℚ₊ (0#→ℚ₊ q p))
+
+invℚ₊≡invℚ : ∀ q p → invℚ (fst q) p ≡ fst (invℚ₊ q)
+invℚ₊≡invℚ q p = cong₂ _·_ (fst (<→sign (fst q)) (0<ℚ₊ q)
+    ) (cong (fst ∘ invℚ₊) (ℚ₊≡ (sym (abs'≡abs (fst q)) ∙
+     absPos (fst q) ((0<ℚ₊ q))))) ∙ ·IdL (fst (invℚ₊ q))
+
+fromNat-invℚ : ∀ n p → invℚ [ pos (suc n) / 1 ] p ≡ [ 1 / 1+ n ]
+fromNat-invℚ n p = invℚ₊≡invℚ _ _
+
+
+invℚ-pos : ∀ x y → 0 < x → 0 < invℚ x y
+invℚ-pos x y z =
+  subst (0 <_)
+    (sym (invℚ₊≡invℚ (x , <→0< _ z) y))
+      (0<ℚ₊ (invℚ₊ (x , <→0< _ z)))
+
+
+0#invℚ : ∀ q 0#q → 0 # (invℚ q 0#q)
+0#invℚ q 0#q = ·Monotone0# _ _  (fst (0#sign q) 0#q)
+  (inl (0<ℚ₊ (invℚ₊ (0#→ℚ₊ q 0#q))))
+
+
+
+
+·DistInvℚ : ∀ x y 0#x 0#y 0#xy →
+  (invℚ x 0#x) · (invℚ y 0#y) ≡ invℚ (x · y) 0#xy
+·DistInvℚ x y 0#x 0#y 0#xy =
+  (sym (·Assoc _ _ _) ∙
+    cong ((sign x) ·_)
+      (·Assoc _ _ _
+       ∙∙ cong (_· fst (invℚ₊ (0#→ℚ₊ y 0#y)))
+         (·Comm _ _) ∙∙
+       sym (·Assoc _ _ _))
+   ∙ (·Assoc _ _ _)) ∙
+   cong₂ _·_
+     (sign·sign x y)
+     (cong fst (invℚ₊Dist· (0#→ℚ₊ x 0#x) (0#→ℚ₊ y 0#y))
+       ∙ cong (fst ∘ invℚ₊) (ℚ₊≡ (abs'·abs' _ _)) )
+
+invℚ-sign : ∀ q 0#q → sign q ≡ (invℚ (sign q) 0#q)
+invℚ-sign q =
+  ⊎.rec (λ p → p ∙ cong (uncurry invℚ)
+    (Σ≡Prop  (λ _ → isProp# _ _)
+     {u = 1 , inl (𝟚.toWitness {Q = <Dec 0 1} _)} (sym p) ))
+     ((λ p → p ∙ cong (uncurry invℚ)
+    (Σ≡Prop  (λ _ → isProp# _ _)
+     {u = -1 , inr (𝟚.toWitness {Q = <Dec -1 0} _)} (sym p) )))
+ ∘ ⊎.map (fst (fst (<≃sign q)))
+   (fst (snd (snd (<≃sign q)))) ∘ invEq (0#sign q)
+
+
+invℚInvol : ∀ q 0#q 0#invQ → invℚ (invℚ q 0#q) 0#invQ ≡ q
+invℚInvol q 0#q 0#invQ =
+  sym (·DistInvℚ (sign q) _ (fst (0#sign q) 0#q)
+    (inl (0<ℚ₊ (invℚ₊ ((0#→ℚ₊ q 0#q)) )))
+    0#invQ )
+    ∙∙ cong₂ _·_ (sym (invℚ-sign _ _))
+     ((invℚ₊≡invℚ _ _ ∙ invℚ₊-invol (0#→ℚ₊ q 0#q)) ∙  sym (abs'≡abs q))  ∙∙
+     (·Comm _ _ ∙ (sign·abs q))
+
+
+_／ℚ[_,_] : ℚ → ∀ r → 0 # r  → ℚ
+q ／ℚ[ r , 0＃r ] = q · (invℚ r 0＃r)
+
+
+ℚ-y/y : ∀ r → (0＃r : 0 # r) → (r ／ℚ[ r , 0＃r ]) ≡ 1
+ℚ-y/y r y = cong (_· (invℚ r y)) (sym (sign·abs r))
+  ∙ sym (·Assoc _ _ _)
+  ∙ cong (abs r ·_) (·Assoc _ _ _ ∙∙
+    cong (_· fst (invℚ₊ (0#→ℚ₊ r y))) (signX·signX r y) ∙∙
+      ·IdL _)
+  ∙ cong (_· fst (invℚ₊ (0#→ℚ₊ r y))) (abs'≡abs _)
+   ∙ x·invℚ₊[x] (0#→ℚ₊ r y)
+
+ℚ-[x·y]/y : ∀ x r → (0＃r : 0 # r) → ((x · r) ／ℚ[ r , 0＃r ]) ≡ x
+ℚ-[x·y]/y x r 0#r = sym (·Assoc _ _ _) ∙∙
+  cong (x ·_) (ℚ-y/y r 0#r) ∙∙ ·IdR x
+
+ℚ-[x/y]·y : ∀ x r → (0＃r : 0 # r) → ((x ／ℚ[ r , 0＃r ]) · r) ≡ x
+ℚ-[x/y]·y x r 0#r = sym (·Assoc _ _ _) ∙∙
+  cong (x ·_) (·Comm _ _ ∙ ℚ-y/y r 0#r) ∙∙ ·IdR x
+
+
+ℚ-x·y≡z→x≡z/y : ∀ x q r → (0＃r : 0 # r)
+               → (x · r) ≡ q
+               → x ≡ q ／ℚ[ r , 0＃r ]
+ℚ-x·y≡z→x≡z/y x q r 0＃r p =
+    sym (ℚ-[x·y]/y x r 0＃r ) ∙ cong (_／ℚ[ r , 0＃r ]) p
+
+ℚ-x/y<z→x/z<y : ∀ x q r  → (0<x : 0 < x) → (0<q : 0 < q) → (0<r : 0 < r)
+               → (x ／ℚ[ r , inl 0<r ]) < q
+               → (x ／ℚ[ q , inl 0<q ]) < r
+ℚ-x/y<z→x/z<y x q r 0<x 0<q 0<r p =
+ subst2 _<_ (sym (·Assoc _ _ _)
+   ∙  cong (x ·_) ((·Comm _ _) ∙
+     cong (_· invℚ r (inl 0<r)) (·Comm _ _) ∙
+      ℚ-[x·y]/y _ _ _ ) )
+   ((·Comm _ _) ∙ ℚ-[x/y]·y _ _ _)
+   (<-·o (x ／ℚ[ r , (inl 0<r) ]) q (r ／ℚ[ q , (inl 0<q) ])
+     (0<-m·n _ _ 0<r (invℚ-pos q (inl 0<q)  0<q)) p)
+
+invℚ≤invℚ : ∀ (p q : ℚ₊) → fst q ≤ fst p → fst (invℚ₊ p) ≤ fst (invℚ₊ q)
+invℚ≤invℚ p q x =
+ subst2 _≤_
+   (cong ((fst q) ·_) (·Comm _ _) ∙
+    (y·[x/y] q (fst (invℚ₊ p)))) (y·[x/y] p (fst (invℚ₊ q)))
+    (≤-·o _ _ (fst ((invℚ₊ p) ℚ₊· (invℚ₊ q)))
+     (0≤ℚ₊ ((invℚ₊ p) ℚ₊· (invℚ₊ q))) x)
+
+maxWithPos : ℚ₊ → ℚ → ℚ₊
+maxWithPos ε q .fst = max (fst ε) q
+maxWithPos ε q .snd = <→0< (max (fst ε) q)
+ (isTrans<≤ 0 (fst ε) _ (0<ℚ₊ ε) (≤max (fst ε) q))
+
+
+1/p+1/q : (p q : ℚ₊) → fst (invℚ₊ p) - fst (invℚ₊ q) ≡
+                       fst (invℚ₊ (p ℚ₊· q))
+                        · (fst q - fst p)
+1/p+1/q (p , p') (q , q') =
+  ElimProp2.go w p q p' q'
+ where
+  w : ElimProp2 λ p q → ∀ p' q'
+           → fst (invℚ₊ (p , p')) - fst (invℚ₊ (q , q')) ≡
+                       fst (invℚ₊ ((p , p') ℚ₊· (q , q')))
+                        · (q - p)
+  w .ElimProp2.isPropB _ _ = isPropΠ2 λ _ _ → isSetℚ _ _
+  w .ElimProp2.f (pos (suc x) , 1+ x') (pos (suc y) , 1+ y') p' q' =
+    eq/ _ _
+      (cong₂ ℤ._·_
+           (λ i → ((pos (suc x') ℤ.· ℕ₊₁→ℤ (·₊₁-identityˡ (1+ y) i))
+           ℤ.+ (ℤ.negsuc·pos y' ( (suc x)) i)))
+           (((λ i → ℤ.pos·pos
+            (ℕ₊₁→ℕ $ fst
+           (ℤ.0<→ℕ₊₁ (pos (suc x) ℤ.· pos (suc y))
+            (·0< _//_.[ pos (suc x) , (1+ x') ]
+             _//_.[ pos (suc y) , (1+ y') ] p' q')))
+             (ℕ₊₁→ℕ ((1+ y') ·₊₁ (·₊₁-identityˡ (1+ x') i))) i) ∙
+               λ i → snd
+               (ℤ.0<→ℕ₊₁ (pos (suc x) ℤ.· pos (suc y))
+                (·0< _//_.[ pos (suc x) , (1+ x') ]
+                _//_.[ pos (suc y) , (1+ y') ] p' q')) (~ i)
+                 ℤ.· (pos (ℕ₊₁→ℕ ((1+ y') ·₊₁ (1+ x'))))) ∙
+                  ℤ.·Comm _ _) ∙ ℤ.·Assoc _ _ _  ∙∙
+              cong (ℤ._· _) (cong₂ ℤ._·_
+                (cong₂ ℤ._+_ (ℤ.·Comm _ _) (cong ℤ.-_ (ℤ.·Comm _ _)))
+                (cong (pos ∘ ℕ₊₁→ℕ)
+                  (·₊₁-comm (1+ y') (1+ x')))
+                 ∙ ℤ.·Comm _ _) ∙ cong ((ℕ₊₁→ℤ
+               (fst (ℤ.0<→ℕ₊₁ (ℕ₊₁→ℤ ((1+ x') ·₊₁ (1+ y'))) tt))
+            ℤ.· ((pos (suc y) ℤ.· ℕ₊₁→ℤ ((1+ x')))
+                 ℤ.+ (ℤ.- (ℤ.pos (suc x) ℤ.· ℕ₊₁→ℤ (1+ y')))))
+          ℤ.·_) (sym (ℤ.pos·pos (suc x) _))
+               ∙∙ λ i → (ℕ₊₁→ℤ (fst (ℤ.0<→ℕ₊₁
+                (ℕ₊₁→ℤ ((1+ x') ·₊₁ (1+ y'))) tt))
+            ℤ.· ((pos (suc y) ℤ.· ℕ₊₁→ℤ (·₊₁-identityˡ (1+ x') (~ i)))
+                 ℤ.+ (ℤ.negsuc·pos x (suc y') (~ i))))
+          ℤ.· ℕ₊₁→ℤ ((1+ x) ·₊₁ (·₊₁-identityˡ (1+ y) (~ i))))
+
+invℚ₊≤invℚ₊ : ∀ x y
+      → fst y ≤ fst x
+      → fst (invℚ₊ x) ≤ fst (invℚ₊ y)
+invℚ₊≤invℚ₊ x y p =
+  subst2 _≤_
+    ((sym (·Assoc _ _ _) ∙∙
+     cong (fst (invℚ₊ x) ·_) (invℚ₊[x]·x y)
+     ∙∙ ·IdR (fst (invℚ₊ x))))
+    (sym (·Assoc _ _ _) ∙∙
+     cong (fst (invℚ₊ y) ·_) (invℚ₊[x]·x x)
+     ∙∙ ·IdR (fst (invℚ₊ y)))
+     (≤Monotone·-onNonNeg _ _ _ _
+        (≡Weaken≤ _ _ (·Comm (fst (invℚ₊ x)) (fst (invℚ₊ y)) ))
+        p
+        ((0≤ℚ₊ ((invℚ₊ x) ℚ₊· (invℚ₊ y))))
+        ((0≤ℚ₊ y)))
+
+
+
+<MonotoneMaxℚ : ∀ m o n s → m < n → o < s → max m o < max n s
+<MonotoneMaxℚ =
+  elimBy≤ (λ x y X o s u v → subst2 _<_ (maxComm _ _) (maxComm _ _)
+                 ((X s o) v u))
+   λ x y x≤y n s _ y<s →
+     subst (_< max n s) (sym (≤→max x y x≤y))
+      (isTrans<≤ _ _ _ y<s (≤max' n s))
+
+<MonotoneMinℚ : ∀ n s m o  → m < n → o < s → min m o < min n s
+<MonotoneMinℚ =
+  elimBy≤ (λ x y X o s u v → subst2 _<_ (minComm _ _) (minComm _ _)
+                 ((X s o) v u))
+   λ x y x≤y n s n<x _ →
+     subst (min n s <_) (sym (≤→min x y x≤y))
+       (isTrans≤< _ _ _ (min≤ n s) n<x)
+
+
+_ℚ^ⁿ_ : ℚ → ℕ → ℚ
+x ℚ^ⁿ zero = 1
+x ℚ^ⁿ suc n = (x ℚ^ⁿ n) · x
+
+0<ℚ^ⁿ : ∀ q (0<q : 0< q) n → 0< (q ℚ^ⁿ n)
+0<ℚ^ⁿ q 0<q zero = tt
+0<ℚ^ⁿ q 0<q (suc n) = snd ((_ , 0<ℚ^ⁿ q 0<q n) ℚ₊· (q , 0<q))
+
+0≤ℚ^ⁿ : ∀ q (0≤q : 0 ≤ q) n → 0 ≤ (q ℚ^ⁿ n)
+0≤ℚ^ⁿ q 0≤q zero = 𝟚.toWitness {Q = ≤Dec 0 1} tt
+0≤ℚ^ⁿ q 0≤q (suc n) = ≤Monotone·-onNonNeg
+ 0 _ 0 _
+  (0≤ℚ^ⁿ q 0≤q n)
+   0≤q (isRefl≤ 0) (isRefl≤ 0)
+
+
+x^ⁿ≤1 : ∀ x n → 0 ≤ x → x ≤ 1 →  (x ℚ^ⁿ n) ≤ 1
+x^ⁿ≤1 x zero 0≤x x≤1 = isRefl≤ 1
+x^ⁿ≤1 x (suc n) 0≤x x≤1 =
+ ≤Monotone·-onNonNeg _ 1 _ 1
+   (x^ⁿ≤1 x n 0≤x x≤1) x≤1 (0≤ℚ^ⁿ x 0≤x n) 0≤x
+
+·-ℚ^ⁿ : ∀ n m x → (x ℚ^ⁿ n) · (x ℚ^ⁿ m) ≡ (x ℚ^ⁿ (n ℕ.+ m))
+·-ℚ^ⁿ zero m x = ·IdL _
+·-ℚ^ⁿ (suc n) m x = (sym (·Assoc _ _ _)
+   ∙ cong ((x ℚ^ⁿ n) ·_) (·Comm _ _))
+  ∙∙ ·Assoc _ _ _
+  ∙∙ cong (_· x) (·-ℚ^ⁿ n m x)
+
+_ℚ₊^ⁿ_ : ℚ₊ → ℕ → ℚ₊
+(q , 0<q) ℚ₊^ⁿ n = (q ℚ^ⁿ n) , 0<ℚ^ⁿ q 0<q n
+
+
+fromNat-^ : ∀ m n → ((fromNat m) ℚ^ⁿ n ) ≡ fromNat (m ℕ.^ n)
+fromNat-^ m zero = refl
+fromNat-^ m (suc n) =
+ cong (_· (fromNat m)) (fromNat-^ m n) ∙
+   (ℕ·→ℚ· _ _) ∙ cong [_/ 1 ] (cong ℤ.pos (ℕ.·-comm _ _))
+
+invℚ₊-ℚ^ⁿ : ∀ q n → fst (invℚ₊ (q ℚ₊^ⁿ n)) ≡ (fst (invℚ₊ q)) ℚ^ⁿ n
+invℚ₊-ℚ^ⁿ q zero = refl
+invℚ₊-ℚ^ⁿ q (suc n) =
+  cong fst (sym (invℚ₊Dist· _ _))
+    ∙ cong (fst ∘ (_ℚ₊· (invℚ₊ q)))
+     (ℚ₊≡ {y = _ , snd ((invℚ₊ q) ℚ₊^ⁿ n)} (invℚ₊-ℚ^ⁿ q n))
+
+
+invℚ₊-<-invℚ₊ : ∀ q r → ((fst q) < (fst r))
+             ≃ (fst (invℚ₊ r) < fst (invℚ₊ q))
+invℚ₊-<-invℚ₊ (q , 0<q) (r , 0<r) = ElimProp2.go w q r 0<q 0<r
+ where
+ w : ElimProp2 λ q r → ∀ 0<q 0<r → (q < r) ≃
+         (fst (invℚ₊ (r , 0<r)) < fst (invℚ₊ (q , 0<q)))
+ w .ElimProp2.isPropB _ _ =
+   isPropΠ2 λ _ _ → isOfHLevel≃ 1 (isProp< _ _) (isProp< _ _)
+ w .ElimProp2.f (ℤ.pos (suc _) , _) (ℤ.pos (suc _) , _) _ _ =
+   propBiimpl→Equiv ℤ.isProp<  ℤ.isProp<
+    (subst2 ℤ._<_ (ℤ.·Comm _ _) (ℤ.·Comm _ _))
+    (subst2 ℤ._<_ (ℤ.·Comm _ _) (ℤ.·Comm _ _))
diff --git a/Cubical/Data/Rationals/Properties.agda b/Cubical/Data/Rationals/Properties.agda
index 100921a315..66cf5e0c55 100644
--- a/Cubical/Data/Rationals/Properties.agda
+++ b/Cubical/Data/Rationals/Properties.agda
@@ -35,74 +35,91 @@ open import Cubical.Data.Rationals.Base
 
 -- useful functions for defining operations on ℚ
 
-onCommonDenom :
-  (g : ℤ × ℕ₊₁ → ℤ × ℕ₊₁ → ℤ)
-  (g-eql : ∀ ((a , b) (c , d) (e , f) : ℤ × ℕ₊₁) (p : a ℤ.· ℕ₊₁→ℤ d ≡ c ℤ.· ℕ₊₁→ℤ b)
-           → ℕ₊₁→ℤ d ℤ.· (g (a , b) (e , f)) ≡ ℕ₊₁→ℤ b ℤ.· (g (c , d) (e , f)))
-  (g-eqr : ∀ ((a , b) (c , d) (e , f) : ℤ × ℕ₊₁) (p : c ℤ.· ℕ₊₁→ℤ f ≡ e ℤ.· ℕ₊₁→ℤ d)
-           → (g (a , b) (c , d)) ℤ.· ℕ₊₁→ℤ f ≡ (g (a , b) (e , f)) ℤ.· ℕ₊₁→ℤ d)
-  → ℚ → ℚ → ℚ
-onCommonDenom g g-eql g-eqr = SetQuotient.rec2 isSetℚ
-  (λ { (a , b) (c , d) → [ g (a , b) (c , d) / b ·₊₁ d ] })
-  (λ { (a , b) (c , d) (e , f) p → eql (a , b) (c , d) (e , f) p })
-  (λ { (a , b) (c , d) (e , f) p → eqr (a , b) (c , d) (e , f) p })
-  where abstract
-        eql : ∀ ((a , b) (c , d) (e , f) : ℤ × ℕ₊₁) (p : a ℤ.· ℕ₊₁→ℤ d ≡ c ℤ.· ℕ₊₁→ℤ b)
-              → [ g (a , b) (e , f) / b ·₊₁ f ] ≡ [ g (c , d) (e , f) / d ·₊₁ f ]
-        eql (a , b) (c , d) (e , f) p =
-          [ g (a , b) (e , f) / b ·₊₁ f ]
-            ≡⟨ sym (·CancelL d) ⟩
-          [ ℕ₊₁→ℤ d ℤ.· (g (a , b) (e , f)) / d ·₊₁ (b ·₊₁ f) ]
-            ≡[ i ]⟨ [ ℕ₊₁→ℤ d ℤ.· (g (a , b) (e , f)) / ·₊₁-assoc d b f i ] ⟩
-          [ ℕ₊₁→ℤ d ℤ.· (g (a , b) (e , f)) / (d ·₊₁ b) ·₊₁ f ]
-            ≡[ i ]⟨ [ g-eql (a , b) (c , d) (e , f) p i / ·₊₁-comm d b i ·₊₁ f ] ⟩
-          [ ℕ₊₁→ℤ b ℤ.· (g (c , d) (e , f)) / (b ·₊₁ d) ·₊₁ f ]
-            ≡[ i ]⟨ [ ℕ₊₁→ℤ b ℤ.· (g (c , d) (e , f)) / ·₊₁-assoc b d f (~ i) ] ⟩
-          [ ℕ₊₁→ℤ b ℤ.· (g (c , d) (e , f)) / b ·₊₁ (d ·₊₁ f) ]
-            ≡⟨ ·CancelL b ⟩
-          [ g (c , d) (e , f) / d ·₊₁ f ] ∎
-        eqr : ∀ ((a , b) (c , d) (e , f) : ℤ × ℕ₊₁) (p : c ℤ.· ℕ₊₁→ℤ f ≡ e ℤ.· ℕ₊₁→ℤ d)
-             → [ g (a , b) (c , d) / b ·₊₁ d ] ≡ [ g (a , b) (e , f) / b ·₊₁ f ]
-        eqr (a , b) (c , d) (e , f) p =
-          [ g (a , b) (c , d) / b ·₊₁ d ]
-            ≡⟨ sym (·CancelR f) ⟩
-          [ (g (a , b) (c , d)) ℤ.· ℕ₊₁→ℤ f / (b ·₊₁ d) ·₊₁ f ]
-            ≡[ i ]⟨ [ (g (a , b) (c , d)) ℤ.· ℕ₊₁→ℤ f / ·₊₁-assoc b d f (~ i) ] ⟩
-          [ (g (a , b) (c , d)) ℤ.· ℕ₊₁→ℤ f / b ·₊₁ (d ·₊₁ f) ]
-            ≡[ i ]⟨ [ g-eqr (a , b) (c , d) (e , f) p i / b ·₊₁ ·₊₁-comm d f i ] ⟩
-          [ (g (a , b) (e , f)) ℤ.· ℕ₊₁→ℤ d / b ·₊₁ (f ·₊₁ d) ]
-            ≡[ i ]⟨ [ (g (a , b) (e , f)) ℤ.· ℕ₊₁→ℤ d / ·₊₁-assoc b f d i ] ⟩
-          [ (g (a , b) (e , f)) ℤ.· ℕ₊₁→ℤ d / (b ·₊₁ f) ·₊₁ d ]
-            ≡⟨ ·CancelR d ⟩
-          [ g (a , b) (e , f) / b ·₊₁ f ] ∎
-
-onCommonDenomSym :
-  (g : ℤ × ℕ₊₁ → ℤ × ℕ₊₁ → ℤ)
-  (g-sym : ∀ x y → g x y ≡ g y x)
-  (g-eql : ∀ ((a , b) (c , d) (e , f) : ℤ × ℕ₊₁) (p : a ℤ.· ℕ₊₁→ℤ d ≡ c ℤ.· ℕ₊₁→ℤ b)
-           → ℕ₊₁→ℤ d ℤ.· (g (a , b) (e , f)) ≡ ℕ₊₁→ℤ b ℤ.· (g (c , d) (e , f)))
-  → ℚ → ℚ → ℚ
-onCommonDenomSym g g-sym g-eql = onCommonDenom g g-eql q-eqr
-  where abstract
-        q-eqr : ∀ ((a , b) (c , d) (e , f) : ℤ × ℕ₊₁) (p : c ℤ.· ℕ₊₁→ℤ f ≡ e ℤ.· ℕ₊₁→ℤ d)
-                → (g (a , b) (c , d)) ℤ.· ℕ₊₁→ℤ f ≡ (g (a , b) (e , f)) ℤ.· ℕ₊₁→ℤ d
-        q-eqr (a , b) (c , d) (e , f) p =
-          (g (a , b) (c , d)) ℤ.· ℕ₊₁→ℤ f ≡[ i ]⟨ ℤ.·Comm (g-sym (a , b) (c , d) i) (ℕ₊₁→ℤ f) i ⟩
-          ℕ₊₁→ℤ f ℤ.· (g (c , d) (a , b)) ≡⟨ g-eql (c , d) (e , f) (a , b) p ⟩
-          ℕ₊₁→ℤ d ℤ.· (g (e , f) (a , b)) ≡[ i ]⟨ ℤ.·Comm (ℕ₊₁→ℤ d) (g-sym (e , f) (a , b) i) i ⟩
-          (g (a , b) (e , f)) ℤ.· ℕ₊₁→ℤ d ∎
-
-onCommonDenomSym-comm : ∀ {g} g-sym {g-eql} (x y : ℚ)
-                        → onCommonDenomSym g g-sym g-eql x y ≡
-                          onCommonDenomSym g g-sym g-eql y x
-onCommonDenomSym-comm g-sym = SetQuotient.elimProp2 (λ _ _ → isSetℚ _ _)
-  (λ { (a , b) (c , d) i → [ g-sym (a , b) (c , d) i / ·₊₁-comm b d i ] })
+record OnCommonDenom : Type where
+ no-eta-equality
+ field
+  g : ℤ × ℕ₊₁ → ℤ × ℕ₊₁ → ℤ
+  g-eql : ∀ ((a , b) (c , d) (e , f) : ℤ × ℕ₊₁) (p : a ℤ.· ℕ₊₁→ℤ d ≡ c ℤ.· ℕ₊₁→ℤ b)
+           → ℕ₊₁→ℤ d ℤ.· (g (a , b) (e , f)) ≡ ℕ₊₁→ℤ b ℤ.· (g (c , d) (e , f))
+  g-eqr : ∀ ((a , b) (c , d) (e , f) : ℤ × ℕ₊₁) (p : c ℤ.· ℕ₊₁→ℤ f ≡ e ℤ.· ℕ₊₁→ℤ d)
+           → (g (a , b) (c , d)) ℤ.· ℕ₊₁→ℤ f ≡ (g (a , b) (e , f)) ℤ.· ℕ₊₁→ℤ d
+
+ eql : ∀ ((a , b) (c , d) (e , f) : ℤ × ℕ₊₁) (p : a ℤ.· ℕ₊₁→ℤ d ≡ c ℤ.· ℕ₊₁→ℤ b)
+       → [ g (a , b) (e , f) / b ·₊₁ f ] ≡ [ g (c , d) (e , f) / d ·₊₁ f ]
+ eql (a , b) (c , d) (e , f) p =
+   [ g (a , b) (e , f) / b ·₊₁ f ]
+     ≡⟨ sym (·CancelL d) ⟩
+   [ ℕ₊₁→ℤ d ℤ.· (g (a , b) (e , f)) / d ·₊₁ (b ·₊₁ f) ]
+     ≡[ i ]⟨ [ ℕ₊₁→ℤ d ℤ.· (g (a , b) (e , f)) / ·₊₁-assoc d b f i ] ⟩
+   [ ℕ₊₁→ℤ d ℤ.· (g (a , b) (e , f)) / (d ·₊₁ b) ·₊₁ f ]
+     ≡[ i ]⟨ [ g-eql (a , b) (c , d) (e , f) p i / ·₊₁-comm d b i ·₊₁ f ] ⟩
+   [ ℕ₊₁→ℤ b ℤ.· (g (c , d) (e , f)) / (b ·₊₁ d) ·₊₁ f ]
+     ≡[ i ]⟨ [ ℕ₊₁→ℤ b ℤ.· (g (c , d) (e , f)) / ·₊₁-assoc b d f (~ i) ] ⟩
+   [ ℕ₊₁→ℤ b ℤ.· (g (c , d) (e , f)) / b ·₊₁ (d ·₊₁ f) ]
+     ≡⟨ ·CancelL b ⟩
+   [ g (c , d) (e , f) / d ·₊₁ f ] ∎
+ eqr : ∀ ((a , b) (c , d) (e , f) : ℤ × ℕ₊₁) (p : c ℤ.· ℕ₊₁→ℤ f ≡ e ℤ.· ℕ₊₁→ℤ d)
+      → [ g (a , b) (c , d) / b ·₊₁ d ] ≡ [ g (a , b) (e , f) / b ·₊₁ f ]
+ eqr (a , b) (c , d) (e , f) p =
+   [ g (a , b) (c , d) / b ·₊₁ d ]
+     ≡⟨ sym (·CancelR f) ⟩
+   [ (g (a , b) (c , d)) ℤ.· ℕ₊₁→ℤ f / (b ·₊₁ d) ·₊₁ f ]
+     ≡[ i ]⟨ [ (g (a , b) (c , d)) ℤ.· ℕ₊₁→ℤ f / ·₊₁-assoc b d f (~ i) ] ⟩
+   [ (g (a , b) (c , d)) ℤ.· ℕ₊₁→ℤ f / b ·₊₁ (d ·₊₁ f) ]
+     ≡[ i ]⟨ [ g-eqr (a , b) (c , d) (e , f) p i / b ·₊₁ ·₊₁-comm d f i ] ⟩
+   [ (g (a , b) (e , f)) ℤ.· ℕ₊₁→ℤ d / b ·₊₁ (f ·₊₁ d) ]
+     ≡[ i ]⟨ [ (g (a , b) (e , f)) ℤ.· ℕ₊₁→ℤ d / ·₊₁-assoc b f d i ] ⟩
+   [ (g (a , b) (e , f)) ℤ.· ℕ₊₁→ℤ d / (b ·₊₁ f) ·₊₁ d ]
+     ≡⟨ ·CancelR d ⟩
+   [ g (a , b) (e , f) / b ·₊₁ f ] ∎
+
+
+ go : ℚ → ℚ → ℚ
+ go = SetQuotient.Rec2.go w
+  where
+  w : SetQuotient.Rec2 ℚ
+  w .SetQuotient.Rec2.isSetB = isSetℚ
+  w .SetQuotient.Rec2.f (a , b) (c , d) = [ g (a , b) (c , d) / b ·₊₁ d ]
+  w .SetQuotient.Rec2.f∼ (a , b) (c , d) (e , f) p = eqr (a , b) (c , d) (e , f) p
+  w .SetQuotient.Rec2.∼f (a , b) (c , d) (e , f) p = eql (a , b) (c , d) (e , f) p
+
+record OnCommonDenomSym : Type where
+ no-eta-equality
+ field
+  g : ℤ × ℕ₊₁ → ℤ × ℕ₊₁ → ℤ
+  g-sym : ∀ x y → g x y ≡ g y x
+  g-eql : ∀ ((a , b) (c , d) (e , f) : ℤ × ℕ₊₁) (p : a ℤ.· ℕ₊₁→ℤ d ≡ c ℤ.· ℕ₊₁→ℤ b)
+           → ℕ₊₁→ℤ d ℤ.· (g (a , b) (e , f)) ≡ ℕ₊₁→ℤ b ℤ.· (g (c , d) (e , f))
+
+ q-eqr : ∀ ((a , b) (c , d) (e , f) : ℤ × ℕ₊₁) (p : c ℤ.· ℕ₊₁→ℤ f ≡ e ℤ.· ℕ₊₁→ℤ d)
+                 → (g (a , b) (c , d)) ℤ.· ℕ₊₁→ℤ f ≡ (g (a , b) (e , f)) ℤ.· ℕ₊₁→ℤ d
+ q-eqr (a , b) (c , d) (e , f) p =
+           (g (a , b) (c , d)) ℤ.· ℕ₊₁→ℤ f ≡[ i ]⟨ ℤ.·Comm (g-sym (a , b) (c , d) i) (ℕ₊₁→ℤ f) i ⟩
+           ℕ₊₁→ℤ f ℤ.· (g (c , d) (a , b)) ≡⟨ g-eql (c , d) (e , f) (a , b) p ⟩
+           ℕ₊₁→ℤ d ℤ.· (g (e , f) (a , b)) ≡[ i ]⟨ ℤ.·Comm (ℕ₊₁→ℤ d) (g-sym (e , f) (a , b) i) i ⟩
+           (g (a , b) (e , f)) ℤ.· ℕ₊₁→ℤ d ∎
+
+ go : ℚ → ℚ → ℚ
+ go = OnCommonDenom.go w
+  where
+  w : OnCommonDenom
+  w .OnCommonDenom.g = g
+  w .OnCommonDenom.g-eql = g-eql
+  w .OnCommonDenom.g-eqr = q-eqr
+
+ go-comm : ∀ x y → go x y ≡ go y x
+ go-comm = SetQuotient.ElimProp2.go w
+  where
+  w : SetQuotient.ElimProp2 (λ z z₁ → go z z₁ ≡ go z₁ z)
+  w .SetQuotient.ElimProp2.isPropB _ _ = isSetℚ _ _
+  w .SetQuotient.ElimProp2.f (a , b) (c , d) i = [ g-sym (a , b) (c , d) i / ·₊₁-comm b d i ]
 
 
 -- basic arithmetic operations on ℚ
 
 infixl 6 _+_
 infixl 7 _·_
+infix  8 -_
 
 private abstract
   lem₁ : ∀ a b c d e (p : a ℤ.· b ≡ c ℤ.· d) → b ℤ.· (a ℤ.· e) ≡ d ℤ.· (c ℤ.· e)
@@ -115,12 +132,13 @@ private abstract
                ∙ cong (ℤ._· b) (ℤ.·Comm a c) ∙ sym (ℤ.·Assoc c a b)
                ∙ cong (c ℤ.·_) (ℤ.·Comm a b)
 
-min : ℚ → ℚ → ℚ
-min = onCommonDenomSym
-  (λ { (a , b) (c , d) → ℤ.min (a ℤ.· ℕ₊₁→ℤ d) (c ℤ.· ℕ₊₁→ℤ b) })
-  (λ { (a , b) (c , d) → ℤ.minComm (a ℤ.· ℕ₊₁→ℤ d) (c ℤ.· ℕ₊₁→ℤ b) })
-   eq
+minR : OnCommonDenomSym
+minR .OnCommonDenomSym.g (a , b) (c , d) = ℤ.min (a ℤ.· ℕ₊₁→ℤ d) (c ℤ.· ℕ₊₁→ℤ b)
+minR .OnCommonDenomSym.g-sym (a , b) (c , d) = ℤ.minComm (a ℤ.· ℕ₊₁→ℤ d) (c ℤ.· ℕ₊₁→ℤ b)
+minR .OnCommonDenomSym.g-eql = eq
+
   where abstract
+
     eq : ((a , b) (c , d) (e , f) : ℤ × ℕ₊₁) (p : a ℤ.· ℕ₊₁→ℤ d ≡ c ℤ.· ℕ₊₁→ℤ b)
        → ℕ₊₁→ℤ d ℤ.· ℤ.min (a ℤ.· ℕ₊₁→ℤ f) (e ℤ.· ℕ₊₁→ℤ b)
        ≡ ℕ₊₁→ℤ b ℤ.· ℤ.min (c ℤ.· ℕ₊₁→ℤ f) (e ℤ.· ℕ₊₁→ℤ d)
@@ -152,11 +170,14 @@ min = onCommonDenomSym
       ℕ₊₁→ℤ b ℤ.· ℤ.min (c ℤ.· ℕ₊₁→ℤ f)
                          (e ℤ.· ℕ₊₁→ℤ d) ∎
 
-max : ℚ → ℚ → ℚ
-max = onCommonDenomSym
-  (λ { (a , b) (c , d) → ℤ.max (a ℤ.· ℕ₊₁→ℤ d) (c ℤ.· ℕ₊₁→ℤ b) })
-  (λ { (a , b) (c , d) → ℤ.maxComm (a ℤ.· ℕ₊₁→ℤ d) (c ℤ.· ℕ₊₁→ℤ b) })
-   eq
+min = OnCommonDenomSym.go minR
+
+maxR : OnCommonDenomSym
+maxR .OnCommonDenomSym.g (a , b) (c , d) = ℤ.max (a ℤ.· ℕ₊₁→ℤ d) (c ℤ.· ℕ₊₁→ℤ b)
+maxR .OnCommonDenomSym.g-sym (a , b) (c , d) = ℤ.maxComm (a ℤ.· ℕ₊₁→ℤ d) (c ℤ.· ℕ₊₁→ℤ b)
+maxR .OnCommonDenomSym.g-eql = eq
+
+
   where abstract
     eq : ((a , b) (c , d) (e , f) : ℤ × ℕ₊₁) (p : a ℤ.· ℕ₊₁→ℤ d ≡ c ℤ.· ℕ₊₁→ℤ b)
        → ℕ₊₁→ℤ d ℤ.· ℤ.max (a ℤ.· ℕ₊₁→ℤ f) (e ℤ.· ℕ₊₁→ℤ b)
@@ -189,13 +210,14 @@ max = onCommonDenomSym
       ℕ₊₁→ℤ b ℤ.· ℤ.max (c ℤ.· ℕ₊₁→ℤ f)
                          (e ℤ.· ℕ₊₁→ℤ d) ∎
 
+max = OnCommonDenomSym.go maxR
+
+
 minComm : ∀ x y → min x y ≡ min y x
-minComm = onCommonDenomSym-comm
-  (λ { (a , b) (c , d) → ℤ.minComm (a ℤ.· ℕ₊₁→ℤ d) (c ℤ.· ℕ₊₁→ℤ b) })
+minComm = OnCommonDenomSym.go-comm minR
 
 maxComm : ∀ x y → max x y ≡ max y x
-maxComm = onCommonDenomSym-comm
-  (λ { (a , b) (c , d) → ℤ.maxComm (a ℤ.· ℕ₊₁→ℤ d) (c ℤ.· ℕ₊₁→ℤ b) })
+maxComm = OnCommonDenomSym.go-comm maxR
 
 minIdem : ∀ x → min x x ≡ x
 minIdem = SetQuotient.elimProp (λ _ → isSetℚ _ _)
@@ -329,11 +351,10 @@ maxAbsorbLMin = SetQuotient.elimProp2 (λ _ _ → isSetℚ _ _)
                                cong ℕ₊₁→ℤ (·₊₁-comm (b ·₊₁ d) b)) ⟩
            a ℤ.· ℕ₊₁→ℤ (b ·₊₁ (b ·₊₁ d)) ∎) }
 
-_+_ : ℚ → ℚ → ℚ
-_+_ = onCommonDenomSym
-  (λ { (a , b) (c , d) → a ℤ.· (ℕ₊₁→ℤ d) ℤ.+ c ℤ.· (ℕ₊₁→ℤ b) })
-  (λ { (a , b) (c , d) → ℤ.+Comm (a ℤ.· (ℕ₊₁→ℤ d)) (c ℤ.· (ℕ₊₁→ℤ b)) })
-   eq
++Rec : OnCommonDenomSym
++Rec .OnCommonDenomSym.g (a , b) (c , d) = a ℤ.· (ℕ₊₁→ℤ d) ℤ.+ c ℤ.· (ℕ₊₁→ℤ b)
++Rec .OnCommonDenomSym.g-sym (a , b) (c , d) = ℤ.+Comm (a ℤ.· (ℕ₊₁→ℤ d)) (c ℤ.· (ℕ₊₁→ℤ b))
++Rec .OnCommonDenomSym.g-eql = eq
   where abstract
     eq : ((a , b) (c , d) (e , f) : ℤ × ℕ₊₁) (p : a ℤ.· ℕ₊₁→ℤ d ≡ c ℤ.· ℕ₊₁→ℤ b)
        → ℕ₊₁→ℤ d ℤ.· (a ℤ.· ℕ₊₁→ℤ f ℤ.+ e ℤ.· ℕ₊₁→ℤ b)
@@ -347,9 +368,12 @@ _+_ = onCommonDenomSym
         ≡⟨ sym (ℤ.·DistR+ (ℕ₊₁→ℤ b) (c ℤ.· ℕ₊₁→ℤ f) (e ℤ.· ℕ₊₁→ℤ d)) ⟩
       ℕ₊₁→ℤ b ℤ.· (c ℤ.· ℕ₊₁→ℤ f ℤ.+ e ℤ.· ℕ₊₁→ℤ d) ∎
 
+
+_+_ : ℚ → ℚ → ℚ
+_+_ = OnCommonDenomSym.go +Rec
+
 +Comm : ∀ x y → x + y ≡ y + x
-+Comm = onCommonDenomSym-comm
-  (λ { (a , b) (c , d) → ℤ.+Comm (a ℤ.· (ℕ₊₁→ℤ d)) (c ℤ.· (ℕ₊₁→ℤ b)) })
++Comm = OnCommonDenomSym.go-comm +Rec
 
 +IdL : ∀ x → 0 + x ≡ x
 +IdL = SetQuotient.elimProp (λ _ → isSetℚ _ _)
@@ -383,15 +407,16 @@ _+_ = onCommonDenomSym
             ≡[ i ]⟨ ℤ.·DistL+ (a ℤ.· d) (c ℤ.· b) f (~ i) ℤ.+ e ℤ.· (b ℤ.· d) ⟩
           (a ℤ.· d ℤ.+ c ℤ.· b) ℤ.· f ℤ.+ e ℤ.· (b ℤ.· d) ∎
 
+·Rec : OnCommonDenomSym
+·Rec .OnCommonDenomSym.g (a , _) (c , _) = a ℤ.· c
+·Rec .OnCommonDenomSym.g-sym (a , _) (c , _) = ℤ.·Comm a c
+·Rec .OnCommonDenomSym.g-eql (a , b) (c , d) (e , _) p = lem₁ a (ℕ₊₁→ℤ d) c (ℕ₊₁→ℤ b) e p
 
 _·_ : ℚ → ℚ → ℚ
-_·_ = onCommonDenomSym
-  (λ { (a , _) (c , _) → a ℤ.· c })
-  (λ { (a , _) (c , _) → ℤ.·Comm a c })
-  (λ { (a , b) (c , d) (e , _) p → lem₁ a (ℕ₊₁→ℤ d) c (ℕ₊₁→ℤ b) e p })
+_·_ = OnCommonDenomSym.go ·Rec
 
 ·Comm : ∀ x y → x · y ≡ y · x
-·Comm = onCommonDenomSym-comm (λ { (a , _) (c , _) → ℤ.·Comm a c })
+·Comm = OnCommonDenomSym.go-comm ·Rec
 
 ·IdL : ∀ x → 1 · x ≡ x
 ·IdL = SetQuotient.elimProp (λ _ → isSetℚ _ _)
@@ -462,6 +487,9 @@ _·_ = onCommonDenomSym
 -Invol : ∀ x → - - x ≡ x
 -Invol x = ·Assoc -1 -1 x ∙ ·IdL x
 
+-Distr : ∀ x y → - (x + y) ≡ - x + - y
+-Distr = ·DistL+ -1
+
 negateEquiv : ℚ ≃ ℚ
 negateEquiv = isoToEquiv (iso -_ -_ -Invol -Invol)
 
@@ -474,6 +502,19 @@ negateEq = ua negateEquiv
 _-_ : ℚ → ℚ → ℚ
 x - y = x + (- y)
 
+
+-·- : ∀ x y → (- x) · (- y) ≡ x · y
+-·- x y = cong (_· (- y)) (·Comm -1 x)
+            ∙∙ sym (·Assoc x (- 1) _)
+            ∙∙ cong (x ·_) (-Invol y)
+
+-[x-y]≡y-x : ∀ x y → - ( x - y ) ≡ y - x
+-[x-y]≡y-x x y = -Distr x (- y) ∙ λ i → +Comm (- x) (-Invol y i) i
+
+-Distr' : ∀ x y → - (x - y) ≡ (- x) + y
+-Distr' x y = -[x-y]≡y-x x y ∙ +Comm y (- x)
+
+
 +InvR : ∀ x → x - x ≡ 0
 +InvR x = +Comm x (- x) ∙ +InvL x
 
@@ -484,3 +525,52 @@ x - y = x + (- y)
 
 +CancelR : ∀ x y z → x + y ≡ z + y → x ≡ z
 +CancelR x y z p = +CancelL y x z (+Comm y x ∙ p ∙ +Comm z y)
+
++CancelL- : ∀ x y z → x + y ≡ z → x ≡ z - y
++CancelL- x y z p = (sym (+IdR x)  ∙ cong (x +_) (sym (+InvR y)))
+  ∙∙  (+Assoc x y (- y)) ∙∙ cong (_- y) p
+
+abs : ℚ → ℚ
+abs x = max x (- x)
+
+abs' : ℚ → ℚ
+abs' = SetQuotient.Rec.go w
+ where
+ w : SetQuotient.Rec ℚ
+ w .SetQuotient.Rec.isSetB = isSetℚ
+ w .SetQuotient.Rec.f (a , b) = [ ℤ.pos (ℤ.abs a) , b ]
+ w .SetQuotient.Rec.f∼ (a , 1+ b) (a' , 1+ b') r = eq/ _ _
+   ((sym (ℤ.pos·pos (ℤ.abs a) (suc b')) ∙
+      cong ℤ.pos (sym (ℤ.abs· (a) (ℕ₊₁→ℤ (1+ b'))) ))
+     ∙∙ cong (λ x → ℤ.pos (ℤ.abs x)) r
+     ∙∙ sym ((sym (ℤ.pos·pos (ℤ.abs a') (suc b)) ∙
+      cong ℤ.pos (sym (ℤ.abs· (a') (ℕ₊₁→ℤ (1+ b))) ))))
+
+abs'≡abs : ∀ x → abs x ≡ abs' x
+abs'≡abs = SetQuotient.ElimProp.go w
+ where
+ w : SetQuotient.ElimProp (λ z → abs z ≡ abs' z)
+ w .SetQuotient.ElimProp.isPropB _ = isSetℚ _ _
+ w .SetQuotient.ElimProp.f (a , 1+ b) = eq/ _ _  ww
+  where
+
+  ww : ℤ.max (a ℤ.· ℕ₊₁→ℤ (1 ·₊₁ 1+ b))
+              ((ℤ.- a)  ℤ.· ℕ₊₁→ℤ (1+ b)) ℤ.· ℤ.pos (suc b) ≡
+         ℤ.pos (ℤ.abs a) ℤ.·
+           ℕ₊₁→ℤ ((1+ b) ·₊₁ (1 ·₊₁ 1+ b))
+  ww = cong (ℤ._· ℤ.pos (suc b))
+         ((λ i → ℤ.max (a ℤ.· ℕ₊₁→ℤ (·₊₁-identityˡ (1+ b) i))
+              ((ℤ.- a)  ℤ.· ℕ₊₁→ℤ (1+ b))) ∙ sym (ℤ.·DistPosLMax a ((ℤ.- a)) (suc b)) ) ∙∙
+      (λ i → ℤ.·Assoc (ℤ.abs-max a (~ i)) (ℕ₊₁→ℤ (1+ b))
+         (ℕ₊₁→ℤ (·₊₁-identityˡ (1+ b) (~ i))) (~ i)) ∙∙
+          cong (ℤ.pos (ℤ.abs a) ℤ.·_)
+           (sym (pos·pos (suc b) (ℕ₊₁→ℕ (·₊₁-identityˡ (1+ b) (~ i1)))))
+
+ℤ+→ℚ+ : ∀ m n → [ m / 1 ] + [ n / 1 ] ≡ [ m ℤ.+ n / 1 ]
+ℤ+→ℚ+ m n = cong [_/ 1 ] (cong₂ ℤ._+_ (ℤ.·IdR m) (ℤ.·IdR n))
+
+ℕ+→ℚ+ : ∀ m n → fromNat m + fromNat n ≡ fromNat (m ℕ.+ n)
+ℕ+→ℚ+ m n = ℤ+→ℚ+ (ℤ.pos m) (ℤ.pos n) ∙ cong [_/ 1 ] (sym (ℤ.pos+ m n))
+
+ℕ·→ℚ· : ∀ m n → fromNat m · fromNat n ≡ fromNat (m ℕ.· n)
+ℕ·→ℚ· m n = cong [_/ 1 ] (sym (ℤ.pos·pos m n))
diff --git a/Cubical/Foundations/HLevels.agda b/Cubical/Foundations/HLevels.agda
index 18fe6927fb..523b385abb 100644
--- a/Cubical/Foundations/HLevels.agda
+++ b/Cubical/Foundations/HLevels.agda
@@ -21,6 +21,7 @@ open import Cubical.Foundations.Isomorphism
 open import Cubical.Foundations.Path
 open import Cubical.Foundations.Transport
 open import Cubical.Foundations.Univalence using (ua ; univalenceIso)
+open import Cubical.Foundations.CartesianKanOps
 
 open import Cubical.Data.Sigma
 open import Cubical.Data.Nat   using (ℕ; zero; suc; _+_; +-zero; +-comm)
@@ -863,3 +864,24 @@ module _ (B : (i j k : I) → Type ℓ)
 
 Π-contractDom : (c : isContr A) → ((x : A) → B x) ≃ B (c .fst)
 Π-contractDom c = isoToEquiv (Π-contractDomIso c)
+
+
+lem722 : {A : Type ℓ} (R : A → A → Type ℓ')
+  (isPropR : ∀ a a' → isProp (R a a'))
+  (impliesId : ∀ a a' → R a a' → a ≡ a')
+  (reflA : ∀ a → R a a)
+  → isSet A
+lem722 R isPropR f ρ x =
+ let u : (p : x ≡ x) →
+          PathP (λ z → p z ≡ x) (f x x (ρ x)) (f x x (transp (λ j → R (p j) x) i0 (ρ x)))
+     u p = λ i → f (p i) x (coe0→i (λ i → R (p i) x) i (ρ x))
+ in λ y → J (λ y p → ∀ q → p ≡ q)
+     λ q i j →
+        hcomp (λ z → λ {
+          (i = i1) → u q j (~ z)
+         ;(i = i0) → f x x
+              (isPropR _ _ (ρ x) (transp (λ j₁ → R (q j₁) x) i0 (ρ x))
+                j) (~ z)
+         ;(j = i0) → u q j (~ z)
+         ;(j = i1) → u q j (~ z)})
+         x
diff --git a/Cubical/HITs/CauchyReals.agda b/Cubical/HITs/CauchyReals.agda
new file mode 100644
index 0000000000..200d8e2dd7
--- /dev/null
+++ b/Cubical/HITs/CauchyReals.agda
@@ -0,0 +1,12 @@
+{-# OPTIONS --safe #-}
+module Cubical.HITs.CauchyReals where
+
+open import Cubical.HITs.CauchyReals.Base public
+open import Cubical.HITs.CauchyReals.Closeness public
+open import Cubical.HITs.CauchyReals.Lipschitz public
+open import Cubical.HITs.CauchyReals.Order public
+open import Cubical.HITs.CauchyReals.Continuous public
+open import Cubical.HITs.CauchyReals.Multiplication public
+open import Cubical.HITs.CauchyReals.Inverse public
+open import Cubical.HITs.CauchyReals.Sequence public
+open import Cubical.HITs.CauchyReals.Derivative public
diff --git a/Cubical/HITs/CauchyReals/Base.agda b/Cubical/HITs/CauchyReals/Base.agda
new file mode 100644
index 0000000000..387d29eaf2
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/Base.agda
@@ -0,0 +1,312 @@
+{-# OPTIONS --safe #-}
+module Cubical.HITs.CauchyReals.Base where
+
+open import Cubical.Foundations.Prelude hiding (Path)
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.HLevels
+
+open import Cubical.Data.Int as ℤ
+open import Cubical.Data.Rationals as ℚ
+open import Cubical.Data.Rationals.Order as ℚ
+
+open import Cubical.Data.NatPlusOne
+
+private
+  variable
+    ℓ ℓ' : Level
+
+-- HoTT Definition 11.3.2.
+
+data ℝ : Type
+
+data _∼[_]_  : ℝ → ℚ₊ → ℝ → Type
+
+data ℝ where
+ rat : ℚ → ℝ
+ -- HoTT (11.3.3)
+ lim : (x : ℚ₊ → ℝ) →
+       (∀ ( δ ε : ℚ₊) → x δ ∼[ δ ℚ₊+ ε ] x ε) →  ℝ
+ -- HoTT (11.3.4)
+ eqℝ : ∀ x y → (∀ ε → x ∼[ ε ] y) → x ≡ y
+
+data _∼[_]_   where
+ rat-rat : ∀ q r ε
+   → (ℚ.- fst ε) ℚ.< (q ℚ.- r)
+   → (q ℚ.- r) ℚ.< fst ε → (rat q) ∼[ ε ] (rat r)
+ rat-lim : ∀ q y ε δ p v →
+        (rat q) ∼[ fst ε ℚ.- fst δ , v ] ( y δ )
+        → (rat q) ∼[ ε ] (lim y p )
+ lim-rat : ∀ x r ε δ p v →
+        (x δ) ∼[ fst ε ℚ.- fst δ , v ] ( rat r )
+        → (lim x p) ∼[ ε ] (rat r )
+ lim-lim : ∀ x y ε δ η p p' v →
+        (x δ) ∼[ (fst ε ℚ.- (fst δ ℚ.+ fst η)) , v ] (y η )
+        → (lim x p) ∼[ ε ] (lim y p' )
+ isProp∼ : ∀ r q r' → isProp (r ∼[ q ] r')
+
+rat-rat-fromAbs : ∀ q r ε
+   → ℚ.abs (q ℚ.- r) ℚ.< fst ε → (rat q) ∼[ ε ] (rat r)
+rat-rat-fromAbs q r ε x =
+  rat-rat _ _ _
+      (isTrans<≤ (ℚ.- fst ε) (ℚ.- ℚ.abs (q ℚ.- r)) (q ℚ.- r)
+         (minus-< (ℚ.abs (q ℚ.- r)) (fst ε)  x)
+           (isTrans≤ (ℚ.- ℚ.abs (q ℚ.- r))
+             (ℚ.- (ℚ.- (q ℚ.- r))) (q ℚ.- r)
+             (minus-≤ (ℚ.- (q ℚ.- r)) (ℚ.abs (q ℚ.- r))
+               (isTrans≤ (ℚ.- (q ℚ.- r)) _ (ℚ.abs (q ℚ.- r))
+                  (ℚ.≤max (ℚ.- (q ℚ.- r)) (q ℚ.- r))
+                    (≡Weaken≤ (ℚ.max (ℚ.- (q ℚ.- r)) (q ℚ.- r))
+                     _
+                       (ℚ.maxComm (ℚ.- (q ℚ.- r)) (q ℚ.- r) ))))
+              (≡Weaken≤ (ℚ.- (ℚ.- (q ℚ.- r))) (((q ℚ.- r)))
+                 (ℚ.-Invol (q ℚ.- r)))))
+    ( isTrans≤< (q ℚ.- r) (ℚ.abs (q ℚ.- r)) (fst ε)
+      (ℚ.≤max (q ℚ.- r) (ℚ.- (q ℚ.- r)) ) x)
+
+
+_∼[_]ₚ_ : ℝ → ℚ₊ → ℝ → hProp ℓ-zero
+x ∼[ ε ]ₚ y = x ∼[ ε ] y , isProp∼ _ _ _
+
+
+instance
+  fromNatℝ : HasFromNat ℝ
+  fromNatℝ = record { Constraint = λ _ → Unit ; fromNat = λ n → rat [ pos n / 1 ] }
+
+instance
+  fromNegℝ : HasFromNeg ℝ
+  fromNegℝ = record { Constraint = λ _ → Unit ; fromNeg = λ n → rat [ neg n / 1 ] }
+
+
+record Elimℝ {ℓ} {ℓ'} (A : ℝ → Type ℓ)
+               (B : ∀ {x y : ℝ} →
+                  A x → A y →
+                ∀ ε → x ∼[ ε ] y → Type ℓ') : Type (ℓ-max ℓ ℓ') where
+ field
+  ratA : ∀ x → A (rat x)
+  -- HoTT (11.3.5)
+  limA : ∀ x p → (a : ∀ q → A (x q)) →
+             (∀ δ ε → B (a δ) (a ε) (δ ℚ₊+ ε) (p _ _) ) → A (lim x p)
+  eqA : ∀ {x y} p a a' → (∀ δ ε → B a a' _ (p (δ ℚ₊+ ε)))
+   → (∀ ε → B a a' ε (p ε))
+   → PathP (λ i → A (eqℝ x y p i)) a a'
+
+  rat-rat-B : ∀ q r ε x x₁ → B (ratA q) (ratA r) ε (rat-rat q r ε x x₁)
+  rat-lim-B : ∀ q y ε δ p v r v' u' →
+       B (ratA q) (v' δ) ((fst ε ℚ.- fst δ) , v) r →
+       B (ratA q) (limA y p v' u') ε (rat-lim q y ε δ p v r)
+  lim-rat-B : ∀ x r ε δ p v u v' u'
+    → B (v' δ) (ratA r) ((fst ε ℚ.- fst δ) , v) u
+    → B (limA x p v' u') (ratA r) ε (lim-rat x r ε δ p v u)
+  lim-lim-B : ∀ x y ε δ η p p' v r v' u' v'' u''
+     → B (v' δ) (v'' η) ((fst ε ℚ.- (fst δ ℚ.+ fst η)) , v) r
+     → B (limA x p v' u') (limA y p' v'' u'')
+     ε (lim-lim x y ε δ η p p' v r)
+
+  isPropB : ∀ {x y} a a' ε u → isProp (B {x} {y} a a' ε u)
+
+ go : ∀ x → A x
+
+ go∼ : ∀ {x x' ε} → (r : x ∼[ ε ] x') →
+         B (go x) (go x') ε r
+
+ go (rat x) = ratA x
+ go (lim x x₁) = limA x x₁ (λ q → go (x q))
+   λ _ _ → go∼ _
+ go (eqℝ x x₁ x₂ i) =
+   eqA x₂ (go x) (go x₁) (λ _ _ → go∼  _)
+      (λ ε → go∼ (x₂ ε)) i
+
+
+ go∼ (rat-rat q r ε x x₁) = rat-rat-B q r ε x x₁
+ go∼ (rat-lim q y ε δ p v r) =
+  rat-lim-B q y ε δ p v r (λ q → go (y q))
+       (λ _ _ → go∼ (p _ _)) (go∼ {rat q} {y δ} r )
+ go∼ (lim-rat x r ε δ p v u) =
+  lim-rat-B x r ε δ p v u (λ q → go (x q))
+       (λ _ _ → go∼ (p _ _)) (go∼ {x δ} {rat r} u )
+ go∼ (lim-lim x y ε δ η p p' v r) =
+   lim-lim-B x y ε δ η p p' v r
+    (λ q → go (x q))
+       (λ _ _ → go∼ (p _ _))
+       (λ q → go (y q))
+       (λ _ _ → go∼ (p' _ _)) (go∼ {x δ} {y η} r)
+ go∼ (isProp∼ r ε r' r₁ r₂ i) =
+  isProp→PathP (λ i → isPropB (go r) (go r') ε ((isProp∼ r ε r' r₁ r₂ i)))
+     (go∼ r₁) (go∼ r₂) i
+
+ -- HoTT (11.3.6)
+ β-go-rat : ∀ q → go (rat q) ≡ ratA q
+ β-go-rat _ = refl
+
+ -- HoTT (11.3.7)
+ β-go-lim : ∀ x y → go (lim x y) ≡ limA x y _ _
+ β-go-lim _ _ = refl
+
+record Elimℝ-Prop {ℓ} (A : ℝ → Type ℓ) : Type ℓ where
+ field
+  ratA : ∀ x → A (rat x)
+  limA : ∀ x p → (∀ q → A (x q)) → A (lim x p)
+  isPropA : ∀ x → isProp (A x)
+
+
+ go : ∀ x → A x
+ go (rat x) = ratA x
+ go (lim x x₁) = limA x x₁ λ q → go (x q)
+ go (eqℝ x x₁ x₂ i) =
+  isProp→PathP (λ i → isPropA (eqℝ x x₁ x₂ i))  (go x) (go x₁) i
+
+record Elimℝ-Prop2 {ℓ} (A : ℝ → ℝ → Type ℓ) : Type ℓ where
+ field
+  rat-ratA : ∀ r q → A (rat r) (rat q)
+  rat-limA : ∀ r x y → (∀ q → A (rat r) (x q)) → A (rat r) (lim x y)
+  lim-ratA : ∀ x y r → (∀ q → A (x q) (rat r)) → A (lim x y) (rat r)
+  lim-limA : ∀ x y x' y' → (∀ q q' → A (x q) (x' q')) → A (lim x y) (lim x' y')
+  isPropA : ∀ x y → isProp (A x y)
+
+
+
+
+ go : ∀ x y → A x y
+ go = Elimℝ-Prop.go w
+  where
+  w : Elimℝ-Prop (λ z → (y : ℝ) → A z y)
+  w .Elimℝ-Prop.ratA x = Elimℝ-Prop.go w'
+   where
+   w' : Elimℝ-Prop _
+   w' .Elimℝ-Prop.ratA = rat-ratA x
+   w' .Elimℝ-Prop.limA = rat-limA x
+   w' .Elimℝ-Prop.isPropA _ = isPropA _ _
+  w .Elimℝ-Prop.limA x p x₁ = Elimℝ-Prop.go w'
+   where
+   w' : Elimℝ-Prop _
+   w' .Elimℝ-Prop.ratA x' = lim-ratA x p x' (flip x₁ (rat x'))
+   w' .Elimℝ-Prop.limA x' p' _ = lim-limA x p x' p' λ q q' → x₁ q (x' q')
+   w' .Elimℝ-Prop.isPropA _ = isPropA _ _
+  w .Elimℝ-Prop.isPropA _ = isPropΠ λ _ → isPropA _ _
+
+
+
+
+record Elimℝ-Prop2Sym {ℓ} (A : ℝ → ℝ → Type ℓ) : Type ℓ where
+ field
+  rat-ratA : ∀ r q → A (rat r) (rat q)
+  rat-limA : ∀ r x y → (∀ q → A (rat r) (x q)) → A (rat r) (lim x y)
+  lim-limA : ∀ x y x' y' → (∀ q q' → A (x q) (x' q')) → A (lim x y) (lim x' y')
+  isSymA : ∀ x y → A x y → A y x
+  isPropA : ∀ x y → isProp (A x y)
+
+
+ go : ∀ x y → A x y
+ go = Elimℝ-Prop2.go w
+  where
+  w : Elimℝ-Prop2 (λ z z₁ → A z z₁)
+  w .Elimℝ-Prop2.rat-ratA = rat-ratA
+  w .Elimℝ-Prop2.rat-limA = rat-limA
+  w .Elimℝ-Prop2.lim-ratA x y r x₁ =
+   isSymA _ _ (rat-limA r x y (isSymA _ _ ∘ x₁))
+  w .Elimℝ-Prop2.lim-limA = lim-limA
+  w .Elimℝ-Prop2.isPropA = isPropA
+
+-- HoTT (11.3.13)
+record Recℝ {ℓ} {ℓ'} (A : Type ℓ)
+               (B : A → A → ℚ₊ → Type ℓ') : Type (ℓ-max ℓ ℓ') where
+ field
+  ratA : ℚ → A
+  limA : (a : ℚ₊ → A) →
+             (∀ δ ε → B (a δ) (a ε) (δ ℚ₊+ ε)) → A
+  eqA : ∀ a a' → (∀ ε → B a a' ε) → a ≡ a'
+
+  rat-rat-B : ∀ q r ε
+       → (ℚ.- fst ε) ℚ.< (q ℚ.- r)
+       → (q ℚ.- r) ℚ.< fst ε
+       → B (ratA q) (ratA r) ε
+  rat-lim-B : ∀ q y ε p δ v →
+       (B (ratA q) (y δ) ((fst ε ℚ.- fst δ) , v)) →
+       B (ratA q) (limA y p) ε
+  lim-rat-B : ∀ x r ε δ p v
+    → B (x δ) (ratA r) ((fst ε ℚ.- fst δ) , v)
+    → B (limA x p) (ratA r) ε
+  lim-lim-B : ∀ x y ε δ η p p' v
+     → B (x δ) (y η) (((fst ε ℚ.- (fst δ ℚ.+ fst η)) , v))
+     → B (limA x p) (limA y p') ε
+
+  isPropB : ∀ a a' ε → isProp (B a a' ε)
+
+ d : Elimℝ (λ _ → A) λ a a' ε _ → B a a' ε
+ d .Elimℝ.ratA = ratA
+ d .Elimℝ.limA x p a x₁ = limA a x₁
+ d .Elimℝ.eqA p a a' x x₁ = eqA a a' x₁
+ d .Elimℝ.rat-rat-B q r ε x x₁ = rat-rat-B q r ε x x₁
+ d .Elimℝ.rat-lim-B q y ε δ p v r v' u' x = rat-lim-B q v' ε u' δ v x
+ d .Elimℝ.lim-rat-B x r ε δ p v u v' u' x₁ =
+  lim-rat-B v' r ε δ u' v x₁
+ d .Elimℝ.lim-lim-B x y ε δ η p p' v r v' u' v'' u'' x₁ =
+   lim-lim-B v' v'' ε δ η u' u'' v x₁
+ d .Elimℝ.isPropB a a' ε u = isPropB a a' ε
+
+ go : ℝ → A
+ go~ : {x x' : ℝ} {ε : ℚ₊} (r : x ∼[ ε ] x') →
+         B (go x) (go x') ε
+ go = Elimℝ.go d
+
+
+
+ go~ = Elimℝ.go∼ d
+
+subst∼ : ∀ {u v ε ε'} → fst ε ≡ fst ε' → u ∼[ ε ] v → u ∼[ ε' ] v
+subst∼ = subst (_ ∼[_] _) ∘ ℚ₊≡
+
+_subst∼[_]_ : ∀ {x x' y y' ε ε'} →
+              x ≡ x' → ε ≡ ε' → y ≡ y' →
+               x ∼[ ε ] y → x' ∼[ ε' ] y'
+_subst∼[_]_ p q r = transport λ i → p i ∼[ q i ] r i
+
+record Casesℝ {ℓ} {ℓ'} (A : Type ℓ)
+               (B : A → A → ℚ₊ → Type ℓ') : Type (ℓ-max ℓ ℓ') where
+ field
+  ratA : ℚ → A
+  limA : (x : ℚ₊ → ℝ) →
+             ((δ ε : ℚ₊) → x δ ∼[ δ ℚ₊+ ε ] x ε) → A
+  eqA : ∀ a a' → (∀ ε → B a a' ε) → a ≡ a'
+
+  rat-rat-B : (q r : ℚ) (ε : ℚ₊) (x : (ℚ.- fst ε) ℚ.< (q ℚ.- r))
+      (x₁ : (q ℚ.- r) ℚ.< fst ε) →
+      B (ratA q) (ratA r) ε
+  rat-lim-B : (q : ℚ) (y : ℚ₊ → ℝ) (ε δ : ℚ₊)
+      (p : (δ₁ ε₁ : ℚ₊) → y δ₁ ∼[ δ₁ ℚ₊+ ε₁ ] y ε₁)
+      (v : 0< (fst ε ℚ.- fst δ))
+      (r : rat q ∼[ (fst ε ℚ.- fst δ) , v ] y δ) (v' : (q₁ : ℚ₊) → A)
+      (u' : (δ₁ ε₁ : ℚ₊) → B (v' δ₁) (v' ε₁) (δ₁ ℚ₊+ ε₁)) →
+      B (ratA q) (v' δ) ((fst ε ℚ.- fst δ) , v) → B (ratA q) (limA y p) ε
+  lim-rat-B : (x : ℚ₊ → ℝ) (r : ℚ) (ε δ : ℚ₊)
+      (p : (δ₁ ε₁ : ℚ₊) → x δ₁ ∼[ δ₁ ℚ₊+ ε₁ ] x ε₁)
+      (v : 0< (fst ε ℚ.- fst δ))
+      (u : x δ ∼[ (fst ε ℚ.- fst δ) , v ] rat r) (v' : (q : ℚ₊) → A)
+      (u' : (δ₁ ε₁ : ℚ₊) → B (v' δ₁) (v' ε₁) (δ₁ ℚ₊+ ε₁)) →
+      B (v' δ) (ratA r) ((fst ε ℚ.- fst δ) , v) → B (limA x p) (ratA r) ε
+  lim-lim-B : (x y : ℚ₊ → ℝ) (ε δ η : ℚ₊)
+      (p : (δ₁ ε₁ : ℚ₊) → x δ₁ ∼[ δ₁ ℚ₊+ ε₁ ] x ε₁)
+      (p' : (δ₁ ε₁ : ℚ₊) → y δ₁ ∼[ δ₁ ℚ₊+ ε₁ ] y ε₁)
+      (v : 0< (fst ε ℚ.- (fst δ ℚ.+ fst η)))
+      (r : x δ ∼[ (fst ε ℚ.- (fst δ ℚ.+ fst η)) , v ] y η) →
+      B (limA x p) (limA y p') ε
+
+  isPropB : ∀ a a' ε → isProp (B a a' ε)
+
+ d : Elimℝ (λ _ → A) λ a a' ε _ → B a a' ε
+ d .Elimℝ.ratA = ratA
+ d .Elimℝ.limA x p a x₁ = limA x p
+ d .Elimℝ.eqA p a a' x x₁ = eqA a a' x₁
+ d .Elimℝ.rat-rat-B = rat-rat-B
+ d .Elimℝ.rat-lim-B = rat-lim-B
+ d .Elimℝ.lim-rat-B = lim-rat-B
+ d .Elimℝ.lim-lim-B x y ε δ η p p' v₁ r _ _ _ _ _ =
+   lim-lim-B x y ε δ η p p' v₁ r
+ d .Elimℝ.isPropB a a' ε _ = isPropB a a' ε
+
+ go : ℝ → A
+ go~ : {x x' : ℝ} {ε : ℚ₊} (r : x ∼[ ε ] x') →
+         B (go x) (go x') ε
+ go = Elimℝ.go d
+ go~ = Elimℝ.go∼ d
+
diff --git a/Cubical/HITs/CauchyReals/Closeness.agda b/Cubical/HITs/CauchyReals/Closeness.agda
new file mode 100644
index 0000000000..979c90f6e1
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/Closeness.agda
@@ -0,0 +1,851 @@
+{-# OPTIONS --safe #-}
+module Cubical.HITs.CauchyReals.Closeness where
+
+open import Cubical.Foundations.Prelude hiding (Path)
+open import Cubical.Foundations.Structure
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.Equiv hiding (_■)
+open import Cubical.Foundations.HLevels
+open import Cubical.Functions.FunExtEquiv
+
+import Cubical.Functions.Logic as L
+
+open import Cubical.Data.Sigma hiding (Path)
+open import Cubical.Data.Rationals as ℚ
+open import Cubical.Data.Rationals.Order as ℚ
+open import Cubical.Data.Rationals.Order.Properties as ℚ
+
+open import Cubical.HITs.PropositionalTruncation as PT
+
+open import Cubical.HITs.CauchyReals.Base
+open import Cubical.HITs.CauchyReals.Lems
+
+
+
+-- HoTT Lemma (11.3.8)
+refl∼ : ∀ r ε → r ∼[ ε ] r
+refl∼ = Elimℝ-Prop.go w
+ where
+ w : Elimℝ-Prop _
+ w .Elimℝ-Prop.ratA x x₁ =
+   rat-rat x x x₁
+     (subst ((ℚ.- (fst x₁)) ℚ.<_) (sym (+InvR x))
+       (minus-< 0 (fst x₁) ((0<→< (fst x₁) (snd x₁)))))
+        --(minus-< 0 (fst x₁) (snd x₁)))
+        ((subst ( ℚ._< (fst x₁)) (sym (+InvR x)) ((0<→< (fst x₁) (snd x₁)))))
+ w .Elimℝ-Prop.limA x p _ ε =
+  let e1 = /2₊ (/2₊ ε)
+      zz = +CancelL- (fst (/2₊ ε)) (fst (/2₊ ε)) (fst ε)
+            (ε/2+ε/2≡ε (fst ε))
+          ∙ cong ( ℚ._-_ (fst ε)) (sym (ε/2+ε/2≡ε (fst (/2₊ ε))))
+  in lim-lim x x ε e1 e1 p p
+        (subst (0<_) zz (snd ((/2₊ ε))))
+       (subst (λ e → x e1 ∼[ e ] x e1)
+       (ℚ₊≡ (ε/2+ε/2≡ε (fst (/2₊ ε)) ∙
+          zz ))
+       (p e1 e1))
+ w .Elimℝ-Prop.isPropA _ = isPropΠ λ _ → isProp∼ _ _ _
+
+
+-- HoTT Lemma (11.3.12)
+sym∼ : ∀ r r' ε → r ∼[ ε ] r' → r' ∼[ ε ] r
+sym∼ r r' ε (rat-rat q r₁ .ε x x₁) =
+ rat-rat r₁ q ε (subst ((ℚ.- fst ε) ℚ.<_)
+  ((ℚ.-Distr' q r₁ ∙ ℚ.+Comm (ℚ.- q) r₁))
+    $ minus-< (q ℚ.- r₁) (fst ε) x₁)
+  (subst2 ℚ._<_ (ℚ.-Distr' q r₁ ∙ ℚ.+Comm (ℚ.- q) r₁)
+    (ℚ.-Invol (fst ε)) (minus-< (ℚ.- fst ε)  (q ℚ.- r₁) x))
+
+sym∼ r r' ε (rat-lim q y .ε δ p v x) =
+ lim-rat y q ε δ p v (sym∼ _ _ _ x)
+sym∼ r r' ε (lim-rat x r₁ .ε δ p v x₁) =
+  rat-lim r₁ x ε δ p v (sym∼ _ _ _ x₁)
+sym∼ r r' ε (lim-lim x y .ε δ η p p' v x₁) =
+ let z = ((sym∼ (x δ) (y η) _ x₁))
+     z' = subst (λ xx → Σ _ λ v → y η ∼[ (fst ε ℚ.- xx) , v ] x δ)
+            (ℚ.+Comm (fst δ) (fst η))
+             (v , z)
+ in lim-lim y x ε η δ  p' p (fst z') (snd z')
+sym∼ r r' ε (isProp∼ .r .ε .r' x x₁ i) =
+  isProp∼ r' ε r (sym∼ _ _ _ x) (sym∼ _ _ _ x₁) i
+
+-- HoTT Theorem (11.3.9)
+isSetℝ : isSet ℝ
+isSetℝ = lem722 (λ r r' → ∀ ε →  r ∼[ ε ] r')
+  (λ _ _ → isPropΠ λ _ → isProp∼ _ _ _)
+   eqℝ
+   refl∼
+
+∼≃≡ : ∀ r r' → (∀ ε → r ∼[ ε ] r') ≃  (r ≡ r')
+∼≃≡ r r' = propBiimpl→Equiv (isPropΠ λ _ → isProp∼ _ _ _) (isSetℝ _ _) (eqℝ _ _)
+  (J (λ r' _ → ∀ ε → r ∼[ ε ] r') (refl∼ _))
+
+≡→∼ : ∀ {ε r r'} → r ≡ r' → r ∼[ ε ] r'
+≡→∼ {ε} {r} {r'} p = invEq (∼≃≡ r r') p ε
+
+
+
+
+rat-rat' : ℚ → ℚ₊ → ℚ → hProp ℓ-zero
+rat-rat' q ε r .fst = ((ℚ.- fst ε) ℚ.< (q ℚ.- r)) × ((q ℚ.- r) ℚ.< fst ε)
+rat-rat' q ε r .snd = isProp× (ℚ.isProp< (ℚ.- fst ε) (q ℚ.- r))
+                        (ℚ.isProp< (q ℚ.- r) (fst ε))
+
+
+rat-rat'-sym : ∀ q ε r → ⟨ rat-rat' q ε r ⟩ → ⟨ rat-rat' r ε q ⟩
+rat-rat'-sym q ε r x .fst =
+  subst ((ℚ.- fst ε) ℚ.<_) (ℚ.-Distr' q r ∙ ℚ.+Comm (ℚ.- q) r)
+   (minus-< (q ℚ.- r) (fst ε) (snd x))
+rat-rat'-sym q ε r x .snd =
+  subst2 (ℚ._<_) (ℚ.-Distr' q r ∙ ℚ.+Comm (ℚ.- q) r) (ℚ.-Invol (fst ε))
+   (minus-<  (ℚ.- fst ε) (q ℚ.- r) (fst x))
+
+Σ< : (ℚ₊ → Type) → (ℚ → Type)
+Σ< P q = Σ _ (P ∘ (q ,_) )
+
+rat-lim' : ℚ₊ → (ℚ₊ → ℚ₊ → hProp ℓ-zero) → hProp ℓ-zero
+rat-lim' ε a =
+  (∃[ δ ∈ ℚ₊ ]
+      Σ< (fst ∘ a δ) (((fst ε) ℚ.- (fst δ)))  ) , squash₁
+
+lim-lim' : ℚ₊ → (ℚ₊ → ℚ₊ → ℚ₊ → hProp ℓ-zero) → hProp ℓ-zero
+lim-lim' ε a =
+  (∃[ (δ , η)  ∈ ℚ₊ × ℚ₊ ]
+      Σ< (fst ∘ a δ η) ((fst ε) ℚ.- (fst δ ℚ.+ fst η)) ) , squash₁
+
+
+w-prop' : (ℚ₊ → hProp ℓ-zero) → Type
+w-prop' = λ △ → ∀ ε → ⟨
+               ( △ ε ) L.⇔ (L.∃[ θ ∶ ℚ₊ ]
+                  (L.∃[ v ] (△ (((fst ε) ℚ.- (fst θ)) , v)))) ⟩
+
+
+substΣ< : (P : Σ (ℚ₊ → hProp ℓ-zero) w-prop') → ∀ {x y} → x ≡ y →
+             Σ< (fst ∘ (fst P)) x → Σ< (fst ∘ (fst P)) y
+substΣ< P = subst (Σ< (fst ∘ (fst P)))
+
+
+pre-w-rel' : Σ (ℚ₊ → hProp ℓ-zero) w-prop' →
+           Σ (ℚ₊ → hProp ℓ-zero) w-prop' → ℚ₊ → ℚ₊ → Type
+
+w-rel'  : Σ (ℚ₊ → hProp ℓ-zero) w-prop' →
+           Σ (ℚ₊ → hProp ℓ-zero) w-prop' → ℚ₊ → Type
+
+pre-w-rel' = λ (△ , _) (◻ , _) ε η
+       → (⟨ △ η ⟩ →  ⟨ ◻ (ε ℚ₊+ η) ⟩)
+
+
+w-rel' = λ △ ◻ ε →
+     ∀ η → pre-w-rel' △ ◻ ε η
+           × pre-w-rel' ◻ △  ε η
+
+w-rel'-sym : ∀ △ ◻ ε → w-rel' △ ◻ ε → w-rel' ◻ △  ε
+w-rel'-sym △ ◻ ε x η = fst Σ-swap-≃ (x η)
+
+w-rel'⇒ : ∀ x y → (∀ ε → w-rel' x y ε) → ∀ ε
+          → ⟨ fst x ε ⟩ → ⟨ fst y ε ⟩
+w-rel'⇒ x y x₁ ε x₂ =
+ let z = fst (snd x ε) x₂
+     z' = PT.map (λ (δ , xx) →
+              /2₊ δ , PT.map
+                  (λ (xxx , xxx') →
+                    substΣ< y
+                      (cong (λ zz → fst (/2₊ δ) ℚ.+ (fst ε ℚ.- zz))
+                        (sym (ε/2+ε/2≡ε (fst δ))) ∙
+                          lem--08 {fst (/2₊ δ)} {fst ε})
+                       (_ , (fst (x₁ (/2₊ δ) _) xxx')))
+                      xx) z
+ in snd (snd y ε)
+       z'
+
+w-rel'→≡ : ∀ x y → (∀ ε → w-rel' x y ε) → x ≡ y
+w-rel'→≡ x y p =
+  Σ≡Prop (λ x₁ → isPropΠ λ x →
+     (snd (x₁ x L.⇔
+     L.∃[∶]-syntax
+     (λ θ → L.∃[]-syntax (λ v₁ → x₁ ((fst x ℚ.- fst θ) , v₁))))))
+      (funExt λ ε →
+   L.⇔toPath (w-rel'⇒ x y p ε)
+     (w-rel'⇒ y x (λ ε₁ → w-rel'-sym x y ε₁ (p ε₁)) ε))
+
+
+
+r-r : ℚ → ℚ → Σ _ w-prop'
+r-r q r .fst ε = rat-rat' q ε r
+r-r q r .snd ε .fst x =
+ let z = getθ ε (q ℚ.- r) x
+ in ∣ fst z , ∣ fst (snd z)  , snd (snd z) ∣₁ ∣₁
+r-r q r .snd ε .snd =
+  PT.rec (snd (rat-rat' q ε r)) (uncurry λ q* →
+   PT.rec (snd (rat-rat' q ε r))
+     λ (x₁ , y) →
+       weak0<' (q ℚ.- r) ε q* (fst y) , weak0< (q ℚ.- r) ε q* (snd y) )
+
+
+
+r-l : (a : ℚ₊ → Σ _ w-prop')
+
+        → Σ _ w-prop'
+r-l a .fst ε = rat-lim' ε (fst ∘ a)
+r-l a .snd ε .fst =
+  PT.rec
+      squash₁
+       λ (q' , v , pp) →
+          let aa = fst ((snd (a q')) ((fst ε ℚ.- fst q') , v)) pp
+          in PT.map
+              (map-snd λ {a''} →
+               (PT.map
+                λ x₂ →
+                  strength-lem-01 ε q' a'' (fst x₂) ,
+                   ∣ q' ,
+                    subst {A = ℚ}
+                    (λ qq → Σ (0< qq)
+                        (λ x₃ → ⟨ a q' .fst (qq , x₃) ⟩))
+                    (sym (ℚ.+Assoc (fst ε) (ℚ.- (fst q')) (ℚ.- (fst a'')))
+                      ∙∙ cong (fst ε ℚ.+_)
+                            (ℚ.+Comm (ℚ.- (fst q')) (ℚ.- (fst a'')))
+                      ∙∙ (ℚ.+Assoc (fst ε) (ℚ.- (fst a'')) (ℚ.- (fst q')))) x₂ ∣₁))
+              aa
+
+r-l a .snd ε .snd =
+       PT.rec
+      squash₁
+        (uncurry λ q' →
+           PT.rec squash₁ (uncurry λ v →
+              PT.map λ (q'' , zz) →
+                let zzz = snd (snd (a q'') (fst ε ℚ.- fst q'' ,
+                     strength-lem-01 ε q' q'' (fst zz)))
+                            ∣ q' ,
+                              ∣ subst {A = ℚ}
+                       (λ qq → Σ (0< qq)
+                        (λ x₃ → ⟨ a q'' .fst (qq , x₃) ⟩))
+                         ((sym (ℚ.+Assoc (fst ε) (ℚ.- (fst q')) (ℚ.- (fst q'')))
+                      ∙∙ cong (fst ε ℚ.+_)
+                            (ℚ.+Comm (ℚ.- (fst q')) (ℚ.- (fst q'')))
+                      ∙∙ (ℚ.+Assoc (fst ε) (ℚ.- (fst q'')) (ℚ.- (fst q')))))
+                         zz ∣₁ ∣₁
+                in q'' , _ , zzz))
+
+
+l-l : (𝕒 : ℚ₊ → ℚ₊ → Σ _ w-prop')
+
+  → Σ (ℚ₊ → hProp ℓ-zero) w-prop'
+
+l-l 𝕒 .fst ε = lim-lim' ε (λ x x₁ → fst (𝕒 x x₁))
+l-l 𝕒 .snd ε .fst =
+ PT.rec squash₁
+ (λ ((δ , η) , (v , y)) →
+    PT.map (map-snd (λ {q'} → PT.map
+          (λ (x , x') → strength-lem-01 ε (δ ℚ₊+ η) q' x , ∣ (δ , η) ,
+            subst (Σ< (fst ∘ (fst (𝕒 δ η))))
+              (+AssocCommR (fst ε) (ℚ.- (fst δ ℚ.+ fst η))
+                (ℚ.- fst q'))
+                (x , x')
+            ∣₁ )))
+              (fst (snd (𝕒 δ η) _) y))
+l-l 𝕒 .snd ε .snd =
+  PT.rec squash₁
+     (uncurry λ q' →
+       PT.rec squash₁ (uncurry λ v →
+         PT.map (map-snd
+           λ {(δ , η)} (x , x') → strength-lem-01 ε q' (δ ℚ₊+ η) x ,
+            (snd (snd (𝕒 δ η) _) ∣ q' , ∣
+              subst (Σ< (fst ∘ (fst (𝕒 δ η))))
+               (sym ((+AssocCommR (fst ε) (ℚ.- (fst δ ℚ.+ fst η))
+                (ℚ.- fst q'))))
+               (x , x') ∣₁ ∣₁) )))
+
+rel-r-r : ∀ 𝕢 → (q r : ℚ) (ε : Σ ℚ 0<_) →
+     (ℚ.- fst ε) ℚ.< (q ℚ.- r) →
+     (q ℚ.- r) ℚ.< fst ε → w-rel' (r-r 𝕢 q) (r-r 𝕢 r) ε
+rel-r-r 𝕢 q r ε x x₁ η =
+ let z : (((q ℚ.- r) ℚ.+ (𝕢 ℚ.- q)) ≡ (𝕢 ℚ.- r))
+     z = lem--09 {q} {r} {𝕢}
+ in (λ (u , v) →
+      subst2 ℚ._<_
+           (sym $ ℚ.-Distr (fst ε) (fst η))
+           z
+            (ℚ.<Monotone+ (ℚ.- fst ε) (q ℚ.- r)
+               (ℚ.- fst η)  (𝕢 ℚ.- q) x u)
+
+               , subst (ℚ._< fst ε ℚ.+ fst η)
+                   z
+                 (ℚ.<Monotone+ (q ℚ.- r) (fst ε) (𝕢 ℚ.- q) (fst η)  x₁ v))
+  , (λ (u , v) →
+       let zz = ℚ.<Monotone+  (ℚ.- (fst ε)) (ℚ.- (q ℚ.- r))
+                       (ℚ.- fst η) (𝕢 ℚ.- r)
+                           (ℚ.minus-< (q ℚ.- r) (fst ε)   x₁) u
+
+       in subst2 ℚ._<_ (sym $ ℚ.-Distr (fst ε) (fst η) )
+                   (lem--010 {q} {r} {𝕢}) zz
+               ,
+           let zz = ℚ.<Monotone+
+                      (ℚ.- (q ℚ.- r)) (ℚ.- (ℚ.- (fst ε))) (𝕢 ℚ.- r)
+                       (fst η) (minus-< (ℚ.- (fst ε)) (q ℚ.- r) x) v
+           in subst2 {x = (ℚ.- (q ℚ.- r)) ℚ.+ (𝕢 ℚ.- r)} {𝕢 ℚ.- q}
+                {z = (ℚ.- (ℚ.- fst ε)) ℚ.+ fst η} {fst (ε ℚ₊+ η)}
+               ℚ._<_
+                (lem--010 {q} {r} {𝕢}) (lem--012 {fst ε} {fst η}) zz)
+
+rel-r-l : ∀ 𝕢 → (q : ℚ) (y : ℚ₊ → Σ (ℚ₊ → hProp ℓ-zero) w-prop')
+     (ε : ℚ₊) (p : (δ ε₁ : ℚ₊) → w-rel' (y δ) (y ε₁) (δ ℚ₊+ ε₁))
+     (δ : ℚ₊) (v₁ : 0< (fst ε ℚ.- fst δ)) →
+     w-rel' (r-r 𝕢 q) (y δ) ((fst ε ℚ.- fst δ) , v₁) →
+     w-rel' (r-r 𝕢 q) (r-l y) ε
+rel-r-l 𝕢 q y ε p δ v₁ x η .fst xx' =
+ let z = fst (x η) xx'
+ in ∣ δ , (subst {x = fst η ℚ.+ (fst ε ℚ.- fst δ)}
+               {y = (fst (ε ℚ₊+ η) ℚ.- fst δ)} 0<_
+               (lem--013 {fst η} {fst ε} {fst δ})
+               (+0< (fst η) (fst ε ℚ.- fst δ) (snd η) v₁) ,
+        subst (fst ∘ fst (y δ)) (ℚ₊≡ (lem--014 {fst ε} {fst δ} {fst η})) z ) ∣₁
+
+rel-r-l 𝕢 q y ε p δ v₁ x η .snd =
+   PT.rec (snd (rat-rat' 𝕢 (ε ℚ₊+ η) q))
+    λ (σ* , (xx , xx')) →
+      let z = fst (p _ _ _) xx'
+          z' = snd (x _) z
+      in subst
+              {x = (((fst ε ℚ.- fst δ) , v₁) ℚ₊+
+                 ((σ* ℚ₊+ δ) ℚ₊+ ((fst η ℚ.- fst σ*) , xx)))}
+                {(ε ℚ₊+ η)}
+             (λ xxx → ⟨ rat-rat' 𝕢 xxx q ⟩)
+               (ℚ₊≡ (lem--015 {fst ε} {fst δ} {fst σ*} {fst η})) z'
+
+rel-l-l' : (x y : ℚ₊ → Σ (ℚ₊ → hProp ℓ-zero) w-prop') (ε δ η : ℚ₊)
+     (p : (δ₁ ε₁ : ℚ₊) → w-rel' (x δ₁) (x ε₁) (δ₁ ℚ₊+ ε₁))
+     (p' : (δ₁ ε₁ : ℚ₊) → w-rel' (y δ₁) (y ε₁) (δ₁ ℚ₊+ ε₁))
+     (v₁ : 0< (fst ε ℚ.- (fst δ ℚ.+ fst η))) → ∀ η' →
+     (∀ η' →
+       pre-w-rel' (x δ) (y η) ((fst ε ℚ.- (fst δ ℚ.+ fst η)) , v₁) η') →
+     pre-w-rel' (r-l x) (r-l y) ε η'
+rel-l-l' x y ε δ η p p' v₁ η' x₁ =
+   PT.map (λ (a , (xx , xx')) →
+       let zz = fst (p a δ _) xx'
+           zz' = x₁ _ zz
+       in η ,
+            subst (ℚ.0<_)
+                (lem-02  (fst ε) (fst δ) (fst η) (fst η'))
+                  (+0< (fst ε ℚ.- (fst δ ℚ.+ fst η))
+                   (fst (δ ℚ₊+ η'))  v₁ (snd (δ ℚ₊+ η')))
+             , (subst (fst ∘ y η .fst)
+             (ℚ₊≡ (lem-01 (fst ε) (fst δ) (fst η) (fst η') (fst a))) zz'))
+
+
+
+rel-l-l : (x y : ℚ₊ → Σ (ℚ₊ → hProp ℓ-zero) w-prop') (ε δ η : ℚ₊)
+     (p : (δ₁ ε₁ : ℚ₊) → w-rel' (x δ₁) (x ε₁) (δ₁ ℚ₊+ ε₁))
+     (p' : (δ₁ ε₁ : ℚ₊) → w-rel' (y δ₁) (y ε₁) (δ₁ ℚ₊+ ε₁))
+     (v₁ : 0< (fst ε ℚ.- (fst δ ℚ.+ fst η))) →
+     w-rel' (x δ) (y η) ((fst ε ℚ.- (fst δ ℚ.+ fst η)) , v₁) →
+     w-rel' (r-l x) (r-l y) ε
+rel-l-l x y ε δ η p p' v₁ x₁ η₁ =
+  rel-l-l' x y ε δ η p p' v₁ η₁ (fst ∘ x₁)
+   , let zz : Σ (0< (fst ε ℚ.- (fst η ℚ.+ fst δ)))
+                  λ v →
+                    (η' : ℚ₊) →
+                pre-w-rel' (y η) (x δ)
+             ((fst ε ℚ.- (fst η ℚ.+ fst δ)) , v) η'
+         zz =
+               subst
+                  (λ xxx → Σ (0< (fst ε ℚ.- xxx))
+                  λ v →
+                    (η' : ℚ₊) →
+                pre-w-rel' (y η) (x δ)
+             ((fst ε ℚ.- xxx) , v) η')
+                  (ℚ.+Comm (fst δ) (fst η))
+                  (v₁ , snd ∘ x₁)
+     in rel-l-l' y x ε η δ  p' p (fst zz) η₁ (snd zz)
+
+w-prop : (ℚ₊ → ℝ → hProp ℓ-zero) → Type
+w-prop =
+ λ ♢ → (∀ u ε → ⟨ (♢ ε u)  L.⇔ (L.∃[ θ ∶ ℚ₊ ]
+                     L.∃[ v ] ♢ (((fst ε) ℚ.- (fst θ)) , v) u)
+                    ⟩ ) ×
+                      (∀ u v ε η →
+                         u ∼[ ε ] v →
+                           (⟨ ♢ η u ⟩ → ⟨ ♢ (ε ℚ₊+ η) v ⟩ ))
+
+
+substΣ<' : (P : Σ (ℚ₊ → ℝ → hProp ℓ-zero) w-prop) → ∀ r → ∀ {x y} → x ≡ y →
+             Σ< (fst ∘ (flip (fst P) r)) x → Σ< (fst ∘ flip (fst P) r) y
+substΣ<' P r = subst (Σ< (fst ∘ (flip (fst P) r)))
+
+
+isProp-w-prop :  ∀ ♢ → isProp (w-prop ♢)
+isProp-w-prop ♢ =
+  isProp× (isPropΠ2 λ u ε →
+              snd (
+     ♢ ε u L.⇔
+     L.∃[∶]-syntax
+     (λ θ → L.∃[]-syntax (λ v₁ → ♢ ((fst ε ℚ.- fst θ) , v₁) u)))
+     )
+    (isPropΠ6 λ _ v ε η _ _ →
+        snd (♢ (ε ℚ₊+ η) v))
+
+w-rel : Σ (ℚ₊ → ℝ → hProp ℓ-zero) w-prop →
+          Σ (ℚ₊ → ℝ → hProp ℓ-zero) w-prop → ℚ₊ → Type
+w-rel = λ (♢ , _) (♥ , _) ε →
+         (∀ u η → (⟨ ♢ η u ⟩ →  ⟨ ♥ (ε ℚ₊+ η) u ⟩)
+                  × (⟨ ♥ η u ⟩ →  ⟨ ♢ (ε ℚ₊+ η) u ⟩))
+
+isSym-w-rel : ∀ a a' → (∀ ε → w-rel a a' ε) → (∀ ε → w-rel a' a ε)
+isSym-w-rel a a' w ε u η = fst Σ-swap-≃ (w ε u η)
+
+w-rel→⇒ : ∀ a a' → (∀ ε → w-rel a a' ε)
+             → ∀ ε u → ⟨ fst a ε u ⟩ → ⟨ fst a' ε u ⟩
+w-rel→⇒ a a' x ε u x₁ =
+  w-rel'⇒ ((flip (fst a) u) , (fst (snd a) u))
+    ((flip (fst a') u) , (fst (snd a') u))
+     (λ ε₁ → x ε₁ u)
+    ε x₁
+
+w-rel→≡ : ∀ a a' → (∀ ε → w-rel a a' ε) → a ≡ a'
+w-rel→≡ a a' w =
+  Σ≡Prop isProp-w-prop
+    (funExt₂ λ ε u →
+       L.⇔toPath (w-rel→⇒ a a' w ε u)
+         (w-rel→⇒ a' a (isSym-w-rel a a' w) ε u))
+
+rel-l-l-l : ∀ {𝕒 : ℚ₊ → Σ (ℚ₊ → ℝ → hProp ℓ-zero) w-prop}
+
+              → (x y : ℚ₊ → ℝ) → ∀ ε δ η
+              (p : ∀ δ₁ ε₁ → x δ₁ ∼[ δ₁ ℚ₊+ ε₁ ] x ε₁)
+              (p' : ∀ δ₁ ε₁ → y δ₁ ∼[ δ₁ ℚ₊+ ε₁ ] y ε₁)
+              (v₁ : 0< (fst ε ℚ.- (fst δ ℚ.+ fst η)))
+              (r : x δ ∼[ (fst ε ℚ.- (fst δ ℚ.+ fst η)) , v₁ ] y η)
+
+    →
+              w-rel'
+     (l-l
+      (λ q η₁ → (λ ε₁ → fst (𝕒 q) ε₁ (x η₁)) , fst (snd (𝕒 q)) (x η₁)))
+     (l-l
+      (λ q η₁ → (λ ε₁ → fst (𝕒 q) ε₁ (y η₁)) , fst (snd (𝕒 q)) (y η₁)))
+     ε
+rel-l-l-l {𝕒} x y ε δ η p p' v₁ r η₁ .fst =
+  PT.map
+    λ ((δ* , η*) , (xx , xx')) →
+     let z = snd (snd (𝕒 δ*)) (x η*) _ _ _ (p _ δ) xx'
+         z' = snd (snd (𝕒 δ*)) _ _ _ _ r z
+     in (δ* , η) , (+₃0<' (fst η₁ ℚ.- (fst δ* ℚ.+ fst η*))
+                   (fst ε ℚ.- (fst δ ℚ.+ fst η))
+                    (fst δ ℚ.+ fst η*)
+                   (fst (ε ℚ₊+ η₁) ℚ.- (fst δ* ℚ.+ fst η))
+                   xx v₁ (snd (δ ℚ₊+ η*))
+                     (lem--016 {fst η₁} {fst δ*} {fst η*} {fst ε} {fst δ}) ,
+            subst (λ xx → ⟨ 𝕒 δ* .fst xx (y η)⟩)
+              (ℚ₊≡ (lem-03 (fst ε) (fst η₁)
+                 (fst δ) (fst η) (fst δ*) (fst η*)))
+                 z')
+rel-l-l-l {𝕒}  x y ε δ η p p' v₁ r  η₁ .snd =
+  PT.map λ ((δ* , η*) , (xx , xx')) →
+     let z = snd (snd (𝕒 δ*)) (y η*) _ _ _ (p' _ η) xx'
+         z' = snd (snd (𝕒 δ*)) _ _ _ _ (sym∼ _ _ _ r) z
+
+     in (δ* , δ) , (
+            +₃0<' (fst η₁ ℚ.- (fst δ* ℚ.+ fst η*))
+                   (fst ε ℚ.- (fst δ ℚ.+ fst η))
+                    (fst η ℚ.+ fst η*)
+                   (fst (ε ℚ₊+ η₁) ℚ.- (fst δ* ℚ.+ fst δ))
+                   xx v₁ (snd (η ℚ₊+ η*))
+                    (lem--017 {fst η₁} {fst δ*} {fst η*} {fst ε} {fst δ})  ,
+            (
+            subst (λ xx → ⟨ 𝕒 δ* .fst xx (x δ)⟩)
+              (ℚ₊≡ (lem-04 (fst ε) (fst η₁)
+                 (fst δ) (fst η) (fst δ*) (fst η*)))
+                 z') )
+module ∼' where
+
+ w' : ℚ → Recℝ (Σ (ℚ₊ → hProp ℓ-zero) w-prop') w-rel'
+ w' 𝕢 .Recℝ.ratA 𝕢' = r-r 𝕢 𝕢'
+ w' 𝕢 .Recℝ.limA 𝕒 _ = r-l 𝕒
+ w' 𝕢 .Recℝ.eqA = w-rel'→≡
+ w' 𝕢 .Recℝ.rat-rat-B = rel-r-r 𝕢
+ w' 𝕢 .Recℝ.rat-lim-B = rel-r-l 𝕢
+ w' 𝕢 .Recℝ.lim-rat-B x r ε δ p v₁ x₁ =
+   w-rel'-sym (r-r 𝕢 r)  (r-l x)  ε
+     (rel-r-l 𝕢 r x ε p δ v₁
+      (w-rel'-sym (x δ) (r-r 𝕢 r) ((fst ε ℚ.- fst δ) , v₁) x₁))
+
+ w' 𝕢 .Recℝ.lim-lim-B = rel-l-l
+ w' 𝕢 .Recℝ.isPropB a a' ε =
+  isPropΠ λ x →
+     isProp× (isProp→ (snd (a' .fst (ε ℚ₊+ x))))
+             (isProp→ (snd (a .fst (ε ℚ₊+ x))))
+
+
+
+
+
+ w'' : (𝕒 : ℚ₊ → Σ (ℚ₊ → ℝ → hProp ℓ-zero) w-prop)
+     → ((δ ε : ℚ₊) → w-rel (𝕒 δ) (𝕒 ε) (δ ℚ₊+ ε))
+     → Casesℝ (Σ (ℚ₊ → hProp ℓ-zero) w-prop') w-rel'
+ w'' 𝕒 𝕡 .Casesℝ.ratA 𝕢 = r-l
+    (λ q → (λ ε → fst (𝕒 q) ε (rat 𝕢)) ,
+          fst (snd (𝕒 q)) (rat 𝕢))
+
+
+ w'' 𝕒 𝕡 .Casesℝ.limA 𝕩 𝕔 =
+   l-l (λ q  η →
+       (λ ε → fst (𝕒 q) ε (𝕩 η))
+       , fst (snd (𝕒 q)) (𝕩 η) )
+
+
+ w'' 𝕒 𝕡 .Casesℝ.eqA = w-rel'→≡
+ w'' 𝕒 𝕡 .Casesℝ.rat-rat-B q r ε x x₁ η .fst =
+   PT.map
+     (uncurry λ q' →
+      λ (xx , xx') →
+       let z = snd (snd (𝕒 q')) _ _ _ _
+               (rat-rat q r ε x x₁) xx'
+       in q' , (substΣ<' (𝕒 q') _
+             (ℚ.+Assoc (fst ε) (fst η) (ℚ.- fst q')) (_ , z)))
+ w'' 𝕒 𝕡 .Casesℝ.rat-rat-B q r ε x x₁ η .snd =
+   PT.map
+     (uncurry λ q' →
+      λ (xx , xx') →
+       let z = snd (snd (𝕒 q')) _ _ _ _
+               (sym∼ _ _ ε (rat-rat q r ε x x₁)) xx'
+       in q' , (substΣ<' (𝕒 q') _ (ℚ.+Assoc (fst ε) (fst η) (ℚ.- fst q')) (_ , z)))
+
+ w'' 𝕒 𝕡 .Casesℝ.rat-lim-B q y ε δ p v₁ r v' u' x η .fst =
+   PT.map
+     λ ((δ* , η*) , (xx , xx')) →
+      let z = snd (snd (𝕒 _)) _ _ _ _ r xx'
+      in ((δ* , η*) , δ) , substΣ<' (𝕒 (δ* , η*)) _
+             (lem--018 {fst ε} {fst δ} {fst η} {δ*} ) (_ , z)
+ w'' 𝕒 𝕡 .Casesℝ.rat-lim-B q y ε δ p v₁ r v' u' x η .snd =
+   PT.map
+     λ ((δ* , η*) , (xx , xx')) →
+      let z = snd (snd (𝕒 _)) _ _ _ _ (p _ _) xx'
+          z' = snd (snd (𝕒 _)) _ _ _ _ (sym∼ _ _ _ r) z
+      in δ* , substΣ<' (𝕒 δ*) _
+             (lem--019 {fst ε} {fst δ} {fst η*}  {fst η} {fst δ*} ) (_ , z')
+ w'' 𝕒 𝕡 .Casesℝ.lim-rat-B x r ε δ p v₁ u v' u' x₁ η .fst =
+   PT.map λ ((δ* , η*) , (xx , xx')) →
+      let z = snd (snd (𝕒 _)) _ _ _ _ (p _ _)  xx'
+          z'  = snd (snd (𝕒 _)) _ _ _ _ u z
+      in δ* , substΣ<' (𝕒 δ*) _
+            (lem--020 {fst ε} {fst δ} {fst η*}  {fst η} {fst δ*}) (_ , z')
+ w'' 𝕒 𝕡 .Casesℝ.lim-rat-B x r ε δ p v₁ u v' u' x₁ η .snd =
+    PT.map
+     λ ((δ* , η*) , (xx , xx')) →
+      let z = snd (snd (𝕒 _)) _ _ _ _ (sym∼ _ _ _ u) xx'
+      in ((δ* , η*) , δ) , substΣ<' (𝕒 (δ* , η*)) _
+            ((lem--021 {fst ε} {fst δ} {fst η}  {δ*})) (_ , z)
+ w'' 𝕒 𝕡 .Casesℝ.lim-lim-B = rel-l-l-l {𝕒}
+ w'' 𝕒 𝕡 .Casesℝ.isPropB a a' ε =
+  isPropΠ λ x →
+     isProp× (isProp→ (snd (a' .fst (ε ℚ₊+ x))))
+             (isProp→ (snd (a .fst (ε ℚ₊+ x))))
+
+ isPropHlp : {P  Q  : ℝ → ℚ₊ →  Type} (P' Q' : ℝ → ℚ₊ →  hProp ℓ-zero) →
+         (x₂ : ℝ) → isProp ((η₂ : ℚ₊) →
+          ( P x₂ η₂  → ⟨ P' x₂ η₂ ⟩) × ( Q x₂ η₂  → ⟨ Q' x₂ η₂ ⟩))
+ isPropHlp P' Q' x =
+   isPropΠ λ η → isProp× (isProp→ (snd (P' x η))) (isProp→ (snd (Q' x η)))
+
+ w : Recℝ (Σ (ℚ₊ → ℝ → hProp ℓ-zero) w-prop) w-rel
+ w .Recℝ.ratA 𝕢 =
+    (λ q 𝕣 → fst (Recℝ.go (w' 𝕢) 𝕣) q)
+   , (λ u ε → snd (Recℝ.go (w' 𝕢) u) ε)
+   , λ u v ε η x → fst (Recℝ.go~ (w' 𝕢)  x η)
+
+ w .Recℝ.limA 𝕒 𝕡 =
+     (λ q 𝕣 → fst (Casesℝ.go (w'' 𝕒 𝕡) 𝕣) q)
+   , (λ u ε → snd (Casesℝ.go (w'' 𝕒 𝕡) u) ε)
+   , λ u v ε η x → fst (Casesℝ.go~ (w'' 𝕒 𝕡)  x η) --
+
+ w .Recℝ.eqA = w-rel→≡
+
+ w .Recℝ.rat-rat-B q r ε u v = Elimℝ-Prop.go www
+  where
+  www : Elimℝ-Prop _
+  www .Elimℝ-Prop.ratA x η =
+
+    rat-rat'-sym x (ε ℚ₊+ η) r
+      ∘S (fst (rel-r-r x q r ε u v η))
+      ∘S rat-rat'-sym q η x ,
+     rat-rat'-sym x (ε ℚ₊+ η) q ∘S (snd (rel-r-r  x q r ε u v η)) ∘S
+      rat-rat'-sym r η x
+  www .Elimℝ-Prop.limA x p x₁ η =
+       PT.map (λ (δ* , (xx , xx'))
+         → δ* , substΣ< (Elimℝ.go (Recℝ.d (w' r)) (x δ*))
+                   (ℚ.+Assoc (fst ε) (fst η) (ℚ.- fst δ*))
+                    (_ , fst (x₁ _ _) xx'))
+     , PT.map (λ (δ* , (xx , xx'))
+         → δ* , substΣ< (Recℝ.go (w' q) (x δ*))
+             ((ℚ.+Assoc (fst ε) (fst η) (ℚ.- fst δ*)))
+              (_ , snd (x₁ _ _) xx'  ))
+  www .Elimℝ-Prop.isPropA = isPropHlp
+      (λ x η → fst (Recℝ.go (w' r) x) (ε ℚ₊+ η))
+      λ x η → fst (Recℝ.go (w' q) x) (ε ℚ₊+ η)
+
+
+ w .Recℝ.rat-lim-B q y ε p δ v₁ x = Elimℝ-Prop.go www
+  where
+  www : Elimℝ-Prop _
+  www .Elimℝ-Prop.ratA x* η .fst xx =
+   let zz = fst (x (rat x*)  η) xx
+   in ∣ δ ,  substΣ<' (y δ) _ (lem--022 {fst ε} {fst δ} {fst η}) (_ , zz) ∣₁
+
+  www .Elimℝ-Prop.ratA x* η .snd =
+    PT.rec (snd (fst (Recℝ.go (w' q) (rat x*)) (ε ℚ₊+ η)))
+      λ (δ* , (xx , xx')) →
+       let zz = snd (p δ _ (rat x*) _) xx'
+           zz' = snd (x (rat x*)  _) zz
+       in subst {x = (((fst ε ℚ.- fst δ) , v₁) ℚ₊+
+             ((δ ℚ₊+ δ*) ℚ₊+ ((fst η ℚ.- fst δ*) , xx)))}
+            {y = (ε ℚ₊+ η)} (fst ∘ fst (Recℝ.go (w' q) (rat x*)))
+             (ℚ₊≡ (lem--023 {fst ε} {fst δ} {fst δ*} {fst η})) zz'
+
+  www .Elimℝ-Prop.limA x* p* x₁* η* .fst =
+    PT.map λ (δ* , (xx , xx')) →
+       let z = fst (x (x* δ*) (_ , xx)) xx'
+
+       in (δ , δ*) , substΣ<' (y δ) _
+              (lem--024 {fst ε} {fst δ} {fst η*} {fst δ*}) (_ , z)
+  www .Elimℝ-Prop.limA x'' pp'' x₁'' η'' .snd =
+     PT.map λ ((δ* , η*) , (xx , xx')) →
+      let z = fst (p _ _ _ _) xx'
+          z' = snd (x (x'' η*) _) z
+      in η* , substΣ< (Elimℝ.go (Recℝ.d (w' q)) (x'' η*))
+                   (lem--025 {fst ε} {fst δ} {fst δ*} {fst η''}) (_ , z')
+
+  www .Elimℝ-Prop.isPropA = isPropHlp
+      (λ x η → fst (Casesℝ.go (w'' y p) x) (ε ℚ₊+ η))
+      λ x η → fst (Recℝ.go (w' q) x) (ε ℚ₊+ η)
+
+ w .Recℝ.lim-rat-B x r ε δ p v₁ x₁  = Elimℝ-Prop.go www
+  where
+  www : Elimℝ-Prop _
+  www .Elimℝ-Prop.ratA x' η' .fst =
+    PT.rec (snd (fst (Recℝ.go (w' r) (rat x')) (ε ℚ₊+ η')))
+      λ (δ* , (xx , xx')) →
+       let zz = snd (p δ _ (rat x') _) xx'
+           zz' = fst (x₁ (rat x') _) zz
+       in subst
+            {x = (((fst ε ℚ.- fst δ) , v₁) ℚ₊+
+             ((δ ℚ₊+ δ*) ℚ₊+ ((fst η' ℚ.- fst δ*) , xx)))}
+             {(ε ℚ₊+ η')}
+             (fst ∘ (fst (Recℝ.go (w' r) (rat x'))))
+            (ℚ₊≡ $ lem--026 {fst ε} {fst δ} {fst δ*} {fst η'}) zz'
+  www .Elimℝ-Prop.ratA x' η' .snd xx =
+   let zz = snd (x₁ (rat x')  η') xx
+   in ∣ δ , substΣ<' (x δ) _ (lem--027 {fst ε} {fst δ} {fst η'}) (_ , zz) ∣₁
+
+  www .Elimℝ-Prop.limA x' p' x₁' η' .fst =
+    PT.map λ ((δ* , η*) , (xx , xx')) →
+      let z = fst (p _ _ _ _) xx'
+          z' = fst (x₁ (x' η*) _) z
+      in η* , substΣ< (Recℝ.go (w' r) (x' η*))
+                ((lem--028 {fst ε} {fst δ}  {fst δ*} {fst η'}  {fst η*})) (_ , z')
+  www .Elimℝ-Prop.limA x' p' x₁' η' .snd =
+    PT.map λ (δ* , (xx , xx')) →
+      let z = snd (x₁ (x' δ*) ((fst η' ℚ.- fst δ*) , xx)) xx'
+
+      in (δ , δ*) , substΣ<' (x δ) _
+          (lem--029 {fst ε} {fst δ} {fst η'} {fst δ*}) (_ , z)
+  www .Elimℝ-Prop.isPropA = isPropHlp
+      (λ x η → fst (Recℝ.go (w' r) x) (ε ℚ₊+ η))
+      λ x₂ η → fst (Casesℝ.go (w'' x p) x₂) (ε ℚ₊+ η)
+
+ w .Recℝ.lim-lim-B x y ε δ η p p' v₁ x₁ = Elimℝ-Prop.go www
+  where
+  www : Elimℝ-Prop _
+  www .Elimℝ-Prop.ratA x* η' .fst =
+    PT.map λ ((δ* , η*) , (xx , xx')) →
+     let z = fst ((p _ _) _ _) xx'
+         z' = fst (x₁ _ _) z
+     in η , substΣ<' (y η) _
+           (lem--030 {fst ε} {fst δ} {fst η} {δ*}  {fst η'}) (_ , z')
+  www .Elimℝ-Prop.ratA x* η' .snd =
+    PT.map λ ((δ* , η*) , (xx , xx')) →
+     let z = fst ((p' _ _) _ _) xx'
+         z' = snd (x₁ _ _) z
+     in δ , substΣ<' (x δ) _
+         (lem--031 {fst ε} {fst δ} {fst η} {δ*}  {fst η'} ) (_ , z')
+  www .Elimℝ-Prop.limA x* p* x₁' η₁ .fst =
+   PT.map λ ((δ* , η*) , (xx , xx')) →
+   let z = (fst (p δ* δ (x* η*) _)) xx'
+       z' : fst
+              (y η .fst
+               (((fst ε ℚ.- (fst δ ℚ.+ fst η)) , v₁) ℚ₊+
+                ((δ* ℚ₊+ δ) ℚ₊+ ((fst η₁ ℚ.- (fst δ* ℚ.+ fst η*)) , xx)))
+               (x* η*))
+       z' = fst (x₁ _ _) z
+   in (η , η*) ,
+          substΣ<' (y η) _
+        (lem--032 {fst ε} {fst δ} {fst η} {fst δ*}  {fst η₁} {fst η*})
+           (_ , z')
+  www .Elimℝ-Prop.limA x* p x₁' η₁ .snd =
+   PT.map λ ((δ* , η*) , (xx , xx')) →
+    let z = (fst (p' _ _ _ _)) xx'
+        z' = snd (x₁ _ _) z
+    in (δ , η*) , substΣ<' (x δ) _
+          (lem--033  {fst ε} {fst δ} {fst η} {fst δ*}  {fst η₁} {fst η*}) (_ , z')
+
+  www .Elimℝ-Prop.isPropA = isPropHlp
+      (λ x₂ η₂ → fst (Casesℝ.go (w'' y p') x₂) (ε ℚ₊+ η₂))
+      λ x₂ η₂ → fst (Casesℝ.go (w'' x p) x₂) (ε ℚ₊+ η₂)
+
+ w .Recℝ.isPropB a a' ε = isPropΠ2 λ u x →
+     isProp× (isProp→ (snd (a' .fst (ε ℚ₊+ x) u)))
+             (isProp→ (snd (a .fst (ε ℚ₊+ x) u)))
+
+
+ -- pre-~' : ℝ → Σ (ℚ₊ → ℝ → (hProp ℓ-zero)) _
+ -- pre-~' = Recℝ.go w
+
+
+-- HoTT Theorem (11.3.16)
+
+_∼'[_]_ : ℝ → ℚ₊ → ℝ → Type
+x ∼'[ ε ] y = ⟨ fst (Recℝ.go ∼'.w x) ε y ⟩
+
+_∼'[_]ₚ_ : ℝ → ℚ₊ → ℝ → hProp ℓ-zero
+x ∼'[ ε ]ₚ y = fst (Recℝ.go ∼'.w x) ε y
+
+
+-- (11.3.17)
+_ : ∀ r r' ε → (rat r) ∼'[ ε ] (rat r') ≡
+              ((ℚ.- fst ε) ℚ.< (r ℚ.- r'))
+               × ((r ℚ.- r') ℚ.< fst ε)
+_ = λ r r' ε → refl
+
+-- (11.3.18)
+_ : ∀ r x y ε → (rat r) ∼'[ ε ] (lim x y) ≡
+              (∃[ δ ∈ ℚ₊ ] Σ[ v ∈ _ ] ((rat r) ∼'[ (fst ε ℚ.- fst δ) , v ] x δ))
+_ = λ r x y ε → refl
+
+-- (11.3.19)
+_ : ∀ r x y ε → (lim x y) ∼'[ ε ] (rat r) ≡
+              (∃[ δ ∈ ℚ₊ ] Σ[ v ∈ _ ]
+                ((x δ) ∼'[ (fst ε ℚ.- fst δ) , v ] rat r ))
+_ = λ r x y ε → refl
+
+-- (11.3.20)
+_ : ∀ x y x' y' ε → (lim x y) ∼'[ ε ] (lim x' y') ≡
+               (∃[ (δ , η) ∈ (ℚ₊ × ℚ₊) ] Σ[ v ∈ _ ]
+                ((x δ) ∼'[ (fst ε ℚ.- (fst δ ℚ.+ fst η)) , v ] (x' η) ))
+_ = λ x y x' y' ε → refl
+
+-- (11.3.23)
+triangle∼' : ∀ u v w ε η
+      → u ∼[ ε ] v
+      → v ∼'[ η ] w
+      → u ∼'[ ε ℚ₊+ η ] w
+triangle∼' u v w ε η x =
+  snd ((Recℝ.go~ ∼'.w {x = u} {v} {ε} x w η ))
+
+
+-- (11.3.21)
+rounded∼' : ∀ u v ε →
+             ⟨ (u ∼'[ ε ]ₚ v) L.⇔
+              (L.∃[ δ ]
+                L.∃[ _ ] u ∼'[ (fst ε ℚ.- fst δ) , _ ]ₚ v) ⟩
+rounded∼' u v ε = fst (snd (Recℝ.go ∼'.w u)) v ε
+
+
+∼→∼' : ∀ x y ε → x ∼[ ε ] y → x ∼'[ ε ] y
+∼→∼' x y ε (rat-rat q r .ε x₁ x₂) = x₁ , x₂
+∼→∼' x y ε (rat-lim q y₁ .ε δ p v₁ x₁) =
+ ∣ δ , v₁ , ∼→∼' (rat q) (y₁ δ) _ x₁ ∣₁
+∼→∼' x y ε (lim-rat x₁ r .ε δ p v₁ x₂) =
+ ∣ δ , v₁ , ∼→∼' (x₁ δ) (rat r)  _ x₂ ∣₁
+∼→∼' x y ε (lim-lim x₁ y₁ .ε δ η p p' v₁ x₂) =
+  ∣ (δ , η) , (v₁ , (∼→∼' _ _ _ x₂)) ∣₁
+∼→∼' x y ε (isProp∼ .x .ε .y x₁ x₂ i) =
+  snd (x ∼'[ ε ]ₚ y) (∼→∼' x y ε x₁) (∼→∼' x y ε x₂) i
+
+∼'→∼ : ∀ x y ε → x ∼'[ ε ] y → x ∼[ ε ] y
+∼'→∼ = Elimℝ-Prop2.go w
+ where
+ w : Elimℝ-Prop2 _
+ w .Elimℝ-Prop2.rat-ratA r q ε =
+   uncurry $ rat-rat r q ε
+ w .Elimℝ-Prop2.rat-limA r x y x₁ ε =
+    PT.rec (isProp∼ _ _ _)
+      λ (δ , (xx , xx')) → rat-lim r x ε δ y  xx (x₁ _ _ xx')
+
+ w .Elimℝ-Prop2.lim-ratA x y r x₁ ε =
+    PT.rec (isProp∼ _ _ _)
+      λ (δ , (xx , xx')) → lim-rat x r ε δ y  xx (x₁ _ _ xx')
+ w .Elimℝ-Prop2.lim-limA x y x' y' x₁ ε =
+    PT.rec (isProp∼ _ _ _)
+      λ ((δ , η) , (xx , xx')) →
+        lim-lim x x' ε δ η y y' xx (x₁ _ _ _ xx')
+ w .Elimℝ-Prop2.isPropA _ _ = isPropΠ2 λ _ _ → isProp∼ _ _ _
+
+
+sym∼' : ∀ r r' ε → r ∼'[ ε ] r' → r' ∼'[ ε ] r
+sym∼' r r' ε =
+  ∼→∼' r' r ε ∘S sym∼ r r' ε ∘S ∼'→∼ r r' ε
+
+
+
+-- (11.3.22)
+triangle∼'' : ∀ u v w ε η
+      → u ∼'[ ε ] v
+      → v ∼[ η ] w
+      → u ∼'[ ε ℚ₊+ η ] w
+triangle∼'' u v w ε η x y =
+  subst (u ∼'[_] w) (ℚ₊≡ (ℚ.+Comm (fst η) (fst ε)))
+   (sym∼' w u _ (triangle∼' w v u η ε (sym∼ v w η y) (sym∼' u v ε x)))
+
+-- HoTT Theorem (11.3.32)
+∼'⇔∼ : ∀ x y ε → ⟨ x ∼'[ ε ]ₚ y L.⇔ x ∼[ ε ]ₚ y ⟩
+∼'⇔∼ x y z = ∼'→∼ x y z , ∼→∼' x y z
+
+
+infixr 6 _∙⇔_
+
+_∙⇔_ : ∀ {ℓ} {A B C : Type ℓ}
+         → ((A → B) × (B → A))
+         → ((B → C) × (C → B))
+         → ((A → C) × (C → A))
+_∙⇔_ (x , _) (y , _) .fst = y ∘ x
+_∙⇔_ (_ , x) (_ , y) .snd = x ∘ y
+
+sym⇔ : ∀ {ℓ} {A B : Type ℓ}
+    → ((A → B) × (B → A))
+    → ((B → A) × (A → B))
+sym⇔ (x , y) = y , x
+
+
+-- HoTT (11.3.33)
+rounded∼ : ∀ u v ε →
+             ⟨ (u ∼[ ε ]ₚ v) L.⇔
+              (L.∃[ δ ]
+                L.∃[ p ] u ∼[ (fst ε ℚ.- fst δ) , p ]ₚ v) ⟩
+rounded∼ u v ε = sym⇔
+      (∼'⇔∼ u v ε) ∙⇔ rounded∼' u v ε ∙⇔
+     (PT.map (map-snd (PT.map (map-snd (fst (∼'⇔∼ u v _)))))
+   ,  PT.map (map-snd (PT.map (map-snd (snd (∼'⇔∼ u v _))))))
+
+-- HoTT (11.3.36)
+
+triangle∼ : ∀ {u v w ε η}
+      → u ∼[ ε ] v
+      → v ∼[ η ] w
+      → u ∼[ ε ℚ₊+ η ] w
+triangle∼ {u} {v} {w} {ε} {η} x  =
+  ∼'→∼ u w (ε ℚ₊+ η) ∘ triangle∼' u v w ε η x ∘ ∼→∼' v w _
+
+
+
+-- _ : ∀ r x y ε → (rat r) ∼'[ ε ] (lim x y) ≡
+--               (∃[ δ ∈ ℚ₊ ] Σ[ v ∈ _ ] ((rat r) ∼'[ (fst ε ℚ.- fst δ) , v ] x δ))
+-- _ = λ r x y ε → refl
+
+-- _ : ∀ r x y ε → (lim x y) ∼'[ ε ] (rat r) ≡
+--               (∃[ δ ∈ ℚ₊ ] Σ[ v ∈ _ ]
+--                 ((x δ) ∼'[ (fst ε ℚ.- fst δ) , v ] rat r ))
+-- _ = λ r x y ε → refl
+
+
+-- _ : ∀ x y x' y' ε → (lim x y) ∼'[ ε ] (lim x' y') ≡
+--                (∃[ (δ , η) ∈ (ℚ₊ × ℚ₊) ] Σ[ v ∈ _ ]
+--                 ((x δ) ∼'[ (fst ε ℚ.- (fst δ ℚ.+ fst η)) , v ] (x' η) ))
+-- _ = λ x y x' y' ε → refl
+
diff --git a/Cubical/HITs/CauchyReals/Continuous.agda b/Cubical/HITs/CauchyReals/Continuous.agda
new file mode 100644
index 0000000000..2f5ab88109
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/Continuous.agda
@@ -0,0 +1,915 @@
+{-# OPTIONS --safe --lossy-unification #-}
+
+module Cubical.HITs.CauchyReals.Continuous where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Structure
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.HLevels
+
+open import Cubical.Data.Bool as 𝟚 hiding (_≤_)
+open import Cubical.Data.Nat as ℕ hiding (_·_;_+_)
+open import Cubical.Data.Int as ℤ using (pos)
+import Cubical.Data.Int.Order as ℤ
+open import Cubical.Data.Sigma
+
+open import Cubical.HITs.PropositionalTruncation as PT
+open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_)
+
+
+open import Cubical.Data.Rationals as ℚ using (ℚ ; [_/_])
+open import Cubical.Data.Rationals.Order as ℚ using
+  ( _ℚ₊+_ ; 0<_ ; ℚ₊ ; _ℚ₊·_ ; ℚ₊≡)
+open import Cubical.Data.Rationals.Order.Properties as ℚ
+ using (invℚ₊;/2₊;/3₊;/4₊)
+
+open import Cubical.Data.NatPlusOne
+
+open import Cubical.HITs.CauchyReals.Base
+open import Cubical.HITs.CauchyReals.Lems
+open import Cubical.HITs.CauchyReals.Closeness
+open import Cubical.HITs.CauchyReals.Lipschitz
+open import Cubical.HITs.CauchyReals.Order
+
+
+0≤absᵣ : ∀ x → 0 ≤ᵣ absᵣ x
+0≤absᵣ = Elimℝ-Prop.go w
+ where
+ w : Elimℝ-Prop (λ z → 0 ≤ᵣ absᵣ z)
+ w .Elimℝ-Prop.ratA q = ≤ℚ→≤ᵣ 0 (ℚ.abs' q)
+   (subst (0 ℚ.≤_) (ℚ.abs'≡abs q) (ℚ.0≤abs q))
+ w .Elimℝ-Prop.limA x p x₁ =
+  let y0 = _
+      zz0 = NonExpanding₂.β-rat-lim maxR 0 (λ q → (absᵣ (x (ℚ.invℚ₊ 1 ℚ₊· q))))
+               y0 _
+
+      zz = sym (congLim' _ _ _
+                λ q →
+                   sym $ x₁ (ℚ.invℚ₊ ([ pos 1 / (1+ 0) ] , tt) ℚ₊· q))
+  in _∙_ {x = maxᵣ 0 (lim (λ q → (absᵣ (x (ℚ.invℚ₊ 1 ℚ₊· q)))) y0)}
+       zz0 zz
+
+ w .Elimℝ-Prop.isPropA _ = isSetℝ _ _
+
+
+-ᵣInvol : ∀ x → -ᵣ (-ᵣ x) ≡ x
+-ᵣInvol = Elimℝ-Prop.go w
+ where
+ w : Elimℝ-Prop _
+ w .Elimℝ-Prop.ratA x = cong rat (ℚ.-Invol x)
+ w .Elimℝ-Prop.limA x p x₁ =
+   congLim _ _ _ _
+     λ q → x₁ _ ∙ cong x (ℚ₊≡ (λ i → ℚ.·IdL (ℚ.·IdL (fst q) i) i))
+ w .Elimℝ-Prop.isPropA x = isSetℝ (-ᵣ (-ᵣ x)) x
+
+
+-ᵣDistr : ∀ x y → -ᵣ (x +ᵣ y) ≡ (-ᵣ x) +ᵣ (-ᵣ y)
+-ᵣDistr = Elimℝ-Prop2Sym.go w
+ where
+ w : Elimℝ-Prop2Sym (λ z z₁ → (-ᵣ (z +ᵣ z₁)) ≡ ((-ᵣ z) +ᵣ (-ᵣ z₁)))
+ w .Elimℝ-Prop2Sym.rat-ratA r q = cong rat (ℚ.-Distr r q)
+ w .Elimℝ-Prop2Sym.rat-limA r x y x₁ =
+   cong (-ᵣ_) (snd (NonExpanding₂.β-rat-lim' sumR r x y))
+    ∙ fromLipshitzNEβ _ _ (λ q → (rat r) +ᵣ (x q))
+         (fst (NonExpanding₂.β-rat-lim' sumR r x y))
+    ∙  (congLim _ _ _ _ λ q → x₁ _ ∙
+      cong (λ q' → (-ᵣ rat r) +ᵣ (-ᵣ x q')) (sym (ℚ₊≡ $ ℚ.·IdL _)))
+    ∙ cong ((rat (ℚ.- r)) +ᵣ_) (sym (fromLipshitzNEβ _ _ x y))
+
+ w .Elimℝ-Prop2Sym.lim-limA x y x' y' x₁ =
+    cong (-ᵣ_) (snd (NonExpanding₂.β-lim-lim/2 sumR x y x' y'))  ∙
+     fromLipshitzNEβ _ _ (λ q → (x (ℚ./2₊ q)) +ᵣ (x' (ℚ./2₊ q)))
+      (fst (NonExpanding₂.β-lim-lim/2 sumR x y x' y')) ∙
+     congLim _ _ _ _ (λ q → x₁ _ _)
+     ∙ sym (snd (NonExpanding₂.β-lim-lim/2 sumR _ _ _ _))
+      ∙ cong₂ _+ᵣ_ (sym (fromLipshitzNEβ _ _ x y))
+           ((sym (fromLipshitzNEβ _ _ x' y')))
+ w .Elimℝ-Prop2Sym.isSymA x y p =
+  cong (-ᵣ_) (+ᵣComm y x)
+   ∙∙ p  ∙∙
+    +ᵣComm (-ᵣ x) (-ᵣ y)
+ w .Elimℝ-Prop2Sym.isPropA x y = isSetℝ (-ᵣ (x +ᵣ y)) ((-ᵣ x) +ᵣ (-ᵣ y))
+
+-absᵣ : ∀ x → absᵣ x ≡ absᵣ (-ᵣ x)
+-absᵣ = Elimℝ-Prop.go w
+ where
+ w : Elimℝ-Prop _
+ w .Elimℝ-Prop.ratA x = cong rat (ℚ.-abs' x)
+ w .Elimℝ-Prop.limA x p x₁ =
+  let yy = _
+  in congLim  (λ v₁ →
+                  Elimℝ.go
+                  yy
+                  (x (ℚ.invℚ₊ 1 ℚ₊· v₁))) _
+                  (λ x₂ → Elimℝ.go yy
+                            (Elimℝ.go
+                             _
+                             (x (1 ℚ₊· (1 ℚ₊· x₂))))) _
+      λ q → _∙_ {y = Elimℝ.go yy (x (1 ℚ₊· (1 ℚ₊· q)))}
+       (cong (Elimℝ.go yy ∘ x) ((ℚ₊≡ (sym (ℚ.·IdL _)))) ) (x₁ _)
+
+ w .Elimℝ-Prop.isPropA x = isSetℝ (absᵣ x) (absᵣ (-ᵣ x))
+
+
+
+-[x-y]≡y-x : ∀ x y → -ᵣ ( x +ᵣ (-ᵣ y) ) ≡ y +ᵣ (-ᵣ x)
+-[x-y]≡y-x x y =
+     -ᵣDistr x (-ᵣ y)
+     ∙ λ i → +ᵣComm (-ᵣ x) (-ᵣInvol y i) i
+
+
+minusComm-absᵣ : ∀ x y → absᵣ (x +ᵣ (-ᵣ y)) ≡ absᵣ (y +ᵣ (-ᵣ x))
+minusComm-absᵣ x y = -absᵣ _ ∙ cong absᵣ (-[x-y]≡y-x x y)
+
+
+open ℚ.HLP
+
+-- HoTT Lemma (11.3.41)
+
+denseℚinℝ : ∀ u v → u <ᵣ v → ∃[ q ∈ ℚ ] ((u <ᵣ rat q) × (rat q <ᵣ v))
+denseℚinℝ u v =
+  PT.map λ ((u , v) , (z , (z' , z''))) →
+            u ℚ.+ ((v ℚ.- u) ℚ.· [ 1 / 2 ]) ,
+              ∣ (u , u ℚ.+ ((v ℚ.- u) ℚ.· [ 1 / 4 ]))
+                , (z , ((
+                     let zz' = ℚ.<-·o u v [ pos 1 / 1+ 3 ]
+                                (ℚ.0<→< [ pos 1 / 1+ 3 ] _ ) z'
+
+                     in subst (ℚ._<
+                              u ℚ.+ (v ℚ.- u) ℚ.· [ pos 1 / 1+ 3 ])
+                               (cong (u ℚ.+_)
+                                 (ℚ.·AnnihilL [ pos 1 / 1+ 3 ]) ∙ ℚ.+IdR u) $
+                           ℚ.≤<Monotone+ u u ([ pos 0 / 1+ 0 ]
+                              ℚ.· [ pos 1 / 1+ 3 ])
+                           ((v ℚ.- u) ℚ.· [ pos 1 / 1+ 3 ])
+                             (ℚ.isRefl≤ u) (
+                              ℚ.<-·o 0 (v ℚ.- u)
+                                 [ pos 1 / 1+ 3 ]
+                                  (ℚ.decℚ<? {0} {[ pos 1 / 1+ 3 ]})
+                                   (ℚ.<→<minus u v z')))
+                    , ≤ℚ→≤ᵣ _ _
+                       (ℚ.≤-o+
+                         ((v ℚ.- u) ℚ.· [ pos 1 / 1+ 3 ])
+                         ((v ℚ.- u) ℚ.· [ pos 1 / 1+ 1 ])
+                          u (ℚ.≤-o· [ pos 1 / 1+ 3 ]
+                             [ pos 1 / 1+ 1 ] (v ℚ.- u)
+                              (ℚ.0≤ℚ₊ (ℚ.<→ℚ₊ u v z'))
+                               (ℚ.decℚ≤? {[ pos 1 / 1+ 3 ]}
+                                          {[ pos 1 / 1+ 1 ]}))))) ∣₁
+                , ∣ (v ℚ.- ((v ℚ.- u) ℚ.· [ 1 / 4 ]) , v) ,
+                  (≤ℚ→≤ᵣ _ _
+                     (subst
+                       {x = (u ℚ.+ (v ℚ.- u) ℚ.· [ pos 3 / 1+ 3 ])}
+                       {(v ℚ.- ((v ℚ.- u) ℚ.· [ pos 1 / 1+ 3 ]))}
+                       (u ℚ.+ (v ℚ.- u) ℚ.· [ pos 1 / 1+ 1 ] ℚ.≤_)
+                        ((cong (u ℚ.+_) (ℚ.·DistR+ _ _ _ ∙ ℚ.+Comm _ _)
+                          ∙ ℚ.+Assoc _ _ _) ∙∙
+                            (cong₂ ℚ._+_
+                              distℚ! u ·[
+                               (ge1 +ge ((neg-ge ge1) ·ge
+                                        ge[ [ pos 3 / 1+ 3 ] ]))
+                                     ≡ (neg-ge ((neg-ge ge1) ·ge
+                                        ge[ [ pos 1 / 1+ 3 ] ]))   ]
+                             distℚ! v ·[ (( ge[ [ pos 3 / 1+ 3 ] ]))
+                                     ≡ (ge1 +ge neg-ge (
+                                        ge[ [ pos 1 / 1+ 3 ] ]))   ])
+                            ∙∙ (ℚ.+Comm _ _ ∙ sym (ℚ.+Assoc v
+                                   (ℚ.- (v ℚ.· [ 1 / 4 ]))
+                                    (ℚ.- ((ℚ.- u) ℚ.· [ 1 / 4 ])))
+                              ∙ cong (ℚ._+_ v)
+                                  (sym (ℚ.·DistL+ -1 _ _)) ∙ cong (ℚ._-_ v)
+                             (sym (ℚ.·DistR+ v (ℚ.- u) [ 1 / 4 ])) ))
+                         (ℚ.≤-o+
+                           ((v ℚ.- u) ℚ.· [ pos 1 / 1+ 1 ])
+                           ((v ℚ.- u) ℚ.· [ pos 3 / 1+ 3 ]) u
+                            (ℚ.≤-o· [ pos 1 / 1+ 1 ] [ pos 3 / 1+ 3 ]
+                              (v ℚ.- u) ((ℚ.0≤ℚ₊ (ℚ.<→ℚ₊ u v z')))
+                                ((ℚ.decℚ≤? {[ pos 1 / 1+ 1 ]}
+                                          {[ pos 3 / 1+ 3 ]})))
+                                  )) , (
+                   subst ((v ℚ.- ((v ℚ.- u) ℚ.· [ pos 1 / 1+ 3 ])) ℚ.<_)
+                    (ℚ.+IdR v) (ℚ.<-o+ (ℚ.- ((v ℚ.- u) ℚ.· [ 1 / 4 ])) 0 v
+                       (ℚ.-ℚ₊<0 (ℚ.<→ℚ₊ u v z' ℚ₊· ([ pos 1 / 1+ 3 ] , _)))) , z'')) ∣₁
+
+
+
+-- 11.3.42
+
+
+
+
+∼→≤ : ∀ u q → u ≤ᵣ (rat q) → ∀ v ε → u ∼'[ ε ] v → v ≤ᵣ rat (q ℚ.+ fst ε)
+∼→≤ u q u≤q v ε u∼v =
+ let maxLip : ((rat q)) ∼[ ε ] maxᵣ v ((rat q))
+     maxLip =
+         subst (_∼[ ε ] maxᵣ v ((rat q)))
+           u≤q $ NonExpanding₂.go∼L maxR ((rat q)) u v ε (∼'→∼ _ _ _ u∼v)
+     zzz = ∼→≤-rat-u q q (≤ᵣ-refl (rat q)) (maxᵣ v ((rat q))) ε (∼→∼' _ _ _ maxLip)
+ in cong (maxᵣ v ∘ rat) (sym (ℚ.≤→max q (q ℚ.+ fst ε)
+          (ℚ.≤+ℚ₊ q q ε (ℚ.isRefl≤ q )))) ∙∙
+     (maxᵣAssoc v (rat q) (rat (q ℚ.+ fst ε)))  ∙∙  zzz
+ where
+
+ ∼→≤-rat-u : ∀ u q → rat u ≤ᵣ (rat q) → ∀  v ε
+             → rat u ∼'[ ε ] v → v ≤ᵣ rat (q ℚ.+ fst ε)
+ ∼→≤-rat-u r q u≤q = Elimℝ-Prop.go w
+  where
+  w : Elimℝ-Prop _
+  w .Elimℝ-Prop.ratA x ε (u , v) = ≤ℚ→≤ᵣ _ _
+    (subst (ℚ._≤ q ℚ.+ fst ε) lem--05 $ ℚ.≤Monotone+ r q (x ℚ.- r) (fst ε)
+      (≤ᵣ→≤ℚ r q u≤q)
+      (ℚ.<Weaken≤ _ _ (ℚ.minus-<'  (fst ε) (x ℚ.- r)
+      $ subst ((ℚ.- fst ε) ℚ.<_) (sym (ℚ.-[x-y]≡y-x x r)) u)))
+  w .Elimℝ-Prop.limA x y x₁ ε =
+       PT.rec (isProp≤ᵣ _ _)
+     (uncurry λ θ →
+       PT.rec (isProp≤ᵣ _ _)
+        (uncurry λ θ<ε →
+          PT.rec (isProp≤ᵣ _ _)
+            λ (η , xx , xx') →
+              let xx'* : rat r
+                       ∼'[ (((ε .fst ℚ.- fst θ) ℚ.- fst η) , xx) ] x η
+                  xx'* = xx'
+
+                  yy : (δ : ℚ₊) → fst δ ℚ.< fst θ →
+                          rat r ∼[ ε ] x δ
+                  yy δ δ<θ =
+                    let z = triangle∼ {rat r}
+                              {x η} {x δ}
+                                {(((ε .fst ℚ.- fst θ) ℚ.- fst η) , xx)}
+                                   { θ ℚ₊+  η  }
+                             (∼'→∼ _ _
+                              ((((ε .fst ℚ.- fst θ) ℚ.- fst η) , xx))
+                               xx')
+                                let uu = (y η δ)
+                                 in ∼-monotone<
+                                       (subst (ℚ._< fst (θ ℚ₊+ η))
+                                          (ℚ.+Comm (fst δ) (fst η))
+                                          (ℚ.<-+o
+                                            (fst δ)
+                                            (fst θ) (fst η)
+                                            δ<θ)) uu
+                    in subst∼ lem--054 z
+
+              in sym (eqℝ _ _ λ ε' →
+                    let ε* = ℚ.min₊ (ℚ./2₊ ε') (ℚ./2₊ θ)
+                        ε*<ε' = snd
+                          (ℚ.<→ℚ₊  (fst ε*) (fst ε')
+                             (
+                             ℚ.isTrans≤< (fst ε*) (fst (ℚ./2₊ ε')) (fst ε')
+                              (ℚ.min≤ (fst (ℚ./2₊ ε')) (fst (ℚ./2₊ θ)))
+                               (ℚ.x/2<x ε') ))
+
+                        ε*<θ = ℚ.isTrans≤< (fst ε*) (fst (ℚ./2₊ θ)) (fst θ)
+                              (ℚ.min≤' (fst (ℚ./2₊ ε')) (fst (ℚ./2₊ θ)))
+                               (ℚ.x/2<x θ)
+
+                        zzz = x₁ ε* ε  (∼→∼' _ _ _ (yy ε* ε*<θ))
+                    in rat-lim (q ℚ.+ fst ε) _ _ ε* _ ε*<ε'
+                           (subst (rat (q ℚ.+ fst ε)
+                             ∼[ (fst ε' ℚ.- fst ε*) , ε*<ε' ]_)
+                              (sym zzz) (refl∼ (rat (q ℚ.+ fst ε))
+                             ((fst ε' ℚ.- fst ε*) , ε*<ε'))) )))
+    ∘ fst (rounded∼' (rat r) (lim x y) ε)
+
+  w .Elimℝ-Prop.isPropA _ = isPropΠ2 λ _ _ → isSetℝ _ _
+
+
+
+-- 11.3.43-i
+
+∼→< : ∀ u q → u <ᵣ (rat q) → ∀ v ε → u ∼'[ ε ] v → v <ᵣ rat (q ℚ.+ fst ε)
+∼→< u q u<q v ε x =
+  PT.map (λ ((q' , r') , z , z' , z'') →
+            ((q' ℚ.+ fst ε) , (r' ℚ.+ fst ε)) ,
+               (∼→≤ u q' z v ε x  , ((ℚ.<-+o q' r' (fst ε) z') ,
+                 ≤ℚ→≤ᵣ (r' ℚ.+ fst ε) (q ℚ.+ fst ε)
+                   (ℚ.≤-+o r' q (fst ε) (≤ᵣ→≤ℚ r' q z'')))))
+            u<q
+
+
+
+
+x+[y-x]/2≡y-[y-x]/2 : ∀ x y →
+  x ℚ.+ (y ℚ.- x) ℚ.· [ 1 / 2 ]
+   ≡ y ℚ.- ((y ℚ.- x) ℚ.· [ 1 / 2 ])
+x+[y-x]/2≡y-[y-x]/2 u v =
+  ((cong (u ℚ.+_) (ℚ.·DistR+ _ _ _ ∙ ℚ.+Comm _ _)
+        ∙ ℚ.+Assoc _ _ _) ∙∙
+          cong₂ ℚ._+_
+            distℚ! u ·[
+             (ge1 +ge ((neg-ge ge1) ·ge
+                      ge[ [ pos 1 / 1+ 1 ] ]))
+                   ≡ (neg-ge ((neg-ge ge1) ·ge
+                      ge[ [ pos 1 / 1+ 1 ] ]))   ]
+           distℚ! v ·[ (( ge[ [ pos 1 / 1+ 1 ] ]))
+                   ≡ (ge1 +ge neg-ge (
+                      ge[ [ pos 1 / 1+ 1 ] ]))   ]
+          ∙∙ (ℚ.+Comm _ _ ∙ sym (ℚ.+Assoc v
+                 (ℚ.- (v ℚ.· [ 1 / 2 ]))
+                  (ℚ.- ((ℚ.- u) ℚ.· [ 1 / 2 ])))
+            ∙ cong (ℚ._+_ v)
+                (sym (ℚ.·DistL+ -1 _ _)) ∙ cong (ℚ._-_ v)
+           (sym (ℚ.·DistR+ v (ℚ.- u) [ 1 / 2 ])) ))
+
+
+-- 11.3.43-ii
+
+∼→<' : ∀ u q → u <ᵣ (rat q) → ∀ v
+   → ∃[ ε ∈ ℚ₊ ] (u ∼'[ ε ] v → v <ᵣ rat q)
+∼→<' u q u<q v =
+ PT.map
+      (λ ((u' , q') , z , z' , z'') →
+            ℚ./2₊ (ℚ.<→ℚ₊ u' q' z')  ,
+              (λ xx →
+                let zwz = ∼→≤  u u'  z v _ xx
+                in ∣ (_ , q') , (zwz ,
+                  (subst2
+                      {x = q' ℚ.- (fst (ℚ./2₊ (ℚ.<→ℚ₊ u' q' z')))}
+                      {u' ℚ.+ fst (ℚ./2₊ (ℚ.<→ℚ₊ u' q' z'))}
+                      ℚ._<_
+                     (sym (x+[y-x]/2≡y-[y-x]/2 u' q'))
+                     (ℚ.+IdR q')
+                     (ℚ.<-o+ (ℚ.- fst (ℚ./2₊ (ℚ.<→ℚ₊ u' q' z'))) 0 q'
+                          (ℚ.-ℚ₊<0 (ℚ./2₊ (ℚ.<→ℚ₊ u' q' z'))))
+                     , z'')) ∣₁ ))
+      u<q
+
+
+-- 11.3.44
+
+lem-11-3-44 : ∀ u ε → u ∼'[ ε ] 0 → absᵣ u <ᵣ rat (fst ε)
+lem-11-3-44 = Elimℝ-Prop.go w
+ where
+ w : Elimℝ-Prop (λ z → (ε : ℚ₊) → z ∼'[ ε ] 0 → absᵣ z <ᵣ rat (fst ε))
+ w .Elimℝ-Prop.ratA x ε (x₁ , x₂) =
+    <ℚ→<ᵣ (ℚ.abs' x) (fst ε)
+      (subst (ℚ._< fst ε) (ℚ.abs'≡abs x)
+        (ℚ.absFrom<×< (fst ε) x
+          (subst ((ℚ.- fst ε) ℚ.<_) (ℚ.+IdR x) x₁)
+           (subst (ℚ._< (fst ε)) ((ℚ.+IdR x)) x₂)))
+ w .Elimℝ-Prop.limA x p x₁ ε =
+   (PT.rec squash₁
+     $ uncurry λ θ → PT.rec squash₁ λ (xx , xx') →
+       let zqz = ((subst∼ {ε' = (θ ℚ₊· ([ pos 1 / 1+ 2 ] , _))}
+                              (ℚ.ε/6+ε/6≡ε/3 (fst θ))
+                            (𝕣-lim-self
+                              x p (θ ℚ₊· ([ pos 1 / 6 ] , _))
+                                 (θ ℚ₊· ([ pos 1 / 6 ] , _)))))
+           by▵ : Σ (ℚ.0< (fst ε ℚ.- (fst θ ℚ.· ℚ.[ 2 / 3 ] )))
+                   (λ z → x (θ ℚ₊· (ℚ.[ pos 1 / 6 ] , _))
+                    ∼'[ (fst ε ℚ.- (fst θ ℚ.· ℚ.[ 2 / 3 ] )) , z ]
+                      0)
+           by▵ =
+             let zz = triangle∼' (x ( θ  ℚ₊·(ℚ.[ 1 / 6 ] , _)))
+                         (lim x p) 0 (( θ  ℚ₊·(ℚ.[ 1 / 3 ] , _)))
+                          ((fst ε ℚ.- fst θ) , xx)
+                         zqz xx'
+                 zz' : ((fst θ) ℚ.· [ 1 / 3 ])
+                         ℚ.+ (fst ε ℚ.- fst θ) ≡
+                         (fst ε ℚ.- (fst θ ℚ.· [ 2 / 3 ]))
+                 zz' = (λ i → ((fst θ) ℚ.· [ 1 / 3 ])
+                         ℚ.+ (fst ε ℚ.-
+                           distℚ! (fst θ) ·[
+                             (ge1) ≡ (ge[ ℚ.[ pos 1 / 1+ 2 ] ]
+                               +ge  ge[ ℚ.[ pos 1 / 1+ 2 ] ]
+                               +ge  ge[ ℚ.[ pos 1 / 1+ 2 ] ] ) ] i ))
+                     ∙∙ lem--055 ∙∙
+                       λ i → fst ε ℚ.-
+                           distℚ! (fst θ) ·[
+                             (ge[ ℚ.[ pos 1 / 1+ 2 ] ]
+                               +ge  ge[ ℚ.[ pos 1 / 1+ 2 ] ])
+                               ≡ (ge[ ℚ.[ pos 2 / 1+ 2 ] ] ) ] i
+             in sΣℚ<' zz' zz
+           xxx : absᵣ (x (θ ℚ₊· ([ pos 1 / 6 ] , tt))) <ᵣ
+                  rat (fst ε ℚ.- (fst θ  ℚ.· [ pos 2 / 1+ 2 ]))
+           xxx = x₁ _ _  (snd (by▵))
+
+           ggg' : absᵣ (lim x p) <ᵣ _
+           ggg' = ∼→< _ _ xxx (absᵣ (lim x p))
+                   ((θ  ℚ₊· ([ pos 1 / 1+ 2 ] , _))) $
+                     ∼→∼' _ _ _ $
+                             absᵣ-nonExpanding _ _ _ zqz
+
+           ggg : absᵣ (lim x p) <ᵣ rat (fst ε)
+           ggg = isTrans<ᵣ (absᵣ (lim x p))
+                   _ (rat (fst ε)) ggg'
+                     (<ℚ→<ᵣ _ _ (subst2 ℚ._<_
+                          (lem--056 ∙
+                            (λ i → (fst ε ℚ.-
+                             ((distℚ! (fst θ) ·[
+                             (ge[ ℚ.[ pos 1 / 1+ 2 ] ]
+                               +ge  ge[ ℚ.[ pos 1 / 1+ 2 ] ])
+                               ≡ (ge[ ℚ.[ pos 2 / 1+ 2 ] ] ) ]) i))
+                                ℚ.+
+                               (fst (θ ℚ₊· ([ pos 1 / 1+ 2 ] , tt)))))
+                               (ℚ.+IdR (fst ε))
+                           (ℚ.<-o+ (ℚ.- (fst θ ℚ.· [ pos 1 / 1+ 2 ])) 0 (fst ε)
+                          (ℚ.-ℚ₊<0 (θ ℚ₊· ([ pos 1 / 1+ 2 ] , tt))))))
+
+
+       in ggg) ∘S fst (rounded∼' (lim x p) 0 ε)
+ w .Elimℝ-Prop.isPropA _ = isPropΠ2 λ _ _ → squash₁
+
+
+∼≃abs<ε⇐ : ∀ u v  ε →
+  (absᵣ (u +ᵣ (-ᵣ  v)) <ᵣ rat (fst ε)) → (u ∼[ ε ] v)
+
+∼≃abs<ε⇐ u v ε = Elimℝ-Prop2Sym.go w u v ε
+ where
+  w : Elimℝ-Prop2Sym λ u v → ∀ ε →
+          (absᵣ (u +ᵣ (-ᵣ  v)) <ᵣ rat (fst ε))
+            → u ∼[ ε ] v
+  w .Elimℝ-Prop2Sym.rat-ratA r q ε z =
+    rat-rat-fromAbs r q ε
+     (subst (ℚ._< fst ε) (sym (ℚ.abs'≡abs _)) (<ᵣ→<ℚ _ _ z))
+  w .Elimℝ-Prop2Sym.rat-limA q x y R ε =
+    PT.rec (isProp∼ _ _ _) ( λ (θ , (xx , xx')) →
+          let 0<θ = ℚ.<→0< _ (<ᵣ→<ℚ 0 θ
+                       (isTrans≤<ᵣ 0 _ (rat θ)
+                         (0≤absᵣ _) xx))
+              ww : ∀ δ η → absᵣ (rat q +ᵣ (-ᵣ lim x y))
+                          ∼[ δ ℚ₊+ η ] absᵣ (rat q +ᵣ (-ᵣ (x δ)))
+              ww δ η =
+                let uu : ⟨ NonExpandingₚ (absᵣ ∘S (rat q +ᵣ_) ∘S -ᵣ_) ⟩
+                    uu = NonExpandingₚ∘ absᵣ ((rat q +ᵣ_) ∘S -ᵣ_)
+                              absᵣ-nonExpanding
+                               (NonExpandingₚ∘ (rat q +ᵣ_) -ᵣ_
+                                      (NonExpanding₂.go∼R sumR (rat q))
+                                       (Lipschitz-ℝ→ℝ-1→NonExpanding
+                                         _ (snd -ᵣR)))
+                in uu (lim x y) (x δ) (δ ℚ₊+ η) (
+                           sym∼ _ _ _ (𝕣-lim-self x y δ η))
+              δ = ℚ./4₊ (ℚ.<→ℚ₊ θ (fst ε) (<ᵣ→<ℚ _ _ xx'))
+              www = ∼→< (absᵣ (rat q +ᵣ (-ᵣ lim x y)))
+                      θ
+                      xx ((absᵣ (rat q +ᵣ (-ᵣ (x δ)))))
+                         (δ ℚ₊+ δ)
+                      (∼→∼' _ _ (δ ℚ₊+ δ) (ww δ δ))
+
+              wwwR = R δ ((θ , 0<θ) ℚ₊+ (δ ℚ₊+ δ)) www
+              zz : fst (δ ℚ₊+ δ) ℚ.+ (fst δ ℚ.+ fst δ) ≡
+                     fst ε ℚ.- θ
+              zz = distℚ! (fst ε ℚ.- θ)
+                     ·[ (ge[ [ 1 / 4 ] ] +ge ge[ [ 1 / 4 ] ]) +ge
+                        (ge[ [ 1 / 4 ] ] +ge ge[ [ 1 / 4 ] ]) ≡ ge1 ]
+          in subst∼ ( sym (ℚ.+Assoc _ _ _) ∙∙
+                    cong (θ ℚ.+_) zz ∙∙ lem--05 {θ} {fst ε} )
+               (triangle∼ wwwR (𝕣-lim-self x y δ δ))) ∘S
+          (denseℚinℝ (absᵣ (rat q +ᵣ (-ᵣ lim x y))) (rat (fst ε)))
+  w .Elimℝ-Prop2Sym.lim-limA x y x' y' R ε =
+      PT.rec (isProp∼ _ _ _) ( λ (θ , (xx , xx')) →
+        let 0<θ = ℚ.<→0< _ (<ᵣ→<ℚ 0 θ
+                       (isTrans≤<ᵣ 0 _ (rat θ)
+                         (0≤absᵣ _) xx))
+            ww : ∀ δ η → absᵣ (lim x y +ᵣ (-ᵣ lim x' y'))
+                        ∼[ (δ ℚ₊+ η) ℚ₊+ (δ ℚ₊+ η) ]
+                         absᵣ ((x δ) +ᵣ (-ᵣ (x' δ)))
+            ww δ η =
+              let uu = absᵣ-nonExpanding
+                    ((lim x y +ᵣ (-ᵣ lim x' y')))
+                    (x δ +ᵣ (-ᵣ x' δ))
+                        _
+                         (NonExpanding₂.go∼₂ sumR
+                          _ _
+                          (sym∼ _ _ _ (𝕣-lim-self x y δ η))
+                          (Lipschitz-ℝ→ℝ-1→NonExpanding
+                                         _ (snd -ᵣR) _ _ _
+                                          (sym∼ _ _ _ (𝕣-lim-self x' y' δ η))))
+              in uu
+            δ = (ℚ.<→ℚ₊ θ (fst ε) (<ᵣ→<ℚ _ _ xx')) ℚ₊· ([ 1 / 6 ] , _)
+            www = ∼→< (absᵣ (lim x y +ᵣ (-ᵣ lim x' y')))
+                      θ
+                      xx ((absᵣ (x δ +ᵣ (-ᵣ (x' δ)))))
+                         ((δ ℚ₊+ δ) ℚ₊+ (δ ℚ₊+ δ))
+                      (∼→∼' _ _ ((δ ℚ₊+ δ) ℚ₊+ (δ ℚ₊+ δ)) (ww δ δ))
+            wwwR = R δ δ
+                       ((θ , 0<θ) ℚ₊+ ((δ ℚ₊+ δ) ℚ₊+ (δ ℚ₊+ δ)))
+                         www
+
+            zz = cong (λ x → (x ℚ.+ x) ℚ.+ x)
+                  (ℚ.ε/6+ε/6≡ε/3 (fst ε ℚ.- θ))
+                   ∙ sym (ℚ.+Assoc _ _ _) ∙ ℚ.ε/3+ε/3+ε/3≡ε (fst ε ℚ.- θ)
+         in uncurry (lim-lim _ _ _ δ δ _ _)
+              (sΣℚ< (ℚ.+CancelL- _ _ _
+                        (sym (ℚ.+Assoc _ _ _) ∙∙
+                    cong (θ ℚ.+_) zz ∙∙ lem--05 {θ} {fst ε} )) wwwR)
+       ) ∘S (denseℚinℝ (absᵣ ((lim x y) +ᵣ (-ᵣ lim x' y'))) (rat (fst ε)))
+  w .Elimℝ-Prop2Sym.isSymA x y u ε =
+    sym∼ _ _ _ ∘S u ε ∘S subst (_<ᵣ rat (fst ε))
+     (minusComm-absᵣ y x)
+  w .Elimℝ-Prop2Sym.isPropA _ _ = isPropΠ2 λ _ _ → isProp∼ _ _ _
+
+
+
+∼≃abs<ε : ∀ u v  ε →
+  (u ∼[ ε ] v) ≃
+    (absᵣ (u +ᵣ (-ᵣ  v)) <ᵣ rat (fst ε))
+∼≃abs<ε u v ε =
+  propBiimpl→Equiv (isProp∼ _ _ _) (squash₁)
+   (λ x →
+    lem-11-3-44 ((u +ᵣ (-ᵣ v))) ε
+      (∼→∼' _ _ _ $  (subst ((u +ᵣ (-ᵣ v)) ∼[ ε ]_) (+-ᵣ v)
+       (+ᵣ-∼ u v (-ᵣ v) ε x))))
+   (∼≃abs<ε⇐ u v ε)
+
+getClampsOnQ : (a : ℚ) →
+      Σ ℕ₊₁ (λ n → absᵣ (rat a) <ᵣ rat [ pos (ℕ₊₁→ℕ n) / 1+ 0 ])
+getClampsOnQ = (map-snd (λ {a} → subst (_<ᵣ rat [ pos (ℕ₊₁→ℕ a) / 1+ 0 ])
+      (cong rat (ℚ.abs'≡abs _ ))
+      ∘S (<ℚ→<ᵣ _ _))) ∘ ℚ.boundℕ
+
+getClamps : ∀ u →
+   ∃[ n ∈ ℕ₊₁ ] absᵣ u <ᵣ fromNat (ℕ₊₁→ℕ n)
+getClamps = Elimℝ-Prop.go w
+ where
+  w : Elimℝ-Prop _
+  w .Elimℝ-Prop.ratA =
+    ∣_∣₁ ∘ getClampsOnQ
+  w .Elimℝ-Prop.limA x p x₁ =
+   PT.map (λ (1+ n , v) →
+   let z' = (subst∼ {ε' = ℚ./2₊ 1} ℚ.decℚ? $ 𝕣-lim-self x p (ℚ./4₊ 1) (ℚ./4₊ 1))
+       z = ∼→< (absᵣ (x (ℚ./4₊ 1))) _ v (absᵣ (lim x p)) 1
+              (∼→∼' _ _ _
+               (∼-monotone< (ℚ.x/2<x 1) (absᵣ-nonExpanding _ _ _ z')) )
+
+       uu = ℤ.·IdR _ ∙ (sym $ ℤ.+Comm 1 (pos 1 ℤ.+ pos n ℤ.· pos 1))
+
+   in (suc₊₁ (1+ n)) , subst ((absᵣ (lim x p) <ᵣ_) ∘ rat) (eq/ _ _ uu) z) $ x₁ (ℚ./4₊ 1)
+  w .Elimℝ-Prop.isPropA _ = squash₁
+
+restrSq : ∀ n → Lipschitz-ℚ→ℚ-restr (fromNat (suc n))
+                  ((2 ℚ₊· fromNat (suc n)))
+                  λ x → x ℚ.· x
+
+restrSq n q r x x₁ ε x₂ =
+
+  subst (ℚ._< 2 ℚ.· fst (fromNat (suc n)) ℚ.· fst ε)
+    (ℚ.abs·abs (q ℚ.+ r) (q ℚ.- r) ∙ cong ℚ.abs (lem--040 {q} {r})) z
+
+ where
+  zz : ℚ.abs (q ℚ.+ r) ℚ.< 2 ℚ.· fst (fromNat (suc n))
+  zz = subst (ℚ.abs (q ℚ.+ r) ℚ.<_)
+           (sym (ℚ.·DistR+ 1 1 (fst (fromNat (suc n)))))
+          (ℚ.isTrans≤< (ℚ.abs (q ℚ.+ r)) (ℚ.abs q ℚ.+ ℚ.abs r)
+            _ (ℚ.abs+≤abs+abs q r)
+              (ℚ.<Monotone+ (ℚ.abs q) _ (ℚ.abs r) _ x x₁ ))
+
+  z : ℚ.abs (q ℚ.+ r) ℚ.· ℚ.abs (q ℚ.- r) ℚ.<
+        2 ℚ.· fst (fromNat (suc n)) ℚ.· fst ε
+  z = ℚ.<Monotone·-onPos _ _ _ _
+      zz x₂ (ℚ.0≤abs (q ℚ.+ r)) ((ℚ.0≤abs (q ℚ.- r)))
+
+
+0<ℕ₊₁ : ∀ n m → 0 ℚ.< ([ ℚ.ℕ₊₁→ℤ n / m ])
+0<ℕ₊₁ n m = ℚ.0<→< ([ ℚ.ℕ₊₁→ℤ n / m ]) tt
+
+1/n<sucK : ∀ m n → ℚ.[ 1 / (suc₊₁ m) ] ℚ.< ([ ℚ.ℕ₊₁→ℤ n / 1 ])
+1/n<sucK m n =
+ subst (1 ℤ.<_) (ℤ.pos·pos _ _) (ℤ.suc-≤-suc (ℤ.suc-≤-suc ℤ.zero-≤pos ))
+
+<Δ : ∀ n → [ 1 / 4 ] ℚ.< ([ pos (suc n) / 1 ])
+<Δ n = 1/n<sucK 3 (1+ n)
+
+
+clampedSq : ∀ (n : ℕ) → Σ (ℝ → ℝ) (Lipschitz-ℝ→ℝ (2 ℚ₊· fromNat (suc n)))
+clampedSq n =
+  let ex = Lipschitz-ℚ→ℚ-extend _
+             _ _ (ℚ.[ (1 , 4) ] , _) (<Δ n) (restrSq n)
+  in fromLipschitz _ (_ , Lipschitz-rat∘ _ _ ex)
+
+IsContinuous : (ℝ → ℝ) → Type
+IsContinuous f =
+ ∀ u ε → ∃[ δ ∈ ℚ₊ ] (∀ v → u ∼[ δ ] v → f u ∼[ ε ] f v)
+
+IsContinuousWithPred : (P : ℝ → hProp ℓ-zero) →
+                        (∀ r → ⟨ P r ⟩ → ℝ) → Type
+IsContinuousWithPred P f =
+  ∀ u ε u∈P  → ∃[ δ ∈ ℚ₊ ] (∀ v v∈P → u ∼[ δ ] v →  f u u∈P ∼[ ε ] f v v∈P)
+
+Lipschitz→IsContinuous : ∀ L f → Lipschitz-ℝ→ℝ L f →  IsContinuous f
+Lipschitz→IsContinuous L f p u ε =
+ ∣ (ℚ.invℚ₊ L) ℚ₊· ε ,
+   (λ v → subst∼ (ℚ.y·[x/y] L (fst ε))
+      ∘S p u v ((invℚ₊ L) ℚ₊· ε)) ∣₁
+
+AsContinuousWithPred : (P : ℝ → hProp ℓ-zero) → (f : ℝ → ℝ)
+                      → IsContinuous f
+                      → IsContinuousWithPred P (λ x _ → f x)
+AsContinuousWithPred P f x u ε _ =
+  PT.map (map-snd (λ y z _ → y z)) (x u ε)
+
+IsContinuousWP∘ : ∀ P P' f g → (h : ∀ r x → ⟨ P (g r x) ⟩)
+   → (IsContinuousWithPred P f)
+   → (IsContinuousWithPred P' g )
+   → IsContinuousWithPred P'
+     (λ r x → f (g r x) (h r x))
+IsContinuousWP∘ P P' f g h fC gC u ε u∈P =
+  PT.rec squash₁
+    (λ (δ , δ∼) →
+      PT.map (map-snd λ x v v∈P →
+          δ∼ (g v v∈P) (h v v∈P) ∘ (x _ v∈P)) (gC u δ u∈P))
+    ((fC (g u u∈P) ε (h _ u∈P)))
+
+IsContinuous∘ : ∀ f g → (IsContinuous f) → (IsContinuous g)
+                    → IsContinuous (f ∘ g)
+IsContinuous∘ f g fC gC u ε =
+  PT.rec squash₁
+    (λ (δ , δ∼) →
+      PT.map (map-snd λ x v → δ∼ (g v) ∘  (x _)  ) (gC u δ))
+    (fC (g u) ε)
+
+isPropIsContinuous : ∀ f → isProp (IsContinuous f)
+isPropIsContinuous f = isPropΠ2 λ _ _ → squash₁
+
+-- HoTT Lemma 11.3.39
+≡Continuous : ∀ f g → IsContinuous f → IsContinuous g
+                → (∀ r → f (rat r) ≡ g (rat r))
+                → ∀ u → f u ≡ g u
+≡Continuous f g fC gC p = Elimℝ-Prop.go w
+ where
+ w : Elimℝ-Prop (λ z → f z ≡ g z)
+ w .Elimℝ-Prop.ratA = p
+ w .Elimℝ-Prop.limA x p R = eqℝ _ _ λ ε →
+   let f' = fC (lim x p) (ℚ./2₊ ε)
+       g' = gC (lim x p) (ℚ./2₊ ε)
+   in PT.rec2
+       (isProp∼ _ _ _)
+        (λ (θ , θ∼) (η , η∼) →
+         let δ = ℚ./2₊ (ℚ.min₊ θ η)
+             zF : f (lim x p) ∼[ ℚ./2₊ ε ] g (x δ)
+             zF = subst (f (lim x p) ∼[ ℚ./2₊ ε ]_)
+                  (R _)
+                 (θ∼ _ (∼-monotone≤ (
+                     subst (ℚ._≤ fst θ)
+                      (sym (ℚ.ε/2+ε/2≡ε (fst (ℚ.min₊ θ η))))
+                       (ℚ.min≤ (fst θ) (fst η)))
+                  (sym∼ _ _ _ ((𝕣-lim-self x p δ δ)))))
+             zG : g (lim x p) ∼[ ℚ./2₊ ε ] g (x δ)
+             zG = η∼ _ (∼-monotone≤ (subst (ℚ._≤ fst η)
+                      (sym (ℚ.ε/2+ε/2≡ε (fst (ℚ.min₊ θ η))))
+                       (ℚ.min≤' (fst θ) (fst η)))
+                  (sym∼ _ _ _ ((𝕣-lim-self x p δ δ))))
+         in subst∼ (ℚ.ε/2+ε/2≡ε (fst ε)) (triangle∼ zF (sym∼ _ _ _ zG)))
+        f' g'
+ w .Elimℝ-Prop.isPropA _ = isSetℝ _ _
+
+openPred : (P : ℝ → hProp ℓ-zero) → hProp ℓ-zero
+openPred P = (∀ x → ⟨ P x ⟩ → ∃[ δ ∈ ℚ₊ ] (∀ y → x ∼[ δ ] y → ⟨ P y ⟩ ) )
+   , isPropΠ2 λ _ _ → squash₁
+
+
+<min-rr : ∀ p q r → p <ᵣ (rat q) → p <ᵣ (rat r) → p <ᵣ minᵣ (rat q) (rat r)
+<min-rr p =
+ ℚ.elimBy≤ (λ x y R a b → subst (p <ᵣ_) (minᵣComm (rat x) (rat y)) (R b a))
+   λ x y x≤y p<x _ → subst ((p <ᵣ_) ∘ rat)
+    (sym (ℚ.≤→min _ _ x≤y) ) (p<x)
+
+
+m·n/m : ∀ m n → [ pos (suc m) / 1 ] ℚ.· [ pos n / 1+ m ] ≡ [ pos n / 1 ]
+m·n/m m n =
+  eq/ _ _ ((λ i → ℤ.·IdR (ℤ.·Comm (pos (suc m)) (pos n) i) i)
+       ∙ cong ((pos n ℤ.·_) ∘ ℚ.ℕ₊₁→ℤ) (sym (·₊₁-identityˡ (1+ m))))
+
+3·x≡x+[x+x] : ∀ x → 3 ℚ.· x ≡ x ℚ.+ (x ℚ.+ x)
+3·x≡x+[x+x] x = ℚ.·Comm _ _ ∙
+  distℚ! x ·[ ge[ 3 ] ≡ ge1 +ge (ge1 +ge ge1) ]
+
+abs'q≤Δ₁ : ∀ q n → absᵣ (rat q) <ᵣ rat [ pos (suc n) / 1+ 0 ]
+     →  ℚ.abs' q ℚ.≤ ([ pos (suc (suc (n))) / 1 ] ℚ.- [ 1 / 4 ])
+abs'q≤Δ₁ q n n< = (ℚ.isTrans≤ (ℚ.abs' q) (fromNat (suc n)) _
+          (ℚ.<Weaken≤ _ _ (<ᵣ→<ℚ _ _ n<))
+           (subst2 ℚ._≤_
+             ((ℚ.+IdR _))
+               ((cong {x = [ 3 / 4 ]} {y = 1 ℚ.- [ 1 / 4 ]}
+                         ([ pos (suc n) / 1 ] ℚ.+_)
+                         (𝟚.toWitness
+                          {Q = ℚ.discreteℚ [ 3 / 4 ] (1 ℚ.- [ 1 / 4 ])}
+                           _ ))
+                          ∙∙ ℚ.+Assoc _ _ _ ∙∙
+                            cong (ℚ._- [ pos 1 / 1+ 3 ])
+                             (ℚ.+Comm [ pos (suc n) / 1 ]
+                               1 ∙
+                                ℚ.ℤ+→ℚ+ 1 (pos (suc n)) ∙
+                                  cong [_/ 1 ]
+                                   (sym (ℤ.pos+ 1 (suc n)))))
+             (ℚ.≤-o+ 0 [ 3 / 4 ] (fromNat (suc n))
+               (𝟚.toWitness {Q = ℚ.≤Dec 0 [ 3 / 4 ]} _ ))))
+
+abs'q≤Δ₁' : ∀ q n → ℚ.abs' q ℚ.≤ [ pos (suc n) / 1+ 0 ]
+     →  ℚ.abs' q ℚ.≤ ([ pos (suc (suc (n))) / 1 ] ℚ.- [ 1 / 4 ])
+abs'q≤Δ₁' q n n< = (ℚ.isTrans≤ (ℚ.abs' q) (fromNat (suc n)) _
+          (n<)
+           (subst2 ℚ._≤_
+             ((ℚ.+IdR _))
+               ((cong {x = [ 3 / 4 ]} {y = 1 ℚ.- [ 1 / 4 ]}
+                         ([ pos (suc n) / 1 ] ℚ.+_)
+                         (𝟚.toWitness
+                          {Q = ℚ.discreteℚ [ 3 / 4 ] (1 ℚ.- [ 1 / 4 ])}
+                           _ ))
+                          ∙∙ ℚ.+Assoc _ _ _ ∙∙
+                            cong (ℚ._- [ pos 1 / 1+ 3 ])
+                             (ℚ.+Comm [ pos (suc n) / 1 ]
+                               1 ∙
+                                ℚ.ℤ+→ℚ+ 1 (pos (suc n)) ∙
+                                  cong [_/ 1 ]
+                                   (sym (ℤ.pos+ 1 (suc n)))))
+             (ℚ.≤-o+ 0 [ 3 / 4 ] (fromNat (suc n))
+               (𝟚.toWitness {Q = ℚ.≤Dec 0 [ 3 / 4 ]} _ ))))
+
+
+ℚabs-abs≤abs- : (x y : ℚ) → (ℚ.abs x ℚ.- ℚ.abs y) ℚ.≤ ℚ.abs (x ℚ.- y)
+ℚabs-abs≤abs- x y =
+ subst2 ℚ._≤_
+   (cong ((ℚ._+ (ℚ.- (ℚ.abs y))) ∘ ℚ.abs) lem--00 )
+   (sym lem--034)
+  (ℚ.≤-+o
+   (ℚ.abs ((x ℚ.- y) ℚ.+ y))
+   (ℚ.abs (x ℚ.- y) ℚ.+ ℚ.abs y) (ℚ.- (ℚ.abs y)) (ℚ.abs+≤abs+abs (x ℚ.- y) y))
+
+IsContinuousAbsᵣ : IsContinuous absᵣ
+IsContinuousAbsᵣ = Lipschitz→IsContinuous _ (fst absᵣL) (snd absᵣL)
+
+
+IsContinuousMaxR : ∀ x → IsContinuous (λ u → maxᵣ u x)
+IsContinuousMaxR x u ε =
+ ∣ ε , (λ v → NonExpanding₂.go∼L maxR _ _ _ ε) ∣₁
+
+IsContinuousMaxL : ∀ x → IsContinuous (maxᵣ x)
+IsContinuousMaxL x u ε =
+ ∣ ε , (λ v → NonExpanding₂.go∼R maxR _ _ _ ε) ∣₁
+
+IsContinuousMinR : ∀ x → IsContinuous (λ u → minᵣ u x)
+IsContinuousMinR x u ε =
+ ∣ ε , (λ v → NonExpanding₂.go∼L minR _ _ _ ε) ∣₁
+
+IsContinuousMinL : ∀ x → IsContinuous (minᵣ x)
+IsContinuousMinL x u ε =
+ ∣ ε , (λ v → NonExpanding₂.go∼R minR _ _ _ ε) ∣₁
+
+
+
+IsContinuous-ᵣ : IsContinuous (-ᵣ_)
+IsContinuous-ᵣ = Lipschitz→IsContinuous _ (fst -ᵣR) (snd -ᵣR)
+
+contDiagNE₂ : ∀ {h} → (ne : NonExpanding₂ h)
+  → ∀ f g → (IsContinuous f) → (IsContinuous g)
+  → IsContinuous (λ x → NonExpanding₂.go ne (f x) (g x))
+contDiagNE₂ ne f g fC gC u ε =
+  PT.map2
+    (λ (x , x') (y , y') →
+      ℚ.min₊ x y , (λ v z →
+          subst∼ (ℚ.ε/2+ε/2≡ε (fst ε))
+           (NonExpanding₂.go∼₂ ne (ℚ./2₊ ε) (ℚ./2₊ ε)
+           (x' v (∼-monotone≤ (ℚ.min≤ (fst x) (fst y)) z))
+           (y' v (∼-monotone≤ (ℚ.min≤' (fst x) (fst y)) z)))))
+   (fC u (ℚ./2₊ ε)) (gC u (ℚ./2₊ ε))
+
+contDiagNE₂WP : ∀ {h} → (ne : NonExpanding₂ h)
+  → ∀ P f g
+     → (IsContinuousWithPred P f)
+     → (IsContinuousWithPred P  g)
+  → IsContinuousWithPred P (λ x x∈ → NonExpanding₂.go ne (f x x∈) (g x x∈))
+contDiagNE₂WP ne P f g fC gC u ε u∈ =
+    PT.map2
+    (λ (x , x') (y , y') →
+
+      ℚ.min₊ x y , (λ v v∈ z →
+          subst∼ (ℚ.ε/2+ε/2≡ε (fst ε))
+           (NonExpanding₂.go∼₂ ne (ℚ./2₊ ε) (ℚ./2₊ ε)
+           (x' v v∈ (∼-monotone≤ (ℚ.min≤ (fst x) (fst y)) z))
+           (y' v v∈ (∼-monotone≤ (ℚ.min≤' (fst x) (fst y)) z))))
+           )
+   (fC u (ℚ./2₊ ε) u∈) (gC u (ℚ./2₊ ε) u∈)
+
+
+
+cont₂+ᵣ : ∀ f g → (IsContinuous f) → (IsContinuous g)
+  → IsContinuous (λ x → f x +ᵣ g x)
+cont₂+ᵣ = contDiagNE₂ sumR
+
+cont₂maxᵣ : ∀ f g → (IsContinuous f) → (IsContinuous g)
+  → IsContinuous (λ x → maxᵣ (f x) (g x))
+cont₂maxᵣ = contDiagNE₂ maxR
+
+cont₂minᵣ : ∀ f g → (IsContinuous f) → (IsContinuous g)
+  → IsContinuous (λ x → minᵣ (f x) (g x))
+cont₂minᵣ = contDiagNE₂ minR
+
+
+
+IsContinuous+ᵣR : ∀ x → IsContinuous (_+ᵣ x)
+IsContinuous+ᵣR x u ε =
+ ∣ ε , (λ v → NonExpanding₂.go∼L sumR _ _ _ ε) ∣₁
+
+IsContinuous+ᵣL : ∀ x → IsContinuous (x +ᵣ_)
+IsContinuous+ᵣL x u ε =
+ ∣ ε , (λ v → NonExpanding₂.go∼R sumR _ _ _ ε) ∣₁
+
+
+absᵣ-triangle : (x y : ℝ) → absᵣ (x +ᵣ y) ≤ᵣ (absᵣ x +ᵣ absᵣ y)
+absᵣ-triangle x y =
+ let z = IsContinuous∘ _ _ (IsContinuous+ᵣR (absᵣ y)) IsContinuousAbsᵣ
+
+ in ≡Continuous
+    (λ x → maxᵣ (absᵣ (x +ᵣ y)) ((absᵣ x +ᵣ absᵣ y)))
+    (λ x → (absᵣ x +ᵣ absᵣ y))
+    (cont₂maxᵣ _ _
+      (IsContinuous∘ _ _ IsContinuousAbsᵣ (IsContinuous+ᵣR y)) z)
+    z
+    (λ r → let z' = IsContinuous∘ _ _ (IsContinuous+ᵣL (absᵣ (rat r)))
+                IsContinuousAbsᵣ
+     in ≡Continuous
+    (λ y → maxᵣ (absᵣ ((rat r) +ᵣ y)) ((absᵣ (rat r) +ᵣ absᵣ y)))
+    (λ y → (absᵣ (rat r) +ᵣ absᵣ y))
+    (cont₂maxᵣ _ _
+        ((IsContinuous∘ _ _ IsContinuousAbsᵣ (IsContinuous+ᵣL (rat r))))
+          z' ) z'
+    (λ r' → cong rat (ℚ.≤→max _ _
+              (subst2 ℚ._≤_ (ℚ.abs'≡abs _)
+                (cong₂ ℚ._+_ (ℚ.abs'≡abs _) (ℚ.abs'≡abs _))
+               (ℚ.abs+≤abs+abs r r') ) )) y) x
+
+
+<ᵣWeaken≤ᵣ : ∀ m n → m <ᵣ n → m ≤ᵣ n
+<ᵣWeaken≤ᵣ m n = PT.rec (isSetℝ _ _)
+ λ ((q , q') , x , x' , x'')
+   → isTrans≤ᵣ _ _ _ x (isTrans≤ᵣ _ _ _ (≤ℚ→≤ᵣ _ _ (ℚ.<Weaken≤ _ _ x')) x'')
+
+≡ᵣWeaken≤ᵣ : ∀ m n → m ≡ n → m ≤ᵣ n
+≡ᵣWeaken≤ᵣ m n p = cong (flip maxᵣ n) p ∙ ≤ᵣ-refl n
+
+IsContinuousId : IsContinuous (λ x → x)
+IsContinuousId u ε = ∣ ε , (λ _ x → x) ∣₁
+
+IsContinuousConst : ∀ x → IsContinuous (λ _ → x)
+IsContinuousConst x u ε = ∣ ε , (λ _ _ → refl∼ _ _ ) ∣₁
+
++IdL : ∀ x → 0 +ᵣ x ≡ x
++IdL = ≡Continuous _ _ (IsContinuous+ᵣL 0) IsContinuousId
+  (cong rat ∘ ℚ.+IdL)
+
++IdR : ∀ x → x +ᵣ 0 ≡ x
++IdR = ≡Continuous _ _ (IsContinuous+ᵣR 0) IsContinuousId
+  (cong rat ∘ ℚ.+IdR)
+
+
++ᵣMaxDistr : ∀ x y z → (maxᵣ x y) +ᵣ z ≡ maxᵣ (x +ᵣ z) (y +ᵣ z)
++ᵣMaxDistr x y z =
+  ≡Continuous _ _
+     (IsContinuous∘ _ _ (IsContinuous+ᵣR z) (IsContinuousMaxR y))
+     (IsContinuous∘ _ _ (IsContinuousMaxR (y +ᵣ z)) (IsContinuous+ᵣR z))
+     (λ x' →
+       ≡Continuous _ _
+         (IsContinuous∘ _ _ (IsContinuous+ᵣR z) (IsContinuousMaxL (rat x')))
+         ((IsContinuous∘ _ _ (IsContinuousMaxL (rat x' +ᵣ z))
+                                (IsContinuous+ᵣR z)))
+         (λ y' → ≡Continuous _ _
+           (IsContinuous+ᵣL (maxᵣ (rat x') ( rat y')))
+           (cont₂maxᵣ _ _ (IsContinuous+ᵣL (rat x'))
+                          (IsContinuous+ᵣL (rat y')))
+           (λ z' → cong rat $ ℚ.+MaxDistrℚ x' y' z')
+           z)
+         y)
+     x
+
+
+
+≤ᵣ-+o : ∀ m n o →  m ≤ᵣ n → (m +ᵣ o) ≤ᵣ (n +ᵣ o)
+≤ᵣ-+o m n o p = sym (+ᵣMaxDistr m n o) ∙ cong (_+ᵣ o) p
+
+≤ᵣ-o+ : ∀ m n o →  m ≤ᵣ n → (o +ᵣ m) ≤ᵣ (o +ᵣ n)
+≤ᵣ-o+ m n o = subst2 _≤ᵣ_ (+ᵣComm _ _) (+ᵣComm _ _)  ∘ ≤ᵣ-+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≤ᵣ _ _ _ (≤ᵣ-+o m n o m≤n) (≤ᵣ-o+ o s n o≤s)
+
+
+
+
+lem--05ᵣ : ∀ δ q →  δ +ᵣ (q +ᵣ (-ᵣ δ)) ≡ q
+lem--05ᵣ δ q = cong (δ +ᵣ_) (+ᵣComm _ _) ∙∙
+   +ᵣAssoc _ _ _  ∙∙
+    (cong (_+ᵣ q) (+-ᵣ δ) ∙ +IdL q)
+
+abs-max : ∀ x → absᵣ x ≡ maxᵣ x (-ᵣ x)
+abs-max = ≡Continuous _ _
+  IsContinuousAbsᵣ
+   (cont₂maxᵣ _ _ IsContinuousId IsContinuous-ᵣ)
+    λ r → cong rat (sym (ℚ.abs'≡abs r))
+
+absᵣNonNeg : ∀ x → 0 ≤ᵣ x → absᵣ x ≡ x
+absᵣNonNeg x p = abs-max x ∙∙ maxᵣComm _ _ ∙∙ z
+ where
+   z : (-ᵣ x) ≤ᵣ x
+   z = subst2 _≤ᵣ_
+     (+IdL (-ᵣ x))
+     (sym (+ᵣAssoc _ _ _) ∙∙ cong (x +ᵣ_) (+-ᵣ x) ∙∙ +IdR x)
+     (≤ᵣ-+o 0 (x +ᵣ x) (-ᵣ x)
+      (≤ᵣMonotone+ᵣ 0 x 0 x p p))
+
+absᵣPos : ∀ x → 0 <ᵣ x → absᵣ x ≡ x
+absᵣPos x = absᵣNonNeg x ∘ <ᵣWeaken≤ᵣ _ _
diff --git a/Cubical/HITs/CauchyReals/Derivative.agda b/Cubical/HITs/CauchyReals/Derivative.agda
new file mode 100644
index 0000000000..59778e28ba
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/Derivative.agda
@@ -0,0 +1,379 @@
+{-# OPTIONS --safe --lossy-unification #-}
+
+module Cubical.HITs.CauchyReals.Derivative where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.HLevels
+open import Cubical.Functions.FunExtEquiv
+
+open import Cubical.Data.Sum as ⊎
+open import Cubical.Data.Int as ℤ using (pos)
+open import Cubical.Data.Sigma
+
+open import Cubical.HITs.PropositionalTruncation as PT
+open import Cubical.Data.NatPlusOne
+open import Cubical.Data.Nat as ℕ hiding (_·_;_+_)
+
+open import Cubical.Data.Rationals as ℚ using (ℚ ; [_/_])
+open import Cubical.Data.Rationals.Order as ℚ using
+  ( _ℚ₊+_ ; 0<_ ; ℚ₊ ; _ℚ₊·_ ; ℚ₊≡)
+open import Cubical.Data.Rationals.Order.Properties as ℚ
+ using (invℚ₊;/2₊;/3₊;/4₊;x/2<x;invℚ)
+
+
+open import Cubical.HITs.CauchyReals.Base
+open import Cubical.HITs.CauchyReals.Lems
+open import Cubical.HITs.CauchyReals.Closeness
+open import Cubical.HITs.CauchyReals.Lipschitz
+open import Cubical.HITs.CauchyReals.Order
+open import Cubical.HITs.CauchyReals.Continuous
+open import Cubical.HITs.CauchyReals.Multiplication
+open import Cubical.HITs.CauchyReals.Inverse
+open import Cubical.HITs.CauchyReals.Sequence
+
+
+
+
+at_limitOf_is_ : (x : ℝ) → (∀ r → x ＃ r → ℝ)  → ℝ → Type
+at x limitOf f is L =
+  ∀ (ε : ℝ₊) → ∃[ δ ∈ ℝ₊ ]
+   (∀ r x＃r → absᵣ (x -ᵣ r) <ᵣ fst δ → absᵣ (L -ᵣ f r x＃r) <ᵣ fst ε)
+
+at_inclLimitOf_is_ : (x : ℝ) → (∀ r → ℝ)  → ℝ → Type
+at x inclLimitOf f is L =
+  ∀ (ε : ℝ₊) → ∃[ δ ∈ ℝ₊ ]
+   (∀ r → absᵣ (x -ᵣ r) <ᵣ fst δ → absᵣ (L -ᵣ f r) <ᵣ fst ε)
+
+inclLimit→Limit : ∀ f x L → at x inclLimitOf f is L
+                          → at x limitOf (λ r _ → f r)  is L
+inclLimit→Limit f x L = PT.map (map-snd (const ∘_)) ∘_
+
+substLim : ∀ {x f f' L}
+  → (∀ r x＃r → f r x＃r ≡ f' r x＃r)
+  → at x limitOf f is L → at x limitOf f' is L
+substLim {x} {L = L} p =  subst (at x limitOf_is L) (funExt₂ p)
+
+IsContinuousInclLim : ∀ f x → IsContinuous f →
+                    at x inclLimitOf f is (f x)
+IsContinuousInclLim f x cx = uncurry
+  λ ε → (PT.rec squash₁
+   λ (q , 0<q , q<ε) →
+     PT.map (λ (δ , X) →
+       (ℚ₊→ℝ₊ δ) ,
+         λ r x₁ → isTrans<ᵣ _ _ _
+           (fst (∼≃abs<ε _ _ _) (X r (invEq (∼≃abs<ε _ _ _) x₁)))
+            q<ε  )
+       (cx x (q , ℚ.<→0< q (<ᵣ→<ℚ 0 q 0<q)))) ∘ denseℚinℝ 0 ε
+
+IsContinuousLim : ∀ f x → IsContinuous f →
+                    at x limitOf (λ r _ → f r) is (f x)
+IsContinuousLim f x cx = inclLimit→Limit _ _ _ (IsContinuousInclLim f x cx)
+
+IsContinuousInclLim→IsContinuous : ∀ f  →
+                    (∀ x → at x inclLimitOf f is (f x))
+                    → IsContinuous f
+IsContinuousInclLim→IsContinuous f xc x (ε , 0<ε) =
+  PT.rec squash₁ w z
+
+ where
+  z = xc x (rat ε , <ℚ→<ᵣ 0 ε (ℚ.0<→< _ 0<ε) )
+  w : Σ ℝ₊
+        (λ δ →
+           (r : ℝ) →
+           absᵣ (x -ᵣ r) <ᵣ fst δ → absᵣ (f x -ᵣ f r) <ᵣ rat ε) →
+        ∃-syntax ℚ₊ (λ δ → (v₁ : ℝ) → x ∼[ δ ] v₁ → f x ∼[ ε , 0<ε ] f v₁)
+  w ((δ , 0<δ) , X) =
+      PT.map (λ (q , 0<q , q<δ) →
+        ((q , ℚ.<→0< q (<ᵣ→<ℚ 0 q 0<q))) ,
+          λ r x∼r → invEq (∼≃abs<ε _ _ _) (X r
+            (isTrans<ᵣ _ _ _ (fst (∼≃abs<ε _ _ _) x∼r) q<δ)))
+       (denseℚinℝ 0 δ 0<δ)
+
+IsContinuousInclLim≃IsContinuous : ∀ f  →
+                    (∀ x → at x inclLimitOf f is (f x))
+                    ≃ (IsContinuous f)
+IsContinuousInclLim≃IsContinuous f =
+  propBiimpl→Equiv (isPropΠ2 λ _ _ → squash₁) (isPropIsContinuous f)
+    (IsContinuousInclLim→IsContinuous f)
+     λ fc x → IsContinuousInclLim f x fc
+
+IsContinuousLimΔ : ∀ f x → IsContinuous f →
+                    at 0 limitOf (λ Δx _ → f (x +ᵣ Δx)) is (f x)
+IsContinuousLimΔ f x cx =
+  subst (at rat [ pos 0 / 1+ 0 ] limitOf (λ Δx _ → f (x +ᵣ Δx)) is_)
+   (cong f (+IdR x))
+  (IsContinuousLim (λ Δx → f (x +ᵣ Δx)) 0
+    (IsContinuous∘ _ _ cx (IsContinuous+ᵣL x)))
+
+
+
+const-lim : ∀ C x → at x limitOf (λ _ _ → C) is C
+const-lim C x ε = ∣ (1 , decℚ<ᵣ?) ,
+  (λ r x＃r x₁ → subst (_<ᵣ fst ε) (cong absᵣ (sym (+-ᵣ C))) (snd ε)) ∣₁
+
+id-lim : ∀ x → at x limitOf (λ r _ → r) is x
+id-lim x ε = ∣ ε , (λ r x＃r p → p )  ∣₁
+
+_$[_]$_ : (ℝ → ℝ)
+        → (ℝ → ℝ → ℝ)
+        → (ℝ → ℝ)
+        → (ℝ → ℝ)
+f $[ _op_ ]$ g = λ r → (f r) op (g r)
+
+_#[_]$_ : {x : ℝ}
+        → (∀ r → x ＃ r → ℝ)
+        → (ℝ → ℝ → ℝ)
+        → (∀ r → x ＃ r → ℝ)
+        → (∀ r → x ＃ r → ℝ)
+f #[ _op_ ]$ g = λ r x → (f r x) op (g r x)
+
++-lim : ∀ x f g F G
+        → at x limitOf f is F
+        → at x limitOf g is G
+        → at x limitOf (f #[ _+ᵣ_ ]$ g) is (F +ᵣ G)
++-lim x f g F G fL gL ε =
+  PT.map2 (λ (δ , p) (δ' , p') →
+       (_ , ℝ₊min δ δ') ,
+        λ r x＃r x₁ →
+         let u = p r x＃r (isTrans<≤ᵣ _ _ _ x₁ (min≤ᵣ _ _))
+             u' = p' r x＃r (isTrans<≤ᵣ _ _ _ x₁ (min≤ᵣ' _ _))
+         in subst2 _<ᵣ_
+                (cong absᵣ (sym L𝐑.lem--041))
+                (x·rat[α]+x·rat[β]=x (fst ε))
+               (isTrans≤<ᵣ _ _ _
+                 (absᵣ-triangle _ _)
+                 (<ᵣMonotone+ᵣ _ _ _ _ u u')))
+    (fL (ε ₊·ᵣ (rat [ 1 / 2 ] , decℚ<ᵣ?)))
+     (gL (ε ₊·ᵣ (rat [ 1 / 2 ] , decℚ<ᵣ?)))
+
+
+·-lim : ∀ x f g F G
+        → at x limitOf f is F
+        → at x limitOf g is G
+        → at x limitOf (f #[ _·ᵣ_ ]$ g) is (F ·ᵣ G)
+·-lim x f g F G fL gL ε = PT.map3 w (fL (ε'f)) (gL (ε'g)) (gL 1)
+
+ where
+
+ ε'f : ℝ₊
+ ε'f = (ε ₊／ᵣ₊ 2) ₊／ᵣ₊ (1 +ᵣ absᵣ G ,
+          <≤ᵣMonotone+ᵣ 0 1 0 (absᵣ G) decℚ<ᵣ? (0≤absᵣ G))
+
+ ε'g : ℝ₊
+ ε'g = (ε ₊／ᵣ₊ 2) ₊／ᵣ₊ (1 +ᵣ absᵣ F ,
+          <≤ᵣMonotone+ᵣ 0 1 0 (absᵣ F) decℚ<ᵣ? (0≤absᵣ F))
+
+ w : _
+ w (δ , p) (δ' , p') (δ'' , p'') = δ* , ww
+
+  where
+
+   δ* : ℝ₊
+   δ* = minᵣ (minᵣ (fst δ) (fst δ')) (fst δ'') ,
+              ℝ₊min ((minᵣ (fst δ) (fst δ')) , (ℝ₊min δ δ')) δ''
+
+   ww : (r : ℝ) (x＃r : x ＃ r) →
+          absᵣ (x -ᵣ r) <ᵣ fst δ* →
+          absᵣ (F ·ᵣ G -ᵣ (f #[ _·ᵣ_ ]$ g) r x＃r) <ᵣ fst ε
+   ww r x＃r x₁ = subst2 _<ᵣ_
+        (cong absᵣ (sym L𝐑.lem--065))
+        yy
+        (isTrans≤<ᵣ _ _ _
+          ((absᵣ-triangle _ _) )
+          (<ᵣMonotone+ᵣ _ _ _ _
+            (isTrans≡<ᵣ _ _ _
+              (·absᵣ _ _)
+              (<ᵣ₊Monotone·ᵣ _ _ _ _
+              (0≤absᵣ _) (0≤absᵣ _) gx< u))
+              (isTrans≡<ᵣ _ _ _ (·absᵣ _ _)
+                (<ᵣ₊Monotone·ᵣ _ _ _ _
+              ((0≤absᵣ F)) (0≤absᵣ _)
+               (subst (_<ᵣ (1 +ᵣ (absᵣ F)))
+                (+IdL _)
+                 (<ᵣ-+o (rat 0) (rat 1) (absᵣ F) decℚ<ᵣ?)) u'))))
+
+
+     where
+      x₁' = isTrans<≤ᵣ _ _ _ x₁
+                 (isTrans≤ᵣ _ _ _ (min≤ᵣ _ _) (min≤ᵣ _ _))
+      x₁'' = isTrans<≤ᵣ _ _ _ x₁
+                 (isTrans≤ᵣ _ _ _ (min≤ᵣ _ _) (min≤ᵣ' _ _))
+      x₁''' = isTrans<≤ᵣ _ _ _ x₁ (min≤ᵣ' _ _)
+      u = p r x＃r x₁'
+      u' = p' r x＃r x₁''
+      u'' = p'' r x＃r x₁'''
+      gx< : absᵣ (g r x＃r) <ᵣ 1 +ᵣ absᵣ G
+      gx< =
+         subst (_<ᵣ (1 +ᵣ absᵣ G))
+            (cong absᵣ (sym (L𝐑.lem--035)))
+
+           (isTrans≤<ᵣ _ _ _
+             (absᵣ-triangle ((g r x＃r) -ᵣ G) G)
+              (<ᵣ-+o _ 1 (absᵣ G)
+                (subst (_<ᵣ 1) (minusComm-absᵣ _ _) u'')))
+      0<1+g = <≤ᵣMonotone+ᵣ 0 1 0 (absᵣ G) decℚ<ᵣ? (0≤absᵣ G)
+      0<1+f = <≤ᵣMonotone+ᵣ 0 1 0 (absᵣ F) decℚ<ᵣ? (0≤absᵣ F)
+
+      yy : _ ≡ _
+      yy = (cong₂ _+ᵣ_
+          (cong ((1 +ᵣ absᵣ G) ·ᵣ_)
+            (cong ((fst (ε ₊／ᵣ₊ 2)) ·ᵣ_)
+              (invℝ≡ _ _ _)
+             ∙ ·ᵣComm  (fst (ε ₊／ᵣ₊ 2))
+            (invℝ (1 +ᵣ absᵣ G)
+                (inl 0<1+g))) ∙
+            ·ᵣAssoc _ _ _)
+          (cong ((1 +ᵣ absᵣ F) ·ᵣ_)
+            (cong ((fst (ε ₊／ᵣ₊ 2)) ·ᵣ_)
+             (invℝ≡ _ _ _)
+             ∙ ·ᵣComm  (fst (ε ₊／ᵣ₊ 2))
+            (invℝ (1 +ᵣ absᵣ F)
+                (inl 0<1+f))) ∙
+             ·ᵣAssoc _ _ _) ∙
+          sym (·DistR+ _ _ (fst (ε ₊／ᵣ₊ 2)))
+           ∙∙ cong {y = 2} (_·ᵣ (fst (ε ₊／ᵣ₊ 2)))
+                           (cong₂ _+ᵣ_
+                               (x·invℝ[x] (1 +ᵣ absᵣ G)
+                                 (inl 0<1+g))
+                               (x·invℝ[x] (1 +ᵣ absᵣ F)
+                                 (inl 0<1+f))
+                              )
+                      ∙∙ ·ᵣComm 2 (fst (ε ₊／ᵣ₊ 2))  ∙
+                        [x/y]·yᵣ (fst ε) _ (inl _))
+
+At_limitOf_ : (x : ℝ) → (∀ r → x ＃ r → ℝ) → Type
+At x limitOf f = Σ _ (at x limitOf f is_)
+
+
+differenceAt : (ℝ → ℝ) → ℝ → ∀ h → 0 ＃ h → ℝ
+differenceAt f x h 0＃h = (f (x +ᵣ h) -ᵣ f x) ／ᵣ[ h , 0＃h ]
+
+
+derivativeAt : (ℝ → ℝ) → ℝ → Type
+derivativeAt f x = At 0 limitOf (differenceAt f x)
+
+derivativeOf_at_is_ : (ℝ → ℝ) → ℝ → ℝ → Type
+derivativeOf f at x is d = at 0 limitOf (differenceAt f x) is d
+
+constDerivative : ∀ C x → derivativeOf (λ _ → C) at x is 0
+constDerivative C x =
+ subst (at 0 limitOf_is 0)
+   (funExt₂ λ r 0＃r → sym (𝐑'.0LeftAnnihilates (invℝ r 0＃r)) ∙
+     cong (_·ᵣ (invℝ r 0＃r)) (sym (+-ᵣ _)))
+   (const-lim 0 0)
+
+idDerivative : ∀ x → derivativeOf (idfun ℝ) at x is 1
+idDerivative x =  subst (at 0 limitOf_is 1)
+   (funExt₂ λ r 0＃r → sym (x·invℝ[x] r 0＃r) ∙
+    cong (_·ᵣ (invℝ r 0＃r)) (sym (L𝐑.lem--063)))
+   (const-lim 1 0)
+
++Derivative : ∀ x f f'x g g'x
+        → derivativeOf f at x is f'x
+        → derivativeOf g at x is g'x
+        → derivativeOf (f $[ _+ᵣ_ ]$ g) at x is (f'x +ᵣ g'x)
++Derivative x f f'x g g'x F G =
+ subst {x = (differenceAt f x) #[ _+ᵣ_ ]$ (differenceAt g x)}
+            {y = (differenceAt (f $[ _+ᵣ_ ]$ g) x)}
+      (at 0 limitOf_is (f'x +ᵣ g'x))
+       (funExt₂ λ h 0＃h →
+         sym (·DistR+ _ _ _) ∙
+          cong (_·ᵣ (invℝ h 0＃h))
+           (sym L𝐑.lem--041)) (+-lim _ _ _ _ _ F G)
+
+C·Derivative : ∀ C x f f'x
+        → derivativeOf f at x is f'x
+        → derivativeOf ((C ·ᵣ_) ∘S f) at x is (C ·ᵣ f'x)
+C·Derivative C x f f'x F =
+   subst {x = λ h 0＃h → C ·ᵣ differenceAt f x h 0＃h}
+            {y = (differenceAt ((C ·ᵣ_) ∘S f) x)}
+      (at 0 limitOf_is (C ·ᵣ f'x))
+       (funExt₂ λ h 0＃h →
+         ·ᵣAssoc _ _ _ ∙
+           cong (_·ᵣ (invℝ h 0＃h)) (·DistL- _ _ _))
+       (·-lim _ _ _ _ _ (const-lim C 0) F)
+
+substDer : ∀ {x f' f g} → (∀ r → f r ≡ g r)
+     → derivativeOf f at x is f'
+     → derivativeOf g at x is f'
+substDer = subst (derivativeOf_at _ is _) ∘ funExt
+
+substDer₂ : ∀ {x f' g' f g} →
+        (∀ r → f r ≡ g r) → f' ≡ g'
+     → derivativeOf f at x is f'
+     → derivativeOf g at x is g'
+substDer₂ p q = subst2 (derivativeOf_at _ is_) (funExt p) q
+
+
+C·Derivative' : ∀ C x f f'x
+        → derivativeOf f at x is f'x
+        → derivativeOf ((_·ᵣ C) ∘S f) at x is (f'x ·ᵣ C)
+C·Derivative' C x f f'x F =
+  substDer₂ (λ _ → ·ᵣComm _ _) (·ᵣComm _ _)
+    (C·Derivative C x f f'x F)
+
+·Derivative : ∀ x f f'x g g'x
+        → IsContinuous g
+        → derivativeOf f at x is f'x
+        → derivativeOf g at x is g'x
+        → derivativeOf (f $[ _·ᵣ_ ]$ g) at x is
+           (f'x ·ᵣ (g x) +ᵣ (f x) ·ᵣ g'x)
+·Derivative x f f'x g g'x gC F G =
+  substLim w
+    (+-lim _ _ _ _ _
+      (·-lim _ _ _ _ _
+        F (IsContinuousLimΔ g x gC))
+      (·-lim _ _ _ _ _
+         (const-lim _ _) G))
+
+ where
+ w : (r : ℝ) (x＃r : 0 ＃ r) → _
+       ≡ differenceAt (f $[ _·ᵣ_ ]$ g) x r x＃r
+ w h 0＃h =
+    cong₂ _+ᵣ_ (sym (·ᵣAssoc _ _ _) ∙
+       cong ((f (x +ᵣ h) -ᵣ f x) ·ᵣ_) (·ᵣComm _ _)
+         ∙ (·ᵣAssoc _ _ _) )
+      (·ᵣAssoc _ (g (x +ᵣ h) -ᵣ g x) (invℝ h 0＃h))
+      ∙ sym (·DistR+ _ _ _) ∙
+       cong (_·ᵣ (invℝ h 0＃h))
+         (cong₂ _+ᵣ_ (·DistR+ _ _ _ ∙
+            cong (f (x +ᵣ h) ·ᵣ g (x +ᵣ h) +ᵣ_) (-ᵣ· _ _))
+           (·DistL+ _ _ _ ∙
+             cong (f x ·ᵣ g (x +ᵣ h) +ᵣ_) (·-ᵣ _ _))
+           ∙ L𝐑.lem--060)
+
+-- LimEverywhere→LimIncl : ∀ f → (∀ x → at x limitOf (λ x _ → f x) is (f x))
+--                            → (∀ x → at x inclLimitOf f is (f x))
+-- LimEverywhere→LimIncl = {!!}
+
+
+-- hasDer→isCont : ∀ f (f' : ℝ → ℝ) →
+--   (∀ x → derivativeOf f at x is f' x )
+--   → IsContinuous f
+-- hasDer→isCont f f' df ε = {!df!}
+
+derivative-^ⁿ : ∀ n x →
+   derivativeOf (_^ⁿ (suc n)) at x
+            is (fromNat (suc n) ·ᵣ (x ^ⁿ n))
+derivative-^ⁿ zero x =
+ substDer₂
+   (λ _ → sym (·IdL _))
+   (sym (·IdL _))
+   (idDerivative x)
+derivative-^ⁿ (suc n) x =
+  substDer₂ (λ _ → refl)
+    (+ᵣComm _ _ ∙ cong₂ _+ᵣ_
+       (·ᵣComm _ _) (sym (·ᵣAssoc _ _ _)) ∙
+       sym (·DistR+ _ _ _) ∙
+        cong (_·ᵣ ((x ^ⁿ n) ·ᵣ idfun ℝ x))
+         (cong rat (ℚ.ℕ+→ℚ+ _ _)))
+    (·Derivative _ _ _ _ _ IsContinuousId
+       (derivative-^ⁿ n x) (idDerivative x))
+
+-- -- -- chainRule : ∀ x f f'gx g g'x
+-- -- --         → derivativeOf g at x is g'x
+-- -- --          → derivativeOf f at (g x) is f'gx
+-- -- --         → derivativeOf (f ∘ g) at x is (f'gx ·ᵣ g'x)
+-- -- -- chainRule = {!!}
diff --git a/Cubical/HITs/CauchyReals/Inverse.agda b/Cubical/HITs/CauchyReals/Inverse.agda
new file mode 100644
index 0000000000..bcdd9b9648
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/Inverse.agda
@@ -0,0 +1,1141 @@
+{-# OPTIONS --lossy-unification --safe #-}
+
+module Cubical.HITs.CauchyReals.Inverse where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Structure
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Function
+
+open import Cubical.Data.Bool as 𝟚 hiding (_≤_)
+open import Cubical.Data.Empty as ⊥
+open import Cubical.Data.Sum as ⊎
+open import Cubical.Data.Unit
+open import Cubical.Data.Int as ℤ using (pos)
+open import Cubical.Data.Sigma
+open import Cubical.Data.NatPlusOne
+
+
+import Cubical.Algebra.CommRing as CR
+import Cubical.Algebra.Ring as RP
+
+
+open import Cubical.Relation.Binary
+
+open import Cubical.HITs.PropositionalTruncation as PT
+
+open import Cubical.Data.Rationals as ℚ using (ℚ ; [_/_])
+open import Cubical.Data.Rationals.Order as ℚ using
+  ( _ℚ₊+_ ; 0<_ ; ℚ₊ ; _ℚ₊·_ ; ℚ₊≡)
+open import Cubical.Data.Rationals.Order.Properties as ℚ
+ using (invℚ₊;/2₊;/3₊;/4₊;x/2<x;invℚ)
+
+
+open import Cubical.HITs.CauchyReals.Base
+open import Cubical.HITs.CauchyReals.Lems
+open import Cubical.HITs.CauchyReals.Closeness
+open import Cubical.HITs.CauchyReals.Lipschitz
+open import Cubical.HITs.CauchyReals.Order
+open import Cubical.HITs.CauchyReals.Continuous
+open import Cubical.HITs.CauchyReals.Multiplication
+
+
+Rℝ = (CR.CommRing→Ring
+               (_ , CR.commringstr 0 1 _+ᵣ_ _·ᵣ_ -ᵣ_ IsCommRingℝ))
+-- module CRℝ = ?
+
+module 𝐑 = CR.CommRingTheory (_ , CR.commringstr 0 1 _+ᵣ_ _·ᵣ_ -ᵣ_ IsCommRingℝ)
+module 𝐑' = RP.RingTheory Rℝ
+
+module 𝐐' = RP.RingTheory (CR.CommRing→Ring ℚCommRing)
+
+module L𝐑 = Lems ((_ , CR.commringstr 0 1 _+ᵣ_ _·ᵣ_ -ᵣ_ IsCommRingℝ))
+
+
+Invᵣ-restrℚ : (η : ℚ₊) →
+  Σ (ℚ → ℚ) (Lipschitz-ℚ→ℚ (invℚ₊ (η ℚ₊· η)))
+
+Invᵣ-restrℚ η = f ,
+  Lipschitz-ℚ→ℚ'→Lipschitz-ℚ→ℚ _ _ w
+ where
+
+ f = fst ∘ invℚ₊ ∘ ℚ.maxWithPos η
+
+ w : ∀ q r → ℚ.abs (f q ℚ.- f r) ℚ.≤
+      fst (invℚ₊ (η ℚ₊· η)) ℚ.· ℚ.abs (q ℚ.- r)
+ w q r =
+  let z = cong ℚ.abs (ℚ.1/p+1/q (ℚ.maxWithPos η q) (ℚ.maxWithPos η r))
+           ∙ ℚ.pos·abs _ _ (ℚ.0≤ℚ₊ (invℚ₊ (ℚ.maxWithPos η q ℚ₊· ℚ.maxWithPos η r)))
+           ∙ cong (fst (invℚ₊ (ℚ.maxWithPos η q ℚ₊· ℚ.maxWithPos η r)) ℚ.·_)
+       ((ℚ.absComm- _ _))
+  in subst (ℚ._≤ fst (invℚ₊ (η ℚ₊· η)) ℚ.· ℚ.abs (q ℚ.- r))
+       (sym z)
+         (ℚ.≤Monotone·-onNonNeg
+           (fst (invℚ₊ (ℚ.maxWithPos η q ℚ₊· ℚ.maxWithPos η r))) _ _ _
+            (ℚ.invℚ₊≤invℚ₊ _ _
+              (ℚ.≤Monotone·-onNonNeg _ _ _ _
+                (ℚ.≤max _ _)
+                (ℚ.≤max _ _)
+                (ℚ.0≤ℚ₊ η)
+                (ℚ.0≤ℚ₊ η)))
+            (ℚ.maxDist (fst η) r q)
+            (ℚ.0≤ℚ₊ (invℚ₊ (ℚ.maxWithPos η q ℚ₊· ℚ.maxWithPos η r)))
+            (ℚ.0≤abs (fst (ℚ.maxWithPos η q) ℚ.- fst (ℚ.maxWithPos η r))))
+
+Invᵣ-restr : (η : ℚ₊) → Σ (ℝ → ℝ) (Lipschitz-ℝ→ℝ (invℚ₊ (η ℚ₊· η)))
+Invᵣ-restr η = (fromLipschitz (invℚ₊ (η ℚ₊· η)))
+                   (_ , Lipschitz-rat∘ _ _ (snd (Invᵣ-restrℚ η)))
+
+
+lowerℚBound : ∀ u → 0 <ᵣ u → ∃[ ε ∈ ℚ₊ ] (rat (fst ε) <ᵣ u)
+lowerℚBound u x =
+  PT.map (λ (ε , (x' , x'')) → (ε , ℚ.<→0< _ (<ᵣ→<ℚ _ _ x')) , x'')
+    (denseℚinℝ 0 u x)
+
+≤absᵣ : ∀ x → x ≤ᵣ absᵣ x
+≤absᵣ = ≡Continuous
+  (λ x → maxᵣ x (absᵣ x))
+  (λ x → absᵣ x)
+  (cont₂maxᵣ _ _ IsContinuousId IsContinuousAbsᵣ)
+  IsContinuousAbsᵣ
+  λ x →  cong (maxᵣ (rat x) ∘ rat) (sym (ℚ.abs'≡abs x))
+     ∙∙ cong rat (ℚ.≤→max _ _ (ℚ.≤abs x)) ∙∙
+     cong rat (ℚ.abs'≡abs x )
+
+from-abs< : ∀ x y z → absᵣ (x +ᵣ (-ᵣ y)) <ᵣ z
+       → (x +ᵣ (-ᵣ y) <ᵣ z)
+          × ((y +ᵣ (-ᵣ x) <ᵣ z))
+            × ((-ᵣ y) +ᵣ x <ᵣ z)
+from-abs< x y z p = isTrans≤<ᵣ _ _ _ (≤absᵣ _) p ,
+ isTrans≤<ᵣ _ _ _ (≤absᵣ _) (subst (_<ᵣ z) (minusComm-absᵣ x y) p)
+   , isTrans≤<ᵣ _ _ _ (≤absᵣ _) (subst (((_<ᵣ z) ∘ absᵣ)) (+ᵣComm x (-ᵣ y)) p)
+
+open ℚ.HLP
+
+∃rationalApprox≤ : ∀ u → (ε : ℚ₊) →
+   ∃[ q ∈ ℚ ] (((rat q) +ᵣ (-ᵣ u)) ≤ᵣ rat (fst ε)) × (u ≤ᵣ rat q)
+∃rationalApprox≤ = Elimℝ-Prop.go w
+ where
+ w : Elimℝ-Prop _
+ w .Elimℝ-Prop.ratA r ε =
+  ∣  r ℚ.+ fst (/2₊ ε) ,
+   ≤ℚ→≤ᵣ _ _ (
+     let zzz : r ℚ.+ (fst (/2₊ ε) ℚ.+ (ℚ.- r)) ≡ fst (/2₊ ε)
+         zzz = (lem--05 {r} {fst (/2₊ ε)})
+         zz = (subst (ℚ._≤ fst ε) (sym (sym (ℚ.+Assoc _ _ _) ∙ zzz))
+            (ℚ.<Weaken≤ _ _ (ℚ.x/2<x (ε))) )
+     in zz)
+       , ≤ℚ→≤ᵣ _ _ (ℚ.≤+ℚ₊ r r (/2₊ ε) (ℚ.isRefl≤ r)) ∣₁
+ w .Elimℝ-Prop.limA x y R ε =
+   let z = 𝕣-lim-dist x y (/4₊ ε)
+   in PT.map (λ (q , z , z') →
+        let (_ , Xzz' , Xzz) = from-abs< _ _ _
+                     (𝕣-lim-dist x y (/4₊ ε))
+
+            zz :  (-ᵣ (lim x y)) +ᵣ x (/2₊ (/4₊ ε))   ≤ᵣ rat (fst (/4₊ ε))
+            zz = <ᵣWeaken≤ᵣ _ _ Xzz
+            zz' :  (lim x y) +ᵣ (-ᵣ (x (/2₊ (/4₊ ε))))   ≤ᵣ rat (fst (/4₊ ε))
+            zz' = <ᵣWeaken≤ᵣ _ _ Xzz'
+        in q ℚ.+ fst (/2₊ ε) ℚ.+ fst (/2₊ (/4₊ ε))  ,
+              let zzz = (≤ᵣ-+o _ _ (rat (fst (/2₊ ε) ℚ.+ fst (/2₊ (/4₊ ε))))
+                      (≤ᵣMonotone+ᵣ _ _ _ _ z zz))
+              in subst2 _≤ᵣ_
+                  (cong (_+ᵣ (rat (fst (/2₊ ε) ℚ.+ fst (/2₊ (/4₊ ε)))))
+                    (L𝐑.lem--059 {rat q}
+                        {x (/2₊ (/4₊ ε))}
+                        { -ᵣ lim x y} ∙ +ᵣComm (rat q) (-ᵣ lim x y))
+                      ∙ sym (+ᵣAssoc (-ᵣ lim x y) (rat q)
+                     (rat (fst (/2₊ ε) ℚ.+ fst (/2₊ (/4₊ ε))))) ∙
+                       +ᵣComm (-ᵣ lim x y)
+                        (rat q +ᵣ rat (fst (/2₊ ε) ℚ.+ fst (/2₊ (/4₊ ε))))
+                         ∙ cong (_+ᵣ (-ᵣ lim x y))
+                           (+ᵣAssoc (rat q) (rat (fst (/2₊ ε)))
+                            (rat (fst (/2₊ (/4₊ ε))))))
+                  (cong rat
+                   (distℚ! (fst ε) ·[
+                        ((ge[ ℚ.[ 1 / 4 ] ]
+                               ·ge ge[ ℚ.[ 1 / 2 ] ])
+                            +ge  ge[ ℚ.[ 1 / 4 ] ]
+                            )
+                                +ge
+                          (ge[ ℚ.[ 1 / 2 ] ]
+                            +ge (ge[ ℚ.[ 1 / 4 ] ]
+                               ·ge ge[ ℚ.[ 1 / 2 ] ]))
+                      ≡ ge1 ]))
+                  zzz
+                ,
+                 isTrans≤ᵣ _ _ _ (subst (_≤ᵣ (rat q +ᵣ rat (fst (/4₊ ε))))
+                   L𝐑.lem--05 (≤ᵣMonotone+ᵣ _ _ _ _ z' zz'))
+                    (≤ℚ→≤ᵣ _ _
+                      (subst (q ℚ.+ fst (/4₊ ε) ℚ.≤_)
+                        (ℚ.+Assoc _ _ _)
+                         (ℚ.≤-o+ _ _ q distℚ≤!
+                          ε [ ge[ ℚ.[ 1 / 4 ] ] ≤
+                          ge[ ℚ.[ 1 / 2 ] ]
+                            +ge (ge[ ℚ.[ 1 / 4 ] ]
+                               ·ge ge[ ℚ.[ 1 / 2 ] ]) ]) )))
+        (R (/2₊ (/4₊ ε)) (/2₊ (/4₊ ε)))
+ w .Elimℝ-Prop.isPropA _ = isPropΠ λ _ → squash₁
+
+
+ℚmax-min-minus : ∀ x y → ℚ.max (ℚ.- x) (ℚ.- y) ≡ ℚ.- (ℚ.min x y)
+ℚmax-min-minus = ℚ.elimBy≤
+ (λ x y p → ℚ.maxComm _ _ ∙∙ p ∙∙ cong ℚ.-_ (ℚ.minComm _ _))
+  λ x y x≤y →
+    ℚ.maxComm _ _ ∙∙ ℚ.≤→max (ℚ.- y) (ℚ.- x) (ℚ.minus-≤ x y x≤y)
+      ∙∙ cong ℚ.-_ (sym (ℚ.≤→min _ _ x≤y))
+
+
+-ᵣ≤ᵣ : ∀ x y → x ≤ᵣ y → -ᵣ y ≤ᵣ -ᵣ x
+-ᵣ≤ᵣ x y p = subst2 _≤ᵣ_
+    (cong (x +ᵣ_) (+ᵣComm _ _) ∙
+      L𝐑.lem--05 {x} { -ᵣ y}) (L𝐑.lem--05 {y} { -ᵣ x}) (≤ᵣ-+o _ _ ((-ᵣ x) +ᵣ (-ᵣ y)) p)
+
+
+-ᵣ<ᵣ : ∀ x y → x <ᵣ y → -ᵣ y <ᵣ -ᵣ x
+-ᵣ<ᵣ x y = PT.map
+  λ ((q , q') , z , z' , z'') →
+       (ℚ.- q' , ℚ.- q) , -ᵣ≤ᵣ _ _ z'' , ((ℚ.minus-< _ _ z') , -ᵣ≤ᵣ _ _ z)
+
+∃rationalApprox< : ∀ u → (ε : ℚ₊) →
+   ∃[ q ∈ ℚ ] (((rat q) +ᵣ (-ᵣ u)) <ᵣ rat (fst ε)) × (u <ᵣ rat q)
+∃rationalApprox< u ε =
+  PT.map (uncurry (λ q (x , x') →
+     q ℚ.+ (fst (/4₊ ε))  ,
+          subst (_<ᵣ (rat (fst ε)))
+            (L𝐑.lem--014 {rat q} {u} {rat (fst (/4₊ ε))})  (
+             isTrans≤<ᵣ _ _ (rat (fst ε)) (≤ᵣ-+o _ _ (rat (fst (/4₊ ε))) x)
+             (<ℚ→<ᵣ _ _ $
+               distℚ<! ε [ ge[ ℚ.[ 1 / 2 ] ]
+                 +ge ge[ ℚ.[ 1 / 4 ] ] < ge1 ])) ,
+              isTrans≤<ᵣ _ _ _ x'
+                (<ℚ→<ᵣ _ _ (ℚ.<+ℚ₊' _ _ (/4₊ ε) (ℚ.isRefl≤ _) )) ))
+            $ ∃rationalApprox≤ u (/2₊ ε)
+
+
+-- TODO: this is overcomplciated! it follows simply form density...
+
+∃rationalApprox : ∀ u → (ε : ℚ₊) →
+   ∃[ (q , q') ∈ (ℚ × ℚ) ] (q' ℚ.- q ℚ.< fst ε) ×
+                           ((rat q <ᵣ u) × (u <ᵣ rat q'))
+∃rationalApprox u ε =
+  PT.map2 (uncurry (λ q (x , x') → uncurry (λ q' (y , y') →
+      ((ℚ.- (q ℚ.+ (fst (/4₊ ε)))) , q' ℚ.+ (fst (/4₊ ε))) ,
+            let zz = ℚ.≤-+o _ _ (fst (/4₊ ε) ℚ.+ fst (/4₊ ε))
+                      (≤ᵣ→≤ℚ _ _ (subst (_≤ᵣ
+                       (rat (fst (/2₊ (/4₊ ε)))
+                      +ᵣ rat (fst (/2₊ (/4₊ ε)))))
+                       (L𝐑.lem--059 {rat q} { -ᵣ u} {rat q'} )
+                      (≤ᵣMonotone+ᵣ _ _ _ _ x y)))
+                zzz : (fst (/2₊ (/4₊ ε)) ℚ.+ fst (/2₊ (/4₊ ε)))
+                    ℚ.+ (fst (/4₊ ε) ℚ.+ fst (/4₊ ε)) ℚ.< fst ε
+                zzz = distℚ<! ε [
+                             (ge[ ℚ.[ 1 / 4 ] ]
+                                ·ge ge[ ℚ.[ 1 / 2 ] ]
+                              +ge ge[ ℚ.[ 1 / 4 ] ]
+                                ·ge ge[ ℚ.[ 1 / 2 ] ] )
+                            +ge (ge[ ℚ.[ 1 / 4 ] ]
+                              +ge ge[ ℚ.[ 1 / 4 ] ]) < ge1 ]
+            in ℚ.isTrans≤< _ _ _
+                   (subst (ℚ._≤ _)
+                    (cong (ℚ._+ ((fst (/4₊ ε) ℚ.+ fst (/4₊ ε))))
+                      (ℚ.+Comm q q')
+                     ∙∙ 𝐐'.+ShufflePairs _ _ _ _
+                     ∙∙ cong (_ ℚ.+_) (sym (ℚ.-Invol _)))
+                    zz)
+                    zzz
+                 ,
+            (subst (rat (ℚ.- (q ℚ.+ fst (/4₊ ε))) <ᵣ_) (-ᵣInvol u)
+               (-ᵣ<ᵣ _ _ $ isTrans≤<ᵣ _ _ _ x'
+                (<ℚ→<ᵣ _ _ (ℚ.<+ℚ₊' _ _ (/4₊ ε) (ℚ.isRefl≤ _) )))
+                 , isTrans≤<ᵣ _ _ _ y'
+                (<ℚ→<ᵣ _ _ (ℚ.<+ℚ₊' _ _ (/4₊ ε) (ℚ.isRefl≤ _) )))
+     )
+     )) (∃rationalApprox≤ (-ᵣ u) (/2₊ (/4₊ ε)))
+        (∃rationalApprox≤ u (/2₊ (/4₊ ε)))
+
+
+
+<ᵣ-+o-pre : ∀ m n o  → m ℚ.< n  → (rat m +ᵣ o) <ᵣ (rat n +ᵣ o)
+<ᵣ-+o-pre m n o m<n =
+  PT.rec2 squash₁ (λ (q , x , x') ((q' , q'') , y , y' , y'') →
+     let x* : (rat q) ≤ᵣ rat (fst (/4₊ Δ)) +ᵣ ((rat m +ᵣ o))
+         x* =  subst (_≤ᵣ rat (fst (/4₊ Δ)) +ᵣ ((rat m +ᵣ o)))
+                (L𝐑.lem--00)
+                 (≤ᵣ-+o _ _
+                  ((rat m +ᵣ o)) (<ᵣWeaken≤ᵣ _ _ x))
+
+         y* : (rat (fst (/4₊ Δ)) +ᵣ (rat m +ᵣ o)) ≤ᵣ
+               (-ᵣ (rat (fst (/4₊ Δ)) +ᵣ (-ᵣ (rat n +ᵣ o))))
+         y* = subst2 {x = rat (fst (/2₊ Δ))
+                 +ᵣ (rat m +ᵣ (o +ᵣ (-ᵣ (rat (fst (/4₊ Δ))))))}
+                _≤ᵣ_ -- (rat m +ᵣ (o +ᵣ (-ᵣ rat (fst (/4₊ Δ)))))
+              ((λ i → +ᵣComm (rat (fst (/2₊ Δ)))
+                   (+ᵣAssoc (rat m) o (-ᵣ rat (fst (/4₊ Δ))) i) i)
+                    ∙ sym (+ᵣAssoc _ _ _) ∙
+                      cong ((rat m +ᵣ o) +ᵣ_)
+                        (cong rat (distℚ! (fst Δ)
+                          ·[ ((neg-ge ge[ ℚ.[ 1 / 4 ] ])
+                           +ge ge[ ℚ.[ 1 / 2 ] ])
+                          ≡ ge[ ℚ.[ 1 / 4 ] ] ]))
+                        ∙ +ᵣComm _ _ )
+              (+ᵣAssoc _ _ _ ∙
+                cong (_+ᵣ (o +ᵣ (-ᵣ rat (fst (/4₊ Δ)))))
+                   (L𝐑.lem--00 {rat n} {rat m}) ∙
+                    +ᵣAssoc _ _ _ ∙
+                     (λ i → +ᵣComm (-ᵣInvol (rat n +ᵣ o) (~ i))
+                       (-ᵣ rat (fst (/4₊ Δ))) i) ∙
+                      sym (-ᵣDistr (rat (fst (/4₊ Δ))) ((-ᵣ (rat n +ᵣ o)))) )
+              (≤ᵣ-+o _ _ (rat m +ᵣ (o +ᵣ (-ᵣ (rat (fst (/4₊ Δ))))))
+                (≤ℚ→≤ᵣ _ _ (ℚ.<Weaken≤ _ _ (x/2<x Δ))))
+
+         z* : -ᵣ (rat (fst (/4₊ Δ)) +ᵣ (-ᵣ (rat n +ᵣ o)))
+               ≤ᵣ ((rat q'))
+         z* = subst ((-ᵣ (rat (fst (/4₊ Δ)) +ᵣ (-ᵣ (rat n +ᵣ o)))) ≤ᵣ_)
+               (cong (-ᵣ_) (sym (+ᵣAssoc (rat q'') (-ᵣ rat q') _)
+                   ∙ L𝐑.lem--05 {rat q''} {(-ᵣ rat q')}) ∙
+                     -ᵣInvol (rat q'))
+
+                    (-ᵣ≤ᵣ _ _ (≤ᵣMonotone+ᵣ _ _ _ _
+                (≤ℚ→≤ᵣ _ _ (ℚ.<Weaken≤ _ _ y))
+                 (<ᵣWeaken≤ᵣ _ _ (-ᵣ<ᵣ _ _ y''))))
+         z : rat q ≤ᵣ rat q'
+         z = isTrans≤ᵣ _ _ _
+              (isTrans≤ᵣ _ _ _
+                  x* y* ) z*
+     in isTrans<ᵣ _ _ _ x'
+        (isTrans≤<ᵣ _ _ _ z y'))
+    (∃rationalApprox< (rat m +ᵣ o) (/4₊ Δ))
+     ((∃rationalApprox (rat n +ᵣ o) (/4₊ Δ)))
+
+ where
+ Δ = ℚ.<→ℚ₊ m n m<n
+
+<ᵣ-+o : ∀ m n o →  m <ᵣ n → (m +ᵣ o) <ᵣ (n +ᵣ o)
+<ᵣ-+o m n o = PT.rec squash₁
+  λ ((q , q') , x , x' , x'') →
+   let y : (m +ᵣ o) ≤ᵣ (rat q +ᵣ o)
+       y = ≤ᵣ-+o m (rat q) o x
+       y'' : (rat q' +ᵣ o) ≤ᵣ (n +ᵣ o)
+       y'' = ≤ᵣ-+o (rat q') n o x''
+
+       y' : (rat q +ᵣ o) <ᵣ (rat q' +ᵣ o)
+       y' = <ᵣ-+o-pre q q' o x'
+
+
+   in isTrans<≤ᵣ _ _ _ (isTrans≤<ᵣ _ _ _ y y') y''
+
+<ᵣ-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
+
+<ᵣMonotone+ᵣ : ∀ m n o s → m <ᵣ n → o <ᵣ s → (m +ᵣ o) <ᵣ (n +ᵣ s)
+<ᵣMonotone+ᵣ m n o s m<n o<s =
+  isTrans<ᵣ _ _ _ (<ᵣ-+o m n o m<n) (<ᵣ-o+ o s n o<s)
+
+≤<ᵣMonotone+ᵣ : ∀ m n o s → m ≤ᵣ n → o <ᵣ s → (m +ᵣ o) <ᵣ (n +ᵣ s)
+≤<ᵣMonotone+ᵣ m n o s m≤n o<s =
+  isTrans≤<ᵣ _ _ _ (≤ᵣ-+o m n o m≤n) (<ᵣ-o+ o s n o<s)
+
+<≤ᵣMonotone+ᵣ : ∀ m n o s → m <ᵣ n → o ≤ᵣ s → (m +ᵣ o) <ᵣ (n +ᵣ s)
+<≤ᵣMonotone+ᵣ m n o s m<n o≤s =
+  isTrans<≤ᵣ _ _ _ (<ᵣ-+o m n o m<n) (≤ᵣ-o+ o s n o≤s)
+
+
+
+ℝ₊+ : (m : ℝ₊) (n : ℝ₊) → 0 <ᵣ (fst m) +ᵣ (fst n)
+ℝ₊+ (m , <m) (n , <n) = <ᵣMonotone+ᵣ 0 m 0 n <m <n
+
+
+
+isAsym<ᵣ : BinaryRelation.isAsym _<ᵣ_
+isAsym<ᵣ x y =
+  PT.rec2 (isProp⊥)
+   λ ((q , q') , x , x' , x'')
+      ((r , r') , y , y' , y'') →
+       let q<r = ℚ.isTrans<≤ _ _ _ x' (≤ᵣ→≤ℚ _ _ (isTrans≤ᵣ _ _ _ x'' y))
+           r<q = ℚ.isTrans<≤ _ _ _ y' (≤ᵣ→≤ℚ _ _ (isTrans≤ᵣ _ _ _ y'' x))
+       in ℚ.isAsym< _ _ q<r r<q
+
+
+_＃_ : ℝ → ℝ → Type
+x ＃ y = (x <ᵣ y) ⊎ (y <ᵣ x)
+
+isProp＃ : ∀ x y → isProp (x ＃ y)
+isProp＃ x y (inl x₁) (inl x₂) = cong inl (squash₁ x₁ x₂)
+isProp＃ x y (inl x₁) (inr x₂) = ⊥.rec (isAsym<ᵣ _ _ x₁ x₂)
+isProp＃ x y (inr x₁) (inl x₂) = ⊥.rec (isAsym<ᵣ _ _ x₁ x₂)
+isProp＃ x y (inr x₁) (inr x₂) = cong inr (squash₁ x₁ x₂)
+
+
+rat＃ : ∀ q q' → (rat q ＃ rat q') ≃ (q ℚ.# q' )
+rat＃ q q' = propBiimpl→Equiv (isProp＃ _ _) (ℚ.isProp# _ _)
+  (⊎.map (<ᵣ→<ℚ _ _) (<ᵣ→<ℚ _ _))
+  (⊎.map (<ℚ→<ᵣ _ _) (<ℚ→<ᵣ _ _))
+
+
+decCut : ∀ x → 0 <ᵣ (absᵣ x) → (0 ＃ x)
+decCut x 0<absX =
+  PT.rec (isProp＃ 0 x)
+    (λ (Δ , Δ<absX) →
+      PT.rec (isProp＃ 0 x)
+         (λ (q , q-x<Δ/2 , x<q) →
+          let z→ : 0 ℚ.< q → 0 <ᵣ x
+              z→ 0<q =
+                let zzz : rat q <ᵣ rat (fst (/2₊ Δ)) →
+                            0 <ᵣ x
+                    zzz q<Δ/2 =
+                      let zzz' =
+                           subst2 _≤ᵣ_
+                             (cong absᵣ (L𝐑.lem--05 {rat q} {x}))
+                               (cong₂ _+ᵣ_
+                                 (absᵣNonNeg _
+                                      (≤ℚ→≤ᵣ _ _
+                                         (ℚ.<Weaken≤ 0 q 0<q )))
+                                  (minusComm-absᵣ _ _ ∙
+                                       absᵣNonNeg _
+                                         (subst (_≤ᵣ (rat q +ᵣ (-ᵣ x)))
+                                           (+-ᵣ x) (≤ᵣ-+o _ _ (-ᵣ x)
+                                          (<ᵣWeaken≤ᵣ _ _ x<q)))))
+                              (absᵣ-triangle (rat q) (x +ᵣ (-ᵣ (rat q))))
+                          zzzz' = subst (absᵣ x <ᵣ_) (cong rat
+                               (ℚ.ε/2+ε/2≡ε (fst Δ)))
+                             (isTrans≤<ᵣ _ _ _ zzz'
+                                     (<ᵣMonotone+ᵣ
+                                       _ _ _ _ q<Δ/2 q-x<Δ/2))
+                      in ⊥.rec (isAsym<ᵣ _ _ Δ<absX zzzz')
+                in ⊎.rec
+                    (λ Δ≤q →
+                       subst2 _<ᵣ_
+                          (+-ᵣ (rat (fst (/2₊ Δ))))
+                          ((cong (rat q +ᵣ_) (-ᵣDistr (rat q) (-ᵣ x))
+                             ∙ (λ i → +ᵣAssoc (rat q) (-ᵣ (rat q))
+                                (-ᵣInvol x i) i) ∙
+                              cong (_+ᵣ x) (+-ᵣ (rat q)) ∙ +IdL x)) --
+                          (≤<ᵣMonotone+ᵣ (rat (fst (/2₊ Δ))) (rat q) _ _
+                            (≤ℚ→≤ᵣ _ _ Δ≤q) (-ᵣ<ᵣ _ _ q-x<Δ/2)))
+                   (zzz ∘S <ℚ→<ᵣ _ _ )
+                    (ℚ.Dichotomyℚ (fst (/2₊ Δ)) q)
+              z← : q ℚ.≤ 0 → x <ᵣ 0
+              z← q≤0 = isTrans<≤ᵣ _ _ _ x<q (≤ℚ→≤ᵣ q 0 q≤0)
+          in ⊎.rec (inr ∘ z←) (inl ∘ z→) (ℚ.Dichotomyℚ q 0))
+         (∃rationalApprox< x (/2₊ Δ)))
+     (lowerℚBound _ 0<absX)
+
+
+
+＃≃0<dist : ∀ x y → x ＃ y ≃ (0 <ᵣ (absᵣ (x +ᵣ (-ᵣ y))))
+＃≃0<dist x y = propBiimpl→Equiv (isProp＃ _ _) squash₁
+  (⊎.rec ((λ x<y → subst (0 <ᵣ_) (minusComm-absᵣ y x)
+                (isTrans<≤ᵣ _ _ _ (subst (_<ᵣ (y +ᵣ (-ᵣ x)))
+             (+-ᵣ x) (<ᵣ-+o _ _ (-ᵣ x) x<y)) (≤absᵣ _ ))))
+         (λ y<x → isTrans<≤ᵣ _ _ _ (subst (_<ᵣ (x +ᵣ (-ᵣ y)))
+             (+-ᵣ y) (<ᵣ-+o _ _ (-ᵣ y) y<x)) (≤absᵣ _ )))
+  (⊎.rec (inr ∘S subst2 _<ᵣ_ (+IdL _) L𝐑.lem--00 ∘S <ᵣ-+o _ _ y)
+         (inl ∘S subst2 _<ᵣ_ L𝐑.lem--05 (+IdR _) ∘S <ᵣ-o+ _ _ y)
+          ∘S decCut (x +ᵣ (-ᵣ y)))
+
+-- ＃≃abs< : ∀ x y → absᵣ x <ᵣ y ≃
+-- ＃≃abs< : ?
+
+isSym＃ : BinaryRelation.isSym _＃_
+isSym＃ _ _ = fst ⊎-swap-≃
+
+0＃→0<abs : ∀ r → 0 ＃ r → 0 <ᵣ absᵣ r
+0＃→0<abs r 0＃r =
+  subst (rat 0 <ᵣ_) (cong absᵣ (+IdR r))
+    (fst (＃≃0<dist r 0) (isSym＃ 0 r 0＃r))
+
+≤ᵣ-·o : ∀ m n o → 0 ℚ.≤ o  →  m ≤ᵣ n → (m ·ᵣ rat o ) ≤ᵣ (n ·ᵣ rat o)
+≤ᵣ-·o m n o 0≤o p = sym (·ᵣMaxDistrPos m n o 0≤o) ∙
+  cong (_·ᵣ rat o) p
+
+
+≤ᵣ-o· : ∀ m n o → 0 ℚ.≤ o →  m ≤ᵣ n → (rat o ·ᵣ m ) ≤ᵣ (rat o ·ᵣ n)
+≤ᵣ-o· m n o q p =
+    cong₂ maxᵣ (·ᵣComm _ _ ) (·ᵣComm _ _ ) ∙ ≤ᵣ-·o m n o q p ∙ ·ᵣComm _ _
+
+-- max≤-lem : ∀ x x' → x <ᵣ y → x' <ᵣ y → maxᵣ x x' ≤ᵣ x
+-- max≤-lem x x' y = {!!}
+
+<ᵣ→Δ : ∀ x y → x <ᵣ y → ∃[ δ ∈ ℚ₊ ] rat (fst δ) <ᵣ y +ᵣ (-ᵣ x)
+<ᵣ→Δ x y = PT.map λ ((q , q') , (a , a' , a'')) →
+              /2₊ (ℚ.<→ℚ₊ q q' a') ,
+                let zz = isTrans<≤ᵣ _ _ _ (<ℚ→<ᵣ _ _ a') a''
+                    zz' = -ᵣ≤ᵣ _ _ a
+                    zz'' = ≤ᵣMonotone+ᵣ _ _ _ _ a'' zz'
+                in isTrans<≤ᵣ _ _ _
+                       (<ℚ→<ᵣ _ _ (x/2<x (ℚ.<→ℚ₊ q q' a')))
+                       zz''
+
+a<b-c⇒c<b-a : ∀ a b c → a <ᵣ b +ᵣ (-ᵣ c) → c <ᵣ b +ᵣ (-ᵣ a)
+a<b-c⇒c<b-a a b c p =
+   subst2 _<ᵣ_ (L𝐑.lem--05 {a} {c})
+                (L𝐑.lem--060 {b} {c} {a})
+     (<ᵣ-+o _ _ (c +ᵣ (-ᵣ a)) p)
+
+a<b-c⇒a+c<b : ∀ a b c → a <ᵣ b +ᵣ (-ᵣ c) → a +ᵣ c <ᵣ b
+a<b-c⇒a+c<b a b c p =
+   subst ((a +ᵣ c) <ᵣ_)
+        (L𝐑.lem--00 {b} {c})
+     (<ᵣ-+o _ _ c p)
+
+
+a-b≤c⇒a-c≤b : ∀ a b c → a +ᵣ (-ᵣ b) ≤ᵣ c  → a +ᵣ (-ᵣ c) ≤ᵣ b
+a-b≤c⇒a-c≤b a b c p =
+  subst2 _≤ᵣ_
+    (L𝐑.lem--060 {a} {b} {c})
+    (L𝐑.lem--05 {c} {b})
+     (≤ᵣ-+o _ _ (b +ᵣ (-ᵣ c)) p)
+
+a-b<c⇒a-c<b : ∀ a b c → a +ᵣ (-ᵣ b) <ᵣ c  → a +ᵣ (-ᵣ c) <ᵣ b
+a-b<c⇒a-c<b a b c p =
+  subst2 _<ᵣ_
+    (L𝐑.lem--060 {a} {b} {c})
+    (L𝐑.lem--05 {c} {b})
+     (<ᵣ-+o _ _ (b +ᵣ (-ᵣ c)) p)
+
+
+a-b<c⇒a<c+b : ∀ a b c → a +ᵣ (-ᵣ b) <ᵣ c  → a <ᵣ c +ᵣ b
+a-b<c⇒a<c+b a b c p =
+  subst (_<ᵣ (c +ᵣ b))
+    (L𝐑.lem--00 {a} {b})
+     (<ᵣ-+o _ _ b p)
+
+≤-o+-cancel : ∀ m n o →  o +ᵣ m ≤ᵣ o +ᵣ n → m ≤ᵣ n
+≤-o+-cancel m n o p =
+     subst2 (_≤ᵣ_) L𝐑.lem--04 L𝐑.lem--04
+     (≤ᵣ-o+ _ _ (-ᵣ o) p)
+
+x≤y→0≤y-x : ∀ x y →  x ≤ᵣ y  → 0 ≤ᵣ y +ᵣ (-ᵣ x)
+x≤y→0≤y-x x y p =
+  subst (_≤ᵣ y +ᵣ (-ᵣ x)) (+-ᵣ x) (≤ᵣ-+o x y (-ᵣ x) p)
+
+x<y→0<y-x : ∀ x y →  x <ᵣ y  → 0 <ᵣ y +ᵣ (-ᵣ x)
+x<y→0<y-x x y p =
+  subst (_<ᵣ y +ᵣ (-ᵣ x)) (+-ᵣ x) (<ᵣ-+o x y (-ᵣ x) p)
+
+0<y-x→x<y : ∀ x y → 0 <ᵣ y +ᵣ (-ᵣ x) → x <ᵣ y
+0<y-x→x<y x y p =
+  subst2 (_<ᵣ_)
+   (+IdL x) (sym (L𝐑.lem--035 {y} {x}))
+    (<ᵣ-+o 0 (y +ᵣ (-ᵣ x)) x p)
+
+
+
+max-lem : ∀ x x' y → maxᵣ (maxᵣ x y) (maxᵣ x' y) ≡ (maxᵣ (maxᵣ x x') y)
+max-lem x x' y = maxᵣAssoc _ _ _ ∙ cong (flip maxᵣ y) (maxᵣComm _ _)
+  ∙ sym (maxᵣAssoc _ _ _) ∙
+    cong (maxᵣ x') (sym (maxᵣAssoc _ _ _) ∙ cong (maxᵣ x) (maxᵣIdem y))
+     ∙ maxᵣAssoc _ _ _ ∙ cong (flip maxᵣ y) (maxᵣComm _ _)
+
+
+
+minᵣIdem : ∀ x → minᵣ x x ≡ x
+minᵣIdem = ≡Continuous _ _
+  (cont₂minᵣ _ _ IsContinuousId IsContinuousId)
+  IsContinuousId
+  (cong rat ∘ ℚ.minIdem)
+
+
+min-lem : ∀ x x' y → minᵣ (minᵣ x y) (minᵣ x' y) ≡ (minᵣ (minᵣ x x') y)
+min-lem x x' y = minᵣAssoc _ _ _ ∙ cong (flip minᵣ y) (minᵣComm _ _)
+  ∙ sym (minᵣAssoc _ _ _) ∙
+    cong (minᵣ x') (sym (minᵣAssoc _ _ _) ∙ cong (minᵣ x) (minᵣIdem y))
+     ∙ minᵣAssoc _ _ _ ∙ cong (flip minᵣ y) (minᵣComm _ _)
+
+
+max≤-lem : ∀ x x' y → x ≤ᵣ y → x' ≤ᵣ y → maxᵣ x x' ≤ᵣ y
+max≤-lem x x' y p p' =
+  sym (max-lem _ _ _)
+   ∙∙ cong₂ maxᵣ p p' ∙∙ maxᵣIdem y
+
+max<-lem : ∀ x x' y → x <ᵣ y → x' <ᵣ y → maxᵣ x x' <ᵣ y
+max<-lem x x' y = PT.map2
+  λ ((q , q') , (a , a' , a''))
+    ((r , r') , (b , b' , b'')) →
+     (ℚ.max q r , ℚ.max q' r') ,
+       (max≤-lem _ _ (rat (ℚ.max q r))
+         (isTrans≤ᵣ _ _ _ a (≤ℚ→≤ᵣ _ _ (ℚ.≤max q r)))
+         ((isTrans≤ᵣ _ _ _ b (≤ℚ→≤ᵣ _ _ (ℚ.≤max' q r)))) ,
+          (ℚ.<MonotoneMaxℚ _ _ _ _ a' b' , max≤-lem _ _ _ a'' b''))
+
+minDistMaxᵣ : ∀ x y y' →
+  maxᵣ x (minᵣ y y') ≡ minᵣ (maxᵣ x y) (maxᵣ x y')
+minDistMaxᵣ x y y' = ≡Continuous _ _
+   (IsContinuousMaxR _)
+   (cont₂minᵣ _ _ (IsContinuousMaxR _) (IsContinuousMaxR _))
+   (λ xR →
+     ≡Continuous _ _
+       (IsContinuous∘ _ _ (IsContinuousMaxL (rat xR)) ((IsContinuousMinR y')))
+       (IsContinuous∘ _ _ (IsContinuousMinR _) (IsContinuousMaxL (rat xR)))
+       (λ yR →
+         ≡Continuous _ _
+           (IsContinuous∘ _ _ (IsContinuousMaxL (rat xR))
+             ((IsContinuousMinL (rat yR))))
+           (IsContinuous∘ _ _ (IsContinuousMinL (maxᵣ (rat xR) (rat yR)))
+             (IsContinuousMaxL (rat xR)))
+           (cong rat ∘ ℚ.minDistMax xR yR ) y')
+       y)
+   x
+
+
+≤maxᵣ : ∀ m n →  m ≤ᵣ maxᵣ m n
+≤maxᵣ m n = maxᵣAssoc _ _ _ ∙ cong (flip maxᵣ n) (maxᵣIdem m)
+
+≤min-lem : ∀ x y y' → x ≤ᵣ y → x ≤ᵣ y' →  x ≤ᵣ minᵣ y y'
+≤min-lem x y y' p p' =
+   minDistMaxᵣ x y y' ∙ cong₂ minᵣ p p'
+
+
+<min-lem : ∀ x x' y → y <ᵣ x → y <ᵣ x' →  y <ᵣ minᵣ x x'
+<min-lem x x' y = PT.map2
+  λ ((q , q') , (a , a' , a''))
+    ((r , r') , (b , b' , b'')) →
+     (ℚ.min q r , ℚ.min q' r') , ≤min-lem _ _ _ a b
+        , ℚ.<MonotoneMinℚ _ _ _ _ a' b' ,
+            ≤min-lem (rat (ℚ.min q' r')) x x'
+             (isTrans≤ᵣ _ _ _ (≤ℚ→≤ᵣ _ _ (ℚ.min≤ q' r')) a'')
+             (isTrans≤ᵣ _ _ _ (≤ℚ→≤ᵣ _ _ (ℚ.min≤' q' r')) b'')
+
+
+
+
+ℝ₊min : (m : ℝ₊) (n : ℝ₊) → 0 <ᵣ minᵣ (fst m) (fst n)
+ℝ₊min (m , <m) (n , <n) = <min-lem m n 0 <m <n
+
+maxAbsorbLMinᵣ : ∀ x y → maxᵣ x (minᵣ x y) ≡ x
+maxAbsorbLMinᵣ x =
+  ≡Continuous _ _
+    (IsContinuous∘ _ _
+      (IsContinuousMaxL _) (IsContinuousMinL x))
+      (IsContinuousConst _)
+     λ y' →
+       ≡Continuous _ _
+          (cont₂maxᵣ _ _ IsContinuousId (IsContinuousMinR _))
+        IsContinuousId
+         (λ x' → cong rat (ℚ.maxAbsorbLMin x' y')) x
+
+min≤ᵣ : ∀ m n → minᵣ m n ≤ᵣ m
+min≤ᵣ m n = maxᵣComm _ _ ∙ maxAbsorbLMinᵣ _ _
+
+min≤ᵣ' : ∀ m n → minᵣ m n ≤ᵣ n
+min≤ᵣ' m n = subst (_≤ᵣ n) (minᵣComm n m) (min≤ᵣ n m)
+
+invℝ'' : Σ (∀ r → ∃[ σ ∈ ℚ₊ ] (rat (fst σ) <ᵣ r) → ℝ)
+      λ _ → Σ (∀ r → 0 <ᵣ r → ℝ) (IsContinuousWithPred (λ r → _ , squash₁))
+invℝ'' = f , (λ r 0<r → f r (lowerℚBound r 0<r)) ,
+   ctnF
+
+ where
+
+ 2co : ∀ σ σ' r
+    → (rat (fst σ ) <ᵣ r)
+    → (rat (fst σ') <ᵣ r)
+    → fst (Invᵣ-restr σ) r ≡ fst (Invᵣ-restr σ') r
+
+ 2co σ σ' = Elimℝ-Prop.go w
+  where
+  w : Elimℝ-Prop _
+  w .Elimℝ-Prop.ratA x σ<x σ'<x =
+    cong (rat ∘ fst ∘ invℚ₊)
+      (ℚ₊≡ (ℚ.≤→max _ _ (≤ᵣ→≤ℚ _  _ (<ᵣWeaken≤ᵣ _ _ σ<x))
+           ∙ sym (ℚ.≤→max _ _ (≤ᵣ→≤ℚ _  _ (<ᵣWeaken≤ᵣ _ _ σ'<x))) ))
+  w .Elimℝ-Prop.limA x y R σ<limX σ'<limX = eqℝ _ _ λ ε →
+    PT.rec (isProp∼ _ _ _)
+      (λ (q , σ⊔<q , q<limX) →
+       let
+           φ*ε = (((invℚ₊ ((invℚ₊ (σ ℚ₊· σ))
+                                   ℚ₊+ (invℚ₊ (σ' ℚ₊· σ'))))
+                                   ℚ₊· ε))
+
+
+           φ*σ = (/2₊ (ℚ.<→ℚ₊ (fst σ⊔) q (<ᵣ→<ℚ _ _ σ⊔<q)))
+
+           φ* : ℚ₊
+           φ* = ℚ.min₊ (/2₊ φ*ε) φ*σ
+
+
+
+           limRestr'' : rat (fst φ*)
+               ≤ᵣ (rat q +ᵣ (-ᵣ rat (fst σ⊔))) ·ᵣ rat [ 1 / 2 ]
+           limRestr'' =
+             let zz = ((ℚ.min≤'
+                    ((fst (/2₊ ((invℚ₊ ((invℚ₊ (σ ℚ₊· σ))
+                                   ℚ₊+ (invℚ₊ (σ' ℚ₊· σ'))))
+                                   ℚ₊· ε))))
+                                    (fst (/2₊
+                             (ℚ.<→ℚ₊ (fst σ⊔) q (<ᵣ→<ℚ _ _ σ⊔<q))
+                          ))))
+             in subst (rat (fst φ*) ≤ᵣ_)
+                (rat·ᵣrat _ _)
+                  (≤ℚ→≤ᵣ (fst φ*)
+                    (fst (/2₊
+                             (ℚ.<→ℚ₊ (fst σ⊔) q (<ᵣ→<ℚ _ _ σ⊔<q))
+                          )) zz)
+
+
+           limRestr' : rat (fst φ* ℚ.+ fst φ*)
+               ≤ᵣ (lim x y +ᵣ (-ᵣ rat (fst σ⊔)))
+           limRestr' =
+             let zz : ((rat q +ᵣ (-ᵣ rat (fst σ⊔)))) ≤ᵣ
+                        ((lim x y +ᵣ (-ᵣ rat (fst σ⊔))) )
+                 zz = ≤ᵣ-+o (rat q) (lim x y) (-ᵣ rat (fst σ⊔))
+                          (<ᵣWeaken≤ᵣ _ _ q<limX)
+             in  subst2 _≤ᵣ_
+                  (sym (rat·ᵣrat _ _) ∙
+                   cong rat (distℚ! (fst φ*) ·[ ge[ 2 ]  ≡ ge1 +ge ge1 ]))
+                    (sym (·ᵣAssoc _ _ _) ∙∙
+                      cong ((lim x y +ᵣ (-ᵣ rat (fst σ⊔))) ·ᵣ_)
+                       (sym (rat·ᵣrat _ _)
+                         ∙ (cong rat (𝟚.toWitness {Q = ℚ.discreteℚ
+                           ([ 1 / 2 ] ℚ.· 2) 1} tt))) ∙∙
+                      ·IdR _ )
+                   (≤ᵣ-·o _ _ 2 (ℚ.decℚ≤? {0} {2}) (isTrans≤ᵣ _ _ _
+                   limRestr'' (≤ᵣ-·o _ _ [ 1 / 2 ] (ℚ.decℚ≤? {0} {[ 1 / 2 ]})
+                         zz)))
+
+
+           limRestr : rat (fst σ⊔)
+               ≤ᵣ ((lim x y +ᵣ (-ᵣ rat (fst φ* ℚ.+ fst φ*))))
+           limRestr = subst2 _≤ᵣ_
+             (L𝐑.lem--00 {rat (fst σ⊔)} {(rat (fst φ*) +ᵣ rat (fst φ*))})
+               (L𝐑.lem--061
+                 {rat (fst σ⊔)} {rat (fst φ* ℚ.+ fst φ*)} {lim x y} )
+             (≤ᵣ-o+ _ _
+               (rat (fst σ⊔) +ᵣ (-ᵣ (rat (fst φ* ℚ.+ fst φ*))))
+                 limRestr')
+
+           ∣x-limX∣ : (lim x y +ᵣ (-ᵣ rat (fst φ* ℚ.+ fst φ*))) <ᵣ x φ*
+
+           ∣x-limX∣ =
+             let zz = isTrans≤<ᵣ _ _ _ (≤absᵣ _)
+                  (subst (_<ᵣ rat (fst φ* ℚ.+ fst φ*))
+                   (minusComm-absᵣ _ _)
+                   (fst (∼≃abs<ε _ _ (φ* ℚ₊+ φ*))
+                   $ 𝕣-lim-self x y φ* φ*))
+             in subst2 _<ᵣ_ (L𝐑.lem--060 {lim x y} {x φ*}
+                           {rat (fst φ* ℚ.+ fst φ*)})
+                  (L𝐑.lem--05 {rat (fst φ* ℚ.+ fst φ*)} {x φ*})
+                   (<ᵣ-+o _ _ (x φ* +ᵣ (-ᵣ rat (fst φ* ℚ.+ fst φ*))) zz)
+
+
+
+           φ : ℚ₊
+           φ = (invℚ₊ (σ ℚ₊· σ)) ℚ₊·  φ*
+           φ' : ℚ₊
+           φ' = (invℚ₊ (σ' ℚ₊· σ')) ℚ₊·  φ*
+           σ⊔<Xφ* : rat (fst σ⊔) <ᵣ x φ*
+           σ⊔<Xφ* = isTrans≤<ᵣ _ _ _ limRestr ∣x-limX∣
+           σ<Xφ* : rat (fst σ) <ᵣ x φ*
+           σ<Xφ* = isTrans≤<ᵣ _ _ _
+              (≤ℚ→≤ᵣ _ _ (ℚ.≤max (fst σ) (fst σ'))) σ⊔<Xφ*
+           σ'<Xφ* : rat (fst σ') <ᵣ x φ*
+           σ'<Xφ* = isTrans≤<ᵣ _ _ _
+              (≤ℚ→≤ᵣ _ _ (ℚ.≤max' (fst σ) (fst σ'))) σ⊔<Xφ*
+
+           preε'< :  (fst ((invℚ₊ (σ ℚ₊· σ)) ℚ₊·  φ*)
+                                   ℚ.+ fst ((invℚ₊ (σ' ℚ₊· σ')) ℚ₊·  φ*))
+                                    ℚ.≤ fst (/2₊ ε)
+           preε'< = subst2 ℚ._≤_
+             (ℚ.·DistR+ _ _ (fst φ*)) (
+                cong (fst (invℚ₊ (σ ℚ₊· σ) ℚ₊+ invℚ₊ (σ' ℚ₊· σ')) ℚ.·_)
+                   (sym (ℚ.·Assoc _ _ _))
+                 ∙ ℚ.y·[x/y] ((invℚ₊ (σ ℚ₊· σ))
+                                   ℚ₊+ (invℚ₊ (σ' ℚ₊· σ'))) (fst (/2₊ ε)) )
+               (ℚ.≤-o· _ _ (fst ((invℚ₊ (σ ℚ₊· σ))
+                                   ℚ₊+ (invℚ₊ (σ' ℚ₊· σ'))))
+                              (ℚ.0≤ℚ₊ ((invℚ₊ (σ ℚ₊· σ))
+                                   ℚ₊+ (invℚ₊ (σ' ℚ₊· σ'))))
+                             (
+                               (ℚ.min≤ (fst (/2₊ φ*ε)) (fst φ*σ))))
+
+           ε'< : 0< (fst ε ℚ.- (fst ((invℚ₊ (σ ℚ₊· σ)) ℚ₊·  φ*)
+                                   ℚ.+ fst ((invℚ₊ (σ' ℚ₊· σ')) ℚ₊·  φ*)))
+           ε'< = snd (ℚ.<→ℚ₊ (fst ((invℚ₊ (σ ℚ₊· σ)) ℚ₊·  φ*)
+                                   ℚ.+ fst ((invℚ₊ (σ' ℚ₊· σ')) ℚ₊·  φ*))
+                                    (fst ε)
+              (ℚ.isTrans≤< _ _ _ preε'< (x/2<x ε)))
+
+
+           φ= = ℚ₊≡ {φ*} $ sym (ℚ.[y·x]/y (invℚ₊ (σ ℚ₊· σ)) (fst φ*))
+
+           φ'= = ℚ₊≡ {φ*} $ sym (ℚ.[y·x]/y (invℚ₊ (σ' ℚ₊· σ')) (fst φ*))
+
+
+           R' : _
+           R' = invEq (∼≃≡ _ _) (R φ* σ<Xφ* σ'<Xφ* )
+             ((fst ε ℚ.- (fst φ ℚ.+ fst φ')) , ε'<)
+
+
+       in (lim-lim _ _ ε φ φ' _ _ ε'<
+                (((cong ((fst (Invᵣ-restr σ)) ∘ x) (φ=))
+                   subst∼[ refl ] (cong ((fst (Invᵣ-restr σ')) ∘ x)
+                     (φ'=))) R')))
+      (denseℚinℝ (rat (fst σ⊔)) (lim x y) σ⊔<limX)
+   where
+   σ⊔ = ℚ.max₊ σ σ'
+
+   σ⊔<limX : rat (fst σ⊔) <ᵣ lim x y
+   σ⊔<limX = max<-lem (rat (fst σ)) (rat (fst σ'))
+      (lim x y) σ<limX σ'<limX
+
+
+  w .Elimℝ-Prop.isPropA _ = isPropΠ2 λ _ _ → isSetℝ _ _
+
+ f' : ∀ r → Σ ℚ₊ (λ σ → rat (fst σ) <ᵣ r) → ℝ
+ f' r (σ , σ<) = fst (Invᵣ-restr σ) r
+
+ f : ∀ r → ∃[ σ ∈ ℚ₊ ] (rat (fst σ) <ᵣ r) → ℝ
+ f r = PT.rec→Set {B = ℝ} isSetℝ (f' r)
+          λ (σ , σ<r) (σ' , σ'<r) → 2co σ σ' r σ<r σ'<r
+
+
+ ctnF : ∀ u ε u∈ → ∃[ δ ∈ ℚ₊ ]
+                 (∀ v v∈P → u ∼[ δ ] v →
+                  f u (lowerℚBound u u∈) ∼[ ε ] f v (lowerℚBound v v∈P))
+ ctnF u ε u∈ = ctnF' (lowerℚBound u u∈)
+
+  where
+  ctnF' : ∀ uu → ∃[ δ ∈ ℚ₊ ]
+                 (∀ v v∈P → u ∼[ δ ] v →
+                  f u uu ∼[ ε ] f v (lowerℚBound v v∈P))
+  ctnF' = PT.elim (λ _ → squash₁)
+    λ (σ , σ<u) →
+     let zz : ∃[ δ ∈ ℚ₊ ] ((v₁ : ℝ) →  u ∼[ δ ] v₁
+                      → f u ∣ σ , σ<u ∣₁ ∼[ ε ] Invᵣ-restr σ .fst v₁)
+         zz = Lipschitz→IsContinuous (invℚ₊ (σ ℚ₊· σ))
+                 (λ z → Invᵣ-restr σ .fst z)
+                 (snd (Invᵣ-restr σ) ) u ε
+
+         zz' : ∃[ δ ∈ ℚ₊ ] (∀ v v∈ →
+                    u ∼[ δ ] v →
+                  f u ∣ σ , σ<u ∣₁ ∼[ ε ] f v (lowerℚBound v v∈))
+         zz' = PT.rec2 squash₁
+             (uncurry (λ δ R (η , η<u-σ)  →
+               let δ' = ℚ.min₊ δ η
+               in ∣ δ' ,
+                   (λ v v∈ →
+                      PT.elim {P = λ vv → u ∼[ δ' ] v →
+                               f u ∣ σ , σ<u ∣₁ ∼[ ε ] f v vv}
+                          (λ _ → isPropΠ λ _ → isProp∼ _ _ _)
+                          (λ (σ' , σ'<v) u∼v →
+                             let zuz :  (u +ᵣ (-ᵣ v)) <ᵣ rat (fst η)
+                                 zuz = isTrans≤<ᵣ _ _ _ (≤absᵣ (u +ᵣ (-ᵣ v)))
+                                    (isTrans<≤ᵣ _ _ _ (fst (∼≃abs<ε _ _ _) u∼v)
+                                       (≤ℚ→≤ᵣ _ _ (ℚ.min≤' (fst δ) (fst η))))
+
+                                 u-η≤v : u +ᵣ (-ᵣ rat (fst η)) ≤ᵣ v
+                                 u-η≤v = a-b≤c⇒a-c≤b _ _ _
+                                          (<ᵣWeaken≤ᵣ _ _ zuz)
+                                 σ<u-η : rat (fst σ) <ᵣ u +ᵣ (-ᵣ rat (fst η))
+                                 σ<u-η = a<b-c⇒c<b-a _ _ _ η<u-σ
+                                 σ<v : rat (fst σ) <ᵣ v
+                                 σ<v = isTrans<≤ᵣ _ _ _ σ<u-η u-η≤v
+                             in subst (f u ∣ σ , σ<u ∣₁ ∼[ ε ]_)
+                                        (2co σ σ' v σ<v σ'<v)
+                                        (R v
+                                         (∼-monotone≤ (ℚ.min≤ _ _) u∼v)))
+                          ((lowerℚBound v v∈))) ∣₁
+                          ))
+           zz (<ᵣ→Δ _ _ σ<u)
+     in zz'
+
+invℝ' : Σ (∀ r → 0 <ᵣ r → ℝ) (IsContinuousWithPred (λ r → _ , squash₁))
+invℝ' = snd invℝ''
+
+invℝ'-rat : ∀ q p' p →
+             fst invℝ' (rat q) p ≡
+              rat (fst (invℚ₊ (q , p')))
+invℝ'-rat q p' p = PT.elim (λ xx →
+                       isSetℝ ((fst invℝ'') (rat q) xx) _)
+                        (λ x → cong (rat ∘ fst ∘ invℚ₊)
+                        (ww x)) (lowerℚBound (rat q) p)
+
+ where
+ ww : ∀ x → (ℚ.maxWithPos (fst x) q) ≡ (q , p')
+ ww x = ℚ₊≡ (ℚ.≤→max (fst (fst x)) q (ℚ.<Weaken≤ _ _ (<ᵣ→<ℚ _ _ (snd x))))
+
+
+
+invℝ'-pos : ∀ u p →
+             0 <ᵣ fst invℝ' u p
+invℝ'-pos u p = PT.rec squash₁
+  (λ (n , u<n) →
+    PT.rec squash₁
+       (λ (σ , X) →
+         PT.rec squash₁
+           (λ ((q , q'*) , x* , x' , x''*) →
+             let q' : ℚ
+                 q' = ℚ.min q'* [ pos (ℕ₊₁→ℕ n) / 1 ]
+                 x : q' ℚ.- q ℚ.< fst σ
+                 x = ℚ.isTrans≤< _ _ _ (
+                    ℚ.≤-+o q' q'* (ℚ.- q)
+                      (ℚ.min≤ q'* [ pos (ℕ₊₁→ℕ n) / 1 ])) x*
+                 x'' : u <ᵣ rat q'
+                 x'' = <min-lem _ _ _ x''* (isTrans≤<ᵣ _ _ _ (≤absᵣ u) u<n)
+
+
+                 0<q' : 0 <ᵣ rat q'
+                 0<q' = isTrans<ᵣ _ _ _ p x''
+                 z' : rat [ 1 / n ] ≤ᵣ invℝ' .fst (rat q') 0<q'
+                 z' = subst (rat [ 1 / n ] ≤ᵣ_) (sym (invℝ'-rat q'
+                               (ℚ.<→0< q' (<ᵣ→<ℚ _ _ 0<q')) 0<q'))
+                            (≤ℚ→≤ᵣ _ _ (
+                             ℚ.invℚ≤invℚ ([ ℚ.ℕ₊₁→ℤ n / 1 ] , _)
+                               (q' , ℚ.<→0< q' (<ᵣ→<ℚ [ pos 0 / 1 ] q' 0<q'))
+                                ((ℚ.min≤' q'* [ pos (ℕ₊₁→ℕ n) / 1 ]))))
+                 z : ((invℝ' .fst (rat q') 0<q') +ᵣ (-ᵣ rat [ 1 / n ]))
+                       <ᵣ
+                       (invℝ' .fst u p)
+                 z = a-b<c⇒a-c<b _ (invℝ' .fst u p) _
+                      (isTrans≤<ᵣ _ _ _ (≤absᵣ _) (fst (∼≃abs<ε _ _ _)
+                      (sym∼ _ _ _  (X (rat q') 0<q'
+                       (sym∼ _ _ _ (invEq (∼≃abs<ε (rat q') u σ) (
+                          isTrans≤<ᵣ _ _ _
+                            (subst (_≤ᵣ ((rat q') +ᵣ (-ᵣ (rat q))))
+                              (sym (absᵣNonNeg (rat q' +ᵣ (-ᵣ u))
+                                (x≤y→0≤y-x _ _ (<ᵣWeaken≤ᵣ _ _ x''))))
+                              (≤ᵣ-o+ _ _ _ (-ᵣ≤ᵣ _ _ (<ᵣWeaken≤ᵣ _ _ x'))))
+                           (<ℚ→<ᵣ _ _ x))))))))
+
+             in isTrans≤<ᵣ _ _ _ (x≤y→0≤y-x _ _ z') z
+             )
+           (∃rationalApprox u σ))
+      (snd invℝ' u ([ 1 / n ]  , _) p))
+  (getClamps u)
+
+signᵣ : ∀ r → 0 ＃ r → ℝ
+signᵣ _ = ⊎.rec (λ _ → rat 1) (λ _ → rat -1)
+
+0<signᵣ : ∀ r 0＃r → 0 <ᵣ r → 0 <ᵣ signᵣ r 0＃r
+0<signᵣ r (inl x) _ = <ℚ→<ᵣ _ _ ((𝟚.toWitness {Q = ℚ.<Dec 0 1} _))
+0<signᵣ r (inr x) y = ⊥.rec (isAsym<ᵣ _ _ x y)
+
+signᵣ-rat : ∀ r p  → signᵣ (rat r) p ≡ rat (ℚ.sign r)
+signᵣ-rat r (inl x) = cong rat (sym (fst (ℚ.<→sign r) (<ᵣ→<ℚ _ _ x)))
+signᵣ-rat r (inr x) = cong rat (sym (snd (snd (ℚ.<→sign r)) (<ᵣ→<ℚ _ _ x)))
+
+0＃ₚ : ℝ → hProp ℓ-zero
+0＃ₚ r = 0 ＃ r , isProp＃ _ _
+
+-- HoTT Theorem (11.3.47)
+
+IsContinuousWithPredSignᵣ : IsContinuousWithPred 0＃ₚ signᵣ
+IsContinuousWithPredSignᵣ u ε =
+ ⊎.elim
+  (λ 0<u → PT.map (λ (q , 0<q , q<u) →
+             ((q , ℚ.<→0< q (<ᵣ→<ℚ _ _ 0<q))) ,
+              λ v v∈P v∼u →
+                ⊎.elim {C = λ v∈P → signᵣ u (inl 0<u) ∼[ ε ] signᵣ v v∈P}
+                  (λ _ → refl∼ _ _)
+                  (⊥.rec ∘ (isAsym<ᵣ 0 v
+                    (subst2 _<ᵣ_ (+ᵣComm _ _ ∙ +-ᵣ _)
+                        (L𝐑.lem--04 {rat q} {v})
+                         (<ᵣMonotone+ᵣ _ _ _ _ (-ᵣ<ᵣ _ _ q<u)
+                       (a-b<c⇒a<c+b _ _ _ (isTrans≤<ᵣ _ _ _ (≤absᵣ _)
+                          (fst (∼≃abs<ε _ _ _) v∼u))))))) v∈P)
+         (denseℚinℝ 0 u 0<u))
+  (λ u<0 → PT.map (λ (q , u<q , q<0) →
+             (ℚ.- q , ℚ.<→0< (ℚ.- q) (ℚ.minus-< _ _ (<ᵣ→<ℚ _ _ q<0))) ,
+              λ v v∈P v∼u →
+                ⊎.elim {C = λ v∈P → signᵣ u (inr u<0) ∼[ ε ] signᵣ v v∈P}
+                  ((⊥.rec ∘ (isAsym<ᵣ v 0
+                    (subst2 _<ᵣ_  (L𝐑.lem--05 {u} {v})
+                     (+-ᵣ (rat q)) (<ᵣMonotone+ᵣ _ _ _ _
+                       u<q (isTrans≤<ᵣ _ _ _ (≤absᵣ _)
+                          (fst (∼≃abs<ε _ _ _) (sym∼ _ _ _ v∼u))))))))
+                  (λ _ → refl∼ _ _) v∈P)
+             (denseℚinℝ u 0 u<0))
+
+
+
+-ᵣ≡[-1·ᵣ] : ∀ x → -ᵣ x ≡ (-1) ·ᵣ x
+-ᵣ≡[-1·ᵣ] = ≡Continuous _ _
+   IsContinuous-ᵣ
+   (IsContinuous·ᵣL -1)
+   λ r → rat·ᵣrat _ _
+
+
+openPred< : ∀ x → ⟨ openPred (λ y → (x <ᵣ y) , squash₁)  ⟩
+openPred< x y =
+     PT.map (map-snd (λ {q} a<y-x v
+        →   isTrans<ᵣ _ _ _
+                (a<b-c⇒c<b-a (rat (fst q)) y x a<y-x )
+          ∘S a-b<c⇒a-c<b y v (rat (fst q))
+          ∘S isTrans≤<ᵣ _ _ _ (≤absᵣ _)
+          ∘S fst (∼≃abs<ε _ _ _)))
+  ∘S lowerℚBound (y +ᵣ (-ᵣ x))
+  ∘S x<y→0<y-x x y
+
+openPred> : ∀ x → ⟨ openPred (λ y → (y <ᵣ x) , squash₁)  ⟩
+openPred> x y =
+       PT.map (map-snd (λ {q} q<x-y v
+        →     flip (isTrans<ᵣ _ _ _)
+                (a<b-c⇒a+c<b (rat (fst q)) x y q<x-y )
+          ∘S a-b<c⇒a<c+b v y (rat (fst q))
+          ∘S isTrans≤<ᵣ _ _ _ (≤absᵣ _)
+          ∘S fst (∼≃abs<ε _ _ _)
+          ∘S sym∼ _ _ _ ))
+  ∘S lowerℚBound (x +ᵣ (-ᵣ y))
+  ∘S x<y→0<y-x y x
+
+
+isOpenPred0＃ : ⟨ openPred 0＃ₚ ⟩
+isOpenPred0＃ x =
+ ⊎.rec
+   (PT.map (map-snd ((inl ∘_) ∘_)) ∘ openPred< 0 x)
+   (PT.map (map-snd ((inr ∘_) ∘_)) ∘ openPred> 0 x)
+
+
+
+·invℝ' : ∀ r 0<r → (r ·ᵣ fst invℝ' (r) 0<r) ≡ 1
+·invℝ' r =  ∘diag $
+  ≡ContinuousWithPred _ _ (openPred< 0) (openPred< 0)
+   _ _ (cont₂·ᵣWP _ _ _
+          (AsContinuousWithPred _ _ IsContinuousId)
+          (snd invℝ'))
+        (AsContinuousWithPred _ _ (IsContinuousConst 1))
+        (λ r r∈ r∈' → cong (rat r ·ᵣ_) (invℝ'-rat r _ r∈)
+          ∙∙ sym (rat·ᵣrat _ _) ∙∙ cong rat (ℚ.x·invℚ₊[x]
+            (r , ℚ.<→0< _ (<ᵣ→<ℚ _ _ r∈)))) r
+
+
+sign²=1 :  ∀ r 0＃r → (signᵣ r 0＃r) ·ᵣ (signᵣ r 0＃r) ≡ 1
+sign²=1 r = ⊎.elim
+    (λ _ → sym (rat·ᵣrat _ _))
+    (λ _ → sym (rat·ᵣrat _ _))
+
+sign·absᵣ : ∀ r 0＃r → absᵣ r ·ᵣ (signᵣ r 0＃r) ≡ r
+sign·absᵣ r = ∘diag $
+  ≡ContinuousWithPred 0＃ₚ 0＃ₚ isOpenPred0＃ isOpenPred0＃
+      (λ r 0＃r → absᵣ r ·ᵣ (signᵣ r 0＃r))
+       (λ r _ → r)
+        (cont₂·ᵣWP _ _ _
+          (AsContinuousWithPred _ _ IsContinuousAbsᵣ)
+          IsContinuousWithPredSignᵣ)
+        (AsContinuousWithPred _ _ IsContinuousId)
+        (λ r 0＃r 0＃r' → (cong₂ _·ᵣ_ refl (signᵣ-rat r 0＃r)
+          ∙ sym (rat·ᵣrat _ _))
+          ∙ cong rat (cong (ℚ._· ℚ.sign r) (sym (ℚ.abs'≡abs r))
+           ∙ ℚ.sign·abs r) ) r
+
+-- HoTT Theorem (11.3.47)
+
+abstract
+ invℝ : ∀ r → 0 ＃ r → ℝ
+ invℝ r 0＃r = signᵣ r 0＃r ·ᵣ fst invℝ' (absᵣ r) (0＃→0<abs r 0＃r)
+
+
+ invℝimpl : ∀ r 0＃r → invℝ r 0＃r ≡
+             signᵣ r 0＃r ·ᵣ fst invℝ' (absᵣ r) (0＃→0<abs r 0＃r)
+
+ invℝimpl r 0＃r = refl
+
+ invℝ≡ : ∀ r 0＃r 0＃r' →
+            invℝ r 0＃r ≡ invℝ r 0＃r'
+ invℝ≡ r 0＃r 0＃r' = cong (invℝ r) (isProp＃ _ _ _ _)
+
+ IsContinuousWithPredInvℝ : IsContinuousWithPred (λ _ → _ , isProp＃ _ _) invℝ
+ IsContinuousWithPredInvℝ =
+    IsContinuousWP∘ 0＃ₚ 0＃ₚ _ _ (λ r x → x)
+    (cont₂·ᵣWP 0＃ₚ _ _
+        IsContinuousWithPredSignᵣ (IsContinuousWP∘ _ _
+            _ _ 0＃→0<abs (snd invℝ')
+          (AsContinuousWithPred _ _ IsContinuousAbsᵣ)))
+      (AsContinuousWithPred _
+        _ IsContinuousId)
+
+
+ invℝ-rat : ∀ q p p' → invℝ (rat q) p ≡ rat (ℚ.invℚ q p')
+ invℝ-rat q p p' =
+   cong₂ _·ᵣ_ (signᵣ-rat q p) (invℝ'-rat _ _ _) ∙ sym (rat·ᵣrat _ _)
+
+
+ invℝ-pos : ∀ x → (p : 0 <ᵣ x) → 0 <ᵣ invℝ x (inl p)
+ invℝ-pos x p = subst (0 <ᵣ_) (sym (·IdL _))
+     (invℝ'-pos (absᵣ x) (0＃→0<abs x (inl p)))
+
+
+ invℝ-neg : ∀ x → (p : x <ᵣ 0) → invℝ x (inr p) <ᵣ 0
+ invℝ-neg x p =
+      subst (_<ᵣ 0)
+        (-ᵣ≡[-1·ᵣ] _)
+        (-ᵣ<ᵣ 0 _ (invℝ'-pos (absᵣ x) (0＃→0<abs x (inr p))))
+
+ invℝ0＃ : ∀ r 0＃r → 0 ＃ (invℝ r 0＃r)
+ invℝ0＃ r = ⊎.elim (inl ∘ invℝ-pos r)
+                    (inr ∘ invℝ-neg r)
+
+
+
+ invℝInvol : ∀ r 0＃r → invℝ (invℝ r 0＃r) (invℝ0＃ r 0＃r) ≡ r
+ invℝInvol r 0＃r = ≡ContinuousWithPred
+   0＃ₚ 0＃ₚ isOpenPred0＃ isOpenPred0＃
+    (λ r 0＃r → invℝ (invℝ r 0＃r) (invℝ0＃ r 0＃r)) (λ x _ → x)
+     (IsContinuousWP∘ _ _ _ _ invℝ0＃
+       IsContinuousWithPredInvℝ IsContinuousWithPredInvℝ)
+     (AsContinuousWithPred _
+        _ IsContinuousId)
+         (λ r 0＃r 0＃r' →
+           let 0#r = (fst (rat＃ 0 r) 0＃r)
+               0#InvR = ℚ.0#invℚ r 0#r
+           in  cong₂ invℝ (invℝ-rat _ _ _)
+                  (isProp→PathP (λ i → isProp＃ _ _) _ _)
+
+              ∙∙ invℝ-rat ((invℚ r (fst (rat＃ [ pos 0 / 1+ 0 ] r) 0＃r)))
+                    (invEq (rat＃ 0 _) 0#InvR)
+                     (ℚ.0#invℚ r (fst (rat＃ [ pos 0 / 1+ 0 ] r) 0＃r))
+                ∙∙ cong rat (ℚ.invℚInvol r 0#r 0#InvR)
+             )
+    r 0＃r 0＃r
+
+ x·invℝ[x] : ∀ r 0＃r → r ·ᵣ (invℝ r 0＃r) ≡ 1
+ x·invℝ[x] r 0＃r =
+   cong (_·ᵣ (invℝ r 0＃r)) (sym (sign·absᵣ r 0＃r))
+    ∙∙ sym (·ᵣAssoc _ _ _)
+    ∙∙ (cong (absᵣ r ·ᵣ_) (·ᵣAssoc _ _ _
+      ∙ cong (_·ᵣ (fst invℝ' (absᵣ r) (0＃→0<abs r 0＃r)))
+         (sign²=1 r 0＃r) ∙ ·IdL (fst invℝ' (absᵣ r) (0＃→0<abs r 0＃r)))
+    ∙ ·invℝ' (absᵣ r) (0＃→0<abs r 0＃r))
+
+_／ᵣ[_,_] : ℝ → ∀ r → 0 ＃ r  → ℝ
+q ／ᵣ[ r , 0＃r ] = q ·ᵣ (invℝ r 0＃r)
+
+_／ᵣ₊_ : ℝ → ℝ₊  → ℝ
+q ／ᵣ₊ (r , 0<r) = q ／ᵣ[ r , inl (0<r) ]
+
+[x·y]/yᵣ : ∀ q r → (0＃r : 0 ＃ r) →
+               ((q ·ᵣ r) ／ᵣ[ r , 0＃r ]) ≡ q
+[x·y]/yᵣ q r 0＃r =
+      sym (·ᵣAssoc _ _ _)
+   ∙∙ cong (q ·ᵣ_) (x·invℝ[x] r 0＃r)
+   ∙∙ ·IdR q
+
+
+[x/y]·yᵣ : ∀ q r → (0＃r : 0 ＃ r) →
+               (q ／ᵣ[ r , 0＃r ]) ·ᵣ r ≡ q
+[x/y]·yᵣ q r 0＃r =
+      sym (·ᵣAssoc _ _ _)
+   ∙∙ cong (q ·ᵣ_) (·ᵣComm _ _ ∙ x·invℝ[x] r 0＃r)
+   ∙∙ ·IdR q
+
+x/y≡z→x≡z·y : ∀ x q r → (0＃r : 0 ＃ r)
+               → (x ／ᵣ[ r , 0＃r ]) ≡ q
+               → x ≡ q ·ᵣ r
+x/y≡z→x≡z·y x q r 0＃r p =
+    sym ([x/y]·yᵣ _ _ _) ∙ cong (_·ᵣ r) p
+
+x·y≡z→x≡z/y : ∀ x q r → (0＃r : 0 ＃ r)
+               → (x ·ᵣ r) ≡ q
+               → x ≡ q ／ᵣ[ r , 0＃r ]
+x·y≡z→x≡z/y x q r 0＃r p =
+    sym ([x·y]/yᵣ _ _ _) ∙ cong (_／ᵣ[ r , 0＃r ]) p
+
+x·rat[α]+x·rat[β]=x : ∀ x →
+    ∀ {α β : ℚ} → {𝟚.True (ℚ.discreteℚ (α ℚ.+ β) 1)} →
+                   (x ·ᵣ rat α) +ᵣ (x ·ᵣ rat β) ≡ x
+x·rat[α]+x·rat[β]=x x {α} {β} {p} =
+   sym (·DistL+ _ _ _)
+    ∙∙ cong (x ·ᵣ_) (decℚ≡ᵣ? {_} {_} {p})
+    ∙∙ ·IdR _
diff --git a/Cubical/HITs/CauchyReals/Lems.agda b/Cubical/HITs/CauchyReals/Lems.agda
new file mode 100644
index 0000000000..5bf319e904
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/Lems.agda
@@ -0,0 +1,287 @@
+{-# OPTIONS --safe #-}
+module Cubical.HITs.CauchyReals.Lems where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Structure
+
+
+open import Cubical.Data.List
+
+import Cubical.Algebra.CommRing as CR
+
+open import Cubical.Tactics.CommRingSolver
+
+module Lems (R : CR.CommRing ℓ-zero) where
+ open CR.CommRingStr (snd R)
+
+
+ lem-01 : ∀ ε δ η η' a →
+       (ε - (δ + η)) +
+       ((a + δ) + (η' - a))
+      ≡ (ε + η') - η
+ lem-01 ε δ η η' a = solve! R
+
+ lem-02 : ∀ ε δ η η' → (ε - (δ + η)) + (δ + η')
+           ≡ ((ε + η') - η)
+ lem-02 ε δ η η' = solve! R
+
+ lem-03 : ∀ ε η₁ δ η δ* η* →
+            (ε - (δ +  η)) +
+       ((η* + δ) + (η₁ - (δ* +  η*)))
+        ≡ (ε + η₁) - (δ* + η)
+ lem-03 ε η₁ δ η δ* η* = solve! R
+
+ lem-04 : ∀ ε η₁ δ η δ* η* →
+            (ε - (δ +  η)) +
+       ((η* + η) + (η₁ - (δ* +  η*)))
+        ≡ (ε + η₁) - (δ* + δ)
+ lem-04 ε η₁ δ η δ* η* = solve! R
+
+ lem-05 : ∀ x y → x + (y - (x + x)) ≡ y - x
+ lem-05 x y = solve! R
+
+ +AssocCommR : ∀ x y z → (x + y) + z ≡ (x + z) + y
+ +AssocCommR x y z = solve! R
+
+ private
+  variable
+   ε δ q q' a'' 𝕢 r η σ* δ* η₁ η* η'' η' x y x' y' a a' b b' c c' θ L : fst R
+
+ lem--00 : (ε - δ) + δ ≡ ε
+ lem--00 = solve! R
+
+ lem--01 : (- (ε - δ)) + (- δ) ≡ (- ε)
+ lem--01 = solve! R
+
+ lem--02 : ε + q + (ε - q) ≡ ε + ε
+ lem--02 = solve! R
+
+ lem--03 : (- ε) + δ ≡ (- (ε - δ))
+ lem--03 = solve! R
+
+ lem--04 : (- ε) + (ε + q) ≡ q
+ lem--04 = solve! R
+
+ lem--05 : δ + (q - δ) ≡ q
+ lem--05 = solve! R
+
+ lem--06 : (ε - q) + (q - δ) ≡ (ε - δ)
+ lem--06 = solve! R
+
+ lem--07 : ε + (- q') + (- a'') + q' ≡ (ε - a'')
+ lem--07 = solve! R
+
+ lem--08 : δ + (ε - (δ + δ)) ≡ (ε - δ)
+ lem--08 = solve! R
+
+ lem--09 : (q - r) + (𝕢 - q) ≡ (𝕢 - r)
+ lem--09 = solve! R
+
+ lem--010 : (- (q - r)) + (𝕢 - r) ≡ (𝕢 - q)
+ lem--010 = solve! R
+
+ lem--012 : (- (- ε)) + η ≡ ε + η
+ lem--012 = solve! R
+
+ lem--013 : η + (ε - δ) ≡ (ε + η) - δ
+ lem--013 = solve! R
+
+ lem--014 : ((ε - δ) + η) ≡ (ε + η) - δ
+ lem--014 = solve! R
+
+ lem--015 : (ε - δ) + ((σ* + δ) + ((η - σ*) )) ≡ ε + η
+ lem--015 = solve! R
+
+ lem--016 : (η₁ - (δ* + η*)) + (ε - (δ + η)) + (δ + η*) ≡ (ε + η₁) - (δ* + η)
+ lem--016 = solve! R
+
+ lem--017 : (η₁ - (δ* + η*)) + (ε - (δ + η)) + (η + η*) ≡ (ε + η₁) - (δ* + δ)
+ lem--017 = solve! R
+
+ lem--018 : (ε - δ) + (η - δ*) ≡ (ε + η) - (δ* + δ)
+ lem--018 = solve! R
+
+ lem--019 : (ε - δ) + ((η* + δ) + (η - (δ* + η*))) ≡ (ε + η) - δ*
+ lem--019 = solve! R
+
+ lem--020 : (ε - δ) + ((η* + δ) + (η - (δ* + η*))) ≡ (ε + η) - δ*
+ lem--020 = solve! R
+
+ lem--021 : (ε - δ) + (η - δ*) ≡ (ε + η) - (δ* + δ)
+ lem--021 = solve! R
+
+ lem--022 : (ε - δ) + η ≡ (ε + η) - δ
+ lem--022 = solve! R
+
+ lem--023 : (((ε - δ)) + ((δ + δ*) + ((η - δ*)))) ≡ (ε + η)
+ lem--023 = solve! R
+
+ lem--024 : (ε - δ) + (η* - δ*) ≡ (ε + η*) - (δ + δ*)
+ lem--024 = solve! R
+
+ lem--025 : (ε - δ) + ((δ* + δ) + ((η'' - (δ* + η*)))) ≡ (ε + η'') - η*
+ lem--025 = solve! R
+
+ lem--026 : (((ε - δ)) + ((δ + δ*) + ((η' - δ*)))) ≡ (ε + η')
+ lem--026 = solve! R
+
+ lem--027 : (ε - δ) + η' ≡ (ε + η') - δ
+ lem--027 = solve! R
+
+ lem--028 : (ε - δ) + ((δ* + δ) + (η' - (δ* + η*))) ≡ (ε + η') - η*
+ lem--028 = solve! R
+
+ lem--029 : (ε - δ) + (η' - δ*) ≡ (ε + η') - (δ + δ*)
+ lem--029 = solve! R
+
+ lem--030 : (ε - (δ + η)) + ((δ* + δ) + (η' - δ*)) ≡ (ε + η') - η
+ lem--030 = solve! R
+
+ lem--031 : (ε - (δ + η)) + ((δ*  + η) + (η' - δ*)) ≡ (ε + η') - δ
+ lem--031 = solve! R
+
+ lem--032 : (ε - (δ + η)) + ((δ* + δ) + ((η₁ - (δ* + η*)))) ≡ (ε + η₁) - (η + η*)
+ lem--032 = solve! R
+
+ lem--033 : (ε - (δ + η₁)) + ((δ* + η₁) + ((η - (δ* + η*)))) ≡ (ε + η) - (δ + η*)
+ lem--033 = solve! R
+
+ lem--034 : ε ≡ ((ε + δ) - δ)
+ lem--034 = solve! R
+
+ lem--035 : ε ≡ ((ε - δ) + δ)
+ lem--035 = solve! R
+
+ lem--036 : (ε - η) ≡
+             ((ε + δ) - (η +  δ))
+ lem--036 = solve! R
+
+ lem--037 : (ε - η) ≡
+             ((δ + ε) - (δ + η))
+ lem--037 = solve! R
+
+ lem--038 : (ε - η) · (ε + η) ≡
+             (ε · ε) - (η · η)
+ lem--038 = solve! R
+
+ lem--039 : (x' - x) · (y' - y) + (x' · y + x · (y' - y))
+            ≡ x' · y'
+ lem--039 = solve! R
+
+ lem--040 : (x' + x) · (x' - x)
+            ≡ x' · x' - x · x
+ lem--040 = solve! R
+
+ lem--041 : (x' + x) - (y' + y)
+            ≡ (x' - y') + (x - y)
+ lem--041 = solve! R
+
+ lem--042 : (a ·  b' ·  c' + c · ( a' ·  b')) ·  c' ≡
+           (a ·  c' + c ·  a') · ( b' ·  c')
+ lem--042 = solve! R
+
+ lem--043 : (b ·  a' ·  c' + c · ( a' ·  b')) ·  c' ≡
+            (b ·  c' + c ·  b') · ( a' ·  c')
+ lem--043 = solve! R
+
+ lem--044 : (θ +  θ) + ( θ) +
+      ( ε - ( ( θ +  θ) +  ( θ +  θ)))
+      ≡ ( (ε + δ) - ( ( θ) +  δ))
+ lem--044 = solve! R
+
+ lem--045 : (x' + x) + (y' + y)
+            ≡ (x' + y') + (x + y)
+ lem--045 = solve! R
+
+ lem--046 : L · (ε + (- δ)) ≡
+    L · ε + (- (L · δ))
+ lem--046 = solve! R
+
+ lem--047 : L · (ε - (δ + η)) ≡
+    ((L · ε) - ((L · δ) + (L · η)))
+ lem--047 = solve! R
+
+ lem--048 : ((x + (y - x) · a) + (y - x) · a) + (y - x) · a ≡ x + (a + a + a) · (y - x)
+ lem--048 = solve! R
+
+ lem--049 : ((ε · x) · y) + ((η · x) · y) ≡ (((ε + η) · x) · y)
+ lem--049 = solve! R
+
+ lem--050 : (- ε) ≡ (x - (x + ε))
+ lem--050 = solve! R
+
+ lem--051 :  y + ((- y) - ε) ≡ (- ((x + ε) - x))
+ lem--051 = solve! R
+
+ lem--052 : ε + x + (- y - ε) ≡ x - y
+ lem--052 = solve! R
+
+ lem--053 : y + (- (- ε)) - y  ≡ (x + ε) - x
+ lem--053 = solve! R
+
+ lem--054 : (((ε - θ) - η) + (θ + η)) ≡ ε
+ lem--054 = solve! R
+
+ lem--055 : θ + (ε - (θ + θ + θ)) ≡ (ε - (θ + θ))
+ lem--055 = solve! R
+
+ lem--056 : (ε - θ) ≡ (ε - (θ + θ)) + θ
+ lem--056 = solve! R
+
+ lem--057 : (x · y) + ((x · y) + (x · y)) ≡  (x + (x + x)) · y
+ lem--057 = solve! R
+
+ lem--058 : (r · q) + (r · q) ≡
+      ((r + q) · (r + q) + - (r · r + q · q))
+ lem--058 = solve! R
+
+ lem--059 : (x' - q) + (y' + q)
+            ≡ x' + y'
+ lem--059 = solve! R
+
+ lem--060 : (x' - q) + (q - y')
+            ≡ x' - y'
+ lem--060 = solve! R
+
+ lem--061 : (q - y) + (x - q) ≡ (x - y)
+ lem--061 = solve! R
+
+ lem--062 : (q - x) - (q - y) ≡ y - x
+ lem--062 = solve! R
+
+ lem--063 : (ε + δ) - ε ≡ δ
+ lem--063 = solve! R
+
+ lem--064 : (x · (ε · x')) + (y · (ε · y'))
+               ≡ ((x · x') + (y · y')) · ε
+ lem--064 = solve! R
+
+ lem--065 : (x' · y') - (x · y)
+              ≡ y · (x' - x) + x' · (y' - y)
+ lem--065 = solve! R
+
+open import Cubical.Data.Rationals as ℚ
+
+
+
+module _ where
+ open CR.CommRingStr
+
+ ℚCommRing : CR.CommRing ℓ-zero
+ ℚCommRing .fst = ℚ.ℚ
+ ℚCommRing .snd .0r = 0
+ ℚCommRing .snd .1r = 1
+ ℚCommRing .snd .CR.CommRingStr._+_ = ℚ._+_
+ ℚCommRing .snd .CR.CommRingStr._·_ = ℚ._·_
+ ℚCommRing .snd .CR.CommRingStr.-_ = ℚ.-_
+ ℚCommRing .snd .isCommRing = isCommRingℚ
+   where
+   abstract
+     isCommRingℚ : CR.IsCommRing 0 1 ℚ._+_ ℚ._·_ (ℚ.-_)
+     isCommRingℚ = CR.makeIsCommRing
+       ℚ.isSetℚ ℚ.+Assoc ℚ.+IdR
+       ℚ.+InvR ℚ.+Comm ℚ.·Assoc
+       ℚ.·IdR (λ x y z → ℚ.·DistL+ x y z) ℚ.·Comm
+
+
+open Lems ℚCommRing public
diff --git a/Cubical/HITs/CauchyReals/Lipschitz.agda b/Cubical/HITs/CauchyReals/Lipschitz.agda
new file mode 100644
index 0000000000..45592123f6
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/Lipschitz.agda
@@ -0,0 +1,653 @@
+{-# OPTIONS --safe --lossy-unification #-}
+
+module Cubical.HITs.CauchyReals.Lipschitz where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Structure
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.HLevels
+
+open import Cubical.Data.Sum as ⊎
+open import Cubical.Data.Int as ℤ
+open import Cubical.Data.Sigma
+
+open import Cubical.HITs.PropositionalTruncation as PT
+
+open import Cubical.Data.Rationals as ℚ using (ℚ ; [_/_])
+open import Cubical.Data.Rationals.Order as ℚ using
+  ( _ℚ₊+_ ; 0<_ ; ℚ₊ ; _ℚ₊·_ ; ℚ₊≡)
+open import Cubical.Data.Rationals.Order.Properties as ℚ
+ using (invℚ₊;/2₊;/3₊;/4₊ ; /4₊+/4₊≡/2₊ ; ε/2+ε/2≡ε)
+
+open import Cubical.Data.NatPlusOne
+
+open import Cubical.HITs.CauchyReals.Base
+open import Cubical.HITs.CauchyReals.Lems
+open import Cubical.HITs.CauchyReals.Closeness
+
+sΣℚ< : ∀ {u v ε ε'} → fst ε ≡ ε' → (u ∼[ ε ] v) →
+         Σ (0< ε') (λ z → u ∼[ ε' , z ] v)
+sΣℚ< {u} {v} {ε} p x =
+   subst (λ ε' → Σ (0< ε') (λ z → u ∼[ ε' , z ] v)) p (snd ε , x)
+
+sΣℚ<' : ∀ {u v ε ε'} → fst ε ≡ ε' → (u ∼'[ ε ] v) →
+         Σ (0< ε') (λ z → u ∼'[ ε' , z ] v)
+sΣℚ<' {u} {v} {ε} p x =
+   subst (λ ε' → Σ (0< ε') (λ z → u ∼'[ ε' , z ] v)) p (snd ε , x)
+
+
+-- 11.3.36
+𝕣-lim : ∀ r y ε δ p →
+          r ∼[ ε ] ( y δ )
+        → r ∼[ ε ℚ₊+ δ  ] (lim y p )
+𝕣-lim = Elimℝ-Prop.go w
+
+ where
+ w : Elimℝ-Prop _
+ w .Elimℝ-Prop.ratA x y ε δ p x₁ =
+   rat-lim x y (ε ℚ₊+ δ) δ p (subst 0<_ ((lem--034 {fst ε} {fst δ})) (snd ε))
+    (subst∼ (lem--034 {fst ε} {fst δ}) x₁)
+ w .Elimℝ-Prop.limA x p R y ε δ p₁ = PT.rec (isProp∼ _ _ _)
+     (uncurry λ θ → PT.rec (isProp∼ _ _ _) (uncurry $ λ vv →
+        uncurry (lim-lim _ _ _ (/4₊ θ) δ _ _) ∘
+                  (sΣℚ< ((λ i → (fst (/4₊+/4₊≡/2₊ θ (~ i)) ℚ.+ fst (/4₊ θ))
+                             ℚ.+ (fst ε ℚ.-
+                                (sym (ε/2+ε/2≡ε (fst θ))
+                                      ∙ cong₂ ℚ._+_ (cong fst $
+                                          sym (/4₊+/4₊≡/2₊ θ))
+                                         (cong fst $ sym (/4₊+/4₊≡/2₊ θ))) i ))
+                         ∙ lem--044 {fst (/4₊ θ)} {fst ε} {fst δ}) ∘
+                    (triangle∼ (R (/4₊ θ) x (/2₊ θ)
+                      (/4₊ θ) p (refl∼ _ _)))))) ∘ fst (rounded∼ _ _ _)
+
+
+ w .Elimℝ-Prop.isPropA _ = isPropΠ5 λ _ _ _ _ _ → isProp∼ _ _ _
+
+
+-- 11.3.37
+𝕣-lim-self : ∀ x y δ ε → x δ ∼[ δ ℚ₊+ ε ] lim x y
+𝕣-lim-self x y δ ε =
+ subst∼ (sym (ℚ.+Assoc _ _ _) ∙ cong (fst δ ℚ.+_) (ε/2+ε/2≡ε (fst ε))) $ 𝕣-lim (x δ) x (δ ℚ₊+ /2₊ ε) ((/2₊ ε)) y
+  (y δ _)
+
+-- 11.3.36
+𝕣-lim' : ∀ r y ε δ p v →
+          r ∼[ fst ε ℚ.- fst δ , v ] ( y δ )
+        → r ∼[ ε ] (lim y p )
+𝕣-lim' r y ε δ p v₁ x =
+   subst∼ (sym (lem--035 {fst ε} {fst δ}))
+     $ 𝕣-lim r y (fst ε ℚ.- fst δ , v₁) δ p x
+
+
+-- HoTT Lemma (11.3.10)
+lim-surj : ∀ r → ∃[ x ∈ _ ] (r ≡ (uncurry lim x) )
+lim-surj = PT.map (map-snd (eqℝ _ _)) ∘ (Elimℝ-Prop.go w)
+ where
+ w : Elimℝ-Prop _
+ w .Elimℝ-Prop.ratA x = ∣ ((λ _ → rat x) , (λ _ _ → refl∼ _ _)) ,
+   (λ ε → rat-lim x (λ v → rat x) ε
+    (/2₊ ε) (λ v v₁ → refl∼ (rat x) (v ℚ₊+ v₁))
+     (subst 0<_ (lem--034 {fst (/2₊ ε)} {fst (/2₊ ε)} ∙ cong (λ e → e ℚ.- fst (/2₊ ε)) (ε/2+ε/2≡ε (fst ε)) ) (snd (/2₊ ε)))
+
+    (refl∼ (rat x) _)) ∣₁
+
+
+ w .Elimℝ-Prop.limA x p _ = ∣ (x , p) , refl∼ _ ∣₁
+ w .Elimℝ-Prop.isPropA _ = squash₁
+
+
+-- TODO : (Lemma 11.3.11)
+
+-- HoTT-11-3-11 : ∀ {ℓ} (A : Type ℓ) (isSetA : isSet A) →
+--        (f : (Σ[ x ∈  (ℚ₊ → ℝ) ] (∀ ( δ ε : ℚ₊) → x δ ∼[ δ ℚ₊+ ε ] x ε))
+--          → A) →
+--       (∀ u v → uncurry lim u ≡ uncurry lim v → f u ≡ f v)
+--       → ∃![ g ∈ (ℝ → A) ] f ≡ g ∘ uncurry lim
+-- HoTT-11-3-11 A isSetA f p =
+--
+
+Lipschitz-ℚ→ℚ : ℚ₊ → (ℚ → ℚ) → Type
+Lipschitz-ℚ→ℚ L f =
+  (∀ q r → (ε : ℚ₊) →
+    ℚ.abs (q ℚ.- r) ℚ.< (fst ε) → ℚ.abs (f q ℚ.- f r) ℚ.< fst (L ℚ₊· ε  ))
+
+
+Lipschitz-ℚ→ℚ' : ℚ₊ → (ℚ → ℚ) → Type
+Lipschitz-ℚ→ℚ' L f =
+  ∀ q r →
+    ℚ.abs (f q ℚ.- f r) ℚ.≤ fst L ℚ.· ℚ.abs (q ℚ.- r)
+
+Lipschitz-ℚ→ℚ'→Lipschitz-ℚ→ℚ : ∀ L f →
+ Lipschitz-ℚ→ℚ' L f → Lipschitz-ℚ→ℚ L f
+Lipschitz-ℚ→ℚ'→Lipschitz-ℚ→ℚ L f P q r ε <ε =
+  ℚ.isTrans≤< _ _ _ (P q r)
+    (ℚ.<-o· (ℚ.abs (q ℚ.- r)) (fst ε) _ (ℚ.0<ℚ₊ L) <ε)
+
+Lipschitz-ℚ→ℚ-restr : ℚ₊ → ℚ₊ → (ℚ → ℚ) → Type
+Lipschitz-ℚ→ℚ-restr Δ L f =
+  (∀ q r → ℚ.abs q ℚ.< fst Δ → ℚ.abs r ℚ.< fst Δ → (ε : ℚ₊) →
+    ℚ.abs (q ℚ.- r) ℚ.< (fst ε) → ℚ.abs (f q ℚ.- f r) ℚ.< fst (L ℚ₊· ε  ))
+
+Lipschitz-ℚ→ℚ-restr' : ℚ₊ → ℚ₊ → (ℚ → ℚ) → Type
+Lipschitz-ℚ→ℚ-restr' Δ L f =
+  (∀ q r → fst Δ ℚ.< ℚ.abs q → fst Δ  ℚ.< ℚ.abs r → (ε : ℚ₊) →
+    ℚ.abs (q ℚ.- r) ℚ.< (fst ε) → ℚ.abs (f q ℚ.- f r) ℚ.< fst (L ℚ₊· ε  ))
+
+
+Lipschitz-ℚ→ℚ-extend : ∀ Δ L f (δ : ℚ₊) → fst δ ℚ.< fst Δ
+ → Lipschitz-ℚ→ℚ-restr Δ L f
+ → Lipschitz-ℚ→ℚ L (f ∘ ℚ.clamp (ℚ.- (fst Δ ℚ.- fst δ)) (fst Δ ℚ.- fst δ))
+Lipschitz-ℚ→ℚ-extend Δ L f δ δ<Δ x q r ε v =
+ let z : ∀ u → ℚ.abs (ℚ.clamp (ℚ.- (fst Δ ℚ.- fst δ)) (fst Δ ℚ.- fst δ) u)
+                  ℚ.< fst Δ
+     z u = ℚ.absFrom<×< (fst Δ)
+              (ℚ.clamp (ℚ.- (fst Δ ℚ.- fst δ)) (fst Δ ℚ.- fst δ) u)
+               (ℚ.isTrans<≤ (ℚ.- (fst Δ)) (ℚ.- (fst Δ ℚ.- fst δ)) _
+                 (subst2 (ℚ._<_)
+                     (ℚ.+IdR _) (ℚ.+Comm _ _
+                      ∙ (sym $ ℚ.-[x-y]≡y-x (fst Δ) (fst δ)))
+                     ((ℚ.<-o+ 0 (fst δ) (ℚ.- (fst Δ)) (ℚ.0<ℚ₊ δ))))
+                 ((ℚ.≤clamp (ℚ.- (fst Δ ℚ.- fst δ)) (fst Δ ℚ.- fst δ) u
+                    (( ℚ.pos[-x≤x] (ℚ.<→ℚ₊ (fst δ) (fst Δ) δ<Δ))))) )
+               (ℚ.isTrans≤< _ _ _ (ℚ.clamp≤ _ _ _)
+                (ℚ.<-ℚ₊' (fst Δ) (fst Δ) δ (ℚ.isRefl≤ (fst Δ)) ))
+
+ in x (ℚ.clamp (ℚ.- (fst Δ ℚ.- fst δ)) (fst Δ ℚ.- fst δ) q)
+            (ℚ.clamp (ℚ.- (fst Δ ℚ.- fst δ)) (fst Δ ℚ.- fst δ) r)
+            (z q) (z r) ε
+             (ℚ.isTrans≤< _ _ _
+               (ℚ.clampDist (ℚ.- (fst Δ ℚ.- fst δ)) (fst Δ ℚ.- fst δ) r q)
+               v)
+
+
+-- HoTT Definition (11.3.14)
+Lipschitz-ℚ→ℝ : ℚ₊ → (ℚ → ℝ) → Type
+Lipschitz-ℚ→ℝ L f =
+  (∀ q r → (ε : ℚ₊) →
+    (ℚ.- (fst ε)) ℚ.< (q ℚ.- r)
+     → q ℚ.- r ℚ.< (fst ε) → f q ∼[ L ℚ₊· ε  ] f r)
+
+Lipschitz-rat∘ : ∀ l f → Lipschitz-ℚ→ℚ l f → Lipschitz-ℚ→ℝ l (rat ∘ f)
+Lipschitz-rat∘ l f x =
+  λ q r ε x₁ x₂ →
+    rat-rat-fromAbs _ _ _
+       $ x q r ε (ℚ.absFrom<×< (fst ε) (q ℚ.- r) x₁ x₂)
+
+Lipschitz-ℝ→ℝ : ℚ₊ → (ℝ → ℝ) → Type
+Lipschitz-ℝ→ℝ L f =
+  (∀ u v → (ε : ℚ₊) →
+    u ∼[ ε  ] v → f u ∼[ L ℚ₊· ε  ] f v)
+
+isPropLipschitz-ℝ→ℝ : ∀ q f → isProp (Lipschitz-ℝ→ℝ q f)
+isPropLipschitz-ℝ→ℝ q f = isPropΠ4 λ _ _ _ _ → isProp∼ _ _ _
+
+·- : ∀ x y → x ℚ.· (ℚ.- y) ≡ ℚ.- (x ℚ.· y)
+·- x y = ℚ.·Assoc x (-1) y
+         ∙∙ cong (ℚ._· y) (ℚ.·Comm x (-1))
+         ∙∙ sym (ℚ.·Assoc (-1) x y)
+
+
+-- HoTT Lemma (11.3.15)
+fromLipschitz : ∀ L → Σ _ (Lipschitz-ℚ→ℝ L) → Σ _ (Lipschitz-ℝ→ℝ L)
+fromLipschitz L (f , fL) = f' ,
+  λ u v ε x → Elimℝ.go∼ w x
+ where
+
+ rl : _
+ rl q y ε δ p v r v' u' z =
+  𝕣-lim' (f q) (v' ∘ (invℚ₊ L) ℚ₊·_)
+            (L ℚ₊· ε) (L ℚ₊· δ)
+          (λ δ₁ ε₁ →
+          subst (λ q₁ → v' (invℚ₊ L ℚ₊· δ₁) ∼[ q₁ ] v' (invℚ₊ L ℚ₊· ε₁))
+          (ℚ.ℚ₊≡
+           ((λ i →
+               fst L ℚ.· ℚ.·DistL+ (fst (invℚ₊ L)) (fst δ₁) (fst ε₁) (~ i))
+            ∙∙ ℚ.·Assoc (fst L) (fst (invℚ₊ L)) (fst δ₁ ℚ.+ fst ε₁) ∙∙
+            ((λ i → ℚ.x·invℚ₊[x] L i ℚ.· fst (δ₁ ℚ₊+ ε₁)) ∙
+             ℚ.·IdL (fst (δ₁ ℚ₊+ ε₁)))))
+          (u' (invℚ₊ L ℚ₊· δ₁) (invℚ₊ L ℚ₊· ε₁)))
+          (subst {x = fst L ℚ.· (fst ε ℚ.+ (ℚ.- fst δ))}
+                 {fst L ℚ.· fst ε ℚ.+ (ℚ.- fst (L ℚ₊· δ))}
+                0<_ ( lem--046 )
+            (ℚ.·0< (fst L) (fst ε ℚ.- fst δ) (snd L) v) )
+              (subst2 (f q ∼[_]_) (ℚ₊≡ lem--046)
+                 (cong v' (ℚ₊≡ (sym $ ℚ.[y·x]/y L (fst δ)))) z)
+
+ w : Elimℝ (λ _ → ℝ) λ u v ε _ → u ∼[ L ℚ₊· ε  ] v
+ w .Elimℝ.ratA = f
+ w .Elimℝ.limA x p a v = lim (a ∘ (invℚ₊ L) ℚ₊·_)
+   λ δ ε →
+    let v' = v ((invℚ₊ L ℚ₊· δ)) ((invℚ₊ L ℚ₊· ε))
+    in subst (λ q → a (invℚ₊ L ℚ₊· δ) ∼[ q ] a (invℚ₊ L ℚ₊· ε))
+        (ℚ₊≡ (cong ((fst L) ℚ.·_)
+                (sym (ℚ.·DistL+ (fst (invℚ₊ L)) (fst δ) (fst ε)))
+                 ∙∙ ℚ.·Assoc (fst L) (fst (invℚ₊ L))
+                      ((fst δ) ℚ.+ (fst ε)) ∙∙
+                       (cong (ℚ._· fst (δ ℚ₊+ ε))
+                        (ℚ.x·invℚ₊[x] L) ∙ ℚ.·IdL (fst (δ ℚ₊+ ε)))))
+
+          v'
+ w .Elimℝ.eqA p a a' x y =
+   eqℝ a a' λ ε →
+     subst (λ q → a ∼[ q ] a')
+        (ℚ₊≡ $
+          ℚ.·Assoc (fst L) (fst (invℚ₊ L)) (fst ε) ∙
+            (cong (ℚ._· fst (ε))
+                        (ℚ.x·invℚ₊[x] L) ∙ ℚ.·IdL (fst (ε))))
+                        (y (invℚ₊ L ℚ₊· ε))
+ w .Elimℝ.rat-rat-B q r ε x x₁ = fL q r ε x x₁
+ w .Elimℝ.rat-lim-B = rl
+ w .Elimℝ.lim-rat-B x r ε δ p v₁ u v' u' x₁ = sym∼ _ _ _ $
+  rl r x ε δ p v₁ (sym∼ _ _ _ u) v' u' (sym∼ _ _ _ x₁)
+ w .Elimℝ.lim-lim-B x y ε δ η p p' v₁ r v' u' v'' u'' x₁ =
+  let e = lem--047
+  in lim-lim _ _ _ (L ℚ₊· δ) (L ℚ₊· η) _ _
+       (subst (0<_) e
+         $ ℚ.·0< (fst L) (fst ε ℚ.- (fst δ ℚ.+ fst η))
+              (snd L) v₁)
+
+        ((cong v' (ℚ₊≡ $ sym (ℚ.[y·x]/y L (fst δ)))
+          subst∼[ ℚ₊≡ e ]
+           cong v'' (ℚ₊≡ $ sym (ℚ.[y·x]/y L (fst η)))) x₁)
+ w .Elimℝ.isPropB _ _ _ _ = isProp∼ _ _ _
+
+
+
+ f' : ℝ → ℝ
+ f' = Elimℝ.go w
+
+
+∼-monotone< : ∀ {u v ε ε'} → fst ε ℚ.< fst ε' → u ∼[ ε ] v → u ∼[ ε' ] v
+∼-monotone< {u} {v} {ε} {ε'} x x₁ =
+  subst∼ (lem--05 {fst ε} {fst ε'})
+   (triangle∼ x₁ (refl∼ v (ℚ.<→ℚ₊ (fst ε) (fst ε') x)))
+
+∼-monotone≤ : ∀ {u v ε ε'} → fst ε ℚ.≤ fst ε' → u ∼[ ε ] v → u ∼[ ε' ] v
+∼-monotone≤ {u} {v} {ε} {ε'} x x₁ =
+   ⊎.rec (flip subst∼ x₁ )
+         (flip ∼-monotone< x₁ )
+     $ ℚ.≤→<⊎≡ (fst ε) (fst ε') x
+
+
+lipschConstIrrel : ∀ L₁ L₂ (x : ℚ₊ → ℝ) → ∀  p₁ p₂ →
+         lim (λ q → x (L₁ ℚ₊· q)) p₁
+       ≡ lim (λ q → x (L₂ ℚ₊· q)) p₂
+lipschConstIrrel L₁ L₂ =
+   ⊎.rec (w L₁ L₂) (λ x x₁ p₁ p₂ →
+     sym (w L₂ L₁ x x₁ p₂ p₁)) (ℚ.getPosRatio L₁ L₂)
+
+
+ where
+ w : ∀ L₁ L₂ → (fst ((invℚ₊ L₁) ℚ₊·  L₂)) ℚ.≤ [ pos 1 / 1+ 0 ] →
+      (x : ℚ₊ → ℝ)
+      (p₁ : (δ ε : ℚ₊) → x (L₁ ℚ₊· δ) ∼[ δ ℚ₊+ ε ] x (L₁ ℚ₊· ε))
+      (p₂ : (δ ε : ℚ₊) → x (L₂ ℚ₊· δ) ∼[ δ ℚ₊+ ε ] x (L₂ ℚ₊· ε)) →
+      lim (λ q → x (L₁ ℚ₊· q)) p₁ ≡ lim (λ q → x (L₂ ℚ₊· q)) p₂
+ w L₁ L₂ L₂/L₁≤1 x p₁ p₂ = eqℝ _ _ $ λ ε →
+
+    (
+      (uncurry (lim-lim _ _ ε (/4₊ ε) (/4₊ ε) p₁ p₂)
+         (sΣℚ< ((((cong (fst (/4₊ ε) ℚ.+_) (ℚ.·IdL _)) ∙
+                  cong fst (/4₊+/4₊≡/2₊ ε)  ) ∙ lem--034 ∙
+               cong₂ (ℚ._-_)
+                  (ε/2+ε/2≡ε (fst ε)) (cong fst $ sym (/4₊+/4₊≡/2₊ ε) ))) (( refl subst∼[ refl ] cong x
+               (ℚ₊≡ (ℚ.·Assoc _ _ _ ∙
+                cong (ℚ._· (fst (/4₊ ε)))
+                  (ℚ.·Assoc _ _ _ ∙
+                   cong (ℚ._· (fst L₂))
+                     (ℚ.x·invℚ₊[x] L₁) ∙ ℚ.·IdL (fst (L₂))) ))) $
+            (∼-monotone≤ {ε' = (/4₊ ε) ℚ₊+ (1 ℚ₊· (/4₊ ε))}
+               (ℚ.≤-o+ _ (1 ℚ.· (fst (/4₊ ε))) (fst (/4₊ ε))
+                 (ℚ.≤-·o (fst (invℚ₊ L₁ ℚ₊· L₂)) 1 (fst (/4₊ ε))
+                  (ℚ.0≤ℚ₊ (/4₊ ε)) L₂/L₁≤1)
+                   ) $ p₁ (/4₊ ε) ((invℚ₊ L₁ ℚ₊· L₂) ℚ₊· /4₊ ε))))
+                   ) )
+
+
+NonExpandingℚₚ : (ℚ → ℚ) → hProp ℓ-zero
+fst (NonExpandingℚₚ f) = ∀ q r → ℚ.abs (f q ℚ.- f r) ℚ.≤ ℚ.abs (q ℚ.- r)
+snd (NonExpandingℚₚ f) = isPropΠ2 λ _ _ → ℚ.isProp≤ _ _
+
+NonExpandingₚ : (ℝ → ℝ) → hProp ℓ-zero
+fst (NonExpandingₚ f) = ∀ u v ε →  u ∼[ ε ] v → f u ∼[ ε ] f v
+snd (NonExpandingₚ f) = isPropΠ4 λ _ _ _ _ → isProp∼ _ _ _
+
+NonExpandingₚ∘ : ∀ f g → ⟨ NonExpandingₚ f ⟩ → ⟨ NonExpandingₚ g ⟩ →
+                    ⟨ NonExpandingₚ (f ∘ g) ⟩
+NonExpandingₚ∘ _ _ x y _ _ _ = x _ _ _ ∘ (y _ _ _)
+
+
+congLim : ∀ x y x' y' → (∀ q → x q ≡ x' q) → lim x y ≡ lim x' y'
+congLim x y x' y' p =
+  congS (uncurry lim)
+          (Σ≡Prop (λ _ → isPropΠ2 λ _ _ → isProp∼ _ _ _)
+           (funExt p))
+
+
+open ℚ.HLP
+
+congLim' : ∀ x y x' → (p : ∀ q → x q ≡ x' q) →
+ lim x y ≡ lim x' (subst (λ x' → (δ ε : ℚ₊) → x' δ ∼[ δ ℚ₊+ ε ] x' ε)
+                      (funExt p) y)
+congLim' x y x' p =
+   congLim x y x' _ p
+
+-- HoTT Lemma (11.3.40)
+record NonExpanding₂ (g : ℚ → ℚ → ℚ ) : Type where
+ no-eta-equality
+ field
+
+  cL : ∀ q r s →
+       ℚ.abs (g q s ℚ.- g r s) ℚ.≤ ℚ.abs (q ℚ.- r)
+
+  cR : ∀ q r s →
+      (ℚ.abs (g q r ℚ.- g q s) ℚ.≤ ℚ.abs (r ℚ.- s))
+
+
+
+
+ zz : (q : ℚ) → Σ (ℝ → ℝ) (Lipschitz-ℝ→ℝ (1 , tt))
+ zz q = fromLipschitz (1 , tt) (rat ∘ g q ,
+    λ q₁ r₁ ε x₀ x →
+      let zz : ℚ.abs (g q q₁ ℚ.- g q r₁) ℚ.≤ ℚ.abs (q₁ ℚ.- r₁)
+          zz = cR q q₁ r₁
+      in rat-rat-fromAbs _ _ _
+           (ℚ.isTrans≤<
+             (ℚ.abs (g q q₁ ℚ.- g q r₁)) (ℚ.abs (q₁ ℚ.- r₁))
+             _ zz
+               (subst (ℚ.abs (q₁ ℚ.- r₁) ℚ.<_) (sym (ℚ.·IdL (fst ε)))
+                 (ℚ.absFrom<×< (fst ε) (q₁ ℚ.- r₁) x₀ x)))
+
+      )
+
+
+ w : Elimℝ
+       _ λ h h' ε v → ∀ u → (fst h u) ∼[ ε ] fst h' u
+ w .Elimℝ.ratA x .fst = fst (zz x)
+
+ w .Elimℝ.ratA x .snd = λ ε u v →
+    subst (fst (zz x) u ∼[_] fst (zz x) v)
+     (ℚ₊≡ $ ℚ.·IdL (fst ε)) ∘S snd (zz x) u v ε
+ w .Elimℝ.limA x p a x₁ .fst u =
+   lim (λ q → fst (a q) u) λ δ ε → x₁ δ ε u
+ w .Elimℝ.limA x p a x₁ .snd ε u v =
+   PT.rec (isProp∼ _ _ _)
+     (uncurry λ q → PT.rec (isProp∼ _ _ _)
+       λ (xx , xx') →
+        let q/2 = /2₊ q
+            z = snd (a q/2) _ _ _ xx'
+        in lim-lim _ _ _ q/2 q/2 _ _
+             (subst 0<_ ((cong (λ d → fst ε ℚ.- d) (sym $ ε/2+ε/2≡ε (fst q)) ))
+                xx)
+             (subst∼ (cong (λ d → fst ε ℚ.- d) (sym $ ε/2+ε/2≡ε (fst q)) ) z))
+     ∘S fst (rounded∼ _ _ _)
+
+ w .Elimℝ.eqA p a a' x x₁ = Σ≡Prop
+   (λ _ → isPropΠ4 λ _ _ _ _ → isProp∼ _ _ _)
+   (funExt λ rr →
+     eqℝ _ _ λ ε → x₁ ε rr)
+ w .Elimℝ.rat-rat-B q r ε x x₁ u =
+    Elimℝ-Prop.go rr u ε x x₁
+
+  where
+  rr :  Elimℝ-Prop λ u → (ε : ℚ₊) (x : (ℚ.- fst ε) ℚ.< (q ℚ.- r))
+         (x₁ : (q ℚ.- r) ℚ.< fst ε) →
+               fst (zz q) u ∼[ ε ] fst (zz r) u
+  rr .Elimℝ-Prop.ratA qq ε x₁ x₂ =
+    rat-rat-fromAbs _ _ _
+      (ℚ.isTrans≤<
+        (ℚ.abs (g q qq ℚ.- g r qq))
+        (ℚ.abs (q ℚ.- r))
+        _
+        (cL q r qq) (ℚ.absFrom<×< (fst ε) (q ℚ.- r) x₁ x₂))
+
+  rr .Elimℝ-Prop.limA x p x₁ ε x₂ x₃ =
+    let ((θ , θ<) , (x₂' , x₃'))  = ℚ.getθ ε ((q ℚ.- r)) (x₂ , x₃)
+        θ/2 = /2₊ (θ , θ<)
+        zzz : fst (zz q) (x θ/2) ∼[ (fst ε ℚ.- θ) , x₂' ]
+               fst (zz r) (x θ/2)
+        zzz = x₁ θ/2  ((fst ε ℚ.- θ) , x₂') (fst x₃') (snd x₃')
+    in lim-lim _ _ _ θ/2 θ/2
+                _ _ (subst 0<_ (cong (λ θ → fst ε ℚ.- θ)
+                              (sym (ε/2+ε/2≡ε θ))) x₂') (
+                 (subst2 (λ xx yy → fst (zz q) (x xx) ∼[ yy ]
+                     fst (zz r) (x xx))
+                       (ℚ₊≡ $ sym (ℚ.·IdL (fst θ/2)))
+                       (ℚ₊≡ (cong (λ θ → fst ε ℚ.- θ)
+                              (sym (ε/2+ε/2≡ε θ)))) zzz))
+  rr .Elimℝ-Prop.isPropA _ = isPropΠ3 λ _ _ _ → isProp∼ _ _ _
+
+ w .Elimℝ.rat-lim-B _ _ ε δ _ _ _ _ _ x _ =
+       subst∼ (sym $ lem--035 {fst ε} {fst δ}) $ 𝕣-lim _ _ _ _ _ (x _)
+ w .Elimℝ.lim-rat-B _ _ ε δ _ _ _ _ _ x₁ _ =
+   subst∼ (sym $ lem--035 {fst ε} {fst δ})
+    $ sym∼ _ _ _ (𝕣-lim _ _ _ _ _ (sym∼ _ _ _ $ x₁ _))
+ w .Elimℝ.lim-lim-B _ _ _ _ _ _ _ _ _ _ _ _ _ x₁ _ =
+   lim-lim _ _ _ _ _ _ _ _ (x₁ _)
+ w .Elimℝ.isPropB a a' ε _ = isPropΠ λ _ → isProp∼ _ _ _
+
+ preF : ℝ → Σ (ℝ → ℝ) λ h → ∀ ε u v → u ∼[ ε ] v → h u ∼[ ε ] h v
+ preF = Elimℝ.go w
+
+
+ go : ℝ → ℝ → ℝ
+ go x = fst (preF x)
+
+ go∼R : ∀ x u v ε → u ∼[ ε ] v → go x u ∼[ ε ] go x v
+ go∼R x u v ε = snd (preF x) ε u v
+
+ go∼L : ∀ x u v ε → u ∼[ ε ] v → go u x ∼[ ε ] go v x
+ go∼L x u v ε y = Elimℝ.go∼ w {u} {v} {ε} y x
+
+
+ go∼₂ : ∀ δ η {u v u' v'} → u ∼[ δ  ] v → u' ∼[ η ] v'
+             → go u u' ∼[ δ ℚ₊+ η ] go v v'
+ go∼₂ δ η {u} {v} {u'} {v'} x x' =
+   (triangle∼ (go∼L u' u v _ x) (go∼R v u' v' _ x'))
+
+
+ β-rat-lim : ∀ r x y y' → go (rat r) (lim x y) ≡
+                         lim (λ q → go (rat r) (x q))
+                          y'
+ β-rat-lim r x y y' = congLim _ _ _ _
+   λ q → cong (go (rat r) ∘ x)
+     (ℚ₊≡ (ℚ.·IdL (fst q)))
+
+
+ β-rat-lim' : ∀ r x y → Σ _
+            λ y' → (go (rat r) (lim x y) ≡
+                         lim (λ q → go (rat r) (x q)) y')
+ β-rat-lim' r x y = _ , congLim' _ _ _
+   λ q → cong (go (rat r) ∘ x)
+     (ℚ₊≡ (ℚ.·IdL (fst q)))
+
+
+ β-lim-lim/2 : ∀ x y x' y' → Σ _ (λ yy' → go (lim x y) (lim x' y') ≡
+                         lim (λ q → go (x (/2₊ q)) (x' (/2₊ q)))
+                          yy')
+ β-lim-lim/2 x y x' y' =
+   let
+       zz : lim (λ q → fst (Elimℝ.go w (x q)) (lim x' y'))
+              (λ δ ε → Elimℝ.go∼ w (y δ ε) (lim x' y')) ≡
+            lim (λ q → fst (Elimℝ.go w (x (/2₊ q))) (x' (/2₊ q)))
+                   λ δ ε →
+                     subst∼ (lem--045 ∙ cong₂ ℚ._+_ (ε/2+ε/2≡ε (fst δ))
+                              (ε/2+ε/2≡ε (fst ε))) $
+                       triangle∼
+                        (go∼R (x (/2₊ δ))  (x' (/2₊ δ)) (x' (/2₊ ε))
+                         (/2₊ δ ℚ₊+ /2₊ ε)
+                          (y' _ _))
+                         (go∼L (x' (/2₊ ε))
+                          (x (/2₊ δ)) (x (/2₊ ε)) _ (y _ _))
+       zz = eqℝ _ _ (λ ε →
+               let ε/4 = /4₊ ε
+                   v = subst {x = fst ε ℚ.· ℚ.[ 3 / 8 ]} (0 ℚ.<_)
+                       (distℚ! (fst ε)
+                        ·[ ge[ ℚ.[ 3 / 8 ] ] ≡
+                          (ge1 +ge
+                        (neg-ge
+                        ((ge[ ℚ.[ pos 1 / 1+ 3 ] ]
+                          ·ge ge[ ℚ.[ pos 1 / 1+ 1 ] ])
+                           +ge ge[ ℚ.[ pos 1 / 1+ 3 ] ])))
+                           +ge
+                        (neg-ge ((ge[ ℚ.[ pos 1 / 4 ] ]
+                          ·ge ge[ ℚ.[ pos 1 / 2 ] ])
+                               +ge
+                               (ge[ ℚ.[ pos 1 / 4 ] ]
+                          ·ge ge[ ℚ.[ pos 1 / 2 ] ]))) ])
+                        (ℚ.0<ℚ₊ (ε ℚ₊· (ℚ.[ 3 / 8 ] , _)))
+               in (lim-lim _ (λ q' → go (x (/2₊ q')) (x' (/2₊ q'))) ε
+                        (/2₊ ε/4) ε/4 _ _) (subst
+                         {y = fst ε ℚ.- (fst (/2₊ ε/4) ℚ.+ (fst ε/4))} (ℚ.0<_)
+                                   distℚ! (fst ε) ·[ ge[ ℚ.[ pos 5 / 8 ] ]
+                                     ≡ (ge1 +ge
+                        (neg-ge
+                        ((ge[ ℚ.[ pos 1 / 4 ] ]
+                          ·ge ge[ ℚ.[ pos 1 / 2 ] ])
+                           +ge ge[ ℚ.[ pos 1 / 4 ] ]))) ]
+                                    ((snd (ε ℚ₊· (ℚ.[ 5 / 8 ] , _)))))
+                        ((go∼R ( x (/2₊ ε/4)) (lim x' y')
+                          (x' (/2₊ ε/4)) _
+                          ((∼-monotone< {ε = /2₊ ε/4 ℚ₊+ /2₊ ε/4}
+                               {(fst ε ℚ.- ((((fst ε) ℚ.· [ 1 / 4 ])
+                                  ℚ.· ℚ.[ 1 / 2 ]) ℚ.+ fst ε/4))
+                                , _} (((ℚ.-<⁻¹ _ _ v)))
+                                   $ sym∼ _ _ _ (𝕣-lim-self x' y'
+                             (/2₊ ε/4) (/2₊ ε/4)))))))
+   in _ , zz
+
+
+NonExpanding₂-flip : ∀ g → NonExpanding₂ g → NonExpanding₂ (flip g)
+NonExpanding₂-flip g ne .NonExpanding₂.cL q r s =
+   NonExpanding₂.cR ne s q r
+NonExpanding₂-flip g ne .NonExpanding₂.cR q r s =
+   NonExpanding₂.cL ne r s q
+
+
+
+isPropNonExpanding₂ : ∀ g → isProp (NonExpanding₂ g)
+isPropNonExpanding₂ g x y i .NonExpanding₂.cL =
+  isPropΠ3 (λ q r s →
+   ℚ.isProp≤ (ℚ.abs (g q s ℚ.- g r s)) (ℚ.abs (q ℚ.- r)))
+     (λ q r s → x .NonExpanding₂.cL q r s)
+    (λ q r s → y .NonExpanding₂.cL q r s) i
+isPropNonExpanding₂ g x y i .NonExpanding₂.cR =
+   isPropΠ3 (λ q r s →
+   ℚ.isProp≤ (ℚ.abs (g q r ℚ.- g q s)) (ℚ.abs (r ℚ.- s)))
+     (λ q r s → x .NonExpanding₂.cR q r s)
+    (λ q r s → y .NonExpanding₂.cR q r s) i
+
+nonExpanding₂Ext : (g g' : _)
+   → (ne : NonExpanding₂ g) (ne' : NonExpanding₂ g')
+   → (∀ x y → g x y ≡ g' x y)
+   → ∀ x y → NonExpanding₂.go ne x y  ≡ NonExpanding₂.go ne' x y
+nonExpanding₂Ext g g' ne ne' p x y =
+  congS (λ x₁ → NonExpanding₂.go (snd x₁) x y)
+   (Σ≡Prop isPropNonExpanding₂ {_ , ne} {_ , ne'}
+    λ i x₁ x₂ → p x₁ x₂ i)
+
+
+NonExpanding₂-flip-go : ∀ g → (ne : NonExpanding₂ g)
+                              (flip-ne : NonExpanding₂ (flip g)) → ∀ x y →
+     (NonExpanding₂.go {g = flip g} flip-ne x y)
+   ≡ (NonExpanding₂.go {g = g} ne y x)
+NonExpanding₂-flip-go g ne flip-ne = Elimℝ-Prop2.go w
+ where
+ w : Elimℝ-Prop2
+          λ z z₁ → NonExpanding₂.go flip-ne z z₁ ≡ NonExpanding₂.go ne z₁ z
+
+ w .Elimℝ-Prop2.rat-ratA _ _ = refl
+ w .Elimℝ-Prop2.rat-limA r x y x₁ =
+   congLim _ _ _ _
+     λ q → congS (NonExpanding₂.go flip-ne (rat r) ∘S x)
+       ((ℚ₊≡ $ (ℚ.·IdL (fst q)) )) ∙ x₁ q
+
+ w .Elimℝ-Prop2.lim-ratA x y r x₁ =
+    congLim _ _ _ _
+     λ q → x₁ q ∙ congS (NonExpanding₂.go ne (rat r) ∘S x)
+      (ℚ₊≡ $ sym (ℚ.·IdL (fst q)) )
+
+ w .Elimℝ-Prop2.lim-limA x y x' y' x₁ =
+      snd (NonExpanding₂.β-lim-lim/2 flip-ne
+        x y x' y') ∙∙
+         cong (uncurry lim)
+          (Σ≡Prop (λ _ → isPropΠ2 λ _ _ → isProp∼ _ _ _)
+           (funExt λ q → x₁ (/2₊ q) (/2₊ q)))
+         ∙∙
+       sym (snd (NonExpanding₂.β-lim-lim/2 ne
+        x' y' x y))
+ w .Elimℝ-Prop2.isPropA _ _ = isSetℝ _ _
+
+module NonExpanding₂-Lemmas
+        (g : ℚ → ℚ → ℚ)
+        (ne : NonExpanding₂ g) where
+
+ module NE = NonExpanding₂ ne
+
+ module _ (gComm : ∀ x y → NE.go x y ≡ NE.go y x)
+          (gAssoc : ∀ p q r → g p (g q r) ≡ g (g p q) r)  where
+  pp : ∀ ε → fst (/2₊ ε) ≡ (fst ε ℚ.- (fst (/4₊ ε) ℚ.+ fst (/4₊ ε)))
+  pp ε = (distℚ! (fst ε) ·[ ge[ ℚ.[ 1 / 2 ] ]
+            ≡ ge1 +ge (neg-ge (ge[ ℚ.[ 1 / 4 ] ]
+               +ge ge[ ℚ.[ 1 / 4 ] ]))  ])
+
+  gAssoc∼ : ∀ x y z → ∀ ε → NE.go x (NE.go y z) ∼[ ε ] NE.go (NE.go x y) z
+  gAssoc∼ = Elimℝ-Prop.go w
+    where
+    w : Elimℝ-Prop _
+    w .Elimℝ-Prop.ratA q y z ε =
+       subst2 (_∼[ ε ]_)
+         (gComm (NE.go y z) (rat q))
+         (λ i → NE.go (gComm y (rat q) i) z)
+         (hh y z ε)
+     where
+     hh : (y z : ℝ) (ε : ℚ₊) →
+            NE.go (NE.go y z) (rat q) ∼[ ε ] NE.go (NE.go y (rat q)) z
+     hh = Elimℝ-Prop.go w'
+       where
+       w' : Elimℝ-Prop _
+       w' .Elimℝ-Prop.ratA p = Elimℝ-Prop.go w''
+         where
+         w'' : Elimℝ-Prop _
+         w'' .Elimℝ-Prop.ratA r ε = ≡→∼ (
+          gComm _ _ ∙∙ cong rat (gAssoc q p r)
+           ∙∙ λ i → NE.go (gComm (rat q) (rat p) i) (rat r))
+         w'' .Elimℝ-Prop.limA x x' R ε =
+           subst2 (_∼[ ε ]_)
+             (λ i → NE.go (gComm (lim x x')  (rat p)  i) (rat q))
+             (sym (gComm (NE.go (rat p) (rat q)) (lim x x')))
+            (hhh ε)
+          where
+          hhh : ∀ ε → NE.go (NE.go (lim x x') (rat p)) (rat q) ∼[ ε ]
+                 NE.go (lim x x') (NE.go (rat p) (rat q))
+          hhh ε =
+           let zzz = R (/4₊ ε) (/2₊ ε)
+           in uncurry (lim-lim _ _ ε (/4₊ ε)
+               (/4₊ ε) _ _)
+                (sΣℚ< (pp ε)
+                  ( (λ i → NE.go (gComm (rat p) (x (/4₊ ε)) i) (rat q))
+                      subst∼[ refl ] gComm (NE.go (rat p) (rat q))
+                                          (x (/4₊ ε))
+                     $ zzz  ))
+
+         w'' .Elimℝ-Prop.isPropA _ = isPropΠ λ _ → isProp∼ _ _ _
+       w' .Elimℝ-Prop.limA x x' R z ε =
+        uncurry (lim-lim _ _ ε (/4₊ ε)
+        (/4₊ ε) _ _)
+         (sΣℚ< (pp ε) (R (/4₊ ε) z (/2₊ ε) ))
+       w' .Elimℝ-Prop.isPropA _ = isPropΠ2 λ _ _ → isProp∼ _ _ _
+
+    w .Elimℝ-Prop.limA x x' R y z ε =
+     uncurry (lim-lim _ _ ε (/4₊ ε)
+        (/4₊ ε) _ _)
+         (sΣℚ< (pp ε)
+          (R (/4₊ ε) y z (/2₊ ε)))
+    w .Elimℝ-Prop.isPropA _ = isPropΠ3 λ _ _ _ → isProp∼ _ _ _
+
+
+fromLipshitzNEβ : ∀ f (fl : Lipschitz-ℚ→ℝ 1 f) x y →
+  fst (fromLipschitz 1 (f , fl)) (lim x y) ≡
+    lim (λ x₁ → Elimℝ.go _ (x x₁))
+     _
+fromLipshitzNEβ f fl x y = congLim' _ _ _
+ λ q → cong (Elimℝ.go _ ∘ x) (ℚ₊≡ $ ℚ.·IdL _)
diff --git a/Cubical/HITs/CauchyReals/Multiplication.agda b/Cubical/HITs/CauchyReals/Multiplication.agda
new file mode 100644
index 0000000000..d11378d2f6
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/Multiplication.agda
@@ -0,0 +1,705 @@
+{-# OPTIONS --safe --lossy-unification #-}
+
+module Cubical.HITs.CauchyReals.Multiplication where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Structure
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.HLevels
+
+open import Cubical.Data.Bool as 𝟚 hiding (_≤_)
+open import Cubical.Data.Nat as ℕ hiding (_·_;_+_)
+open import Cubical.Data.Unit
+open import Cubical.Data.Int as ℤ using (pos)
+import Cubical.Data.Int.Order as ℤ
+open import Cubical.Data.Sigma
+
+open import Cubical.HITs.PropositionalTruncation as PT
+open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_)
+
+open import Cubical.Data.NatPlusOne
+
+import Cubical.Algebra.CommRing as CR
+
+open import Cubical.Data.Rationals as ℚ using (ℚ ; [_/_])
+open import Cubical.Data.Rationals.Order as ℚ using
+  ( _ℚ₊+_ ; 0<_ ; ℚ₊ ; _ℚ₊·_ ; ℚ₊≡)
+open import Cubical.Data.Rationals.Order.Properties as ℚ
+ using (invℚ₊;/2₊;/3₊;/4₊)
+
+open import Cubical.HITs.CauchyReals.Base
+open import Cubical.HITs.CauchyReals.Lems
+open import Cubical.HITs.CauchyReals.Closeness
+open import Cubical.HITs.CauchyReals.Lipschitz
+open import Cubical.HITs.CauchyReals.Order
+open import Cubical.HITs.CauchyReals.Continuous
+
+-- HoTT (11.3.46)
+sqᵣ' : Σ (ℝ → ℝ) IsContinuous
+sqᵣ'  = (λ r → f r (getClamps r))
+  , λ u ε →
+     PT.elim2 {P = λ gcr _ →
+        ∃[ δ ∈ ℚ₊ ] (∀ v → u ∼[ δ ] v
+            → f u gcr ∼[ ε ] (f v (getClamps v)))}
+       (λ _ _ → squash₁)
+       (λ (1+ n , nL) (1+ n' , n'L) →
+        let L = (2 ℚ₊· fromNat (suc (suc n')))
+            1<L : pos 1 ℤ.<
+               ℚ.ℕ₊₁→ℤ
+                (fst
+                 (ℤ.0<→ℕ₊₁ (2 ℤ.· (pos (suc (suc n'))))
+                  (ℚ.·0< 2 (fromNat (suc (suc n')))
+                   tt tt)))
+            1<L = subst (1 ℤ.<_)
+                   (ℤ.pos·pos 2 (suc (suc n')) ∙ (snd
+                 (ℤ.0<→ℕ₊₁ (2 ℤ.· (pos (suc (suc n'))))
+                  (ℚ.·0< 2 (fromNat (suc (suc n')))
+                   tt tt))) )
+                    (ℤ.suc-≤-suc
+                      (ℤ.suc-≤-suc (ℤ.zero-≤pos
+                        {l = (n' ℕ.+ suc (suc (n' ℕ.+ zero)))} )))
+
+            δ = (invℚ₊ L) ℚ₊· ε
+        in ∣ δ , (λ v →
+              PT.elim {P = λ gcv → u ∼[ δ ] v → f' u (1+ n , nL) ∼[ ε ] f v gcv}
+               (λ _ → isPropΠ λ _ → isProp∼ _ _ _ )
+                 (uncurry (λ (1+ n*) n*L u∼v →
+                     let z = snd (clampedSq (suc n')) u v
+                                   δ u∼v
+                         zz : absᵣ (v +ᵣ (-ᵣ u)) <ᵣ rat (fst ε)
+
+                         zz =
+                           subst2 (_<ᵣ_)
+                             (minusComm-absᵣ u v)
+                              (cong rat (ℚ.·IdL (fst ε)))
+                                 (isTrans<ᵣ _ _ _
+                                  (fst (∼≃abs<ε _ _ _) u∼v)
+                                  (<ℚ→<ᵣ _ _ (ℚ.<-·o _ 1 (fst ε)
+                                   (ℚ.0<ℚ₊ ε)
+                                     (subst (1 ℤ.<_)
+                                       (sym (ℤ.·IdL _))
+                                        1<L ))))
+                         zz* = (sym (absᵣNonNeg (absᵣ u +ᵣ rat (fst ε))
+                                (subst (_≤ᵣ (absᵣ u +ᵣ rat (fst ε)))
+                                 (+IdR 0)
+                                  (≤ᵣMonotone+ᵣ 0 (absᵣ u)
+                                    0 (rat (fst ε))
+                                     (0≤absᵣ u)
+                                      (≤ℚ→≤ᵣ _ _ $ ℚ.0≤ℚ₊ ε)))))
+                         zz' : absᵣ v ≤ᵣ absᵣ (absᵣ u +ᵣ rat (fst ε))
+                         zz' =
+                            subst2 (_≤ᵣ_)
+                              (cong absᵣ (lem--05ᵣ _ _))
+                              zz*
+                              (isTrans≤ᵣ
+                               (absᵣ (u +ᵣ (v +ᵣ (-ᵣ u))))
+                                (absᵣ u +ᵣ absᵣ (v +ᵣ (-ᵣ u)))
+                                _
+                               (absᵣ-triangle u (v +ᵣ (-ᵣ u)))
+                               (≤ᵣ-o+ _ _ (absᵣ u)
+                                 (<ᵣWeaken≤ᵣ _ _ zz)))
+                     in ( 2co (1+ n') (1+ n) u
+                        (isTrans≤<ᵣ (absᵣ u) _ _
+                          (subst2 (_≤ᵣ_)
+                            (+IdR (absᵣ u))
+                            zz*
+                            (≤ᵣMonotone+ᵣ
+                              (absᵣ u) (absᵣ u)
+                               0 (rat (fst ε))
+                               (≤ᵣ-refl (absᵣ u))
+                               ((≤ℚ→≤ᵣ _ _ $ ℚ.0≤ℚ₊ ε)))) n'L) nL
+                         subst∼[ ℚ₊≡ (ℚ.y·[x/y] L (fst ε)) ]
+                         2co (1+ n') (1+ n*) v
+
+                          ((isTrans≤<ᵣ (absᵣ v) _ _
+                            zz' n'L))
+                            n*L)
+                      z))
+                       (getClamps v))   ∣₁)
+       (getClamps u) (getClamps (absᵣ u +ᵣ rat (fst ε)))
+ where
+
+ 2co : ∀ n n' r
+    → (absᵣ r <ᵣ fromNat (ℕ₊₁→ℕ n))
+    → (absᵣ r <ᵣ fromNat (ℕ₊₁→ℕ n'))
+    → fst (clampedSq (ℕ₊₁→ℕ n)) r ≡ fst (clampedSq (ℕ₊₁→ℕ n')) r
+
+ 2co (1+ n) (1+ n') = Elimℝ-Prop.go w
+  where
+  w : Elimℝ-Prop
+        (λ z →
+           absᵣ z <ᵣ fromNat (suc n) →
+           absᵣ z <ᵣ fromNat (suc n') →
+           fst (clampedSq (suc n)) z ≡ fst (clampedSq (suc n')) z)
+  w .Elimℝ-Prop.ratA q n< n<' =
+    let Δ : ℕ → ℚ₊
+        Δ n = ℚ.<→ℚ₊
+             ([ 1 / 4 ])
+             ([ pos (suc (suc (n))) / 1 ])
+
+             ((<Δ (suc (n))))
+        q* : ℕ → ℚ
+        q* n = ℚ.clamp (ℚ.- (fst (Δ n))) (fst (Δ n)) q
+        q₁ = q* n
+        q₂ = q* n'
+
+        -Δ₁≤q : ∀ n → absᵣ (rat q) <ᵣ rat [ pos (suc n) / 1+ 0 ]
+             → ℚ.- (fst (Δ n)) ℚ.≤ q
+        -Δ₁≤q n n< = subst (ℚ.- fst (Δ n) ℚ.≤_) (ℚ.-Invol q)
+         (ℚ.minus-≤ (ℚ.- q) (fst (Δ n))
+           (ℚ.isTrans≤ _ _ _ (
+            subst (ℚ.- q ℚ.≤_) (sym (ℚ.-abs q) ∙
+               ℚ.abs'≡abs q) (ℚ.≤abs (ℚ.- q))) (abs'q≤Δ₁ q n n<)))
+
+        q₁= : ∀ n n< → q* n ≡ q
+        q₁= n n< = ℚ.inClamps (ℚ.- (fst (Δ n))) (fst (Δ n)) q
+           (-Δ₁≤q n n<) (ℚ.isTrans≤ q (ℚ.abs' q) (fst (Δ n))
+                 (subst (q ℚ.≤_) (ℚ.abs'≡abs q)
+                    (ℚ.≤abs q)) (abs'q≤Δ₁ q n n<))
+        z : q₁ ℚ.· q₁
+             ≡ q₂ ℚ.· q₂
+        z = cong₂ ℚ._·_ (q₁= n n<) (q₁= n n<)
+              ∙ sym (cong₂ ℚ._·_ (q₁= n' n<') (q₁= n' n<'))
+    in cong rat z
+  w .Elimℝ-Prop.limA x p R n< n<' = eqℝ _ _
+    λ ε → PT.rec (isProp∼ _ _ _) (ww ε) <n⊓
+
+
+   where
+
+   n⊓ = ℕ.min n n'
+   n⊔ = ℕ.max n n'
+
+   <n⊓ : absᵣ (lim x p) <ᵣ rat [ pos (suc n⊓) / 1+ 0 ]
+   <n⊓ =
+    let z = <min-rr _ _ _ n< n<'
+    in subst (absᵣ (lim x p) <ᵣ_)
+      (cong (rat ∘ [_/ 1+ 0 ]) (
+       cong₂ ℤ.min (cong (1 ℤ.+_) (ℤ.·IdR (pos n))
+         ∙ sym (ℤ.pos+ 1 n)) ((cong (1 ℤ.+_) (ℤ.·IdR (pos n'))
+         ∙ sym (ℤ.pos+ 1 n')))
+        ∙ ℤ.min-pos-pos (suc n) (suc n'))) z
+
+   ww : ∀ ε → absᵣ (lim x p) Σ<ᵣ
+               rat [ pos (suc n⊓) / 1+ 0 ]
+            → fst (clampedSq (suc n)) (lim x p) ∼[ ε ]
+                fst (clampedSq (suc n')) (lim x p)
+   ww ε ((q , q') , lx≤q , q<q' , q'≤n) =
+    lim-lim _ _ ε δ η _ _ 0<ε-[δ+η] ll
+    where
+     Δ = ℚ.<→ℚ₊ q q' q<q'
+     θ = ℚ.min₊ (ℚ./3₊ ε) Δ
+
+     3θ≤ε : (fst θ) ℚ.+ ((fst θ) ℚ.+ (fst θ)) ℚ.≤ fst ε
+     3θ≤ε = subst2 ℚ._≤_
+        (3·x≡x+[x+x] (fst θ))
+         (cong (3 ℚ.·_) (ℚ.·Comm _ _) ∙ ℚ.y·[x/y] 3 (fst ε))
+       (ℚ.≤-o· ((ℚ.min (fst (ℚ./3₊ ε)) (fst Δ)))
+                (fst (ℚ./3₊ ε)) 3 ((ℚ.0≤ℚ₊ 3)) (ℚ.min≤ (fst (ℚ./3₊ ε)) (fst Δ)))
+
+
+     δ = (([ pos (suc (suc n)) / 1+ (suc n⊔) ] , _)
+                                    ℚ₊· θ)
+     η = (([ pos (suc (suc n')) / 1+ (suc n⊔) ] , _)
+                                    ℚ₊· θ)
+     υ = invℚ₊ (2 ℚ₊· fromNat (suc (suc n⊔))) ℚ₊· θ
+
+     ν-δη : ∀ n* → fst (invℚ₊ (2 ℚ₊· fromNat (suc (suc n⊔))) ℚ₊· θ)
+            ≡ fst (invℚ₊ (2 ℚ₊· fromNat (suc (suc n*))) ℚ₊·
+            ((([ pos (suc (suc n*)) / 1+ (suc n⊔) ] , _)
+                                    ℚ₊· θ)))
+     ν-δη n* = cong (ℚ._· fst θ)
+         (cong (fst ∘ invℚ₊)
+              (cong {x = fromNat (suc (suc n⊔)) , _}
+                    {y = fromNat (suc (suc n*)) ℚ₊·
+                         ([ pos (suc (suc n⊔)) / 2+ n* ] , _)}
+               (2 ℚ₊·_) (ℚ₊≡ (sym (m·n/m _ _))) ∙
+            ℚ₊≡ (ℚ.·Assoc 2 _ _))
+          ∙ cong fst (sym (ℚ.invℚ₊Dist· _
+             ([ pos (suc (suc n⊔)) / 1+ (suc n*) ] , _))))
+           ∙ sym (ℚ.·Assoc (fst (invℚ₊ (2 ℚ₊· fromNat (suc (suc n*)))))
+             [ pos (suc (suc n*)) / 1+ (suc n⊔) ] (fst θ))
+
+     0<ε-[δ+η] : 0< (fst ε ℚ.- (fst δ ℚ.+ fst η))
+     0<ε-[δ+η] = snd (ℚ.<→ℚ₊ (fst δ ℚ.+ fst η) (fst ε)
+          (ℚ.isTrans<≤ _ _ _
+             ( let z = ((ℚ.≤Monotone+
+                      (fst δ) (fst θ)
+                      (fst η)  (fst θ)
+                        (subst (fst δ ℚ.≤_) (ℚ.·IdL (fst θ))
+                         (ℚ.≤-·o ([ pos (suc (suc n)) / 1+ (suc n⊔) ]) 1
+                            (fst θ) (ℚ.0≤ℚ₊ θ)
+                              (subst2 ℤ._≤_ (sym (ℤ.·IdR _))
+                               (ℤ.max-pos-pos (suc (suc n)) (suc (suc n'))
+                                  ∙ sym (ℤ.·IdL _))
+                                  (ℤ.≤max {pos (suc (suc n))}
+                                     {pos (suc (suc n'))}))))
+                        (subst (fst η ℚ.≤_) (ℚ.·IdL (fst θ))
+                         ((ℚ.≤-·o ([ pos (suc (suc n')) / 1+ (suc n⊔) ]) 1
+                            (fst θ) (ℚ.0≤ℚ₊ θ)
+                             ((subst2 ℤ._≤_ (sym (ℤ.·IdR _))
+                               (ℤ.maxComm _ _
+                                 ∙ ℤ.max-pos-pos (suc (suc n)) (suc (suc n'))
+                                 ∙ sym (ℤ.·IdL _))
+                                  (ℤ.≤max {pos (suc (suc n'))}
+                                     {pos (suc (suc n))}))))))))
+                   z' = ℚ.<≤Monotone+
+                         0 (fst θ)
+                        (fst δ ℚ.+ (fst η))  (fst θ ℚ.+ (fst θ))
+                        (ℚ.0<ℚ₊ θ) z
+               in subst (ℚ._<
+                     fst θ ℚ.+ (fst θ ℚ.+ fst θ))
+                       (ℚ.+IdL (fst δ ℚ.+ (fst η))) z')
+
+                     3θ≤ε))
+
+     R' :
+       fst (clampedSq (suc n)) (x υ)
+        ∼[ (fst ε ℚ.- (fst δ ℚ.+ fst η)) , 0<ε-[δ+η] ]
+         fst (clampedSq (suc n')) (x υ)
+     R' = invEq (∼≃≡ _ _) (R υ ν<n ν<n') _
+      where
+
+       υ+υ<Δ : fst (υ ℚ₊+ υ) ℚ.< fst Δ
+       υ+υ<Δ = ℚ.isTrans<≤
+        (fst (υ ℚ₊+ υ)) (fst θ) (fst Δ)
+         (subst2 (ℚ._<_)
+          (ℚ.·DistR+
+             (fst (invℚ₊ (2 ℚ₊· fromNat (suc (suc n⊔)))))
+             (fst (invℚ₊ (2 ℚ₊· fromNat (suc (suc n⊔)))))
+             (fst θ))
+             (ℚ.·IdL (fst θ))
+             ((ℚ.<-·o
+               (((fst (invℚ₊ (2 ℚ₊· fromNat (suc (suc n⊔))))))
+                ℚ.+
+                ((fst (invℚ₊ (2 ℚ₊· fromNat (suc (suc n⊔)))))))
+                1 (fst θ)
+              (ℚ.0<ℚ₊ θ)
+               (subst (ℚ._< 1)
+                 (sym (ℚ.ε/2+ε/2≡ε _) ∙ cong (λ x → x ℚ.+ x)
+                   (ℚ.·Comm _ _ ∙ cong fst
+                     (ℚ.invℚ₊Dist· 2 (fromNat (suc (suc n⊔))))))
+                   (1/n<sucK _ _) ))))
+               (ℚ.min≤' (fst (ℚ./3₊ ε)) (fst Δ))
+
+       ν<n⊓ : absᵣ (x υ) <ᵣ (fromNat (suc n⊓))
+       ν<n⊓ = isTrans≤<ᵣ (absᵣ (x υ))
+                 (rat (q ℚ.+ fst (υ ℚ₊+ υ))) ((fromNat (suc n⊓)))
+                 (∼→≤ _ _ lx≤q _ _
+                      (∼→∼' _ _ _ (absᵣ-nonExpanding _ _ _
+                            (sym∼ _ _ _ (𝕣-lim-self x p υ υ)))))
+                    (isTrans<≤ᵣ
+                       (rat (q ℚ.+ fst (υ ℚ₊+ υ)))
+                       (rat q')
+                       (rat [ pos (suc n⊓) / 1+ 0 ])
+                        (subst {x = rat (q ℚ.+ fst Δ) }
+                            (rat (q ℚ.+ fst (υ ℚ₊+ υ)) <ᵣ_)
+                          (cong rat (lem--05 {q} {q'}))
+                           (<ℚ→<ᵣ _ _ (ℚ.<-o+ _ _ q υ+υ<Δ))) q'≤n)
+
+       ν<n : absᵣ (x υ) <ᵣ fromNat (suc n)
+       ν<n = isTrans<≤ᵣ (absᵣ (x υ)) (fromNat (suc n⊓)) (fromNat (suc n))
+                ν<n⊓ (≤ℚ→≤ᵣ _ _
+                  (subst (λ n* → [ n* / 1+ 0 ] ℚ.≤ (fromNat (suc n)))
+                    (ℤ.min-pos-pos (suc n) (suc n'))
+                     (ℚ.≤ℤ→≤ℚ _ _ (ℤ.min≤ {pos (suc n)} {pos (suc n')})) ))
+
+       ν<n' : absᵣ (x υ) <ᵣ fromNat (suc n')
+       ν<n' = isTrans<≤ᵣ (absᵣ (x υ)) (fromNat (suc n⊓)) (fromNat (suc n'))
+                ν<n⊓ (≤ℚ→≤ᵣ _ _
+                  (subst (λ n* → [ n* / 1+ 0 ] ℚ.≤ (fromNat (suc n')))
+                    (ℤ.minComm (pos (suc n')) (pos (suc n))
+                      ∙ ℤ.min-pos-pos (suc n) (suc n'))
+                     (ℚ.≤ℤ→≤ℚ _ _ (ℤ.min≤ {pos (suc n')} {pos (suc n)})) ))
+
+
+     ll : fst (clampedSq (suc n))
+            (x (invℚ₊ (2 ℚ₊· fromNat (suc (suc n))) ℚ₊· δ))
+            ∼[ (fst ε ℚ.- (fst δ ℚ.+ fst η)) , _ ]
+             fst (clampedSq (suc n'))
+            (x (invℚ₊ (2 ℚ₊· fromNat (suc (suc n'))) ℚ₊· η))
+     ll = cong (fst (clampedSq (suc n)) ∘S x) (ℚ₊≡ (ν-δη n))
+             subst∼[ refl ]
+           cong (fst (clampedSq (suc n')) ∘S x) (ℚ₊≡ (ν-δη n')) $ R'
+
+  w .Elimℝ-Prop.isPropA _ = isPropΠ2 λ _ _ → isSetℝ _ _
+
+ f' : ∀ r → _ → ℝ
+ f' r = (λ ((1+ n) , <n) → fst (clampedSq (suc n)) r )
+
+ f : ∀ r → ∃[ n ∈ ℕ₊₁ ] absᵣ r <ᵣ fromNat (ℕ₊₁→ℕ n) → ℝ
+ f r = PT.rec→Set {B = ℝ} isSetℝ
+    (f' r)
+    (λ (n , u) (n' , u') → 2co n n' r u u')
+
+sqᵣ : ℝ → ℝ
+sqᵣ = fst sqᵣ'
+
+/2ᵣ-L : Σ _ _
+/2ᵣ-L = fromLipschitz ([ 1 / 2 ] , _)
+  (_ , Lipschitz-rat∘ ([ 1 / 2 ] , _) (ℚ._· [ 1 / 2 ])
+   λ q r ε x →
+     subst (ℚ._< ([ 1 / 2 ]) ℚ.· (fst ε))
+      (sym (ℚ.pos·abs [ 1 / 2 ] (q ℚ.- r)
+       (𝟚.toWitness {Q = ℚ.≤Dec 0 [ 1 / 2 ]} _ ))
+       ∙ cong ℚ.abs (ℚ.·Comm _ _ ∙ ℚ.·DistR+ q (ℚ.- r) [ 1 / 2 ]
+        ∙ cong ((q ℚ.· [ 1 / 2 ]) ℚ.+_)
+            (sym (ℚ.·Assoc -1 r [ 1 / 2 ]))))
+      (ℚ.<-o· (ℚ.abs (q ℚ.- r)) (fst ε) [ 1 / 2 ]
+       ((𝟚.toWitness {Q = ℚ.<Dec 0 [ 1 / 2 ]} _ )) x))
+
+/2ᵣ = fst /2ᵣ-L
+
+
+infixl 7 _·ᵣ_
+
+_·ᵣ_ : ℝ → ℝ → ℝ
+u ·ᵣ v = /2ᵣ ((sqᵣ (u +ᵣ v)) +ᵣ (-ᵣ (sqᵣ u +ᵣ sqᵣ v)))
+
+
+sqᵣ-rat : ∀ r → sqᵣ (rat r) ≡ rat (r ℚ.· r)
+sqᵣ-rat = ElimProp.go w
+ where
+ w : ElimProp (λ z → sqᵣ (rat z) ≡ rat (z ℚ.· z))
+ w .ElimProp.isPropB _ = isSetℝ _ _
+ w .ElimProp.f x = cong
+       (λ x → rat (x ℚ.· x))
+        (ℚ.inClamps (ℚ.- c) c _
+         -c<x x<c)
+
+    where
+    x' = (_//_.[ x ])
+
+    c : ℚ
+    c = (fst (fromNat (suc (suc (getClampsOnQ x' .fst .ℕ₊₁.n))))
+        ℚ.- _//_.[ 1 , 4 ])
+
+
+    c' = fromNat ((suc (getClampsOnQ x' .fst .ℕ₊₁.n)))
+
+    <c' : ℚ.abs' x' ℚ.< c'
+    <c' = <ᵣ→<ℚ _ _ (snd (getClampsOnQ x'))
+
+    c'≤c : c' ℚ.≤ c
+    c'≤c = subst2 ℚ._≤_
+             (ℚ.+IdR c') (ℚ.+Assoc c' 1 (ℚ.- [ 1 / 4 ])
+               ∙ cong ((ℚ._- [ 1 / 4 ])) (ℚ.+Comm c' 1 ∙
+                ℚ.ℕ+→ℚ+ _ _))
+             (ℚ.≤-o+ 0 (1 ℚ.- [ 1 / 4 ]) c' ℚ.decℚ≤?  )
+
+    <c : ℚ.abs' x' ℚ.≤ c
+    <c = ℚ.isTrans≤ (ℚ.abs' x') c' c
+       (ℚ.<Weaken≤ (ℚ.abs' x') c' <c') c'≤c
+
+
+    -c<x : ℚ.- c ℚ.≤ x'
+    -c<x = subst (ℚ.- c ℚ.≤_) (ℚ.-Invol x') (ℚ.minus-≤ (ℚ.- x') c
+       (ℚ.isTrans≤ (ℚ.- x') (ℚ.abs' x') c (ℚ.-≤abs' x') <c))
+
+
+    x<c :  _//_.[ x ] ℚ.≤ c
+    x<c = ℚ.isTrans≤ x' (ℚ.abs' x') c (ℚ.≤abs' x') <c
+
+
+open ℚ.HLP
+
+
+rat·ᵣrat : ∀ r q → rat (r ℚ.· q) ≡ rat r ·ᵣ rat q
+rat·ᵣrat r q =
+  cong rat (
+     distℚ! (r ℚ.· q) ·[ ge1 ≡ (ge1 +ge ge1) ·ge ge[ [ 1 / 2 ] ] ]
+       ∙ cong (ℚ._· [ 1 / 2 ]) (lem--058 {r} {q})) ∙
+   λ i → /2ᵣ ((sqᵣ-rat (r ℚ.+ q) (~ i))
+    +ᵣ (-ᵣ (sqᵣ-rat r (~ i) +ᵣ sqᵣ-rat q (~ i))))
+
+
+·ᵣComm : ∀ x y → x ·ᵣ y ≡ y ·ᵣ x
+·ᵣComm u v i =
+  /2ᵣ ((sqᵣ (+ᵣComm u v i)) +ᵣ (-ᵣ (+ᵣComm (sqᵣ u) (sqᵣ v) i)))
+
+IsContinuousSqᵣ : IsContinuous sqᵣ
+IsContinuousSqᵣ = snd sqᵣ'
+
+IsContinuous/2ᵣ : IsContinuous /2ᵣ
+IsContinuous/2ᵣ = Lipschitz→IsContinuous _ (fst /2ᵣ-L) (snd /2ᵣ-L)
+
+IsContinuous·ᵣR : ∀ x → IsContinuous (_·ᵣ x)
+IsContinuous·ᵣR x =
+  IsContinuous∘ _
+   (λ u → (sqᵣ (u +ᵣ x)) +ᵣ (-ᵣ ((sqᵣ u) +ᵣ (sqᵣ x))))
+    IsContinuous/2ᵣ
+      (cont₂+ᵣ (λ u → (sqᵣ (u +ᵣ x)))
+        (λ u → (-ᵣ ((sqᵣ u) +ᵣ (sqᵣ x))))
+         (IsContinuous∘ _ _ IsContinuousSqᵣ (IsContinuous+ᵣR x))
+          (IsContinuous∘ _ _ IsContinuous-ᵣ
+             (IsContinuous∘ _ _ (IsContinuous+ᵣR (sqᵣ x)) IsContinuousSqᵣ)))
+
+IsContinuous·ᵣL : ∀ x → IsContinuous (x ·ᵣ_)
+IsContinuous·ᵣL x = subst IsContinuous
+  (funExt λ z → ·ᵣComm z x) (IsContinuous·ᵣR x)
+
+
+
+·ᵣAssoc : ∀ x y z →  x ·ᵣ (y ·ᵣ z) ≡ (x ·ᵣ y) ·ᵣ z
+·ᵣAssoc r r' r'' =
+  ≡Continuous (_·ᵣ (r' ·ᵣ r'')) (λ x → (x ·ᵣ r') ·ᵣ r'')
+     (IsContinuous·ᵣR (r' ·ᵣ r''))
+     (IsContinuous∘ _ _ (IsContinuous·ᵣR r'') (IsContinuous·ᵣR r'))
+      (λ q →
+        ≡Continuous
+          (λ x → (rat q ·ᵣ (x ·ᵣ r'')))
+          (λ x → ((rat q ·ᵣ x) ·ᵣ r''))
+          ((IsContinuous∘ _ _ (IsContinuous·ᵣL (rat q))
+             (IsContinuous·ᵣR r'')))
+          (IsContinuous∘ _ _
+           (IsContinuous·ᵣR r'')
+           (IsContinuous·ᵣL (rat q)))
+          (λ q' →
+            ≡Continuous
+               (λ x → (rat q ·ᵣ (rat q' ·ᵣ x)))
+               (λ x → ((rat q ·ᵣ rat q') ·ᵣ x))
+               (IsContinuous∘ _ _
+                 (IsContinuous·ᵣL (rat q))
+                 (IsContinuous·ᵣL (rat q')))
+               (IsContinuous·ᵣL (rat q ·ᵣ rat q'))
+               (λ q'' →
+                 cong (rat q ·ᵣ_) (sym (rat·ᵣrat q' q''))
+                   ∙∙ sym (rat·ᵣrat q (q' ℚ.· q'')) ∙∙
+                   cong rat (ℚ.·Assoc _ _ _)
+                   ∙∙ rat·ᵣrat (q ℚ.· q') q'' ∙∙
+                   cong (_·ᵣ rat q'') (rat·ᵣrat q q')) r'') r') r
+
+·IdR : ∀ x → x ·ᵣ 1 ≡ x
+·IdR = ≡Continuous _ _ (IsContinuous·ᵣR 1) IsContinuousId
+  (λ r → sym (rat·ᵣrat r 1) ∙ cong rat (ℚ.·IdR r) )
+
+·IdL : ∀ x → 1 ·ᵣ x ≡ x
+·IdL = ≡Continuous _ _ (IsContinuous·ᵣL 1) IsContinuousId
+  (λ r → sym (rat·ᵣrat 1 r) ∙ cong rat (ℚ.·IdL r) )
+
+·DistL+ : (x y z : ℝ) → (x ·ᵣ (y +ᵣ z)) ≡ ((x ·ᵣ y) +ᵣ (x ·ᵣ z))
+·DistL+ x y z =
+  ≡Continuous _ _
+   (IsContinuous·ᵣR (y +ᵣ z))
+   (cont₂+ᵣ _ _ (IsContinuous·ᵣR y) (IsContinuous·ᵣR z))
+   (λ x' →
+     ≡Continuous _ _
+       (IsContinuous∘ _ _ (IsContinuous·ᵣL (rat x')) (IsContinuous+ᵣR z))
+       (IsContinuous∘ _ _
+        (IsContinuous+ᵣR (rat x' ·ᵣ z)) (IsContinuous·ᵣL (rat x')))
+       (λ y' →
+         ≡Continuous _ _
+           (IsContinuous∘ _ _ (IsContinuous·ᵣL (rat x'))
+             (IsContinuous+ᵣL (rat y')))
+           (IsContinuous∘ _ _ (IsContinuous+ᵣL (rat x' ·ᵣ rat y'))
+                (IsContinuous·ᵣL (rat x')) )
+           (λ z' → sym (rat·ᵣrat _ _)
+                  ∙∙ cong rat (ℚ.·DistL+ x' y' z') ∙∙
+                    cong₂ _+ᵣ_ (rat·ᵣrat _ _) (rat·ᵣrat _ _)) z)
+       y)
+   x
+
+
+·DistR+ : (x y z : ℝ) → ((x +ᵣ y) ·ᵣ z) ≡ ((x ·ᵣ z) +ᵣ (y ·ᵣ z))
+·DistR+ x y z = ·ᵣComm _ _ ∙∙ ·DistL+ z x y
+  ∙∙ cong₂ _+ᵣ_ (·ᵣComm _ _) (·ᵣComm _ _)
+
+IsCommRingℝ : CR.IsCommRing 0 1 (_+ᵣ_) (_·ᵣ_) (-ᵣ_)
+IsCommRingℝ = CR.makeIsCommRing
+ isSetℝ
+  +ᵣAssoc +IdR +-ᵣ +ᵣComm ·ᵣAssoc
+   ·IdR ·DistL+ ·ᵣComm
+
+
+
+·ᵣMaxDistrPos : ∀ x y z → 0 ℚ.≤ z →  (maxᵣ x y) ·ᵣ (rat z) ≡ maxᵣ (x ·ᵣ rat z) (y ·ᵣ rat z)
+·ᵣMaxDistrPos x y z 0<z =
+  ≡Continuous _ _
+     (IsContinuous∘ _ _ (IsContinuous·ᵣR (rat z)) (IsContinuousMaxR y))
+     (IsContinuous∘ _ _ (IsContinuousMaxR
+       (y ·ᵣ (rat z))) (IsContinuous·ᵣR (rat z)))
+     (λ x' →
+       ≡Continuous _ _
+         (IsContinuous∘ _ _ (IsContinuous·ᵣR (rat z)) (IsContinuousMaxL (rat x')))
+         ((IsContinuous∘ _ _ (IsContinuousMaxL (rat x' ·ᵣ (rat z)))
+                                (IsContinuous·ᵣR (rat z))))
+         (λ y' → sym (rat·ᵣrat _ _)
+             ∙∙ cong rat (ℚ.·MaxDistrℚ' x' y' z 0<z) ∙∙
+              (cong₂ maxᵣ (rat·ᵣrat x' z) (rat·ᵣrat y' z)))
+         y)
+     x
+
+
+
+𝕣-lim-dist : ∀ x y ε → absᵣ ((x (ℚ./2₊ ε)) +ᵣ (-ᵣ lim x y)) <ᵣ rat (fst ε)
+𝕣-lim-dist x y ε =
+   fst (∼≃abs<ε _ _ ε) $ subst∼ (ℚ.ε/2+ε/2≡ε (fst ε))
+     $ 𝕣-lim-self x y (ℚ./2₊ ε) (ℚ./2₊ ε)
+
+≡ContinuousWithPred : ∀ P P' → ⟨ openPred P ⟩ → ⟨ openPred P' ⟩ → ∀ f g
+  → IsContinuousWithPred P  f
+  → IsContinuousWithPred P' g
+  → (∀ r r∈ r∈' → f (rat r) r∈  ≡ g (rat r) r∈')
+  → ∀ u u∈ u∈' → f u u∈ ≡ g u u∈'
+≡ContinuousWithPred P P' oP oP' f g fC gC e = Elimℝ-Prop.go w
+ where
+ w : Elimℝ-Prop
+       (λ z → (u∈ : ⟨ P z ⟩) (u∈' : ⟨ P' z ⟩) → f z u∈ ≡ g z u∈')
+ w .Elimℝ-Prop.ratA = e
+ w .Elimℝ-Prop.limA x p R x∈ x∈' = PT.rec2 (isSetℝ _ _)
+  (λ (Δ , PΔ) (Δ' , PΔ') → eqℝ _ _ λ ε₀ →
+   let ε = ε₀
+       f' = fC (lim x p) (ℚ./2₊ ε) x∈
+       g' = gC (lim x p) (ℚ./2₊ ε) x∈'
+   in PT.rec2
+       (isProp∼ _ _ _)
+        (λ (θ , θ∼) (η , η∼) →
+         let δ = ℚ./2₊ (ℚ.min₊ (ℚ.min₊ Δ Δ') (ℚ.min₊ θ η))
+             limX∼x = sym∼ _ _ _ (𝕣-lim-self x p δ δ)
+             xδ∈P : ⟨ P (x δ) ⟩
+             xδ∈P = PΔ (x δ)
+                     (∼-monotone≤
+                       (((subst (ℚ._≤ fst Δ)
+                        (sym (ℚ.ε/2+ε/2≡ε
+                          (fst ((ℚ.min₊
+                           (ℚ.min₊ (Δ) (Δ')) (ℚ.min₊ θ η))))))
+                       (ℚ.isTrans≤ _ _ _ ((ℚ.min≤
+                          (fst (ℚ.min₊ (Δ) (Δ'))) (fst (ℚ.min₊ θ η)))
+                           ) (ℚ.min≤ (fst Δ) (fst Δ'))))))
+                       limX∼x)
+             xδ∈P' : ⟨ P' (x δ) ⟩
+             xδ∈P' = PΔ' (x δ)
+                     (∼-monotone≤ ((((subst (ℚ._≤ fst Δ')
+                        (sym (ℚ.ε/2+ε/2≡ε
+                          (fst ((ℚ.min₊
+                           (ℚ.min₊ (Δ) (Δ')) (ℚ.min₊ θ η))))))
+                       (ℚ.isTrans≤ _ _ _ ((ℚ.min≤
+                          (fst (ℚ.min₊ (Δ) (Δ'))) (fst (ℚ.min₊ θ η)))
+                           ) (ℚ.min≤' (fst Δ) (fst Δ'))))))) limX∼x)
+             zF : f (lim x p) x∈ ∼[ ℚ./2₊ ε ] g (x δ) xδ∈P'
+             zF = subst (f (lim x p) x∈ ∼[ ℚ./2₊ ε ]_)
+                  (R _ xδ∈P xδ∈P')
+                 (θ∼ _ _ (∼-monotone≤
+                    ((subst (ℚ._≤ fst θ)
+                        (sym (ℚ.ε/2+ε/2≡ε
+                          (fst ((ℚ.min₊
+                           (ℚ.min₊ (Δ) (Δ')) (ℚ.min₊ θ η))))))
+                       (ℚ.isTrans≤ _ _ _ ((ℚ.min≤'
+                          (fst (ℚ.min₊ (Δ) (Δ'))) (fst (ℚ.min₊ θ η)))
+                           ) (ℚ.min≤ (fst θ) (fst η)))))
+                  (sym∼ _ _ _ ((𝕣-lim-self x p δ δ)))))
+             zG : g (lim x p) x∈'  ∼[ ℚ./2₊ ε ] g (x δ) xδ∈P'
+             zG = η∼ _ _
+                   (∼-monotone≤
+                        ((subst (ℚ._≤ fst η)
+                        (sym (ℚ.ε/2+ε/2≡ε
+                          (fst ((ℚ.min₊
+                           (ℚ.min₊ (Δ) (Δ')) (ℚ.min₊ θ η))))))
+                       (ℚ.isTrans≤ _ _ _ ((ℚ.min≤'
+                          (fst (ℚ.min₊ (Δ) (Δ'))) (fst (ℚ.min₊ θ η)))
+                           ) (ℚ.min≤' (fst θ) (fst η)))))
+
+                  (sym∼ _ _ _ ((𝕣-lim-self x p δ δ))))
+             zz = subst∼ ((ℚ.ε/2+ε/2≡ε (fst ε))) (triangle∼ zF (sym∼ _ _ _ zG))
+         in  zz)
+        f' g') (oP (lim x p) x∈) (oP' (lim x p) x∈')
+
+ w .Elimℝ-Prop.isPropA _ = isPropΠ2 λ _ _ → isSetℝ _ _
+
+
+
+
+cont₂·ᵣ : ∀ f g → (IsContinuous f) → (IsContinuous g)
+  → IsContinuous (λ x → f x ·ᵣ g x)
+cont₂·ᵣ f g fC gC = IsContinuous∘ _
+   (λ u → (sqᵣ (f u +ᵣ g u)) +ᵣ (-ᵣ ((sqᵣ (f u)) +ᵣ (sqᵣ (g u)))))
+    IsContinuous/2ᵣ
+     (cont₂+ᵣ _ _
+       (IsContinuous∘ _ _
+         IsContinuousSqᵣ
+          (cont₂+ᵣ _ _ fC gC))
+       (IsContinuous∘ _ _
+          IsContinuous-ᵣ
+          (cont₂+ᵣ _ _
+            (IsContinuous∘ _ _ IsContinuousSqᵣ fC)
+            ((IsContinuous∘ _ _ IsContinuousSqᵣ gC)))))
+
+⊤Pred : ℝ → hProp ℓ-zero
+⊤Pred = (λ _ → Unit , isPropUnit )
+
+
+IsContinuousWP∘' : ∀ P f g
+   → (IsContinuous f)
+   → (IsContinuousWithPred P g )
+   → IsContinuousWithPred P
+     (λ r x → f (g r x))
+IsContinuousWP∘' P f g fC gC u ε u∈P =
+  PT.rec squash₁
+    (λ (δ , δ∼) →
+      PT.map (map-snd λ x v v∈P →
+          δ∼ (g v v∈P) ∘ (x _ v∈P)) (gC u δ u∈P))
+    ((fC (g u u∈P) ε))
+
+
+
+cont₂·ᵣWP : ∀ P f g
+  → (IsContinuousWithPred P f)
+  → (IsContinuousWithPred P g)
+  → IsContinuousWithPred P (λ x x∈ → f x x∈ ·ᵣ g x x∈)
+cont₂·ᵣWP P f g fC gC = IsContinuousWP∘' P _
+   (λ u x∈ → (sqᵣ (f u x∈ +ᵣ g u x∈)) +ᵣ
+    (-ᵣ ((sqᵣ (f u x∈)) +ᵣ (sqᵣ (g u x∈)))))
+    IsContinuous/2ᵣ
+    (contDiagNE₂WP sumR P _ _
+      ((IsContinuousWP∘' P _ _
+         IsContinuousSqᵣ
+          (contDiagNE₂WP sumR P _ _ fC gC)))
+      ((IsContinuousWP∘' P _ _
+          IsContinuous-ᵣ
+          (contDiagNE₂WP sumR P _ _
+            (IsContinuousWP∘' P _ _ IsContinuousSqᵣ fC)
+            ((IsContinuousWP∘' P _ _ IsContinuousSqᵣ gC))))))
+
+
+·-ᵣ : ∀ x y → x ·ᵣ (-ᵣ y) ≡ -ᵣ (x ·ᵣ y)
+·-ᵣ x =
+  ≡Continuous _ _ (IsContinuous∘ _ _
+       (IsContinuous·ᵣL x) IsContinuous-ᵣ)
+      (IsContinuous∘ _ _ IsContinuous-ᵣ (IsContinuous·ᵣL x))
+       λ y' →
+         ≡Continuous _ _
+             (IsContinuous·ᵣR (-ᵣ (rat y')))
+              ((IsContinuous∘ _ _ IsContinuous-ᵣ (IsContinuous·ᵣR (rat y'))))
+          (λ x' → sym (rat·ᵣrat _ _) ∙∙ cong rat (·- x' y') ∙∙
+              (cong -ᵣ_ (rat·ᵣrat _ _)))
+          x
+
+·DistL- : (x y z : ℝ) → (x ·ᵣ (y -ᵣ z)) ≡ ((x ·ᵣ y) -ᵣ (x ·ᵣ z))
+·DistL- x y z = ·DistL+ x y (-ᵣ z) ∙ cong ((x ·ᵣ y) +ᵣ_) (·-ᵣ _ _)
+
+
+-ᵣ· : ∀ x y →  ((-ᵣ x) ·ᵣ y) ≡  -ᵣ (x ·ᵣ y)
+-ᵣ· x y = ·ᵣComm _ _ ∙∙ ·-ᵣ y x ∙∙ cong -ᵣ_ (·ᵣComm _ _)
+
+
+_^ⁿ_ : ℝ → ℕ → ℝ
+x ^ⁿ zero = 1
+x ^ⁿ suc n = (x ^ⁿ n) ·ᵣ x
+
+
+·absᵣ : ∀ x y → absᵣ (x ·ᵣ y) ≡ absᵣ x ·ᵣ absᵣ y
+·absᵣ x = ≡Continuous _ _
+  ((IsContinuous∘ _ _  IsContinuousAbsᵣ (IsContinuous·ᵣL x)
+                    ))
+  (IsContinuous∘ _ _ (IsContinuous·ᵣL (absᵣ x))
+                    IsContinuousAbsᵣ)
+  λ y' →
+    ≡Continuous _ _
+  ((IsContinuous∘ _ _  IsContinuousAbsᵣ (IsContinuous·ᵣR (rat y'))
+                    ))
+  (IsContinuous∘ _ _ (IsContinuous·ᵣR (absᵣ (rat y')))
+                    IsContinuousAbsᵣ)
+                     (λ x' →
+                       cong absᵣ (sym (rat·ᵣrat _ _)) ∙∙
+                        cong rat (sym (ℚ.abs'·abs' _ _)) ∙∙ rat·ᵣrat _ _) x
diff --git a/Cubical/HITs/CauchyReals/Order.agda b/Cubical/HITs/CauchyReals/Order.agda
new file mode 100644
index 0000000000..bd88e12a10
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/Order.agda
@@ -0,0 +1,469 @@
+{-# OPTIONS --safe --lossy-unification #-}
+
+module Cubical.HITs.CauchyReals.Order where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Structure
+open import Cubical.Foundations.Function
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.HLevels
+
+open import Cubical.Data.Bool as 𝟚 hiding (_≤_)
+open import Cubical.Data.Nat as ℕ hiding (_·_;_+_)
+open import Cubical.Data.Empty as ⊥
+open import Cubical.Data.Sum as ⊎
+open import Cubical.Data.Int as ℤ
+import Cubical.Data.Int.Order as ℤ
+open import Cubical.Data.Sigma
+open import Cubical.Relation.Nullary
+
+open import Cubical.HITs.PropositionalTruncation as PT
+open import Cubical.HITs.SetQuotients as SQ renaming (_/_ to _//_)
+
+
+open import Cubical.Data.Rationals as ℚ using (ℚ ; [_/_])
+open import Cubical.Data.Rationals.Order as ℚ using
+  ( _ℚ₊+_ ; 0<_ ; ℚ₊ ; _ℚ₊·_ ; ℚ₊≡)
+open import Cubical.Data.Rationals.Order.Properties as ℚ
+ using (invℚ₊;/2₊;/3₊;/4₊)
+
+open import Cubical.Data.NatPlusOne
+
+open import Cubical.Data.NatPlusOne
+open import Cubical.Foundations.Path
+open import Cubical.Foundations.CartesianKanOps
+
+
+open import Cubical.HITs.CauchyReals.Base
+open import Cubical.HITs.CauchyReals.Lems
+open import Cubical.HITs.CauchyReals.Closeness
+open import Cubical.HITs.CauchyReals.Lipschitz
+
+
+
+sumR : NonExpanding₂ ℚ._+_
+sumR .NonExpanding₂.cL q r s =
+ ℚ.≡Weaken≤  (ℚ.abs ((q ℚ.+ s) ℚ.- (r ℚ.+ s))) (ℚ.abs (q ℚ.- r))
+  (sym $ cong ℚ.abs (lem--036 {q} {r} {s}))
+sumR .NonExpanding₂.cR q r s =
+   ℚ.≡Weaken≤ (ℚ.abs ((q ℚ.+ r) ℚ.- (q ℚ.+ s))) (ℚ.abs (r ℚ.- s))
+   (sym $ cong ℚ.abs (lem--037 {r} {s} {q}))
+
+infix  8 -ᵣ_
+infixl 6 _+ᵣ_ _-ᵣ_
+
+
+_+ᵣ_ : ℝ → ℝ → ℝ
+_+ᵣ_ = NonExpanding₂.go sumR
+
++ᵣ-∼ : ∀ u v r ε → u ∼[ ε ] v → (u +ᵣ r) ∼[ ε ] (v +ᵣ r)
++ᵣ-∼ u v r =
+  NonExpanding₂.go∼L sumR r u v
+
+minR : NonExpanding₂ ℚ.min
+minR = w
+
+ where
+
+ w' : (q r s : ℚ) → ℚ.abs (ℚ.min q s ℚ.- ℚ.min r s) ℚ.≤ ℚ.abs (q ℚ.- r)
+ w' q r s =
+  let s' = ℚ.min r q
+  in subst (ℚ._≤ (ℚ.abs (q ℚ.- r)))
+     (cong {x = ℚ.min (ℚ.max s' q) s ℚ.-
+                   ℚ.min (ℚ.max s' r) s}
+           {y = ℚ.min q s ℚ.- ℚ.min r s}
+            ℚ.abs
+       (cong₂ (λ q' r' → ℚ.min q' s ℚ.-
+                   ℚ.min r' s)
+                 (ℚ.maxComm s' q ∙∙
+                   cong (ℚ.max q) (ℚ.minComm r q)
+                  ∙∙ ℚ.maxAbsorbLMin q r )
+             ((ℚ.maxComm s' r ∙ ℚ.maxAbsorbLMin r q )
+               ))) (ℚ.clampDist s' s r q)
+
+
+ w : NonExpanding₂ ℚ.min
+ w .NonExpanding₂.cL = w'
+ w .NonExpanding₂.cR q r s =
+   subst2 (λ u v → ℚ.abs (u ℚ.- v) ℚ.≤ ℚ.abs (r ℚ.- s))
+        (ℚ.minComm r q) (ℚ.minComm s q) (w' r s q)
+
+
+
+maxR : NonExpanding₂ ℚ.max
+maxR = w
+ where
+
+ h : ∀ q r s →  ℚ.min (ℚ.max s q) (ℚ.max s (ℚ.max r q)) ≡ ℚ.max q s
+ h q r s = cong (ℚ.min (ℚ.max s q)) (cong (ℚ.max s) (ℚ.maxComm r q)
+             ∙ ℚ.maxAssoc s q r) ∙
+      ℚ.minAbsorbLMax (ℚ.max s q) r ∙ ℚ.maxComm s q
+
+ w' : (q r s : ℚ) → ℚ.abs (ℚ.max q s ℚ.- ℚ.max r s) ℚ.≤ ℚ.abs (q ℚ.- r)
+ w' q r s =
+  let s' = ℚ.max s (ℚ.max r q)
+  in subst (ℚ._≤ (ℚ.abs (q ℚ.- r)))
+       ( cong {x = ℚ.min (ℚ.max s q) s' ℚ.-
+                   ℚ.min (ℚ.max s r) s'}
+           {y = ℚ.max q s ℚ.- ℚ.max r s}
+            ℚ.abs
+            (cong₂ ℚ._-_
+              (h q r s)
+              (cong (ℚ.min (ℚ.max s r))
+                 (cong (ℚ.max s) (ℚ.maxComm r q))
+                ∙ h r q s)) )
+       (ℚ.clampDist s s' r q )
+
+ w : NonExpanding₂ ℚ.max
+ w .NonExpanding₂.cL = w'
+ w .NonExpanding₂.cR q r s =
+   subst2 (λ u v → ℚ.abs (u ℚ.- v) ℚ.≤ ℚ.abs (r ℚ.- s))
+        (ℚ.maxComm r q) (ℚ.maxComm s q)
+         (w' r s q)
+
+minᵣ = NonExpanding₂.go minR
+maxᵣ = NonExpanding₂.go maxR
+
+_≤ᵣ_ : ℝ → ℝ → Type
+u ≤ᵣ v = maxᵣ u v ≡ v
+
+Lipschitz-ℝ→ℝ-1→NonExpanding : ∀ f
+  → Lipschitz-ℝ→ℝ 1 f → ⟨ NonExpandingₚ f ⟩
+Lipschitz-ℝ→ℝ-1→NonExpanding f x _ _ _ =
+  subst∼ (ℚ.·IdL _) ∘S x _ _ _
+
+
+maxᵣComm : ∀ x y → NonExpanding₂.go maxR x y ≡ NonExpanding₂.go maxR y x
+maxᵣComm x y =
+  nonExpanding₂Ext ℚ.max (flip ℚ.max)
+    maxR (NonExpanding₂-flip ℚ.max maxR) ℚ.maxComm x y ∙
+   (NonExpanding₂-flip-go ℚ.max maxR
+     (NonExpanding₂-flip ℚ.max maxR) x y )
+
+minᵣComm : ∀ x y → NonExpanding₂.go minR x y ≡ NonExpanding₂.go minR y x
+minᵣComm x y =
+  nonExpanding₂Ext ℚ.min (flip ℚ.min)
+    minR (NonExpanding₂-flip ℚ.min minR) ℚ.minComm x y ∙
+   (NonExpanding₂-flip-go ℚ.min minR
+     (NonExpanding₂-flip ℚ.min minR) x y )
+
+
++ᵣComm : ∀ x y → NonExpanding₂.go sumR x y ≡ NonExpanding₂.go sumR y x
++ᵣComm x y =
+  nonExpanding₂Ext ℚ._+_ (flip ℚ._+_)
+    sumR (NonExpanding₂-flip ℚ._+_ sumR) ℚ.+Comm x y ∙
+   (NonExpanding₂-flip-go ℚ._+_ sumR
+     (NonExpanding₂-flip ℚ._+_ sumR) x y )
+
+
+
+inj-rat : ∀ q r → rat q ≡ rat r → q ≡ r
+inj-rat q r x with (ℚ.discreteℚ q r)
+... | yes p = p
+... | no ¬p =
+  let (zz , zz') = ∼→∼' (rat q) (rat r) _
+           $ invEq (∼≃≡ (rat q) (rat r)) x (ℚ.abs (q ℚ.- r) ,
+               ℚ.≠→0<abs q r ¬p)
+  in ⊥.rec (ℚ.isIrrefl< (ℚ.abs (q ℚ.- r))
+        (ℚ.absFrom<×< (ℚ.abs (q ℚ.- r)) (q ℚ.- r)
+          zz zz'))
+
+≤ℚ→≤ᵣ : ∀ q r → q ℚ.≤ r → rat q ≤ᵣ rat r
+≤ℚ→≤ᵣ q r x = cong rat (ℚ.≤→max q r x)
+
+≤ᵣ→≤ℚ : ∀ q r → rat q ≤ᵣ rat r → q ℚ.≤ r
+≤ᵣ→≤ℚ q r x = subst (q ℚ.≤_) (inj-rat _ _ x) (ℚ.≤max q r)
+
+
+≤ᵣ≃≤ℚ : ∀ q r → (rat q ≤ᵣ rat r) ≃ (q ℚ.≤ r)
+≤ᵣ≃≤ℚ q r = propBiimpl→Equiv
+ (isSetℝ _ _) (ℚ.isProp≤ _ _)
+  (≤ᵣ→≤ℚ q r) (≤ℚ→≤ᵣ q r)
+
+
+
+maxᵣIdem : ∀ x → maxᵣ x x ≡ x
+maxᵣIdem = Elimℝ-Prop.go w
+ where
+ w : Elimℝ-Prop (λ z → maxᵣ z z ≡ z)
+ w .Elimℝ-Prop.ratA = cong rat ∘ ℚ.maxIdem
+ w .Elimℝ-Prop.limA x p x₁ =
+   snd (NonExpanding₂.β-lim-lim/2 maxR x p x p)
+    ∙ eqℝ _ _
+       λ ε → lim-lim _ _ _ (/2₊ ε)
+                 (/2₊ (/2₊ ε)) _ _
+                   (subst ℚ.0<_ (cong₂ ℚ._-_
+                            (ℚ.·IdR (fst ε))
+                            (cong (fst ε ℚ.·_) ℚ.decℚ? ∙∙
+                               ℚ.·DistL+ (fst ε) _ _  ∙∙
+                                cong ((fst (/2₊ ε) ℚ.+_))
+                                  (ℚ.·Assoc (fst ε) ℚ.[ 1 / 2 ]
+                                     ℚ.[ 1 / 2 ])))
+                     (snd (ℚ.<→ℚ₊ ((fst ε) ℚ.· (ℚ.[ 3 / 4 ]))
+                         (fst ε ℚ.· 1)
+                       (ℚ.<-o· _ _ (fst ε)
+                         (ℚ.0<ℚ₊ ε) ℚ.decℚ<?))))
+                  (invEq (∼≃≡  _ _ ) (x₁ (/2₊ (/2₊ ε))) _)
+
+ w .Elimℝ-Prop.isPropA _ = isSetℝ _ _
+
+
+
+≤ᵣ-refl : ∀ x → x ≤ᵣ x
+≤ᵣ-refl x = maxᵣIdem x
+
+
+_Σ<ᵣ_ : ℝ → ℝ → Type
+u Σ<ᵣ v = Σ[ (q , r) ∈ (ℚ × ℚ) ] (u ≤ᵣ rat q) × (q ℚ.< r) × (rat r ≤ᵣ v)
+
+infix 4 _≤ᵣ_ _<ᵣ_
+
+_<ᵣ_ : ℝ → ℝ → Type
+u <ᵣ v = ∃[ (q , r) ∈ (ℚ × ℚ) ] (u ≤ᵣ rat q) × (q ℚ.< r) × (rat r ≤ᵣ v)
+
+
+isProp≤ᵣ : ∀ x y → isProp (x ≤ᵣ y)
+isProp≤ᵣ _ _ = isSetℝ _ _
+
+
+<ℚ→<ᵣ : ∀ q r → q ℚ.< r → rat q <ᵣ rat r
+<ℚ→<ᵣ x y x<y =
+  let y-x : ℚ₊
+      y-x = ℚ.<→ℚ₊ x y x<y
+
+      x' = x ℚ.+ fst (/3₊ (y-x))
+      y' = x' ℚ.+ fst (/3₊ (y-x))
+  in ∣ (x' , y') ,
+          ≤ℚ→≤ᵣ x x' (
+             subst (ℚ._≤ x') (ℚ.+IdR x)
+                   (ℚ.≤-o+ 0 (fst (/3₊ (y-x))) x
+                    (ℚ.0≤ℚ₊ (/3₊ (y-x)))) )
+        , subst (ℚ._< y') (ℚ.+IdR x')
+                   (ℚ.<-o+ 0 (fst (/3₊ (y-x))) x'
+                    (ℚ.0<ℚ₊ (/3₊ (y-x))))
+        , ≤ℚ→≤ᵣ y' y
+            (subst2 (ℚ._≤_) (ℚ.+IdR y')
+               (lem--048 {x} {y} {ℚ.[ 1 / 3 ]}
+                 ∙∙
+                  cong {x = ℚ.[ 1 / 3 ] ℚ.+ ℚ.[ 1 / 3 ] ℚ.+ ℚ.[ 1 / 3 ]}
+                    {1} (λ a → x ℚ.+ a ℚ.· (y ℚ.- x))
+                   ℚ.decℚ?
+                  ∙∙ (cong (x ℚ.+_) (ℚ.·IdL (y ℚ.- x))
+                      ∙ lem--05))
+              ((ℚ.≤-o+ 0 (fst (/3₊ (y-x))) y'
+                    (ℚ.0≤ℚ₊ (/3₊ (y-x))))))  ∣₁
+
+<ᵣ→<ℚ : ∀ q r → rat q <ᵣ rat r → q ℚ.< r
+<ᵣ→<ℚ = ElimProp2.go w
+ where
+ w : ElimProp2 (λ z z₁ → rat z <ᵣ rat z₁ → z ℚ.< z₁)
+ w .ElimProp2.isPropB _ _ = isProp→ (ℚ.isProp< _ _)
+ w .ElimProp2.f x y =
+  PT.rec (ℚ.isProp< _ _)
+   λ ((x' , y') , a , b , c) →
+     ℚ.isTrans<≤ _//_.[ x ] y' _//_.[ y ]
+      (ℚ.isTrans≤< _//_.[ x ] x' y' (≤ᵣ→≤ℚ _ _ a) b)
+        (≤ᵣ→≤ℚ _ _ c)
+
+<ᵣ≃<ℚ : ∀ q r → (rat q <ᵣ rat r) ≃ (q ℚ.< r)
+<ᵣ≃<ℚ q r = propBiimpl→Equiv
+ squash₁ (ℚ.isProp< _ _)
+  (<ᵣ→<ℚ q r) (<ℚ→<ᵣ q r)
+
+maxᵣAssoc : ∀ x y z → maxᵣ x (maxᵣ y z) ≡ maxᵣ (maxᵣ x y) z
+maxᵣAssoc x y z =
+  (fst (∼≃≡ _ _)) (NonExpanding₂-Lemmas.gAssoc∼ _
+    maxR maxᵣComm ℚ.maxAssoc x y z)
+
+minᵣAssoc : ∀ x y z → minᵣ x (minᵣ y z) ≡ minᵣ (minᵣ x y) z
+minᵣAssoc x y z =
+  (fst (∼≃≡ _ _)) (NonExpanding₂-Lemmas.gAssoc∼ _
+    minR minᵣComm ℚ.minAssoc x y z)
+
+
++ᵣAssoc : ∀ x y z →  x +ᵣ (y +ᵣ z) ≡ (x +ᵣ y) +ᵣ z
++ᵣAssoc x y z =
+  (fst (∼≃≡ _ _)) (NonExpanding₂-Lemmas.gAssoc∼ _
+    sumR +ᵣComm ℚ.+Assoc x y z)
+
+isTrans≤ᵣ : ∀ x y z → x ≤ᵣ y → y ≤ᵣ z → x ≤ᵣ z
+isTrans≤ᵣ x y z u v = ((cong (maxᵣ x) (sym v)
+  ∙ maxᵣAssoc x y z) ∙ cong (flip maxᵣ z) u) ∙ v
+
+isTrans<ᵣ : ∀ x y z → x <ᵣ y → y <ᵣ z → x <ᵣ z
+isTrans<ᵣ x y z =
+ PT.map2 λ ((q , r) , (u , v , w))
+           ((q' , r') , (u' , v' , w')) →
+            ((q , r')) ,
+             (u , ℚ.isTrans< q q' r' (ℚ.isTrans<≤ q r q' v
+                      (≤ᵣ→≤ℚ r q' (isTrans≤ᵣ _ _ _ w u')))
+                        v' , w')
+
+isTrans≤<ᵣ : ∀ x y z → x ≤ᵣ y → y <ᵣ z → x <ᵣ z
+isTrans≤<ᵣ x y z u =
+ PT.map $ map-snd λ (v , v' , v'')
+   → isTrans≤ᵣ x y _ u v  , v' , v''
+
+isTrans<≤ᵣ : ∀ x y z → x <ᵣ y → y ≤ᵣ z → x <ᵣ z
+isTrans<≤ᵣ x y z = flip λ u →
+ PT.map $ map-snd λ (v , v' , v'')
+   → v  , v' , isTrans≤ᵣ _ y z v'' u
+
+isTrans≤≡ᵣ : ∀ x y z → x ≤ᵣ y → y ≡ z → x ≤ᵣ z
+isTrans≤≡ᵣ x y z p q = subst (x ≤ᵣ_) q p
+
+isTrans≡≤ᵣ : ∀ x y z → x ≡ y → y ≤ᵣ z → x ≤ᵣ z
+isTrans≡≤ᵣ x y z p q = subst (_≤ᵣ z) (sym p) q
+
+isTrans<≡ᵣ : ∀ x y z → x <ᵣ y → y ≡ z → x <ᵣ z
+isTrans<≡ᵣ x y z p q = subst (x <ᵣ_) q p
+
+isTrans≡<ᵣ : ∀ x y z → x ≡ y → y <ᵣ z → x <ᵣ z
+isTrans≡<ᵣ x y z p q = subst (_<ᵣ z) (sym p) q
+
+
+-ᵣR : Σ (ℝ → ℝ) (Lipschitz-ℝ→ℝ (1 , tt))
+-ᵣR = fromLipschitz (1 , _)
+  ((rat ∘ ℚ.-_ ) , λ q r ε x x₁ →
+    subst∼ {ε = ε} (sym $ ℚ.·IdL (fst ε))
+     (rat-rat _ _ _ (subst ((ℚ.- fst ε) ℚ.<_)
+       (ℚ.-Distr q (ℚ.- r))
+       (ℚ.minus-< (q ℚ.- r) (fst ε) x₁)) (
+       ℚ.minus-<' (fst ε) ((ℚ.- q) ℚ.- (ℚ.- r))
+        (subst ((ℚ.- fst ε) ℚ.<_)
+         (sym (ℚ.-[x-y]≡y-x r q) ∙
+           cong (ℚ.-_) (ℚ.+Comm r (ℚ.- q) ∙
+             cong ((ℚ.- q) ℚ.+_) (sym $ ℚ.-Invol r))) x))))
+
+-ᵣ_ : ℝ → ℝ
+-ᵣ_ = fst -ᵣR
+
+
+_-ᵣ_ : ℝ → ℝ → ℝ
+x -ᵣ y = x +ᵣ (-ᵣ y)
+
+
+open ℚ.HLP
+
++-ᵣ : ∀ x → x -ᵣ x ≡ 0
++-ᵣ = fst (∼≃≡ _ _) ∘ Elimℝ-Prop.go w
+ where
+ w : Elimℝ-Prop _ --(λ z → (z +ᵣ (-ᵣ z)) ≡ 0)
+ w .Elimℝ-Prop.ratA x = invEq (∼≃≡ _ _) (cong rat (ℚ.+InvR x)) --
+ w .Elimℝ-Prop.limA x p x₁ ε =
+
+    lim-rat _ _ _ (/4₊ ε) _ (distℚ0<! ε (ge1 +ge (neg-ge ge[ ℚ.[ 1 / 4 ] ])))
+      (subst∼ (distℚ! (fst ε) ·[ ge[ ℚ.[ 1 / 2 ] ] +ge ge[ ℚ.[ 1 / 4 ] ]
+             ≡ (ge1 +ge (neg-ge ge[ ℚ.[ 1 / 4 ] ]))  ]) (triangle∼
+        (NonExpanding₂.go∼R sumR (x (/4₊ ε)) (-ᵣ lim x p)
+         (-ᵣ x (/4₊ ε)) (/2₊ ε) (subst∼ (ℚ.·IdL (fst (/2₊ ε)) ) $
+          snd -ᵣR (lim x p) (x (/4₊ ε)) (/2₊ ε)
+          (subst∼ (cong fst (ℚ./4₊+/4₊≡/2₊ ε))
+           $ sym∼ _ _ _ $ 𝕣-lim-self x p (/4₊ ε) (/4₊ ε))))
+        (x₁ ((/4₊ ε)) (/4₊ ε) )))
+
+ w .Elimℝ-Prop.isPropA _ = isPropΠ λ _ → isProp∼ _ _ _
+
+
+
+abs-dist : ∀ q r → ℚ.abs (ℚ.abs' q ℚ.- ℚ.abs' r) ℚ.≤ ℚ.abs (q ℚ.- r)
+abs-dist =
+  ℚ.elimBy≡⊎<'
+    (λ x y → subst2 ℚ._≤_ (ℚ.absComm- _ _) (ℚ.absComm- _ _))
+    (λ x → ℚ.≡Weaken≤ _ _ (cong ℚ.abs (ℚ.+InvR (ℚ.abs' x) ∙ sym (ℚ.+InvR x))))
+    λ x ε → subst (ℚ.abs (ℚ.abs' x ℚ.- ℚ.abs' (x ℚ.+ fst ε)) ℚ.≤_)
+      (sym (ℚ.-[x-y]≡y-x x (x ℚ.+ fst ε)) ∙ sym (ℚ.absNeg (x ℚ.- (x ℚ.+ fst ε))
+         ((subst {x = ℚ.- (fst ε) } {(x ℚ.- (x ℚ.+ fst ε))}
+           (ℚ._< 0) lem--050 (ℚ.-ℚ₊<0 ε)))))
+
+      ((ℚ.absFrom≤×≤ ((x ℚ.+ fst ε) ℚ.- x)
+        (ℚ.abs' x ℚ.- ℚ.abs' (x ℚ.+ fst ε))
+         (subst2
+             {x = (ℚ.abs (fst ε ℚ.+ x)) ℚ.+
+                     ((ℚ.- ℚ.abs' (x ℚ.+ fst ε)) ℚ.- fst ε)}
+             {y = ℚ.- ((x ℚ.+ fst ε) ℚ.- x)}
+            ℚ._≤_ (cong (ℚ._+ ((ℚ.- ℚ.abs' (x ℚ.+ fst ε)) ℚ.- fst ε))
+                      (λ i → ℚ.abs'≡abs (ℚ.+Comm (fst ε) x i) i) ∙
+                          lem--051 )
+                       (λ i → lem--052 {fst ε} {ℚ.abs'≡abs x i}
+                               {ℚ.abs' (x ℚ.+ fst ε)} i) $
+           ℚ.≤-+o (ℚ.abs (fst ε ℚ.+ x)) (fst ε ℚ.+ ℚ.abs x)
+           ((ℚ.- ℚ.abs' (x ℚ.+ fst ε)) ℚ.- fst ε)
+             (ℚ.abs+pos (fst ε) x (ℚ.0<ℚ₊ ε)))
+         (subst2 {x = ℚ.abs (x ℚ.+ fst ε ℚ.+ (ℚ.- fst ε)) ℚ.+
+                     (ℚ.- ℚ.abs' (x ℚ.+ fst ε))}
+                  {ℚ.abs' x ℚ.- ℚ.abs' (x ℚ.+ fst ε)}
+            ℚ._≤_ (cong ((ℚ._+
+                 (ℚ.- ℚ.abs' (x ℚ.+ fst ε))))
+                   (congS ℚ.abs (sym (lem--034 {x} {fst ε}))
+                     ∙ ℚ.abs'≡abs _))
+                  ((λ i → ℚ.abs'≡abs (x ℚ.+ fst ε) i
+                   ℚ.+ (ℚ.absNeg (ℚ.- fst ε) (ℚ.-ℚ₊<0 ε) i) ℚ.+
+                      (ℚ.- ℚ.abs' (x ℚ.+ fst ε))) ∙
+                       lem--053)
+           $ ℚ.≤-+o (ℚ.abs (x ℚ.+ fst ε ℚ.+ (ℚ.- fst ε)))
+                 (ℚ.abs (x ℚ.+ fst ε) ℚ.+ ℚ.abs (ℚ.- fst ε))
+            (ℚ.- ℚ.abs' (x ℚ.+ fst ε))
+            (ℚ.abs+≤abs+abs (x ℚ.+ fst ε) (ℚ.- (fst ε))))))
+
+
+
+absᵣL : Σ _ _
+absᵣL = fromLipschitz 1 (rat ∘ ℚ.abs' , h )
+ where
+ h : Lipschitz-ℚ→ℝ 1 (λ x → rat (ℚ.abs' x))
+ h q r ε x x₁ = subst∼ {ε = ε} (sym (ℚ.·IdL (fst ε)))
+    (rat-rat-fromAbs _ _ _ (
+      ℚ.isTrans≤< _ _ (fst ε) ((abs-dist q r))
+        (ℚ.absFrom<×< (fst ε) (q ℚ.- r) x x₁)))
+
+absᵣ = fst absᵣL
+
+absᵣ-nonExpanding : ⟨ NonExpandingₚ absᵣ ⟩
+absᵣ-nonExpanding u v ε x =
+  subst∼ (ℚ.·IdL _) $ snd absᵣL u v ε x
+
+lim≤rat→∼ : ∀ x y r → (lim x y ≤ᵣ rat r)
+                    ≃ (∀ ε → ∃[ δ ∈ _ ]
+                         Σ _ λ v →
+                           (maxᵣ (x δ) (rat r))
+                              ∼'[ (fst ε ℚ.- fst δ , v) ] (rat r) )
+lim≤rat→∼ x y r =
+  invEquiv (∼≃≡ _ _ ) ∙ₑ
+    equivΠCod λ ε →
+      propBiimpl→Equiv (isProp∼ _ _ _) squash₁ (∼→∼' _ _ _) (∼'→∼ _ _ _)
+
+
+maxᵣ-lem : ∀ u v r ε → u ∼[ ε ] v →
+                   (((ε₁ : ℚ₊) →
+                      maxᵣ v (rat r) ∼[ ε₁ ] rat r)) →
+                      maxᵣ u (rat r) ∼[ ε ] rat r
+maxᵣ-lem u v r ε xx x =
+   subst (NonExpanding₂.go maxR u (rat r) ∼[ ε ]_)
+      (fst (∼≃≡ (NonExpanding₂.go maxR v (rat r)) (rat r)) x )
+        (NonExpanding₂.go∼L maxR (rat r) u v ε xx)
+
+
+
+ℝ₊ = Σ _ λ r → 0 <ᵣ r
+
+
+ℚ₊→ℝ₊ : ℚ₊ → ℝ₊
+ℚ₊→ℝ₊ (x , y) = rat x , <ℚ→<ᵣ 0 x (ℚ.0<→< x y)
+
+decℚ≡ᵣ? : ∀ {x y} → {𝟚.True (ℚ.discreteℚ x y)} →  (rat x ≡ rat y)
+decℚ≡ᵣ? {x} {y} {p} = cong rat (ℚ.decℚ? {x} {y} {p})
+
+decℚ<ᵣ? : ∀ {x y} → {𝟚.True (ℚ.<Dec x y)} →  (rat x <ᵣ rat y)
+decℚ<ᵣ? {x} {y} {p} = <ℚ→<ᵣ x y (ℚ.decℚ<? {x} {y} {p})
+
+decℚ≤ᵣ? : ∀ {x y} → {𝟚.True (ℚ.≤Dec x y)} →  (rat x ≤ᵣ rat y)
+decℚ≤ᵣ? {x} {y} {p} = ≤ℚ→≤ᵣ x y (ℚ.decℚ≤? {x} {y} {p})
+
+instance
+  fromNatℝ₊ : HasFromNat ℝ₊
+  fromNatℝ₊ = record {
+     Constraint = λ { zero → ⊥ ; _ → Unit }
+   ; fromNat = λ { zero {{()}}  ; (suc n) →
+     (rat [ pos (suc n) / 1 ]) , <ℚ→<ᵣ _ _
+       (ℚ.<ℤ→<ℚ _ _ (ℤ.suc-≤-suc ℤ.zero-≤pos)) }}
diff --git a/Cubical/HITs/CauchyReals/Sequence.agda b/Cubical/HITs/CauchyReals/Sequence.agda
new file mode 100644
index 0000000000..fd7054d972
--- /dev/null
+++ b/Cubical/HITs/CauchyReals/Sequence.agda
@@ -0,0 +1,968 @@
+{-# OPTIONS --safe --lossy-unification #-}
+
+module Cubical.HITs.CauchyReals.Sequence where
+
+open import Cubical.Foundations.Prelude
+open import Cubical.Foundations.Equiv
+open import Cubical.Foundations.Isomorphism
+open import Cubical.Foundations.HLevels
+open import Cubical.Foundations.Function
+
+open import Cubical.Data.Bool as 𝟚 hiding (_≤_)
+open import Cubical.Data.Nat as ℕ hiding (_·_;_+_)
+import Cubical.Data.Nat.Mod as ℕ
+import Cubical.Data.Nat.Order as ℕ
+open import Cubical.Data.Empty as ⊥
+open import Cubical.Data.Sum as ⊎
+open import Cubical.Data.Int as ℤ using (pos)
+import Cubical.Data.Int.Order as ℤ
+open import Cubical.Data.Sigma
+
+open import Cubical.HITs.PropositionalTruncation as PT
+
+open import Cubical.Data.NatPlusOne
+
+open import Cubical.Data.Rationals as ℚ using (ℚ ; [_/_])
+open import Cubical.Data.Rationals.Order as ℚ using
+  ( _ℚ₊+_ ; 0<_ ; ℚ₊ ; _ℚ₊·_ ; ℚ₊≡)
+open import Cubical.Data.Rationals.Order.Properties as ℚ
+ using (invℚ₊;/2₊;/3₊;/4₊;x/2<x;invℚ;_ℚ^ⁿ_;_ℚ₊^ⁿ_)
+
+
+open import Cubical.HITs.CauchyReals.Base
+open import Cubical.HITs.CauchyReals.Lems
+open import Cubical.HITs.CauchyReals.Closeness
+open import Cubical.HITs.CauchyReals.Lipschitz
+open import Cubical.HITs.CauchyReals.Order
+open import Cubical.HITs.CauchyReals.Continuous
+open import Cubical.HITs.CauchyReals.Multiplication
+open import Cubical.HITs.CauchyReals.Inverse
+
+
+
+
+
+Seq : Type
+Seq = ℕ → ℝ
+
+
+≤ᵣ-·ᵣo : ∀ m n o → 0 ≤ᵣ o  →  m ≤ᵣ n → (m ·ᵣ o ) ≤ᵣ (n ·ᵣ o)
+≤ᵣ-·ᵣo m n o 0≤o m≤n = subst (λ o →
+   (m ·ᵣ o ) ≤ᵣ (n ·ᵣ o)) 0≤o (w ∙
+      cong (_·ᵣ maxᵣ (rat [ pos 0 / 1+ 0 ]) o) m≤n)
+ where
+ w : maxᵣ (m ·ᵣ maxᵣ 0 o ) (n ·ᵣ maxᵣ 0 o) ≡  (maxᵣ m n ·ᵣ maxᵣ 0 o)
+ w = ≡Continuous _ _
+     (cont₂maxᵣ _ _
+       ((IsContinuous∘ _ _
+         (IsContinuous·ᵣL m) (IsContinuousMaxL 0)  ))
+       ((IsContinuous∘ _ _
+         (IsContinuous·ᵣL n) (IsContinuousMaxL 0)  )))
+     (IsContinuous∘ _ _
+         (IsContinuous·ᵣL _) (IsContinuousMaxL 0)  )
+      (λ o' →
+        ≡Continuous _ _
+          (IsContinuous∘ _ _ (IsContinuousMaxR ((n ·ᵣ maxᵣ 0 (rat o'))))
+                (IsContinuous·ᵣR (maxᵣ 0 (rat o'))) )
+          (IsContinuous∘ _ _  (IsContinuous·ᵣR (maxᵣ 0 (rat o')))
+                                (IsContinuousMaxR n))
+          (λ m' →
+            ≡Continuous
+              (λ n → maxᵣ (rat m' ·ᵣ maxᵣ 0 (rat o') ) (n ·ᵣ maxᵣ 0 (rat o')))
+              (λ n →  maxᵣ (rat m') n ·ᵣ maxᵣ 0 (rat o'))
+              ((IsContinuous∘ _ _
+                (IsContinuousMaxL (((rat m') ·ᵣ maxᵣ 0 (rat o'))))
+                (IsContinuous·ᵣR (maxᵣ 0 (rat o'))) ))
+              (IsContinuous∘ _ _ ((IsContinuous·ᵣR (maxᵣ 0 (rat o'))))
+                  (IsContinuousMaxL (rat m')))
+              (λ n' →
+                 (cong₂ maxᵣ (sym (rat·ᵣrat _ _)) (sym (rat·ᵣrat _ _)))
+                  ∙∙ cong rat (sym (ℚ.·MaxDistrℚ' m' n' (ℚ.max 0 o')
+                      (ℚ.≤max 0 o'))) ∙∙
+                  rat·ᵣrat _ _
+                 ) n) m) o
+
+≤ᵣ-o·ᵣ : ∀ m n o → 0 ≤ᵣ o →  m ≤ᵣ n → (o ·ᵣ m   ) ≤ᵣ (o ·ᵣ n)
+≤ᵣ-o·ᵣ m n o 0≤o p = subst2 _≤ᵣ_
+  (·ᵣComm _ _)
+  (·ᵣComm _ _)
+  (≤ᵣ-·ᵣo m n o 0≤o p)
+
+≤ᵣ₊Monotone·ᵣ : ∀ m n o s → 0 ≤ᵣ n → 0 ≤ᵣ o
+       → m ≤ᵣ n → o ≤ᵣ s
+       → (m ·ᵣ o) ≤ᵣ (n ·ᵣ s)
+≤ᵣ₊Monotone·ᵣ m n o s 0≤n 0≤o m≤n o≤s =
+  isTrans≤ᵣ _ _ _ (≤ᵣ-·ᵣo m n o 0≤o m≤n)
+    (≤ᵣ-o·ᵣ o s n 0≤n o≤s)
+
+
+
+
+ℝ₊· : (m : ℝ₊) (n : ℝ₊) → 0 <ᵣ (fst m) ·ᵣ (fst n)
+ℝ₊· (m , 0<m) (n , 0<n) = PT.map2
+  (λ ((q , q') , 0≤q , q<q' , q'≤m) →
+   λ ((r , r') , 0≤r , r<r' , r'≤n) →
+    let 0<r' = ℚ.isTrans≤< _ _ _ (≤ᵣ→≤ℚ 0 r 0≤r) r<r'
+        qr₊ = (q' , ℚ.<→0< _ (ℚ.isTrans≤< _ _ _ (≤ᵣ→≤ℚ 0 q 0≤q) q<q'))
+               ℚ₊· (r' , ℚ.<→0< _ 0<r')
+    in (fst (/2₊ qr₊) , fst qr₊) ,
+         ≤ℚ→≤ᵣ _ _ (ℚ.0≤ℚ₊ (/2₊ qr₊)) ,
+           x/2<x qr₊ ,
+           subst (_≤ᵣ (m ·ᵣ n))
+             (sym (rat·ᵣrat q' r'))
+              (≤ᵣ₊Monotone·ᵣ (rat q')
+                (m) (rat r') n (<ᵣWeaken≤ᵣ _ _ 0<m)
+                               (<ᵣWeaken≤ᵣ _ _ (<ℚ→<ᵣ _ _ 0<r'))
+                             q'≤m r'≤n) ) 0<m 0<n
+
+_₊+ᵣ_ : ℝ₊ → ℝ₊ → ℝ₊
+(m , 0<m) ₊+ᵣ (n , 0<n) = m +ᵣ n , <ᵣMonotone+ᵣ 0 m 0 n 0<m 0<n
+
+_₊·ᵣ_ : ℝ₊ → ℝ₊  → ℝ₊
+(m , 0<m) ₊·ᵣ (n , 0<n) = _ , ℝ₊· (m , 0<m) (n , 0<n)
+
+_₊／ᵣ₊_ : ℝ₊ → ℝ₊  → ℝ₊
+(q , 0<q) ₊／ᵣ₊ (r , 0<r) = (q ／ᵣ[ r , inl (0<r) ] ,
+  ℝ₊· (q , 0<q) (_ , invℝ-pos r 0<r) )
+
+
+
+
+0<1/x : ∀ x 0＃x → 0 <ᵣ x → 0 <ᵣ invℝ x 0＃x
+0<1/x x 0＃x 0<x = subst (0 <ᵣ_)  (sym (invℝimpl x 0＃x)) (ℝ₊·
+  (_ , 0<signᵣ x 0＃x 0<x)
+  (_ , invℝ'-pos (absᵣ x) (0＃→0<abs x 0＃x)))
+
+<ᵣ-·ᵣo : ∀ m n (o : ℝ₊) →  m <ᵣ n → (m ·ᵣ (fst o)) <ᵣ (n ·ᵣ (fst o))
+<ᵣ-·ᵣo m n (o , 0<o) p =
+  let z = subst (0 <ᵣ_) (·DistR+ n (-ᵣ m) o ∙
+                   cong ((n ·ᵣ o) +ᵣ_) (-ᵣ· m o))
+           (ℝ₊· (_ , x<y→0<y-x _ _ p) (o , 0<o))
+  in 0<y-x→x<y _ _ z
+
+<ᵣ-o·ᵣ : ∀ m n (o : ℝ₊) →  m <ᵣ n → ((fst o) ·ᵣ m) <ᵣ ((fst o) ·ᵣ n )
+<ᵣ-o·ᵣ m n (o , 0<o) p =
+  subst2 (_<ᵣ_)
+    (·ᵣComm _ _) (·ᵣComm _ _) (<ᵣ-·ᵣo m n (o , 0<o) p)
+
+
+
+<ᵣ₊Monotone·ᵣ : ∀ m n o s → (0 ≤ᵣ m) → (0 ≤ᵣ o)
+       → m <ᵣ n → o <ᵣ s
+       → (m ·ᵣ o) <ᵣ (n ·ᵣ s)
+<ᵣ₊Monotone·ᵣ m n o s 0≤m 0≤o = PT.map2
+   (λ m<n@((q , q') , m≤q , q<q' , q'≤n) →
+        λ ((r , r') , o≤r , r<r' , r'≤s) →
+    let 0≤q = isTrans≤ᵣ _ _ _ 0≤m m≤q
+        0≤r = isTrans≤ᵣ _ _ _ 0≤o o≤r
+        0≤r' = isTrans≤ᵣ _ _ _ 0≤r (≤ℚ→≤ᵣ _ _ (ℚ.<Weaken≤ _ _ r<r'))
+        0≤n = isTrans≤ᵣ _ _ _ 0≤m (<ᵣWeaken≤ᵣ _ _ ∣ m<n ∣₁)
+     in (q ℚ.· r , q' ℚ.· r') ,
+           subst (m ·ᵣ o ≤ᵣ_) (sym (rat·ᵣrat _ _))
+              (≤ᵣ₊Monotone·ᵣ m (rat q) o (rat r)
+               (0≤q) 0≤o m≤q o≤r) ,
+                ℚ.<Monotone·-onPos _ _ _ _
+                  q<q' r<r' (≤ᵣ→≤ℚ _ _ 0≤q)
+                            (≤ᵣ→≤ℚ _ _ 0≤r) ,
+                (subst (_≤ᵣ n ·ᵣ s ) (sym (rat·ᵣrat _ _))
+                  (≤ᵣ₊Monotone·ᵣ (rat q') n (rat r') s
+                    0≤n 0≤r'
+                    q'≤n r'≤s)))
+
+
+
+/nᵣ-L : (n : ℕ₊₁) → Σ _ (Lipschitz-ℝ→ℝ _)
+/nᵣ-L n = (fromLipschitz ([ 1 / n ] , _)
+  (_ , Lipschitz-rat∘ ([ 1 / n ] , _) (ℚ._· [ 1 / n ])
+   λ q r ε x →
+     subst (ℚ._< ([ 1 / n ]) ℚ.· (fst ε))
+      (sym (ℚ.pos·abs [ 1 / n ] (q ℚ.- r)
+       (ℚ.<Weaken≤ 0 [ 1 / n ]
+           ( (ℚ.0<→< [ 1 / n ] _))))
+       ∙ cong ℚ.abs (ℚ.·Comm _ _ ∙ ℚ.·DistR+ q (ℚ.- r) [ 1 / n ]
+        ∙ cong ((q ℚ.· [ 1 / n ]) ℚ.+_)
+            (sym (ℚ.·Assoc -1 r [ 1 / n ]))))
+      (ℚ.<-o· (ℚ.abs (q ℚ.- r)) (fst ε) [ 1 / n ]
+       ((ℚ.0<→< [ 1 / n ] _))
+       x)))
+
+/nᵣ : ℕ₊₁ → ℝ → ℝ
+/nᵣ = fst ∘ /nᵣ-L
+
+/nᵣ-／ᵣ : ∀ n x (p : 0 ＃ fromNat (ℕ₊₁→ℕ n))
+            → /nᵣ n x ≡ (x ／ᵣ[ fromNat (ℕ₊₁→ℕ n) , p ] )
+/nᵣ-／ᵣ n x p = ≡Continuous _ _
+  (Lipschitz→IsContinuous _ (fst (/nᵣ-L n)) (snd (/nᵣ-L n)))
+   (IsContinuous·ᵣR _)
+  (λ r → cong rat (cong (r ℚ.·_) (cong [ 1 /_] (sym (·₊₁-identityˡ _))))
+    ∙ rat·ᵣrat _ _ ∙
+      cong (rat r ·ᵣ_) (sym (invℝ-rat _ _ (fst (rat＃ _ _) p)) )) x
+
+/nᵣ-pos : ∀ n x → 0 <ᵣ x → 0 <ᵣ /nᵣ n x
+/nᵣ-pos n x 0<x = subst (0 <ᵣ_) (sym (/nᵣ-／ᵣ _ _ _))
+                     (ℝ₊· (_ , 0<x) (_ , invℝ-pos _
+                         (<ℚ→<ᵣ _ _ (ℚ.0<→< _ tt))))
+
+seqSumUpTo : (ℕ → ℝ) → ℕ →  ℝ
+seqSumUpTo s zero = 0
+seqSumUpTo s (suc n) = s zero +ᵣ seqSumUpTo (s ∘ suc) n
+
+seqSumUpTo· : ∀ s r n → seqSumUpTo s n ·ᵣ r ≡ seqSumUpTo ((_·ᵣ r) ∘ s) n
+seqSumUpTo· s r zero = 𝐑'.0LeftAnnihilates r
+seqSumUpTo· s r (suc n) =
+  ·DistR+ (s zero) (seqSumUpTo (s ∘ suc) n) r ∙
+   cong ((s zero ·ᵣ r) +ᵣ_) (seqSumUpTo· (s ∘ suc) r n)
+
+
+
+seqSumUpTo' : (ℕ → ℝ) → ℕ →  ℝ
+seqSumUpTo' s zero = 0
+seqSumUpTo' s (suc n) = seqSumUpTo' s n +ᵣ s n
+
+seqΣ : Seq → Seq
+seqΣ = seqSumUpTo'
+
+seqΣ' : Seq → Seq
+seqΣ' = seqSumUpTo
+
+
+seqSumUpTo-suc : ∀ f n → seqSumUpTo f n +ᵣ f n ≡
+      f zero +ᵣ seqSumUpTo (λ x → f (suc x)) n
+seqSumUpTo-suc f zero = +ᵣComm _ _
+seqSumUpTo-suc f (suc n) =
+  sym (+ᵣAssoc _ _ _) ∙
+    cong ((f zero) +ᵣ_ ) (seqSumUpTo-suc _ _)
+
+seqSumUpTo≡seqSumUpTo' : ∀ f n → seqSumUpTo' f n ≡ seqSumUpTo f n
+seqSumUpTo≡seqSumUpTo' f zero = refl
+seqSumUpTo≡seqSumUpTo' f (suc n) =
+ cong (_+ᵣ (f n)) (seqSumUpTo≡seqSumUpTo' (f) n) ∙
+   seqSumUpTo-suc f n
+
+<-·sk-cancel : ∀ {m n k} → m ℕ.· suc k ℕ.< n ℕ.· suc k → m ℕ.< n
+<-·sk-cancel {n = zero} x = ⊥.rec (ℕ.¬-<-zero x)
+<-·sk-cancel {zero} {n = suc n} x = ℕ.suc-≤-suc (ℕ.zero-≤ {n})
+<-·sk-cancel {suc m} {n = suc n} {k} x =
+  ℕ.suc-≤-suc {suc m} {n}
+    (<-·sk-cancel {m} {n} {k}
+     (ℕ.≤-k+-cancel (subst (ℕ._≤ (k ℕ.+ n ℕ.· suc k))
+       (sym (ℕ.+-suc _ _)) (ℕ.pred-≤-pred x))))
+
+2≤x→1<quotient[x/2] : ∀ n → 0 ℕ.< (ℕ.quotient (2 ℕ.+ n) / 2)
+2≤x→1<quotient[x/2] n =
+ let z : 0 ℕ.<
+             ((ℕ.quotient (2 ℕ.+ n) / 2) ℕ.· 2)
+     z = subst (0 ℕ.<_) (ℕ.·-comm _ _)
+          (ℕ.≤<-trans ℕ.zero-≤ (ℕ.<-k+-cancel (subst (ℕ._< 2 ℕ.+
+             (2 ℕ.· (ℕ.quotient (2 ℕ.+ n) / 2)))
+           (ℕ.≡remainder+quotient 2 (2 ℕ.+ n))
+             (ℕ.<-+k {k = 2 ℕ.· (ℕ.quotient (2 ℕ.+ n) / 2)}
+              (ℕ.mod< 1 (2 ℕ.+ n))))))
+ in <-·sk-cancel {0} {ℕ.quotient (2 ℕ.+ n) / 2 } {k = 1}
+     z
+
+
+
+open ℕ.Minimal
+
+-- invFacℕ : ∀ n → Σ _ (Least (λ k → n ℕ.< 2 !))
+-- invFacℕ = {!!}
+
+log2ℕ : ∀ n → Σ _ (Least (λ k → n ℕ.< 2 ^ k))
+log2ℕ n = w n n ℕ.≤-refl
+ where
+
+  w : ∀ N n → n ℕ.≤ N
+          → Σ _ (Least (λ k → n ℕ.< 2 ^ k))
+  w N zero x = 0 , (ℕ.≤-refl , λ k' q → ⊥.rec (ℕ.¬-<-zero q))
+  w N (suc zero) x = 1 , (ℕ.≤-refl ,
+     λ { zero q → ℕ.<-asym (ℕ.suc-≤-suc ℕ.≤-refl)
+      ; (suc k') q → ⊥.rec (ℕ.¬-<-zero (ℕ.pred-≤-pred q))})
+  w zero (suc (suc n)) x = ⊥.rec (ℕ.¬-<-zero x)
+  w (suc N) (suc (suc n)) x =
+   let (k , (X , Lst)) = w N
+          (ℕ.quotient 2 ℕ.+ n / 2)
+          (ℕ.≤-trans (ℕ.pred-≤-pred (ℕ.2≤x→quotient[x/2]<x n))
+             (ℕ.pred-≤-pred x))
+       z = ℕ.≡remainder+quotient 2 (2 ℕ.+ n)
+       zz = ℕ.<-+-≤ X X
+       zzz : suc (suc n) ℕ.< (2 ^ suc k)
+       zzz = subst2 (ℕ._<_)
+           (ℕ.+-comm _ _
+              ∙ sym (ℕ.+-assoc ((ℕ.remainder 2 ℕ.+ n / 2)) _ _)
+               ∙ cong ((ℕ.remainder 2 ℕ.+ n / 2) ℕ.+_)
+             ((cong ((ℕ.quotient 2 ℕ.+ n / 2) ℕ.+_)
+              (sym (ℕ.+-zero (ℕ.quotient 2 ℕ.+ n / 2)))))
+             ∙ z)
+           (cong ((2 ^ k) ℕ.+_) (sym (ℕ.+-zero (2 ^ k))))
+           (ℕ.≤<-trans
+             (ℕ.≤-k+ (ℕ.≤-+k (ℕ.pred-≤-pred (ℕ.mod< 1 (2 ℕ.+ n))))) zz)
+   in (suc k)
+       , zzz
+        , λ { zero 0'<sk 2+n<2^0' →
+                ⊥.rec (ℕ.¬-<-zero (ℕ.pred-≤-pred 2+n<2^0'))
+            ; (suc k') k'<sk 2+n<2^k' →
+               Lst k' (ℕ.pred-≤-pred k'<sk)
+                (<-·sk-cancel {k = 1}
+                    (subst2 ℕ._<_ (ℕ.·-comm _ _) (ℕ.·-comm _ _)
+                      (ℕ.≤<-trans (_ , z)
+                         2+n<2^k' )))}
+
+
+
+
+
+0<x^ⁿ : ∀ x n → 0 <ᵣ x → 0 <ᵣ (x ^ⁿ n)
+0<x^ⁿ x zero x₁ = <ℚ→<ᵣ _ _ (𝟚.toWitness {Q = ℚ.<Dec 0 1} tt)
+0<x^ⁿ x (suc n) x₁ = ℝ₊· (_ , 0<x^ⁿ x n x₁) (_ , x₁)
+
+
+geometricProgression : ℝ → ℝ → ℕ → ℝ
+geometricProgression a r zero = a
+geometricProgression a r (suc n) =
+  (geometricProgression a r n) ·ᵣ r
+
+geometricProgressionClosed : ∀ a r n →
+ geometricProgression a r n ≡ a ·ᵣ (r ^ⁿ n)
+geometricProgressionClosed a r zero = sym (·IdR a)
+geometricProgressionClosed a r (suc n) =
+  cong (_·ᵣ r) (geometricProgressionClosed a r n) ∙
+   sym (·ᵣAssoc _ _ _)
+
+geometricProgression-suc : ∀ a r n →
+   geometricProgression a r (suc n) ≡
+    geometricProgression (a ·ᵣ r) r n
+geometricProgression-suc a r zero = refl
+geometricProgression-suc a r (suc n) =
+  cong (_·ᵣ r) (geometricProgression-suc a r n)
+
+
+geometricProgression-suc' : ∀ a r n →
+   geometricProgression a r (suc n) ≡
+    geometricProgression (a) r n  ·ᵣ r
+geometricProgression-suc' a r _ = refl
+
+Sₙ : ℝ → ℝ → ℕ → ℝ
+Sₙ a r = seqSumUpTo (geometricProgression a r)
+
+
+Sₙ-suc : ∀ a r n → Sₙ a r (suc n) ≡ (a +ᵣ (Sₙ a r n ·ᵣ r ))
+Sₙ-suc a r n = cong (a +ᵣ_) (sym (seqSumUpTo· (geometricProgression a r) r n) )
+
+
+SₙLem' : ∀ a n r → (Sₙ a r n) ·ᵣ (1 +ᵣ (-ᵣ r))  ≡
+                   a ·ᵣ (1 +ᵣ (-ᵣ (r ^ⁿ n)))
+SₙLem' a n r =
+ let z : Sₙ a r n +ᵣ geometricProgression a r n
+            ≡ (a +ᵣ (Sₙ a r n ·ᵣ r))
+     z = cong (_+ᵣ (geometricProgression a r n))
+           (sym (seqSumUpTo≡seqSumUpTo' (geometricProgression a r) n))
+            ∙∙ seqSumUpTo≡seqSumUpTo' (geometricProgression a r) _
+          ∙∙ Sₙ-suc a r n
+     z' = ((sym (+IdR _) ∙ cong ((Sₙ a r n +ᵣ (-ᵣ (Sₙ a r n ·ᵣ r))) +ᵣ_)
+             (sym (+-ᵣ (geometricProgression a r n))))
+           ∙ 𝐑'.+ShufflePairs _ _ _ _ )
+         ∙∙ cong₂ _+ᵣ_ z (
+           (+ᵣComm (-ᵣ (Sₙ a r n ·ᵣ r))
+              (-ᵣ (geometricProgression a r n)))) ∙∙
+            (𝐑'.+ShufflePairs _ _ _ _ ∙
+              cong ((a +ᵣ (-ᵣ (geometricProgression a r n))) +ᵣ_)
+             ( (+-ᵣ (Sₙ a r n ·ᵣ r))) ∙ +IdR _)
+ in (·DistL+ (Sₙ a r n) 1 (-ᵣ r)
+      ∙ cong₂ _+ᵣ_ (·IdR (Sₙ a r n)) (𝐑'.-DistR· (Sₙ a r n) r))
+      ∙∙ z' ∙∙ (cong₂ _+ᵣ_ (sym (·IdR a))
+       (cong (-ᵣ_) (geometricProgressionClosed a r n) ∙
+        sym (𝐑'.-DistR· _ _))
+     ∙ sym (·DistL+ a 1 (-ᵣ ((r ^ⁿ (n))))))
+
+SₙLem : ∀ a r (0＃1-r : 0 ＃ (1 +ᵣ (-ᵣ r))) n →
+              (Sₙ a r n)   ≡
+                   a ·ᵣ ((1 +ᵣ (-ᵣ (r ^ⁿ n)))
+                     ／ᵣ[ (1 +ᵣ (-ᵣ r)) , 0＃1-r ])
+SₙLem a r 0＃1-r n =
+     x·y≡z→x≡z/y (Sₙ a r n)
+       (a ·ᵣ (1 +ᵣ (-ᵣ (r ^ⁿ n))))
+        _ 0＃1-r (SₙLem' a n r)
+      ∙ sym (·ᵣAssoc _ _ _)
+
+Sₙ-sup : ∀ a r n → (0 <ᵣ a) → (0 <ᵣ r) → (r<1 : r <ᵣ 1) →
+                (Sₙ a r n)
+                <ᵣ (a ·ᵣ (invℝ (1 +ᵣ (-ᵣ r)) (inl (x<y→0<y-x _ _ r<1))))
+Sₙ-sup a r n a<0 0<r r<1  =
+   isTrans≤<ᵣ _ _ _ (≡ᵣWeaken≤ᵣ _ _ (SₙLem a r _ n))
+     (<ᵣ-o·ᵣ _ _ (a , a<0)
+      (isTrans<≤ᵣ _ _ _
+          (<ᵣ-·ᵣo (1 +ᵣ (-ᵣ (r ^ⁿ n))) 1
+            (invℝ (1 +ᵣ (-ᵣ r)) (inl (x<y→0<y-x _ _ r<1)) ,
+              0<1/x _ _ (( (x<y→0<y-x _ _ r<1))))
+            (isTrans<≤ᵣ _ _ _
+               (<ᵣ-o+ _ _ 1 (-ᵣ<ᵣ 0 (r ^ⁿ n) (0<x^ⁿ r n 0<r)))
+               (≡ᵣWeaken≤ᵣ _ _ (+IdR _)) ))
+          (≡ᵣWeaken≤ᵣ _ _ (·IdL _ ) )))
+
+Seq<→Σ< : (s s' : Seq) →
+  (∀ n → s n <ᵣ s' n) →
+   ∀ n → seqSumUpTo s (suc n) <ᵣ seqSumUpTo s' (suc n)
+Seq<→Σ< s s' x zero = subst2 _<ᵣ_
+  (sym (+IdR _)) (sym (+IdR _)) (x 0)
+Seq<→Σ< s s' x (suc n) = <ᵣMonotone+ᵣ _ _ _ _
+ (x 0) (Seq<→Σ< (s ∘ suc) (s' ∘ suc) (x ∘ suc) n)
+
+Seq≤→Σ≤ : (s s' : Seq) →
+  (∀ n → s n ≤ᵣ s' n) →
+   ∀ n → seqSumUpTo s n ≤ᵣ seqSumUpTo s' n
+Seq≤→Σ≤ s s' x zero = ≤ᵣ-refl _
+Seq≤→Σ≤ s s' x (suc n) = ≤ᵣMonotone+ᵣ _ _ _ _
+ (x 0) (Seq≤→Σ≤ (s ∘ suc) (s' ∘ suc) (x ∘ suc) n)
+
+Seq'≤→Σ≤ : (s s' : Seq) →
+  (∀ n → s n ≤ᵣ s' n) →
+   ∀ n → seqSumUpTo' s n ≤ᵣ seqSumUpTo' s' n
+Seq'≤→Σ≤ s s' x zero = ≤ᵣ-refl _
+Seq'≤→Σ≤ s s' x (suc n) =
+ ≤ᵣMonotone+ᵣ _ _ _ _
+ (Seq'≤→Σ≤ s s' x n)  (x n)
+
+0≤seqΣ : ∀ s → (∀ n → 0 ≤ᵣ s n)
+            → ∀ n → 0 ≤ᵣ seqΣ s n
+0≤seqΣ s x zero = ≤ᵣ-refl _
+0≤seqΣ s x (suc n) =
+  ≤ᵣMonotone+ᵣ _ _ _ _ (0≤seqΣ s x n) (x n)
+
+seriesDiff : (s : Seq)  →
+  ∀ N n → (seqΣ s (n ℕ.+ N) +ᵣ (-ᵣ seqΣ s N)) ≡
+     seqΣ (s ∘ (ℕ._+ N)) n
+seriesDiff s N zero = +-ᵣ (seqΣ s N)
+seriesDiff s N (suc n) =
+  cong (_+ᵣ _) (+ᵣComm _ _) ∙∙
+  sym (+ᵣAssoc _ _ _) ∙∙
+   cong (s (n ℕ.+ N) +ᵣ_) (seriesDiff s N n)
+    ∙ +ᵣComm (s (n ℕ.+ N)) (seqΣ (s ∘ (ℕ._+ N)) n)
+
+
+IsCauchySequence : Seq → Type
+IsCauchySequence s =
+  ∀ (ε : ℝ₊) → Σ[ N ∈ ℕ ] (∀ m n → N ℕ.< n → N ℕ.< m →
+    absᵣ ((s n) +ᵣ (-ᵣ (s m))) <ᵣ fst ε   )
+
+IsCauchySequence' : Seq → Type
+IsCauchySequence' s =
+  ∀ (ε : ℚ₊) → Σ[ N ∈ ℕ ] (∀ m n → N ℕ.< n → N ℕ.< m →
+    absᵣ ((s n) +ᵣ (-ᵣ (s m))) <ᵣ rat (fst ε)   )
+
+
+IsConvSeries : Seq → Type
+IsConvSeries s =
+    ∀ (ε : ℝ₊) →
+     Σ[ N ∈ ℕ ] ∀ n m →
+       absᵣ (seqΣ (s ∘ (ℕ._+ (n ℕ.+ (suc N)))) m) <ᵣ fst ε
+
+IsConvSeries' : Seq → Type
+IsConvSeries' s =
+    ∀ (ε : ℚ₊) →
+     Σ[ N ∈ ℕ ] ∀ n m →
+       absᵣ (seqΣ (s ∘ (ℕ._+ (n ℕ.+ (suc N)))) m) <ᵣ rat (fst ε)
+
+
+IsoIsConvSeriesIsCauchySequenceSum : (s : Seq) →
+  Iso (IsConvSeries s) (IsCauchySequence (seqΣ s))
+IsoIsConvSeriesIsCauchySequenceSum s =
+   codomainIsoDep λ ε →
+     Σ-cong-iso-snd λ N →
+        isProp→Iso (isPropΠ2 λ _ _ → squash₁)
+         (isPropΠ4 λ _ _ _ _ → squash₁ )
+         (λ f → ℕ.elimBy≤
+           (λ n n' X <n <n' → subst (_<ᵣ fst ε)
+             (minusComm-absᵣ _ _) (X <n' <n))
+           λ n n' n≤n' N<n' N<n →
+              subst ((_<ᵣ fst ε) ∘ absᵣ)
+                 (cong (λ x → seqΣ (s ∘ (ℕ._+ x)) (n' ∸ n))
+                    (ℕ.[n-m]+m (suc N) n N<n)
+                   ∙∙ sym (seriesDiff s n (n' ∸ n)) ∙∙
+                   cong (_+ᵣ (-ᵣ seqΣ s n))
+                     (cong (seqΣ s)
+                       (ℕ.[n-m]+m n n' n≤n')))
+                 (f (n ∸ (suc N)) (n' ∸ n)))
+         λ f n m →
+           subst ((_<ᵣ fst ε) ∘ absᵣ)
+             (seriesDiff s (n ℕ.+ suc N) m)
+               (f (n ℕ.+ (suc N)) (m ℕ.+ (n ℕ.+ suc N))
+               (subst (N ℕ.<_) (sym (ℕ.+-assoc _ _ _))
+                 (ℕ.≤SumRight {suc N} {m ℕ.+ n}))
+               (ℕ.≤SumRight {suc N} {n}))
+
+
+IsConvSeries≃IsCauchySequenceSum : (s : Seq) →
+  IsConvSeries s ≃ IsCauchySequence (seqΣ s)
+IsConvSeries≃IsCauchySequenceSum s =
+  isoToEquiv (IsoIsConvSeriesIsCauchySequenceSum s)
+
+IsoIsConvSeries'IsCauchySequenceSum' : (s : Seq) →
+  Iso (IsConvSeries' s) (IsCauchySequence' (seqΣ s))
+IsoIsConvSeries'IsCauchySequenceSum' s =
+ codomainIsoDep λ ε →
+     Σ-cong-iso-snd λ N →
+        isProp→Iso (isPropΠ2 λ _ _ → squash₁)
+         (isPropΠ4 λ _ _ _ _ → squash₁ )
+
+         (λ f → ℕ.elimBy≤
+           (λ n n' X <n <n' → subst (_<ᵣ rat (fst ε))
+             (minusComm-absᵣ _ _) (X <n' <n))
+           λ n n' n≤n' N<n' N<n →
+              subst ((_<ᵣ rat (fst ε)) ∘ absᵣ)
+                 (cong (λ x → seqΣ (s ∘ (ℕ._+ x)) (n' ∸ n))
+                    (ℕ.[n-m]+m (suc N) n N<n)
+                   ∙∙ sym (seriesDiff s n (n' ∸ n)) ∙∙
+                   cong (_+ᵣ (-ᵣ seqΣ s n))
+                     (cong (seqΣ s)
+                       (ℕ.[n-m]+m n n' n≤n')))
+                 (f (n ∸ (suc N)) (n' ∸ n)))
+         λ f n m →
+           subst ((_<ᵣ rat (fst ε)) ∘ absᵣ)
+             (seriesDiff s (n ℕ.+ suc N) m)
+               (f (n ℕ.+ (suc N)) (m ℕ.+ (n ℕ.+ suc N))
+               (subst (N ℕ.<_) (sym (ℕ.+-assoc _ _ _))
+                 (ℕ.≤SumRight {suc N} {m ℕ.+ n}))
+               (ℕ.≤SumRight {suc N} {n}))
+
+
+IsConvSeries'≃IsCauchySequence'Sum : (s : Seq) →
+  IsConvSeries' s ≃ IsCauchySequence' (seqΣ s)
+IsConvSeries'≃IsCauchySequence'Sum s =
+  isoToEquiv (IsoIsConvSeries'IsCauchySequenceSum' s)
+
+isCauchyAprox : (ℚ₊ → ℝ) → Type
+isCauchyAprox f = (δ ε : ℚ₊) →
+  (absᵣ (f δ +ᵣ (-ᵣ  f ε)) <ᵣ rat (fst (δ ℚ₊+ ε)))
+
+lim' : ∀ x → isCauchyAprox x → ℝ
+lim' x y = lim x λ δ ε  → (invEq (∼≃abs<ε _ _ _)) (y δ ε)
+
+-- HoTT 11.3.49
+
+fromCauchySequence : ∀ s → IsCauchySequence s → ℝ
+fromCauchySequence s ics =
+  lim x y
+
+ where
+ x : ℚ₊ → ℝ
+ x q = s (suc (fst (ics (ℚ₊→ℝ₊ q))))
+
+ y : (δ ε : ℚ₊) → x δ ∼[ δ ℚ₊+ ε ] x ε
+ y δ ε = invEq (∼≃abs<ε _ _ _)
+    (ww (ℕ.Dichotomyℕ δₙ εₙ) )
+  where
+  δₙ = fst (ics (ℚ₊→ℝ₊ δ))
+  εₙ = fst (ics (ℚ₊→ℝ₊ ε))
+
+  ww : _ ⊎ _ → absᵣ (x δ +ᵣ (-ᵣ x ε)) <ᵣ rat (fst (δ ℚ₊+ ε))
+  ww (inl δₙ≤εₙ) =
+   let z = snd (ics (ℚ₊→ℝ₊ δ)) (suc εₙ) (suc δₙ)
+              ℕ.≤-refl  (ℕ.suc-≤-suc δₙ≤εₙ )
+   in isTrans<ᵣ (absᵣ (x δ +ᵣ (-ᵣ x ε)))
+           (rat (fst (δ))) (rat (fst (δ ℚ₊+ ε)))
+           z (<ℚ→<ᵣ _ _ (ℚ.<+ℚ₊' (fst δ) (fst δ) ε (ℚ.isRefl≤ (fst δ))))
+  ww (inr εₙ<δₙ) =
+    let z = snd (ics (ℚ₊→ℝ₊ ε)) (suc εₙ) (suc δₙ)
+               (ℕ.≤-suc εₙ<δₙ) ℕ.≤-refl
+    in isTrans<ᵣ (absᵣ (x δ +ᵣ (-ᵣ x ε)))
+           (rat (fst (ε))) (rat (fst (δ ℚ₊+ ε)))
+           z ((<ℚ→<ᵣ _ _
+               (subst ((fst ε) ℚ.<_) (ℚ.+Comm _ _)
+               (ℚ.<+ℚ₊' (fst ε) (fst ε) δ (ℚ.isRefl≤ (fst ε))))))
+
+
+-- TODO HoTT 11.3.50.
+
+fromCauchySequence' : ∀ s → IsCauchySequence' s → ℝ
+fromCauchySequence' s ics =
+  lim x y
+
+ where
+ x : ℚ₊ → ℝ
+ x q = s (suc (fst (ics q)))
+
+ y : (δ ε : ℚ₊) → x δ ∼[ δ ℚ₊+ ε ] x ε
+ y δ ε = invEq (∼≃abs<ε _ _ _)
+    (ww (ℕ.Dichotomyℕ δₙ εₙ) )
+  where
+  δₙ = fst (ics δ)
+  εₙ = fst (ics ε)
+
+  ww : _ ⊎ _ → absᵣ (x δ +ᵣ (-ᵣ x ε)) <ᵣ rat (fst (δ ℚ₊+ ε))
+  ww (inl δₙ≤εₙ) =
+   let z = snd (ics δ) (suc εₙ) (suc δₙ)
+              ℕ.≤-refl  (ℕ.suc-≤-suc δₙ≤εₙ )
+   in isTrans<ᵣ (absᵣ (x δ +ᵣ (-ᵣ x ε)))
+           (rat (fst (δ))) (rat (fst (δ ℚ₊+ ε)))
+           z (<ℚ→<ᵣ _ _ (ℚ.<+ℚ₊' (fst δ) (fst δ) ε (ℚ.isRefl≤ (fst δ))))
+  ww (inr εₙ<δₙ) =
+    let z = snd (ics ε) (suc εₙ) (suc δₙ)
+               (ℕ.≤-suc εₙ<δₙ) ℕ.≤-refl
+    in isTrans<ᵣ (absᵣ (x δ +ᵣ (-ᵣ x ε)))
+           (rat (fst (ε))) (rat (fst (δ ℚ₊+ ε)))
+           z ((<ℚ→<ᵣ _ _
+               (subst ((fst ε) ℚ.<_) (ℚ.+Comm _ _)
+               (ℚ.<+ℚ₊' (fst ε) (fst ε) δ (ℚ.isRefl≤ (fst ε))))))
+
+
+limₙ→∞_is_ : Seq → ℝ → Type
+limₙ→∞ s is x =
+  ∀ (ε : ℝ₊) → Σ[ N ∈ ℕ ]
+    (∀ n → N ℕ.< n →
+      absᵣ ((s n) +ᵣ (-ᵣ x)) <ᵣ (fst ε))
+
+lim'ₙ→∞_is_ : Seq → ℝ → Type
+lim'ₙ→∞ s is x =
+  ∀ (ε : ℚ₊) → Σ[ N ∈ ℕ ]
+    (∀ n → N ℕ.< n →
+      absᵣ ((s n) +ᵣ (-ᵣ x)) <ᵣ (rat (fst ε)))
+
+
+
+Limₙ→∞ : Seq → Type
+Limₙ→∞ s = Σ _ (limₙ→∞ s is_)
+
+
+ε<2ⁿ : (ε : ℚ₊) → Σ[ n ∈ ℕ ] fst ε ℚ.< 2 ℚ^ⁿ n
+ε<2ⁿ ε = let n = fst (log2ℕ (fst (ℚ.ceilℚ₊ ε))) in n ,
+         subst (fst ε ℚ.<_) (sym (ℚ.fromNat-^ _ _))
+          (ℚ.isTrans< _ _ (fromNat (2 ^ n))
+                  ((snd (ℚ.ceilℚ₊ ε)))
+                   (ℚ.<ℤ→<ℚ (ℤ.pos ((fst (ℚ.ceilℚ₊ ε))))
+                     _ (ℤ.ℕ≤→pos-≤-pos  _ _
+                    (fst (snd (log2ℕ (fst (ℚ.ceilℚ₊ ε))))))))
+
+
+1/2ⁿ<ε : (ε : ℚ₊) → Σ[ n ∈ ℕ ] [ 1 / 2 ] ℚ^ⁿ n ℚ.< fst ε
+1/2ⁿ<ε ε =
+ let (n , 1/ε<n) = ε<2ⁿ (invℚ₊ ε)
+ in n , invEq (ℚ.invℚ₊-<-invℚ₊ (([ 1 / 2 ] , _) ℚ₊^ⁿ n) ε)
+         (subst (fst (invℚ₊ ε) ℚ.<_)
+           (sym (ℚ.invℚ₊-ℚ^ⁿ ([ 1 / 2 ] , _) n)) 1/ε<n)
+
+
+
+ratio→seqLimit : ∀ (s : Seq) → (∀ n → Σ[ r ∈ ℚ ] (s n ≡ rat r))
+  → (sPos : ∀ n → rat 0 <ᵣ (s n))
+  → lim'ₙ→∞ (λ n →  s (suc n) ／ᵣ[ s n , inl ((sPos n)) ]) is 0
+  → lim'ₙ→∞ s is 0
+ratio→seqLimit s sRat sPos l (ε , 0<ε) =
+ (uncurry w)
+    (l ([ 1 / 2 ] , _))
+
+ where
+ w : ∀ N → ((n : ℕ) →  N ℕ.< n →
+          absᵣ ((s (suc n) ／ᵣ[ s n , inl (sPos n) ]) +ᵣ (-ᵣ 0)) <ᵣ
+          rat [ 1 / 2 ]) →
+       Σ ℕ (λ N → (n : ℕ) → N ℕ.< n → absᵣ (s n +ᵣ (-ᵣ 0)) <ᵣ rat ε)
+ w N f =
+     let 0<s' = ((subst (0 <ᵣ_) (snd (sRat (suc N))))
+                   (sPos (suc N)))
+         δ₊ = (ε , 0<ε) ℚ₊· invℚ₊ (fst (sRat (suc N)) ,
+                 (ℚ.<→0< _  (<ᵣ→<ℚ 0 _
+                   0<s')))
+         (m½ , q) = 1/2ⁿ<ε δ₊
+         pp : rat ([ 1 / 2 ] ℚ^ⁿ m½)  <ᵣ
+                 ((rat ε ·ᵣ invℝ (s (suc N)) (inl (sPos _))))
+         pp = isTrans<≡ᵣ _ _ _ (<ℚ→<ᵣ _ _ q)
+                 (rat·ᵣrat _ _ ∙
+                   cong (rat ε ·ᵣ_)
+                     (cong rat (sym (ℚ.invℚ₊≡invℚ _
+                       (inl (<ᵣ→<ℚ 0 _ 0<s'))))
+                       ∙ sym (invℝ-rat _ (inl 0<s') _) ∙
+                       cong₂ invℝ (sym (snd (sRat (suc N))))
+                         (isProp→PathP (λ i → isProp＃ _ _)  _ _)))
+         pp' = subst ((rat ([ ℤ.pos 1 / 1+ 1 ] ℚ^ⁿ m½) ·ᵣ s (suc N)) <ᵣ_)
+                  ([x/y]·yᵣ _ _ _) (<ᵣ-·ᵣo _ _ (s (suc N) , (sPos _)) pp)
+         zzz : ∀ m → s (((suc (suc (m ℕ.+ m½))) ℕ.+ N))
+                     ≤ᵣ
+                      s (suc N) ·ᵣ  (rat ([ ℤ.pos 1 / 1+ 1 ] ℚ^ⁿ m½))
+         zzz m  = isTrans≤ᵣ _ _ _ (g (m ℕ.+ m½))
+                     (≤ᵣ-o·ᵣ _ _ (s (suc N)) (<ᵣWeaken≤ᵣ _ _ (sPos _))
+                       (≤ℚ→≤ᵣ _ _ (subst2 ℚ._≤_ (ℚ.·-ℚ^ⁿ (suc m) m½ [ 1 / 2 ])
+                           (ℚ.·IdL _)
+                          (ℚ.≤-·o (([ ℤ.pos 1 / 1+ 1 ] ℚ^ⁿ (suc m)))
+                               1 _ ((ℚ.0≤ℚ₊ (_ ℚ₊^ⁿ m½)))
+                                  (ℚ.x^ⁿ≤1 [ ℤ.pos 1 / 1+ 1 ] (suc m)
+                                    (𝟚.toWitness
+                                       {Q = ℚ.≤Dec 0  [ ℤ.pos 1 / 1+ 1 ]} tt)
+                                    (𝟚.toWitness
+                                       {Q = ℚ.≤Dec [ ℤ.pos 1 / 1+ 1 ] 1} tt))
+                                  ))) )
+     in (1 ℕ.+ m½) ℕ.+ N ,
+          λ m <m →
+           isTrans≤<ᵣ _ _ _ (
+               subst2 (_≤ᵣ_)
+               (cong s ((cong (ℕ._+ N) (cong suc (sym (+-suc _ _))
+                ∙ sym (+-suc _ _)) ∙ sym (ℕ.+-assoc _ _ N) )
+                   ∙ snd <m) ∙ sym (absᵣPos _ (sPos _))
+                 ∙ cong absᵣ (sym (+IdR (s m))) )
+                 (·ᵣComm _ _)
+                (zzz (fst <m)) --(zzz m <m)
+                ) pp'
+          --   (lowerℚBound (ε ·ᵣ invℝ (s (suc N)) (inl (sPos _)))
+          -- (ℝ₊· (ε , 0<ε) (_ , invℝ-pos (s (suc N)) (sPos _))))
+  where
+
+   f' : ((n : ℕ) →  N ℕ.< n →
+          (s (suc n)) <ᵣ
+          s n ·ᵣ rat [ 1 / 2 ])
+   f' n n< =
+    subst2 _<ᵣ_
+      ((congS (_·ᵣ s n) (+IdR _) ∙
+        [x/y]·yᵣ _ _ _)) (·ᵣComm _ _)
+     (<ᵣ-·ᵣo _ _ (s n , sPos _)
+      (isTrans≤<ᵣ _ _ _ (≤absᵣ _) (f n n<)))
+
+   g : ∀ m → s ((suc (suc m)) ℕ.+ N)
+             ≤ᵣ (s (suc N)) ·ᵣ rat ([ 1 / 2 ] ℚ^ⁿ (suc m))
+   g zero = subst (s (suc (suc N)) ≤ᵣ_)
+                (cong ((s (suc N) ·ᵣ_) ∘ rat) (sym (ℚ.·IdR _)))
+                 (<ᵣWeaken≤ᵣ _ _ (f' (suc N) (ℕ.≤-refl {suc N})))
+   g (suc m) =
+     isTrans≤ᵣ _ _ _ (<ᵣWeaken≤ᵣ _ _ (f' (2 ℕ.+ m ℕ.+ N)
+      (subst (N ℕ.<_)
+        (cong suc (ℕ.+-suc _ _)) (ℕ.≤SumRight {suc N} {suc m})))) ww
+    where
+    ww : (s (suc (suc m) ℕ.+ N) ·ᵣ rat [ 1 / 2 ]) ≤ᵣ
+         (s (suc N) ·ᵣ rat ([ 1 / 2 ] ℚ^ⁿ suc (suc m)))
+
+    ww =
+       subst ((s (suc (suc m) ℕ.+ N) ·ᵣ rat [ 1 / 2 ]) ≤ᵣ_)
+
+         (sym (·ᵣAssoc _ _ _) ∙
+           cong (s (suc N) ·ᵣ_) (sym (rat·ᵣrat _ _)))
+            (≤ᵣ-·o _ _ [ 1 / 2 ] (ℚ.decℚ≤? {0} {[ 1 / 2 ]}) (g m))
+
+
+-- TODO : generalize properly
+ratioTest₊ : ∀ (s : Seq) → (sPos : ∀ n → rat 0 <ᵣ (s n))
+     → lim'ₙ→∞ s is 0
+     → (lim'ₙ→∞ (λ n →  s (suc n) ／ᵣ[ s n , inl ((sPos n)) ]) is 0)
+     → IsConvSeries' s
+ratioTest₊ s sPos l' l ε₊@(ε , 0<ε) =
+  N , ww
+
+ where
+ ½ᵣ = (ℚ₊→ℝ₊ ([ 1 / 2 ] , _))
+ N½ = l ([ 1 / 2 ] , _)
+ ε/2 : ℚ₊
+ ε/2 = /2₊ ε₊
+
+ Nε = (l' ε/2)
+
+ N : ℕ
+ N = suc (ℕ.max (suc (fst N½)) (fst Nε))
+
+ ww : ∀ m n → absᵣ (seqΣ (λ x → s (x ℕ.+ (m ℕ.+ suc N))) n) <ᵣ (rat ε)
+ ww m n = isTrans≤<ᵣ _ _ _
+   (≡ᵣWeaken≤ᵣ _ _
+     (absᵣNonNeg (seqΣ (λ x → s (x ℕ.+ (m ℕ.+ suc N))) n)
+     (0≤seqΣ _ (λ n → <ᵣWeaken≤ᵣ _ _ (sPos (n ℕ.+ (m ℕ.+ suc N)))) _))) pp
+
+  where
+  s' : Seq
+  s' = s ∘ (ℕ._+ (suc (m ℕ.+ N)))
+
+
+  f' : ((n : ℕ) →  N ℕ.≤ n →
+         (s (suc n)) ≤ᵣ
+         s n ·ᵣ rat [ 1 / 2 ])
+  f' n n< =
+     subst2 {x = ((s (suc n) ／ᵣ[ s n , inl (sPos n) ])
+                    +ᵣ 0 ) ·ᵣ s n }
+        _≤ᵣ_ (congS (_·ᵣ s n) (+IdR _) ∙
+          [x/y]·yᵣ _ _ _) (·ᵣComm _ _)
+       ((<ᵣWeaken≤ᵣ _ _
+          (<ᵣ-·ᵣo _ _ (s n , sPos _)
+           (isTrans≤<ᵣ _ _ _ (≤absᵣ _)
+             (snd N½ n (
+              ℕ.<-trans (ℕ.left-≤-max {suc (fst N½)} {fst Nε})
+               n<))))))
+
+
+  p : ∀ n → s' n ≤ᵣ geometricProgression (s (m ℕ.+ N)) (fst ½ᵣ) n
+  p zero =
+     isTrans≤ᵣ _ _ _ ((f' (m ℕ.+ N) (ℕ.≤SumRight {N} {m}) ))
+             (subst ((s (m ℕ.+ N) ·ᵣ rat [ ℤ.pos 1 / 1+ 1 ]) ≤ᵣ_)
+                (·IdR _)
+                 (≤ᵣ-o·ᵣ (fst ½ᵣ) 1 (s (m ℕ.+ N))
+                   (<ᵣWeaken≤ᵣ _ _ (sPos _))
+                  (≤ℚ→≤ᵣ _ _ ((𝟚.toWitness {Q = ℚ.≤Dec ([ 1 / 2 ]) 1} _)))))
+
+  p (suc n) =
+    isTrans≤ᵣ _ _ _ (f' _
+      (subst (N ℕ.≤_) (sym (ℕ.+-assoc n (1 ℕ.+ m) N))
+        ℕ.≤SumRight))
+      (≤ᵣ-·o _ _ ([ 1 / 2 ]) ((𝟚.toWitness {Q = ℚ.≤Dec 0 ([ 1 / 2 ])} _)) (p n))
+
+  p' = Seq'≤→Σ≤ s' (geometricProgression (s (m ℕ.+ N)) (fst ½ᵣ))
+        p
+
+  s<ε : (s (m ℕ.+ N)) <ᵣ rat (fst ε/2)
+  s<ε = subst (_<ᵣ rat (fst ε/2)) (+IdR _)
+           ((isTrans≤<ᵣ _ _ _
+          (≤absᵣ ((s (m ℕ.+ N)) +ᵣ (-ᵣ 0))) (snd Nε _
+           (ℕ.≤<-trans ℕ.right-≤-max ℕ.≤SumRight))))
+
+
+  pp : (seqΣ (λ x → s (x ℕ.+ (m ℕ.+ suc N))) n) <ᵣ (rat ε)
+  pp =
+      subst {x = ℕ._+ suc (m ℕ.+ N) } {y = λ z → z ℕ.+ (m ℕ.+ suc N)}
+           (λ h → seqΣ (s ∘S h) n <ᵣ rat ε)
+
+          (funExt (λ x → cong (x ℕ.+_) (sym (ℕ.+-suc _ _)) ))
+          (isTrans≤<ᵣ _ _ _ (p' n)
+            (isTrans≤<ᵣ _ _ _
+              (≡ᵣWeaken≤ᵣ _ _ (seqSumUpTo≡seqSumUpTo' _ _))
+                (isTrans<≤ᵣ _ _ _
+                 (Sₙ-sup (s (m ℕ.+ N)) (fst ½ᵣ)
+                   n (sPos _) (snd ½ᵣ)
+                    (<ℚ→<ᵣ _ _ ((𝟚.toWitness {Q = ℚ.<Dec [ 1 / 2 ] 1} tt))))
+                (isTrans≤ᵣ _ _ _
+                  (≤ᵣ₊Monotone·ᵣ _ _ _ 2
+                        (<ᵣWeaken≤ᵣ _ _ (<ℚ→<ᵣ _ _ (ℚ.0<ℚ₊ ε/2)))
+                          (<ᵣWeaken≤ᵣ _ _
+                             ((0<1/x _ _ (
+                       <ℚ→<ᵣ _ _
+                       (𝟚.toWitness {Q = ℚ.<Dec 0 [ 1 / 2 ]} tt)))))
+
+                    (<ᵣWeaken≤ᵣ _ _ s<ε)
+                    (≡ᵣWeaken≤ᵣ _ _
+                       (invℝ-rat _ _
+                        (inl ((𝟚.toWitness {Q = ℚ.<Dec 0 [ 1 / 2 ]} tt))))))
+                        (≡ᵣWeaken≤ᵣ _ _ (sym (rat·ᵣrat _  _) ∙
+                          cong rat (sym (ℚ.·Assoc _ _ _) ∙
+                            cong (ε ℚ.·_) ℚ.decℚ? ∙ ℚ.·IdR _)))
+
+                        ))))
+
+
+expSeq : ℝ → Seq
+expSeq x zero = 1
+expSeq x (suc n) = /nᵣ (1+ n) (expSeq x n ·ᵣ x)
+
+expSeq-rat : ∀ (q : ℚ) → (n : ℕ) → Σ[ r ∈ ℚ ] (expSeq (rat q) n ≡ rat r)
+expSeq-rat q zero = 1 , refl
+expSeq-rat q (suc n) =
+  let (e , p) = expSeq-rat q n
+  in (e ℚ.· q)  ℚ.· [ 1 / (1+ n) ] ,
+       cong (/nᵣ (1+ n)) (cong (_·ᵣ (rat q)) p ∙ sym (rat·ᵣrat _ _))
+
+expSeries-rat : ∀ (q : ℚ) → (n : ℕ) →
+  Σ[ r ∈ ℚ ] (seqΣ (expSeq (rat q)) n ≡ rat r)
+expSeries-rat q zero = 0 , refl
+expSeries-rat q (suc n) =
+  let (e , p) = expSeries-rat q n
+      (e' , p') = expSeq-rat q n
+  in (e ℚ.+ e') , cong₂ _+ᵣ_ p p'
+
+expSeqPos : ∀ x → 0 <ᵣ x → ∀ n → 0 <ᵣ expSeq x n
+expSeqPos x 0<x zero = decℚ<ᵣ?
+expSeqPos x 0<x (suc n) =
+ /nᵣ-pos (1+ n) _ (ℝ₊· (_ , expSeqPos x 0<x n) (_ , 0<x))
+
+limₙ→∞[expSeqRatio]=0 : ∀ x → ∀ (0<x : 0 ℚ.< x)  → lim'ₙ→∞
+      (λ n →
+         expSeq (rat x) (suc n) ／ᵣ[ expSeq (rat x) n ,
+         inl (expSeqPos (rat x) (<ℚ→<ᵣ 0 x 0<x) n) ])
+      is 0
+limₙ→∞[expSeqRatio]=0 x 0<x =
+  subst (lim'ₙ→∞_is 0)
+    (funExt (w (rat x) _))
+    w'
+
+ where
+ x₊ : ℚ₊
+ x₊ = x , ℚ.<→0< _ 0<x
+
+ 0<ᵣx = <ℚ→<ᵣ 0 x 0<x
+ w : ∀ x 0<x n → (x ·ᵣ rat ([ 1 / 1+ n ])) ≡ (expSeq x (suc n) ／ᵣ[ expSeq x n ,
+                    inl (expSeqPos x 0<x n) ])
+ w x 0<x zero = cong₂ {y = expSeq x 1} _·ᵣ_
+        (( sym (·IdR x) ∙
+        (cong
+            (x ·ᵣ_) (sym (invℝ-rat _
+              (invEq (rat＃ _ _) (inl (ℚ.decℚ<? {0} {1})))
+               (inl (ℚ.decℚ<? {0} {1}))))) ∙ sym (/nᵣ-／ᵣ 1 (x)
+          (invEq (rat＃ _ _) (inl (ℚ.decℚ<? {0} {1}))))
+           ∙ (cong (/nᵣ 1) (sym (·IdL x))) ) )
+     (sym (invℝ-rat 1 (inl ((expSeqPos x 0<x zero)))
+            ((inl (ℚ.decℚ<? {0} {1})))))
+
+ w x 0<x (suc n) =
+   let z = _
+       z' = _
+   in ((cong (x ·ᵣ_) ((sym (·IdL _) ∙
+         cong₂ _·ᵣ_ (sym (x·invℝ[x] _ _))
+           (cong rat (sym (ℚ.fromNat-invℚ _
+                (inl (ℚ.<ℤ→<ℚ _ _ (ℤ.suc-≤-suc ℤ.zero-≤pos )))))
+             ∙ sym (invℝ-rat _ _ _)))
+               ∙ sym (·ᵣAssoc _ _ _))
+         ∙ ·ᵣAssoc _ (expSeq x (suc n)) _)
+           ∙ cong₂ (_·ᵣ_) (·ᵣComm _ _) (·ᵣComm z' z))
+       ∙ (·ᵣAssoc _ z z'
+         ∙ cong (_／ᵣ[ expSeq x (suc n) ,
+                    inl (expSeqPos x 0<x (suc n)) ])
+                     (sym (/nᵣ-／ᵣ (2+ n) (/nᵣ (1+ n) (expSeq x n ·ᵣ x) ·ᵣ x)
+                       (inl (<ℚ→<ᵣ 0 _ (ℚ.<ℤ→<ℚ _ _
+                         (ℤ.suc-≤-suc ℤ.zero-≤pos )))))))
+
+ w' : lim'ₙ→∞ _ is 0
+ w' ε =
+  let (cN , X) = ℚ.ceilℚ₊ (x₊ ℚ₊· (invℚ₊ ε))
+
+      X'' = subst (ℚ._< [ pos cN / 1+ 0 ])
+               (cong (x ℚ.·_) (sym (ℚ.invℚ₊≡invℚ ε _) ))
+             X
+      X' : x ℚ.· [ pos 1 / 1+ cN ] ℚ.< fst ε
+
+      X' = subst (ℚ._< fst ε)
+             ((cong (x ℚ.·_) (ℚ.fromNat-invℚ _ _)))
+            (ℚ.ℚ-x/y<z→x/z<y x [ pos (suc cN) / 1 ] (fst ε)
+                        0<x (ℚ.<ℤ→<ℚ _ _ (ℤ.suc-≤-suc ℤ.zero-≤pos))
+                         (ℚ.0<→< _ (snd ε))
+                         (ℚ.isTrans< _ [ pos (cN) / 1+ 0 ] _
+                           X'' (ℚ.<ℤ→<ℚ _ _ ℤ.isRefl≤ )))
+  in (suc cN) , (λ n' <n' →
+      let 0<n' = ℚ.<ℤ→<ℚ _ _
+             (ℤ.ℕ≤→pos-≤-pos _ _ (ℕ.suc-≤-suc ℕ.zero-≤))
+      in isTrans≡<ᵣ _ _ _
+          (cong absᵣ (+IdR _) ∙ absᵣPos _
+            (ℝ₊· (_ , <ℚ→<ᵣ 0 x 0<x)
+                       (_ ,
+                          <ℚ→<ᵣ _ _
+                           (ℚ.invℚ-pos [ pos (suc n') / 1 ]
+                            (inl 0<n') 0<n')))
+                             ∙ sym (rat·ᵣrat _ _))
+           (<ℚ→<ᵣ _ _ (ℚ.isTrans< _ _ _
+             (ℚ.<-o· [ 1 / 1+ n' ]
+                     [ 1 / 1+ cN ] x 0<x
+                      ((ℤ.ℕ≤→pos-≤-pos _ _ (ℕ.≤-suc <n'))))
+                          X')))
+
+
+limₙ→∞[expSeq]=0 : ∀ x → (0<x : 0 ℚ.< x) →  lim'ₙ→∞ expSeq (rat x) is 0
+limₙ→∞[expSeq]=0 x 0<x =
+  ratio→seqLimit _ (expSeq-rat x)
+      (expSeqPos (rat x) _) (limₙ→∞[expSeqRatio]=0 x 0<x)
+
+
+expSeriesConvergesAtℚ₊ : ∀ x → 0 ℚ.< x → IsConvSeries' (expSeq (rat x))
+expSeriesConvergesAtℚ₊ x 0<x =
+ ratioTest₊ (expSeq (rat x)) (expSeqPos (rat x) (<ℚ→<ᵣ _ _ 0<x))
+      (limₙ→∞[expSeq]=0 x  0<x)
+      (limₙ→∞[expSeqRatio]=0 x 0<x)
+
+expℚ₊ : ℚ₊ → ℝ
+expℚ₊ q = fromCauchySequence' _
+  (fst (IsConvSeries'≃IsCauchySequence'Sum (expSeq (rat (fst q))))
+    (expSeriesConvergesAtℚ₊ (fst q) (ℚ.0<ℚ₊ q)))
+
+
+expSeriesVal : ℕ → ℚ
+expSeriesVal n = fst (expSeries-rat 1 n)
+
+𝑒 : ℝ
+𝑒 = expℚ₊ 1
diff --git a/Cubical/HITs/PropositionalTruncation/Properties.agda b/Cubical/HITs/PropositionalTruncation/Properties.agda
index 7f143a450c..90337bddcd 100644
--- a/Cubical/HITs/PropositionalTruncation/Properties.agda
+++ b/Cubical/HITs/PropositionalTruncation/Properties.agda
@@ -25,7 +25,7 @@ open import Cubical.HITs.PropositionalTruncation.Base
 private
   variable
     ℓ ℓ' : Level
-    A B C : Type ℓ
+    A B C D : Type ℓ
     A′ : Type ℓ'
 
 ∥∥-isPropDep : (P : A → Type ℓ) → isOfHLevelDep 1 (λ x → ∥ P x ∥₁)
@@ -167,6 +167,9 @@ map f = rec squash₁ (∣_∣₁ ∘ f)
 map2 : (A → B → C) → (∥ A ∥₁ → ∥ B ∥₁ → ∥ C ∥₁)
 map2 f = rec (isPropΠ λ _ → squash₁) (map ∘ f)
 
+map3 : (A → B → C → D) → (∥ A ∥₁ → ∥ B ∥₁ → ∥ C ∥₁ → ∥ D ∥₁)
+map3 f = rec (isPropΠ2 λ _ _ → squash₁) (map2 ∘ f)
+
 -- The propositional truncation can be eliminated into non-propositional
 -- types as long as the function used in the eliminator is 'coherently
 -- constant.' The details of this can be found in the following paper:
diff --git a/Cubical/HITs/SetQuotients/Properties.agda b/Cubical/HITs/SetQuotients/Properties.agda
index f2327a424d..abee1c3f3c 100644
--- a/Cubical/HITs/SetQuotients/Properties.agda
+++ b/Cubical/HITs/SetQuotients/Properties.agda
@@ -351,3 +351,123 @@ descendMapPath f g isSetM path i x =
                         g x   ∎ })
     ([]surjective x)
     i
+
+
+
+record Rec {A : Type ℓ} {R : A → A → Type ℓ'} (B : Type ℓ'') :
+     Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')  where
+ no-eta-equality
+ field
+  isSetB : isSet B
+  f : A → B
+  f∼ : ∀ a a' → R a a' → f a ≡ f a'
+
+
+ go : _ / R → B
+ go [ a ] = f a
+ go (eq/ a a' r i) = f∼ a a' r i
+ go (squash/ x y p q i i₁) =
+   isSetB (go x) (go y) (cong go p) (cong go q) i i₁
+
+
+record Elim {A : Type ℓ} {R : A → A → Type ℓ'} (B : A / R →  Type ℓ'') :
+     Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')  where
+ no-eta-equality
+ field
+  isSetB : ∀ x → isSet (B x)
+  f : ∀ x → B [ x ]
+  f∼ : ∀ a a' → (r : R a a') → PathP (λ i → B (eq/ a a' r i)) (f a) (f a')
+
+
+ go : ∀ x → B x
+ go [ a ] = f a
+ go (eq/ a a' r i) = f∼ a a' r i
+ go (squash/ x y p q i i₁) =
+   isSet→SquareP
+     (λ i i₁ → (isSetB (squash/ x y p q i i₁)))
+     (cong go p) (cong go q) (λ _ → go x) (λ _ → go y)  i i₁
+
+record ElimProp {A : Type ℓ} {R : A → A → Type ℓ'} (B : A / R →  Type ℓ'') :
+     Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')  where
+ no-eta-equality
+ field
+  isPropB : ∀ x → isProp (B x)
+  f : ∀ x → B [ x ]
+
+ go : ∀ x → B x
+ go = Elim.go w
+  where
+  w : Elim B
+  w .Elim.isSetB = isProp→isSet ∘ isPropB
+  w .Elim.f = f
+  w .Elim.f∼ a a' r =
+    isProp→PathP (λ i → isPropB (eq/ a a' r i) ) _ _
+
+
+record Rec2 {A : Type ℓ} {R : A → A → Type ℓ'} (B : Type ℓ'') :
+     Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')  where
+ no-eta-equality
+ field
+  isSetB : isSet B
+  f : A → A → B
+  f∼ : ∀ x (a a' : A) → R a a' → f x a ≡ f x a'
+  ∼f : ∀ (a a' : A) x → R a a' → f a x ≡ f a' x
+
+
+
+ go : _ / R  → _ / R → B
+ go = Rec.go w
+  where
+  w : Rec {A = A} {R} (_ / R → B)
+  w .Rec.isSetB = isSet→ isSetB
+  w .Rec.f x = Rec.go w'
+     where
+      w' : Rec _
+      w' .Rec.isSetB = isSetB
+      w' .Rec.f x' = f x x'
+      w' .Rec.f∼ = f∼ x
+  w .Rec.f∼ a a' r = funExt
+    (ElimProp.go w')
+   where
+   w' : ElimProp _
+   w' .ElimProp.isPropB _ = isSetB _ _
+   w' .ElimProp.f x = ∼f a a' x r
+
+
+record ElimProp2 {A : Type ℓ} {R : A → A → Type ℓ'} (B : A / R → A / R →  Type ℓ'') :
+     Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')  where
+ no-eta-equality
+ field
+  isPropB : ∀ x y → isProp (B x y)
+  f : ∀ x y → B [ x ] [ y ]
+
+ go : ∀ x y → B x y
+ go = ElimProp.go w
+  where
+  w : ElimProp (λ z → (y : A / R) → B z y)
+  w .ElimProp.isPropB _ = isPropΠ λ _ → isPropB _ _
+  w .ElimProp.f x = ElimProp.go w'
+   where
+   w' : ElimProp (λ z → B [ x ] z)
+   w' .ElimProp.isPropB _ = isPropB _ _
+   w' .ElimProp.f = f x
+
+
+record ElimProp3 {A : Type ℓ} {R : A → A → Type ℓ'}
+        (B : A / R → A / R → A / R →  Type ℓ'') :
+     Type (ℓ-max (ℓ-max ℓ ℓ') ℓ'')  where
+ no-eta-equality
+ field
+  isPropB : ∀ x y z → isProp (B x y z)
+  f : ∀ x y z → B [ x ] [ y ] [ z ]
+
+ go : ∀ x y z → B x y z
+ go = ElimProp2.go w
+  where
+  w : ElimProp2 (λ z z₁ → (z₂ : A / R) → B z z₁ z₂)
+  w .ElimProp2.isPropB _ _ = isPropΠ λ _ → isPropB _ _ _
+  w .ElimProp2.f x y = ElimProp.go w'
+   where
+   w' : ElimProp (λ z → B [ x ] [ y ] z)
+   w' .ElimProp.isPropB _ = isPropB _ _ _
+   w' .ElimProp.f = f x y